1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992-2020 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
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
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
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 */
60 #include "coretypes.h"
67 #include "stringpool.h"
68 #include "insn-config.h"
71 #include "diagnostic.h"
72 #include "fold-const.h"
73 #include "stor-layout.h"
81 #include "dwarf2out.h"
82 #include "dwarf2asm.h"
85 #include "tree-pretty-print.h"
86 #include "print-rtl.h"
88 #include "common/common-target.h"
89 #include "langhooks.h"
94 #include "gdb/gdb-index.h"
96 #include "stringpool.h"
98 #include "file-prefix-map.h" /* remap_debug_filename() */
100 static void dwarf2out_source_line (unsigned int, unsigned int, const char *,
102 static rtx_insn *last_var_location_insn;
103 static rtx_insn *cached_next_real_insn;
104 static void dwarf2out_decl (tree);
105 static bool is_redundant_typedef (const_tree);
107 #ifndef XCOFF_DEBUGGING_INFO
108 #define XCOFF_DEBUGGING_INFO 0
111 #ifndef HAVE_XCOFF_DWARF_EXTRAS
112 #define HAVE_XCOFF_DWARF_EXTRAS 0
115 #ifdef VMS_DEBUGGING_INFO
116 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
118 /* Define this macro to be a nonzero value if the directory specifications
119 which are output in the debug info should end with a separator. */
120 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
121 /* Define this macro to evaluate to a nonzero value if GCC should refrain
122 from generating indirect strings in DWARF2 debug information, for instance
123 if your target is stuck with an old version of GDB that is unable to
124 process them properly or uses VMS Debug. */
125 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
127 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
128 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
131 /* ??? Poison these here until it can be done generically. They've been
132 totally replaced in this file; make sure it stays that way. */
133 #undef DWARF2_UNWIND_INFO
134 #undef DWARF2_FRAME_INFO
135 #if (GCC_VERSION >= 3000)
136 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
139 /* The size of the target's pointer type. */
141 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
144 /* Array of RTXes referenced by the debugging information, which therefore
145 must be kept around forever. */
146 static GTY(()) vec<rtx, va_gc> *used_rtx_array;
148 /* A pointer to the base of a list of incomplete types which might be
149 completed at some later time. incomplete_types_list needs to be a
150 vec<tree, va_gc> *because we want to tell the garbage collector about
152 static GTY(()) vec<tree, va_gc> *incomplete_types;
154 /* Pointers to various DWARF2 sections. */
155 static GTY(()) section *debug_info_section;
156 static GTY(()) section *debug_skeleton_info_section;
157 static GTY(()) section *debug_abbrev_section;
158 static GTY(()) section *debug_skeleton_abbrev_section;
159 static GTY(()) section *debug_aranges_section;
160 static GTY(()) section *debug_addr_section;
161 static GTY(()) section *debug_macinfo_section;
162 static const char *debug_macinfo_section_name;
163 static unsigned macinfo_label_base = 1;
164 static GTY(()) section *debug_line_section;
165 static GTY(()) section *debug_skeleton_line_section;
166 static GTY(()) section *debug_loc_section;
167 static GTY(()) section *debug_pubnames_section;
168 static GTY(()) section *debug_pubtypes_section;
169 static GTY(()) section *debug_str_section;
170 static GTY(()) section *debug_line_str_section;
171 static GTY(()) section *debug_str_dwo_section;
172 static GTY(()) section *debug_str_offsets_section;
173 static GTY(()) section *debug_ranges_section;
174 static GTY(()) section *debug_frame_section;
176 /* Maximum size (in bytes) of an artificially generated label. */
177 #define MAX_ARTIFICIAL_LABEL_BYTES 40
179 /* According to the (draft) DWARF 3 specification, the initial length
180 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
181 bytes are 0xffffffff, followed by the length stored in the next 8
184 However, the SGI/MIPS ABI uses an initial length which is equal to
185 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
187 #ifndef DWARF_INITIAL_LENGTH_SIZE
188 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
191 #ifndef DWARF_INITIAL_LENGTH_SIZE_STR
192 #define DWARF_INITIAL_LENGTH_SIZE_STR (DWARF_OFFSET_SIZE == 4 ? "-4" : "-12")
195 /* Round SIZE up to the nearest BOUNDARY. */
196 #define DWARF_ROUND(SIZE,BOUNDARY) \
197 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
199 /* CIE identifier. */
200 #if HOST_BITS_PER_WIDE_INT >= 64
201 #define DWARF_CIE_ID \
202 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
204 #define DWARF_CIE_ID DW_CIE_ID
208 /* A vector for a table that contains frame description
209 information for each routine. */
210 #define NOT_INDEXED (-1U)
211 #define NO_INDEX_ASSIGNED (-2U)
213 static GTY(()) vec<dw_fde_ref, va_gc> *fde_vec;
215 struct GTY((for_user)) indirect_string_node {
217 unsigned int refcount;
218 enum dwarf_form form;
223 struct indirect_string_hasher : ggc_ptr_hash<indirect_string_node>
225 typedef const char *compare_type;
227 static hashval_t hash (indirect_string_node *);
228 static bool equal (indirect_string_node *, const char *);
231 static GTY (()) hash_table<indirect_string_hasher> *debug_str_hash;
233 static GTY (()) hash_table<indirect_string_hasher> *debug_line_str_hash;
235 /* With split_debug_info, both the comp_dir and dwo_name go in the
236 main object file, rather than the dwo, similar to the force_direct
237 parameter elsewhere but with additional complications:
239 1) The string is needed in both the main object file and the dwo.
240 That is, the comp_dir and dwo_name will appear in both places.
242 2) Strings can use four forms: DW_FORM_string, DW_FORM_strp,
243 DW_FORM_line_strp or DW_FORM_strx/GNU_str_index.
245 3) GCC chooses the form to use late, depending on the size and
248 Rather than forcing the all debug string handling functions and
249 callers to deal with these complications, simply use a separate,
250 special-cased string table for any attribute that should go in the
251 main object file. This limits the complexity to just the places
254 static GTY (()) hash_table<indirect_string_hasher> *skeleton_debug_str_hash;
256 static GTY(()) int dw2_string_counter;
258 /* True if the compilation unit places functions in more than one section. */
259 static GTY(()) bool have_multiple_function_sections = false;
261 /* Whether the default text and cold text sections have been used at all. */
262 static GTY(()) bool text_section_used = false;
263 static GTY(()) bool cold_text_section_used = false;
265 /* The default cold text section. */
266 static GTY(()) section *cold_text_section;
268 /* The DIE for C++14 'auto' in a function return type. */
269 static GTY(()) dw_die_ref auto_die;
271 /* The DIE for C++14 'decltype(auto)' in a function return type. */
272 static GTY(()) dw_die_ref decltype_auto_die;
274 /* Forward declarations for functions defined in this file. */
276 static void output_call_frame_info (int);
277 static void dwarf2out_note_section_used (void);
279 /* Personality decl of current unit. Used only when assembler does not support
281 static GTY(()) rtx current_unit_personality;
283 /* Whether an eh_frame section is required. */
284 static GTY(()) bool do_eh_frame = false;
286 /* .debug_rnglists next index. */
287 static unsigned int rnglist_idx;
289 /* Data and reference forms for relocatable data. */
290 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
291 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
293 #ifndef DEBUG_FRAME_SECTION
294 #define DEBUG_FRAME_SECTION ".debug_frame"
297 #ifndef FUNC_BEGIN_LABEL
298 #define FUNC_BEGIN_LABEL "LFB"
301 #ifndef FUNC_SECOND_SECT_LABEL
302 #define FUNC_SECOND_SECT_LABEL "LFSB"
305 #ifndef FUNC_END_LABEL
306 #define FUNC_END_LABEL "LFE"
309 #ifndef PROLOGUE_END_LABEL
310 #define PROLOGUE_END_LABEL "LPE"
313 #ifndef EPILOGUE_BEGIN_LABEL
314 #define EPILOGUE_BEGIN_LABEL "LEB"
317 #ifndef FRAME_BEGIN_LABEL
318 #define FRAME_BEGIN_LABEL "Lframe"
320 #define CIE_AFTER_SIZE_LABEL "LSCIE"
321 #define CIE_END_LABEL "LECIE"
322 #define FDE_LABEL "LSFDE"
323 #define FDE_AFTER_SIZE_LABEL "LASFDE"
324 #define FDE_END_LABEL "LEFDE"
325 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
326 #define LINE_NUMBER_END_LABEL "LELT"
327 #define LN_PROLOG_AS_LABEL "LASLTP"
328 #define LN_PROLOG_END_LABEL "LELTP"
329 #define DIE_LABEL_PREFIX "DW"
331 /* Match the base name of a file to the base name of a compilation unit. */
334 matches_main_base (const char *path)
336 /* Cache the last query. */
337 static const char *last_path = NULL;
338 static int last_match = 0;
339 if (path != last_path)
342 int length = base_of_path (path, &base);
344 last_match = (length == main_input_baselength
345 && memcmp (base, main_input_basename, length) == 0);
350 #ifdef DEBUG_DEBUG_STRUCT
353 dump_struct_debug (tree type, enum debug_info_usage usage,
354 enum debug_struct_file criterion, int generic,
355 int matches, int result)
357 /* Find the type name. */
358 tree type_decl = TYPE_STUB_DECL (type);
360 const char *name = 0;
361 if (TREE_CODE (t) == TYPE_DECL)
364 name = IDENTIFIER_POINTER (t);
366 fprintf (stderr, " struct %d %s %s %s %s %d %p %s\n",
368 DECL_IN_SYSTEM_HEADER (type_decl) ? "sys" : "usr",
369 matches ? "bas" : "hdr",
370 generic ? "gen" : "ord",
371 usage == DINFO_USAGE_DFN ? ";" :
372 usage == DINFO_USAGE_DIR_USE ? "." : "*",
374 (void*) type_decl, name);
377 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
378 dump_struct_debug (type, usage, criterion, generic, matches, result)
382 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
387 /* Get the number of HOST_WIDE_INTs needed to represent the precision
388 of the number. Some constants have a large uniform precision, so
389 we get the precision needed for the actual value of the number. */
392 get_full_len (const wide_int &op)
394 int prec = wi::min_precision (op, UNSIGNED);
395 return ((prec + HOST_BITS_PER_WIDE_INT - 1)
396 / HOST_BITS_PER_WIDE_INT);
400 should_emit_struct_debug (tree type, enum debug_info_usage usage)
402 if (debug_info_level <= DINFO_LEVEL_TERSE)
405 enum debug_struct_file criterion;
407 bool generic = lang_hooks.types.generic_p (type);
410 criterion = debug_struct_generic[usage];
412 criterion = debug_struct_ordinary[usage];
414 if (criterion == DINFO_STRUCT_FILE_NONE)
415 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
416 if (criterion == DINFO_STRUCT_FILE_ANY)
417 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
419 type_decl = TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type));
421 if (type_decl != NULL)
423 if (criterion == DINFO_STRUCT_FILE_SYS && DECL_IN_SYSTEM_HEADER (type_decl))
424 return DUMP_GSTRUCT (type, usage, criterion, generic, false, true);
426 if (matches_main_base (DECL_SOURCE_FILE (type_decl)))
427 return DUMP_GSTRUCT (type, usage, criterion, generic, true, true);
430 return DUMP_GSTRUCT (type, usage, criterion, generic, false, false);
433 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
434 switch to the data section instead, and write out a synthetic start label
435 for collect2 the first time around. */
438 switch_to_eh_frame_section (bool back ATTRIBUTE_UNUSED)
440 if (eh_frame_section == 0)
444 if (EH_TABLES_CAN_BE_READ_ONLY)
450 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
452 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
454 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
457 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
458 && (fde_encoding & 0x70) != DW_EH_PE_aligned
459 && (per_encoding & 0x70) != DW_EH_PE_absptr
460 && (per_encoding & 0x70) != DW_EH_PE_aligned
461 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
462 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
463 ? 0 : SECTION_WRITE);
466 flags = SECTION_WRITE;
468 #ifdef EH_FRAME_SECTION_NAME
469 eh_frame_section = get_section (EH_FRAME_SECTION_NAME, flags, NULL);
471 eh_frame_section = ((flags == SECTION_WRITE)
472 ? data_section : readonly_data_section);
473 #endif /* EH_FRAME_SECTION_NAME */
476 switch_to_section (eh_frame_section);
478 #ifdef EH_FRAME_THROUGH_COLLECT2
479 /* We have no special eh_frame section. Emit special labels to guide
483 tree label = get_file_function_name ("F");
484 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
485 targetm.asm_out.globalize_label (asm_out_file,
486 IDENTIFIER_POINTER (label));
487 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
492 /* Switch [BACK] to the eh or debug frame table section, depending on
496 switch_to_frame_table_section (int for_eh, bool back)
499 switch_to_eh_frame_section (back);
502 if (!debug_frame_section)
503 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
504 SECTION_DEBUG, NULL);
505 switch_to_section (debug_frame_section);
509 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
511 enum dw_cfi_oprnd_type
512 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
517 case DW_CFA_GNU_window_save:
518 case DW_CFA_remember_state:
519 case DW_CFA_restore_state:
520 return dw_cfi_oprnd_unused;
523 case DW_CFA_advance_loc1:
524 case DW_CFA_advance_loc2:
525 case DW_CFA_advance_loc4:
526 case DW_CFA_MIPS_advance_loc8:
527 return dw_cfi_oprnd_addr;
530 case DW_CFA_offset_extended:
532 case DW_CFA_offset_extended_sf:
533 case DW_CFA_def_cfa_sf:
535 case DW_CFA_restore_extended:
536 case DW_CFA_undefined:
537 case DW_CFA_same_value:
538 case DW_CFA_def_cfa_register:
539 case DW_CFA_register:
540 case DW_CFA_expression:
541 case DW_CFA_val_expression:
542 return dw_cfi_oprnd_reg_num;
544 case DW_CFA_def_cfa_offset:
545 case DW_CFA_GNU_args_size:
546 case DW_CFA_def_cfa_offset_sf:
547 return dw_cfi_oprnd_offset;
549 case DW_CFA_def_cfa_expression:
550 return dw_cfi_oprnd_loc;
557 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
559 enum dw_cfi_oprnd_type
560 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
565 case DW_CFA_def_cfa_sf:
567 case DW_CFA_offset_extended_sf:
568 case DW_CFA_offset_extended:
569 return dw_cfi_oprnd_offset;
571 case DW_CFA_register:
572 return dw_cfi_oprnd_reg_num;
574 case DW_CFA_expression:
575 case DW_CFA_val_expression:
576 return dw_cfi_oprnd_loc;
578 case DW_CFA_def_cfa_expression:
579 return dw_cfi_oprnd_cfa_loc;
582 return dw_cfi_oprnd_unused;
586 /* Output one FDE. */
589 output_fde (dw_fde_ref fde, bool for_eh, bool second,
590 char *section_start_label, int fde_encoding, char *augmentation,
591 bool any_lsda_needed, int lsda_encoding)
593 const char *begin, *end;
594 static unsigned int j;
595 char l1[MAX_ARTIFICIAL_LABEL_BYTES], l2[MAX_ARTIFICIAL_LABEL_BYTES];
597 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
599 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
601 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
602 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + j);
603 if (!XCOFF_DEBUGGING_INFO || for_eh)
605 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
606 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
607 " indicating 64-bit DWARF extension");
608 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
611 ASM_OUTPUT_LABEL (asm_out_file, l1);
614 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
616 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
617 debug_frame_section, "FDE CIE offset");
619 begin = second ? fde->dw_fde_second_begin : fde->dw_fde_begin;
620 end = second ? fde->dw_fde_second_end : fde->dw_fde_end;
624 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, begin);
625 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
626 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref, false,
627 "FDE initial location");
628 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
629 end, begin, "FDE address range");
633 dw2_asm_output_addr (DWARF2_ADDR_SIZE, begin, "FDE initial location");
634 dw2_asm_output_delta (DWARF2_ADDR_SIZE, end, begin, "FDE address range");
641 int size = size_of_encoded_value (lsda_encoding);
643 if (lsda_encoding == DW_EH_PE_aligned)
645 int offset = ( 4 /* Length */
647 + 2 * size_of_encoded_value (fde_encoding)
648 + 1 /* Augmentation size */ );
649 int pad = -offset & (PTR_SIZE - 1);
652 gcc_assert (size_of_uleb128 (size) == 1);
655 dw2_asm_output_data_uleb128 (size, "Augmentation size");
657 if (fde->uses_eh_lsda)
659 ASM_GENERATE_INTERNAL_LABEL (l1, second ? "LLSDAC" : "LLSDA",
660 fde->funcdef_number);
661 dw2_asm_output_encoded_addr_rtx (lsda_encoding,
662 gen_rtx_SYMBOL_REF (Pmode, l1),
664 "Language Specific Data Area");
668 if (lsda_encoding == DW_EH_PE_aligned)
669 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
670 dw2_asm_output_data (size_of_encoded_value (lsda_encoding), 0,
671 "Language Specific Data Area (none)");
675 dw2_asm_output_data_uleb128 (0, "Augmentation size");
678 /* Loop through the Call Frame Instructions associated with this FDE. */
679 fde->dw_fde_current_label = begin;
681 size_t from, until, i;
684 until = vec_safe_length (fde->dw_fde_cfi);
686 if (fde->dw_fde_second_begin == NULL)
689 until = fde->dw_fde_switch_cfi_index;
691 from = fde->dw_fde_switch_cfi_index;
693 for (i = from; i < until; i++)
694 output_cfi ((*fde->dw_fde_cfi)[i], fde, for_eh);
697 /* If we are to emit a ref/link from function bodies to their frame tables,
698 do it now. This is typically performed to make sure that tables
699 associated with functions are dragged with them and not discarded in
700 garbage collecting links. We need to do this on a per function basis to
701 cope with -ffunction-sections. */
703 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
704 /* Switch to the function section, emit the ref to the tables, and
705 switch *back* into the table section. */
706 switch_to_section (function_section (fde->decl));
707 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label);
708 switch_to_frame_table_section (for_eh, true);
711 /* Pad the FDE out to an address sized boundary. */
712 ASM_OUTPUT_ALIGN (asm_out_file,
713 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
714 ASM_OUTPUT_LABEL (asm_out_file, l2);
719 /* Return true if frame description entry FDE is needed for EH. */
722 fde_needed_for_eh_p (dw_fde_ref fde)
724 if (flag_asynchronous_unwind_tables)
727 if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde->decl))
730 if (fde->uses_eh_lsda)
733 /* If exceptions are enabled, we have collected nothrow info. */
734 if (flag_exceptions && (fde->all_throwers_are_sibcalls || fde->nothrow))
740 /* Output the call frame information used to record information
741 that relates to calculating the frame pointer, and records the
742 location of saved registers. */
745 output_call_frame_info (int for_eh)
750 char l1[MAX_ARTIFICIAL_LABEL_BYTES], l2[MAX_ARTIFICIAL_LABEL_BYTES];
751 char section_start_label[MAX_ARTIFICIAL_LABEL_BYTES];
752 bool any_lsda_needed = false;
753 char augmentation[6];
754 int augmentation_size;
755 int fde_encoding = DW_EH_PE_absptr;
756 int per_encoding = DW_EH_PE_absptr;
757 int lsda_encoding = DW_EH_PE_absptr;
759 rtx personality = NULL;
762 /* Don't emit a CIE if there won't be any FDEs. */
766 /* Nothing to do if the assembler's doing it all. */
767 if (dwarf2out_do_cfi_asm ())
770 /* If we don't have any functions we'll want to unwind out of, don't emit
771 any EH unwind information. If we make FDEs linkonce, we may have to
772 emit an empty label for an FDE that wouldn't otherwise be emitted. We
773 want to avoid having an FDE kept around when the function it refers to
774 is discarded. Example where this matters: a primary function template
775 in C++ requires EH information, an explicit specialization doesn't. */
778 bool any_eh_needed = false;
780 FOR_EACH_VEC_ELT (*fde_vec, i, fde)
782 if (fde->uses_eh_lsda)
783 any_eh_needed = any_lsda_needed = true;
784 else if (fde_needed_for_eh_p (fde))
785 any_eh_needed = true;
786 else if (TARGET_USES_WEAK_UNWIND_INFO)
787 targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, 1, 1);
794 /* We're going to be generating comments, so turn on app. */
798 /* Switch to the proper frame section, first time. */
799 switch_to_frame_table_section (for_eh, false);
801 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
802 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
804 /* Output the CIE. */
805 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
806 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
807 if (!XCOFF_DEBUGGING_INFO || for_eh)
809 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4 && !for_eh)
810 dw2_asm_output_data (4, 0xffffffff,
811 "Initial length escape value indicating 64-bit DWARF extension");
812 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
813 "Length of Common Information Entry");
815 ASM_OUTPUT_LABEL (asm_out_file, l1);
817 /* Now that the CIE pointer is PC-relative for EH,
818 use 0 to identify the CIE. */
819 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
820 (for_eh ? 0 : DWARF_CIE_ID),
821 "CIE Identifier Tag");
823 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
824 use CIE version 1, unless that would produce incorrect results
825 due to overflowing the return register column. */
826 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
828 if (return_reg >= 256 || dwarf_version > 2)
830 dw2_asm_output_data (1, dw_cie_version, "CIE Version");
833 augmentation_size = 0;
835 personality = current_unit_personality;
841 z Indicates that a uleb128 is present to size the
842 augmentation section.
843 L Indicates the encoding (and thus presence) of
844 an LSDA pointer in the FDE augmentation.
845 R Indicates a non-default pointer encoding for
847 P Indicates the presence of an encoding + language
848 personality routine in the CIE augmentation. */
850 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
851 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
852 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
854 p = augmentation + 1;
858 augmentation_size += 1 + size_of_encoded_value (per_encoding);
859 assemble_external_libcall (personality);
864 augmentation_size += 1;
866 if (fde_encoding != DW_EH_PE_absptr)
869 augmentation_size += 1;
871 if (p > augmentation + 1)
873 augmentation[0] = 'z';
877 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
878 if (personality && per_encoding == DW_EH_PE_aligned)
880 int offset = ( 4 /* Length */
882 + 1 /* CIE version */
883 + strlen (augmentation) + 1 /* Augmentation */
884 + size_of_uleb128 (1) /* Code alignment */
885 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
887 + 1 /* Augmentation size */
888 + 1 /* Personality encoding */ );
889 int pad = -offset & (PTR_SIZE - 1);
891 augmentation_size += pad;
893 /* Augmentations should be small, so there's scarce need to
894 iterate for a solution. Die if we exceed one uleb128 byte. */
895 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
899 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
900 if (dw_cie_version >= 4)
902 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "CIE Address Size");
903 dw2_asm_output_data (1, 0, "CIE Segment Size");
905 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
906 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
907 "CIE Data Alignment Factor");
909 if (dw_cie_version == 1)
910 dw2_asm_output_data (1, return_reg, "CIE RA Column");
912 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
916 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
919 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
920 eh_data_format_name (per_encoding));
921 dw2_asm_output_encoded_addr_rtx (per_encoding,
927 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
928 eh_data_format_name (lsda_encoding));
930 if (fde_encoding != DW_EH_PE_absptr)
931 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
932 eh_data_format_name (fde_encoding));
935 FOR_EACH_VEC_ELT (*cie_cfi_vec, i, cfi)
936 output_cfi (cfi, NULL, for_eh);
938 /* Pad the CIE out to an address sized boundary. */
939 ASM_OUTPUT_ALIGN (asm_out_file,
940 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
941 ASM_OUTPUT_LABEL (asm_out_file, l2);
943 /* Loop through all of the FDE's. */
944 FOR_EACH_VEC_ELT (*fde_vec, i, fde)
948 /* Don't emit EH unwind info for leaf functions that don't need it. */
949 if (for_eh && !fde_needed_for_eh_p (fde))
952 for (k = 0; k < (fde->dw_fde_second_begin ? 2 : 1); k++)
953 output_fde (fde, for_eh, k, section_start_label, fde_encoding,
954 augmentation, any_lsda_needed, lsda_encoding);
957 if (for_eh && targetm.terminate_dw2_eh_frame_info)
958 dw2_asm_output_data (4, 0, "End of Table");
960 /* Turn off app to make assembly quicker. */
965 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
968 dwarf2out_do_cfi_startproc (bool second)
973 fprintf (asm_out_file, "\t.cfi_startproc\n");
975 targetm.asm_out.post_cfi_startproc (asm_out_file, current_function_decl);
977 /* .cfi_personality and .cfi_lsda are only relevant to DWARF2
979 if (targetm_common.except_unwind_info (&global_options) != UI_DWARF2)
982 rtx personality = get_personality_function (current_function_decl);
986 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
989 /* ??? The GAS support isn't entirely consistent. We have to
990 handle indirect support ourselves, but PC-relative is done
991 in the assembler. Further, the assembler can't handle any
992 of the weirder relocation types. */
993 if (enc & DW_EH_PE_indirect)
994 ref = dw2_force_const_mem (ref, true);
996 fprintf (asm_out_file, "\t.cfi_personality %#x,", enc);
997 output_addr_const (asm_out_file, ref);
998 fputc ('\n', asm_out_file);
1001 if (crtl->uses_eh_lsda)
1003 char lab[MAX_ARTIFICIAL_LABEL_BYTES];
1005 enc = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1006 ASM_GENERATE_INTERNAL_LABEL (lab, second ? "LLSDAC" : "LLSDA",
1007 current_function_funcdef_no);
1008 ref = gen_rtx_SYMBOL_REF (Pmode, lab);
1009 SYMBOL_REF_FLAGS (ref) = SYMBOL_FLAG_LOCAL;
1011 if (enc & DW_EH_PE_indirect)
1012 ref = dw2_force_const_mem (ref, true);
1014 fprintf (asm_out_file, "\t.cfi_lsda %#x,", enc);
1015 output_addr_const (asm_out_file, ref);
1016 fputc ('\n', asm_out_file);
1020 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
1021 this allocation may be done before pass_final. */
1024 dwarf2out_alloc_current_fde (void)
1028 fde = ggc_cleared_alloc<dw_fde_node> ();
1029 fde->decl = current_function_decl;
1030 fde->funcdef_number = current_function_funcdef_no;
1031 fde->fde_index = vec_safe_length (fde_vec);
1032 fde->all_throwers_are_sibcalls = crtl->all_throwers_are_sibcalls;
1033 fde->uses_eh_lsda = crtl->uses_eh_lsda;
1034 fde->nothrow = crtl->nothrow;
1035 fde->drap_reg = INVALID_REGNUM;
1036 fde->vdrap_reg = INVALID_REGNUM;
1038 /* Record the FDE associated with this function. */
1040 vec_safe_push (fde_vec, fde);
1045 /* Output a marker (i.e. a label) for the beginning of a function, before
1049 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
1050 unsigned int column ATTRIBUTE_UNUSED,
1051 const char *file ATTRIBUTE_UNUSED)
1053 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1059 current_function_func_begin_label = NULL;
1061 do_frame = dwarf2out_do_frame ();
1063 /* ??? current_function_func_begin_label is also used by except.c for
1064 call-site information. We must emit this label if it might be used. */
1066 && (!flag_exceptions
1067 || targetm_common.except_unwind_info (&global_options) == UI_SJLJ))
1070 fnsec = function_section (current_function_decl);
1071 switch_to_section (fnsec);
1072 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1073 current_function_funcdef_no);
1074 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
1075 current_function_funcdef_no);
1076 dup_label = xstrdup (label);
1077 current_function_func_begin_label = dup_label;
1079 /* We can elide FDE allocation if we're not emitting frame unwind info. */
1083 /* Unlike the debug version, the EH version of frame unwind info is a per-
1084 function setting so we need to record whether we need it for the unit. */
1085 do_eh_frame |= dwarf2out_do_eh_frame ();
1087 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1088 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1089 would include pass_dwarf2_frame. If we've not created the FDE yet,
1093 fde = dwarf2out_alloc_current_fde ();
1095 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1096 fde->dw_fde_begin = dup_label;
1097 fde->dw_fde_current_label = dup_label;
1098 fde->in_std_section = (fnsec == text_section
1099 || (cold_text_section && fnsec == cold_text_section));
1101 /* We only want to output line number information for the genuine dwarf2
1102 prologue case, not the eh frame case. */
1103 #ifdef DWARF2_DEBUGGING_INFO
1105 dwarf2out_source_line (line, column, file, 0, true);
1108 if (dwarf2out_do_cfi_asm ())
1109 dwarf2out_do_cfi_startproc (false);
1112 rtx personality = get_personality_function (current_function_decl);
1113 if (!current_unit_personality)
1114 current_unit_personality = personality;
1116 /* We cannot keep a current personality per function as without CFI
1117 asm, at the point where we emit the CFI data, there is no current
1118 function anymore. */
1119 if (personality && current_unit_personality != personality)
1120 sorry ("multiple EH personalities are supported only with assemblers "
1121 "supporting %<.cfi_personality%> directive");
1125 /* Output a marker (i.e. a label) for the end of the generated code
1126 for a function prologue. This gets called *after* the prologue code has
1130 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED,
1131 const char *file ATTRIBUTE_UNUSED)
1133 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1135 /* Output a label to mark the endpoint of the code generated for this
1137 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
1138 current_function_funcdef_no);
1139 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, PROLOGUE_END_LABEL,
1140 current_function_funcdef_no);
1141 cfun->fde->dw_fde_vms_end_prologue = xstrdup (label);
1144 /* Output a marker (i.e. a label) for the beginning of the generated code
1145 for a function epilogue. This gets called *before* the prologue code has
1149 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1150 const char *file ATTRIBUTE_UNUSED)
1152 dw_fde_ref fde = cfun->fde;
1153 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1155 if (fde->dw_fde_vms_begin_epilogue)
1158 /* Output a label to mark the endpoint of the code generated for this
1160 ASM_GENERATE_INTERNAL_LABEL (label, EPILOGUE_BEGIN_LABEL,
1161 current_function_funcdef_no);
1162 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, EPILOGUE_BEGIN_LABEL,
1163 current_function_funcdef_no);
1164 fde->dw_fde_vms_begin_epilogue = xstrdup (label);
1167 /* Output a marker (i.e. a label) for the absolute end of the generated code
1168 for a function definition. This gets called *after* the epilogue code has
1172 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
1173 const char *file ATTRIBUTE_UNUSED)
1176 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1178 last_var_location_insn = NULL;
1179 cached_next_real_insn = NULL;
1181 if (dwarf2out_do_cfi_asm ())
1182 fprintf (asm_out_file, "\t.cfi_endproc\n");
1184 /* Output a label to mark the endpoint of the code generated for this
1186 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
1187 current_function_funcdef_no);
1188 ASM_OUTPUT_LABEL (asm_out_file, label);
1190 gcc_assert (fde != NULL);
1191 if (fde->dw_fde_second_begin == NULL)
1192 fde->dw_fde_end = xstrdup (label);
1196 dwarf2out_frame_finish (void)
1198 /* Output call frame information. */
1199 if (targetm.debug_unwind_info () == UI_DWARF2)
1200 output_call_frame_info (0);
1202 /* Output another copy for the unwinder. */
1204 output_call_frame_info (1);
1207 /* Note that the current function section is being used for code. */
1210 dwarf2out_note_section_used (void)
1212 section *sec = current_function_section ();
1213 if (sec == text_section)
1214 text_section_used = true;
1215 else if (sec == cold_text_section)
1216 cold_text_section_used = true;
1219 static void var_location_switch_text_section (void);
1220 static void set_cur_line_info_table (section *);
1223 dwarf2out_switch_text_section (void)
1225 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1227 dw_fde_ref fde = cfun->fde;
1229 gcc_assert (cfun && fde && fde->dw_fde_second_begin == NULL);
1231 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_SECOND_SECT_LABEL,
1232 current_function_funcdef_no);
1234 fde->dw_fde_second_begin = ggc_strdup (label);
1235 if (!in_cold_section_p)
1237 fde->dw_fde_end = crtl->subsections.cold_section_end_label;
1238 fde->dw_fde_second_end = crtl->subsections.hot_section_end_label;
1242 fde->dw_fde_end = crtl->subsections.hot_section_end_label;
1243 fde->dw_fde_second_end = crtl->subsections.cold_section_end_label;
1245 have_multiple_function_sections = true;
1247 /* There is no need to mark used sections when not debugging. */
1248 if (cold_text_section != NULL)
1249 dwarf2out_note_section_used ();
1251 if (dwarf2out_do_cfi_asm ())
1252 fprintf (asm_out_file, "\t.cfi_endproc\n");
1254 /* Now do the real section switch. */
1255 sect = current_function_section ();
1256 switch_to_section (sect);
1258 fde->second_in_std_section
1259 = (sect == text_section
1260 || (cold_text_section && sect == cold_text_section));
1262 if (dwarf2out_do_cfi_asm ())
1263 dwarf2out_do_cfi_startproc (true);
1265 var_location_switch_text_section ();
1267 if (cold_text_section != NULL)
1268 set_cur_line_info_table (sect);
1271 /* And now, the subset of the debugging information support code necessary
1272 for emitting location expressions. */
1274 /* Data about a single source file. */
1275 struct GTY((for_user)) dwarf_file_data {
1276 const char * filename;
1280 /* Describe an entry into the .debug_addr section. */
1284 ate_kind_rtx_dtprel,
1288 struct GTY((for_user)) addr_table_entry {
1290 unsigned int refcount;
1292 union addr_table_entry_struct_union
1294 rtx GTY ((tag ("0"))) rtl;
1295 char * GTY ((tag ("1"))) label;
1297 GTY ((desc ("%1.kind"))) addr;
1300 typedef unsigned int var_loc_view;
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 char *vl_symbol; /* Label for beginning of view list. Ditto. */
1313 const char *section; /* Section this loclist is relative to */
1314 dw_loc_descr_ref expr;
1315 var_loc_view vbegin, vend;
1317 /* True if all addresses in this and subsequent lists are known to be
1320 /* True if this list has been replaced by dw_loc_next. */
1322 /* True if it has been emitted into .debug_loc* / .debug_loclists*
1324 unsigned char emitted : 1;
1325 /* True if hash field is index rather than hash value. */
1326 unsigned char num_assigned : 1;
1327 /* True if .debug_loclists.dwo offset has been emitted for it already. */
1328 unsigned char offset_emitted : 1;
1329 /* True if note_variable_value_in_expr has been called on it. */
1330 unsigned char noted_variable_value : 1;
1331 /* True if the range should be emitted even if begin and end
1336 static dw_loc_descr_ref int_loc_descriptor (poly_int64);
1337 static dw_loc_descr_ref uint_loc_descriptor (unsigned HOST_WIDE_INT);
1339 /* Convert a DWARF stack opcode into its string name. */
1342 dwarf_stack_op_name (unsigned int op)
1344 const char *name = get_DW_OP_name (op);
1349 return "OP_<unknown>";
1352 /* Return TRUE iff we're to output location view lists as a separate
1353 attribute next to the location lists, as an extension compatible
1354 with DWARF 2 and above. */
1357 dwarf2out_locviews_in_attribute ()
1359 return debug_variable_location_views == 1;
1362 /* Return TRUE iff we're to output location view lists as part of the
1363 location lists, as proposed for standardization after DWARF 5. */
1366 dwarf2out_locviews_in_loclist ()
1368 #ifndef DW_LLE_view_pair
1371 return debug_variable_location_views == -1;
1375 /* Return a pointer to a newly allocated location description. Location
1376 descriptions are simple expression terms that can be strung
1377 together to form more complicated location (address) descriptions. */
1379 static inline dw_loc_descr_ref
1380 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
1381 unsigned HOST_WIDE_INT oprnd2)
1383 dw_loc_descr_ref descr = ggc_cleared_alloc<dw_loc_descr_node> ();
1385 descr->dw_loc_opc = op;
1386 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
1387 descr->dw_loc_oprnd1.val_entry = NULL;
1388 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
1389 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
1390 descr->dw_loc_oprnd2.val_entry = NULL;
1391 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
1396 /* Add a location description term to a location description expression. */
1399 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
1401 dw_loc_descr_ref *d;
1403 /* Find the end of the chain. */
1404 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
1410 /* Compare two location operands for exact equality. */
1413 dw_val_equal_p (dw_val_node *a, dw_val_node *b)
1415 if (a->val_class != b->val_class)
1417 switch (a->val_class)
1419 case dw_val_class_none:
1421 case dw_val_class_addr:
1422 return rtx_equal_p (a->v.val_addr, b->v.val_addr);
1424 case dw_val_class_offset:
1425 case dw_val_class_unsigned_const:
1426 case dw_val_class_const:
1427 case dw_val_class_unsigned_const_implicit:
1428 case dw_val_class_const_implicit:
1429 case dw_val_class_range_list:
1430 /* These are all HOST_WIDE_INT, signed or unsigned. */
1431 return a->v.val_unsigned == b->v.val_unsigned;
1433 case dw_val_class_loc:
1434 return a->v.val_loc == b->v.val_loc;
1435 case dw_val_class_loc_list:
1436 return a->v.val_loc_list == b->v.val_loc_list;
1437 case dw_val_class_view_list:
1438 return a->v.val_view_list == b->v.val_view_list;
1439 case dw_val_class_die_ref:
1440 return a->v.val_die_ref.die == b->v.val_die_ref.die;
1441 case dw_val_class_fde_ref:
1442 return a->v.val_fde_index == b->v.val_fde_index;
1443 case dw_val_class_symview:
1444 return strcmp (a->v.val_symbolic_view, b->v.val_symbolic_view) == 0;
1445 case dw_val_class_lbl_id:
1446 case dw_val_class_lineptr:
1447 case dw_val_class_macptr:
1448 case dw_val_class_loclistsptr:
1449 case dw_val_class_high_pc:
1450 return strcmp (a->v.val_lbl_id, b->v.val_lbl_id) == 0;
1451 case dw_val_class_str:
1452 return a->v.val_str == b->v.val_str;
1453 case dw_val_class_flag:
1454 return a->v.val_flag == b->v.val_flag;
1455 case dw_val_class_file:
1456 case dw_val_class_file_implicit:
1457 return a->v.val_file == b->v.val_file;
1458 case dw_val_class_decl_ref:
1459 return a->v.val_decl_ref == b->v.val_decl_ref;
1461 case dw_val_class_const_double:
1462 return (a->v.val_double.high == b->v.val_double.high
1463 && a->v.val_double.low == b->v.val_double.low);
1465 case dw_val_class_wide_int:
1466 return *a->v.val_wide == *b->v.val_wide;
1468 case dw_val_class_vec:
1470 size_t a_len = a->v.val_vec.elt_size * a->v.val_vec.length;
1471 size_t b_len = b->v.val_vec.elt_size * b->v.val_vec.length;
1473 return (a_len == b_len
1474 && !memcmp (a->v.val_vec.array, b->v.val_vec.array, a_len));
1477 case dw_val_class_data8:
1478 return memcmp (a->v.val_data8, b->v.val_data8, 8) == 0;
1480 case dw_val_class_vms_delta:
1481 return (!strcmp (a->v.val_vms_delta.lbl1, b->v.val_vms_delta.lbl1)
1482 && !strcmp (a->v.val_vms_delta.lbl2, b->v.val_vms_delta.lbl2));
1484 case dw_val_class_discr_value:
1485 return (a->v.val_discr_value.pos == b->v.val_discr_value.pos
1486 && a->v.val_discr_value.v.uval == b->v.val_discr_value.v.uval);
1487 case dw_val_class_discr_list:
1488 /* It makes no sense comparing two discriminant value lists. */
1494 /* Compare two location atoms for exact equality. */
1497 loc_descr_equal_p_1 (dw_loc_descr_ref a, dw_loc_descr_ref b)
1499 if (a->dw_loc_opc != b->dw_loc_opc)
1502 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1503 address size, but since we always allocate cleared storage it
1504 should be zero for other types of locations. */
1505 if (a->dtprel != b->dtprel)
1508 return (dw_val_equal_p (&a->dw_loc_oprnd1, &b->dw_loc_oprnd1)
1509 && dw_val_equal_p (&a->dw_loc_oprnd2, &b->dw_loc_oprnd2));
1512 /* Compare two complete location expressions for exact equality. */
1515 loc_descr_equal_p (dw_loc_descr_ref a, dw_loc_descr_ref b)
1521 if (a == NULL || b == NULL)
1523 if (!loc_descr_equal_p_1 (a, b))
1532 /* Add a constant POLY_OFFSET to a location expression. */
1535 loc_descr_plus_const (dw_loc_descr_ref *list_head, poly_int64 poly_offset)
1537 dw_loc_descr_ref loc;
1540 gcc_assert (*list_head != NULL);
1542 if (known_eq (poly_offset, 0))
1545 /* Find the end of the chain. */
1546 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
1549 HOST_WIDE_INT offset;
1550 if (!poly_offset.is_constant (&offset))
1552 loc->dw_loc_next = int_loc_descriptor (poly_offset);
1553 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_plus, 0, 0));
1558 if (loc->dw_loc_opc == DW_OP_fbreg
1559 || (loc->dw_loc_opc >= DW_OP_breg0 && loc->dw_loc_opc <= DW_OP_breg31))
1560 p = &loc->dw_loc_oprnd1.v.val_int;
1561 else if (loc->dw_loc_opc == DW_OP_bregx)
1562 p = &loc->dw_loc_oprnd2.v.val_int;
1564 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1565 offset. Don't optimize if an signed integer overflow would happen. */
1567 && ((offset > 0 && *p <= INTTYPE_MAXIMUM (HOST_WIDE_INT) - offset)
1568 || (offset < 0 && *p >= INTTYPE_MINIMUM (HOST_WIDE_INT) - offset)))
1571 else if (offset > 0)
1572 loc->dw_loc_next = new_loc_descr (DW_OP_plus_uconst, offset, 0);
1577 = uint_loc_descriptor (-(unsigned HOST_WIDE_INT) offset);
1578 add_loc_descr (&loc->dw_loc_next, new_loc_descr (DW_OP_minus, 0, 0));
1582 /* Return a pointer to a newly allocated location description for
1585 static inline dw_loc_descr_ref
1586 new_reg_loc_descr (unsigned int reg, poly_int64 offset)
1588 HOST_WIDE_INT const_offset;
1589 if (offset.is_constant (&const_offset))
1592 return new_loc_descr ((enum dwarf_location_atom) (DW_OP_breg0 + reg),
1595 return new_loc_descr (DW_OP_bregx, reg, const_offset);
1599 dw_loc_descr_ref ret = new_reg_loc_descr (reg, 0);
1600 loc_descr_plus_const (&ret, offset);
1605 /* Add a constant OFFSET to a location list. */
1608 loc_list_plus_const (dw_loc_list_ref list_head, poly_int64 offset)
1611 for (d = list_head; d != NULL; d = d->dw_loc_next)
1612 loc_descr_plus_const (&d->expr, offset);
1615 #define DWARF_REF_SIZE \
1616 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1618 /* The number of bits that can be encoded by largest DW_FORM_dataN.
1619 In DWARF4 and earlier it is DW_FORM_data8 with 64 bits, in DWARF5
1620 DW_FORM_data16 with 128 bits. */
1621 #define DWARF_LARGEST_DATA_FORM_BITS \
1622 (dwarf_version >= 5 ? 128 : 64)
1624 /* Utility inline function for construction of ops that were GNU extension
1626 static inline enum dwarf_location_atom
1627 dwarf_OP (enum dwarf_location_atom op)
1631 case DW_OP_implicit_pointer:
1632 if (dwarf_version < 5)
1633 return DW_OP_GNU_implicit_pointer;
1636 case DW_OP_entry_value:
1637 if (dwarf_version < 5)
1638 return DW_OP_GNU_entry_value;
1641 case DW_OP_const_type:
1642 if (dwarf_version < 5)
1643 return DW_OP_GNU_const_type;
1646 case DW_OP_regval_type:
1647 if (dwarf_version < 5)
1648 return DW_OP_GNU_regval_type;
1651 case DW_OP_deref_type:
1652 if (dwarf_version < 5)
1653 return DW_OP_GNU_deref_type;
1657 if (dwarf_version < 5)
1658 return DW_OP_GNU_convert;
1661 case DW_OP_reinterpret:
1662 if (dwarf_version < 5)
1663 return DW_OP_GNU_reinterpret;
1667 if (dwarf_version < 5)
1668 return DW_OP_GNU_addr_index;
1672 if (dwarf_version < 5)
1673 return DW_OP_GNU_const_index;
1682 /* Similarly for attributes. */
1683 static inline enum dwarf_attribute
1684 dwarf_AT (enum dwarf_attribute at)
1688 case DW_AT_call_return_pc:
1689 if (dwarf_version < 5)
1690 return DW_AT_low_pc;
1693 case DW_AT_call_tail_call:
1694 if (dwarf_version < 5)
1695 return DW_AT_GNU_tail_call;
1698 case DW_AT_call_origin:
1699 if (dwarf_version < 5)
1700 return DW_AT_abstract_origin;
1703 case DW_AT_call_target:
1704 if (dwarf_version < 5)
1705 return DW_AT_GNU_call_site_target;
1708 case DW_AT_call_target_clobbered:
1709 if (dwarf_version < 5)
1710 return DW_AT_GNU_call_site_target_clobbered;
1713 case DW_AT_call_parameter:
1714 if (dwarf_version < 5)
1715 return DW_AT_abstract_origin;
1718 case DW_AT_call_value:
1719 if (dwarf_version < 5)
1720 return DW_AT_GNU_call_site_value;
1723 case DW_AT_call_data_value:
1724 if (dwarf_version < 5)
1725 return DW_AT_GNU_call_site_data_value;
1728 case DW_AT_call_all_calls:
1729 if (dwarf_version < 5)
1730 return DW_AT_GNU_all_call_sites;
1733 case DW_AT_call_all_tail_calls:
1734 if (dwarf_version < 5)
1735 return DW_AT_GNU_all_tail_call_sites;
1738 case DW_AT_dwo_name:
1739 if (dwarf_version < 5)
1740 return DW_AT_GNU_dwo_name;
1743 case DW_AT_addr_base:
1744 if (dwarf_version < 5)
1745 return DW_AT_GNU_addr_base;
1754 /* And similarly for tags. */
1755 static inline enum dwarf_tag
1756 dwarf_TAG (enum dwarf_tag tag)
1760 case DW_TAG_call_site:
1761 if (dwarf_version < 5)
1762 return DW_TAG_GNU_call_site;
1765 case DW_TAG_call_site_parameter:
1766 if (dwarf_version < 5)
1767 return DW_TAG_GNU_call_site_parameter;
1776 /* And similarly for forms. */
1777 static inline enum dwarf_form
1778 dwarf_FORM (enum dwarf_form form)
1783 if (dwarf_version < 5)
1784 return DW_FORM_GNU_addr_index;
1788 if (dwarf_version < 5)
1789 return DW_FORM_GNU_str_index;
1798 static unsigned long int get_base_type_offset (dw_die_ref);
1800 /* Return the size of a location descriptor. */
1802 static unsigned long
1803 size_of_loc_descr (dw_loc_descr_ref loc)
1805 unsigned long size = 1;
1807 switch (loc->dw_loc_opc)
1810 size += DWARF2_ADDR_SIZE;
1812 case DW_OP_GNU_addr_index:
1814 case DW_OP_GNU_const_index:
1816 gcc_assert (loc->dw_loc_oprnd1.val_entry->index != NO_INDEX_ASSIGNED);
1817 size += size_of_uleb128 (loc->dw_loc_oprnd1.val_entry->index);
1836 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1839 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1844 case DW_OP_plus_uconst:
1845 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1883 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1886 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1889 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
1892 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1893 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1896 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1898 case DW_OP_bit_piece:
1899 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1900 size += size_of_uleb128 (loc->dw_loc_oprnd2.v.val_unsigned);
1902 case DW_OP_deref_size:
1903 case DW_OP_xderef_size:
1912 case DW_OP_call_ref:
1913 case DW_OP_GNU_variable_value:
1914 size += DWARF_REF_SIZE;
1916 case DW_OP_implicit_value:
1917 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1918 + loc->dw_loc_oprnd1.v.val_unsigned;
1920 case DW_OP_implicit_pointer:
1921 case DW_OP_GNU_implicit_pointer:
1922 size += DWARF_REF_SIZE + size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
1924 case DW_OP_entry_value:
1925 case DW_OP_GNU_entry_value:
1927 unsigned long op_size = size_of_locs (loc->dw_loc_oprnd1.v.val_loc);
1928 size += size_of_uleb128 (op_size) + op_size;
1931 case DW_OP_const_type:
1932 case DW_OP_GNU_const_type:
1935 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1936 size += size_of_uleb128 (o) + 1;
1937 switch (loc->dw_loc_oprnd2.val_class)
1939 case dw_val_class_vec:
1940 size += loc->dw_loc_oprnd2.v.val_vec.length
1941 * loc->dw_loc_oprnd2.v.val_vec.elt_size;
1943 case dw_val_class_const:
1944 size += HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT;
1946 case dw_val_class_const_double:
1947 size += HOST_BITS_PER_DOUBLE_INT / BITS_PER_UNIT;
1949 case dw_val_class_wide_int:
1950 size += (get_full_len (*loc->dw_loc_oprnd2.v.val_wide)
1951 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
1958 case DW_OP_regval_type:
1959 case DW_OP_GNU_regval_type:
1962 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1963 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned)
1964 + size_of_uleb128 (o);
1967 case DW_OP_deref_type:
1968 case DW_OP_GNU_deref_type:
1971 = get_base_type_offset (loc->dw_loc_oprnd2.v.val_die_ref.die);
1972 size += 1 + size_of_uleb128 (o);
1976 case DW_OP_reinterpret:
1977 case DW_OP_GNU_convert:
1978 case DW_OP_GNU_reinterpret:
1979 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
1980 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
1984 = get_base_type_offset (loc->dw_loc_oprnd1.v.val_die_ref.die);
1985 size += size_of_uleb128 (o);
1988 case DW_OP_GNU_parameter_ref:
1998 /* Return the size of a series of location descriptors. */
2001 size_of_locs (dw_loc_descr_ref loc)
2006 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
2007 field, to avoid writing to a PCH file. */
2008 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
2010 if (l->dw_loc_opc == DW_OP_skip || l->dw_loc_opc == DW_OP_bra)
2012 size += size_of_loc_descr (l);
2017 for (size = 0, l = loc; l != NULL; l = l->dw_loc_next)
2019 l->dw_loc_addr = size;
2020 size += size_of_loc_descr (l);
2026 /* Return the size of the value in a DW_AT_discr_value attribute. */
2029 size_of_discr_value (dw_discr_value *discr_value)
2031 if (discr_value->pos)
2032 return size_of_uleb128 (discr_value->v.uval);
2034 return size_of_sleb128 (discr_value->v.sval);
2037 /* Return the size of the value in a DW_AT_discr_list attribute. */
2040 size_of_discr_list (dw_discr_list_ref discr_list)
2044 for (dw_discr_list_ref list = discr_list;
2046 list = list->dw_discr_next)
2048 /* One byte for the discriminant value descriptor, and then one or two
2049 LEB128 numbers, depending on whether it's a single case label or a
2052 size += size_of_discr_value (&list->dw_discr_lower_bound);
2053 if (list->dw_discr_range != 0)
2054 size += size_of_discr_value (&list->dw_discr_upper_bound);
2059 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
2060 static void get_ref_die_offset_label (char *, dw_die_ref);
2061 static unsigned long int get_ref_die_offset (dw_die_ref);
2063 /* Output location description stack opcode's operands (if any).
2064 The for_eh_or_skip parameter controls whether register numbers are
2065 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2066 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2067 info). This should be suppressed for the cases that have not been converted
2068 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2071 output_loc_operands (dw_loc_descr_ref loc, int for_eh_or_skip)
2073 dw_val_ref val1 = &loc->dw_loc_oprnd1;
2074 dw_val_ref val2 = &loc->dw_loc_oprnd2;
2076 switch (loc->dw_loc_opc)
2078 #ifdef DWARF2_DEBUGGING_INFO
2081 dw2_asm_output_data (2, val1->v.val_int, NULL);
2086 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
2087 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 4,
2089 fputc ('\n', asm_out_file);
2094 dw2_asm_output_data (4, val1->v.val_int, NULL);
2099 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
2100 targetm.asm_out.output_dwarf_dtprel (asm_out_file, 8,
2102 fputc ('\n', asm_out_file);
2107 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
2108 dw2_asm_output_data (8, val1->v.val_int, NULL);
2115 gcc_assert (val1->val_class == dw_val_class_loc);
2116 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2118 dw2_asm_output_data (2, offset, NULL);
2121 case DW_OP_implicit_value:
2122 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2123 switch (val2->val_class)
2125 case dw_val_class_const:
2126 dw2_asm_output_data (val1->v.val_unsigned, val2->v.val_int, NULL);
2128 case dw_val_class_vec:
2130 unsigned int elt_size = val2->v.val_vec.elt_size;
2131 unsigned int len = val2->v.val_vec.length;
2135 if (elt_size > sizeof (HOST_WIDE_INT))
2140 for (i = 0, p = (unsigned char *) val2->v.val_vec.array;
2143 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
2144 "fp or vector constant word %u", i);
2147 case dw_val_class_const_double:
2149 unsigned HOST_WIDE_INT first, second;
2151 if (WORDS_BIG_ENDIAN)
2153 first = val2->v.val_double.high;
2154 second = val2->v.val_double.low;
2158 first = val2->v.val_double.low;
2159 second = val2->v.val_double.high;
2161 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
2163 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
2167 case dw_val_class_wide_int:
2170 int len = get_full_len (*val2->v.val_wide);
2171 if (WORDS_BIG_ENDIAN)
2172 for (i = len - 1; i >= 0; --i)
2173 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
2174 val2->v.val_wide->elt (i), NULL);
2176 for (i = 0; i < len; ++i)
2177 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
2178 val2->v.val_wide->elt (i), NULL);
2181 case dw_val_class_addr:
2182 gcc_assert (val1->v.val_unsigned == DWARF2_ADDR_SIZE);
2183 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val2->v.val_addr, NULL);
2198 case DW_OP_implicit_value:
2199 /* We currently don't make any attempt to make sure these are
2200 aligned properly like we do for the main unwind info, so
2201 don't support emitting things larger than a byte if we're
2202 only doing unwinding. */
2207 dw2_asm_output_data (1, val1->v.val_int, NULL);
2210 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2213 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2216 dw2_asm_output_data (1, val1->v.val_int, NULL);
2218 case DW_OP_plus_uconst:
2219 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2253 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2257 unsigned r = val1->v.val_unsigned;
2258 if (for_eh_or_skip >= 0)
2259 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2260 gcc_assert (size_of_uleb128 (r)
2261 == size_of_uleb128 (val1->v.val_unsigned));
2262 dw2_asm_output_data_uleb128 (r, NULL);
2266 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
2270 unsigned r = val1->v.val_unsigned;
2271 if (for_eh_or_skip >= 0)
2272 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2273 gcc_assert (size_of_uleb128 (r)
2274 == size_of_uleb128 (val1->v.val_unsigned));
2275 dw2_asm_output_data_uleb128 (r, NULL);
2276 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
2280 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2282 case DW_OP_bit_piece:
2283 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2284 dw2_asm_output_data_uleb128 (val2->v.val_unsigned, NULL);
2286 case DW_OP_deref_size:
2287 case DW_OP_xderef_size:
2288 dw2_asm_output_data (1, val1->v.val_int, NULL);
2294 if (targetm.asm_out.output_dwarf_dtprel)
2296 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
2299 fputc ('\n', asm_out_file);
2306 #ifdef DWARF2_DEBUGGING_INFO
2307 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
2314 case DW_OP_GNU_addr_index:
2316 case DW_OP_GNU_const_index:
2318 gcc_assert (loc->dw_loc_oprnd1.val_entry->index != NO_INDEX_ASSIGNED);
2319 dw2_asm_output_data_uleb128 (loc->dw_loc_oprnd1.val_entry->index,
2320 "(index into .debug_addr)");
2326 unsigned long die_offset
2327 = get_ref_die_offset (val1->v.val_die_ref.die);
2328 /* Make sure the offset has been computed and that we can encode it as
2330 gcc_assert (die_offset > 0
2331 && die_offset <= (loc->dw_loc_opc == DW_OP_call2
2334 dw2_asm_output_data ((loc->dw_loc_opc == DW_OP_call2) ? 2 : 4,
2339 case DW_OP_call_ref:
2340 case DW_OP_GNU_variable_value:
2342 char label[MAX_ARTIFICIAL_LABEL_BYTES
2343 + HOST_BITS_PER_WIDE_INT / 2 + 2];
2344 gcc_assert (val1->val_class == dw_val_class_die_ref);
2345 get_ref_die_offset_label (label, val1->v.val_die_ref.die);
2346 dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
2350 case DW_OP_implicit_pointer:
2351 case DW_OP_GNU_implicit_pointer:
2353 char label[MAX_ARTIFICIAL_LABEL_BYTES
2354 + HOST_BITS_PER_WIDE_INT / 2 + 2];
2355 gcc_assert (val1->val_class == dw_val_class_die_ref);
2356 get_ref_die_offset_label (label, val1->v.val_die_ref.die);
2357 dw2_asm_output_offset (DWARF_REF_SIZE, label, debug_info_section, NULL);
2358 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
2362 case DW_OP_entry_value:
2363 case DW_OP_GNU_entry_value:
2364 dw2_asm_output_data_uleb128 (size_of_locs (val1->v.val_loc), NULL);
2365 output_loc_sequence (val1->v.val_loc, for_eh_or_skip);
2368 case DW_OP_const_type:
2369 case DW_OP_GNU_const_type:
2371 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die), l;
2373 dw2_asm_output_data_uleb128 (o, NULL);
2374 switch (val2->val_class)
2376 case dw_val_class_const:
2377 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2378 dw2_asm_output_data (1, l, NULL);
2379 dw2_asm_output_data (l, val2->v.val_int, NULL);
2381 case dw_val_class_vec:
2383 unsigned int elt_size = val2->v.val_vec.elt_size;
2384 unsigned int len = val2->v.val_vec.length;
2389 dw2_asm_output_data (1, l, NULL);
2390 if (elt_size > sizeof (HOST_WIDE_INT))
2395 for (i = 0, p = (unsigned char *) val2->v.val_vec.array;
2398 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
2399 "fp or vector constant word %u", i);
2402 case dw_val_class_const_double:
2404 unsigned HOST_WIDE_INT first, second;
2405 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2407 dw2_asm_output_data (1, 2 * l, NULL);
2408 if (WORDS_BIG_ENDIAN)
2410 first = val2->v.val_double.high;
2411 second = val2->v.val_double.low;
2415 first = val2->v.val_double.low;
2416 second = val2->v.val_double.high;
2418 dw2_asm_output_data (l, first, NULL);
2419 dw2_asm_output_data (l, second, NULL);
2422 case dw_val_class_wide_int:
2425 int len = get_full_len (*val2->v.val_wide);
2426 l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2428 dw2_asm_output_data (1, len * l, NULL);
2429 if (WORDS_BIG_ENDIAN)
2430 for (i = len - 1; i >= 0; --i)
2431 dw2_asm_output_data (l, val2->v.val_wide->elt (i), NULL);
2433 for (i = 0; i < len; ++i)
2434 dw2_asm_output_data (l, val2->v.val_wide->elt (i), NULL);
2442 case DW_OP_regval_type:
2443 case DW_OP_GNU_regval_type:
2445 unsigned r = val1->v.val_unsigned;
2446 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2448 if (for_eh_or_skip >= 0)
2450 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2451 gcc_assert (size_of_uleb128 (r)
2452 == size_of_uleb128 (val1->v.val_unsigned));
2454 dw2_asm_output_data_uleb128 (r, NULL);
2455 dw2_asm_output_data_uleb128 (o, NULL);
2458 case DW_OP_deref_type:
2459 case DW_OP_GNU_deref_type:
2461 unsigned long o = get_base_type_offset (val2->v.val_die_ref.die);
2463 dw2_asm_output_data (1, val1->v.val_int, NULL);
2464 dw2_asm_output_data_uleb128 (o, NULL);
2468 case DW_OP_reinterpret:
2469 case DW_OP_GNU_convert:
2470 case DW_OP_GNU_reinterpret:
2471 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
2472 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
2475 unsigned long o = get_base_type_offset (val1->v.val_die_ref.die);
2477 dw2_asm_output_data_uleb128 (o, NULL);
2481 case DW_OP_GNU_parameter_ref:
2484 gcc_assert (val1->val_class == dw_val_class_die_ref);
2485 o = get_ref_die_offset (val1->v.val_die_ref.die);
2486 dw2_asm_output_data (4, o, NULL);
2491 /* Other codes have no operands. */
2496 /* Output a sequence of location operations.
2497 The for_eh_or_skip parameter controls whether register numbers are
2498 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2499 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2500 info). This should be suppressed for the cases that have not been converted
2501 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2504 output_loc_sequence (dw_loc_descr_ref loc, int for_eh_or_skip)
2506 for (; loc != NULL; loc = loc->dw_loc_next)
2508 enum dwarf_location_atom opc = loc->dw_loc_opc;
2509 /* Output the opcode. */
2510 if (for_eh_or_skip >= 0
2511 && opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2513 unsigned r = (opc - DW_OP_breg0);
2514 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2515 gcc_assert (r <= 31);
2516 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2518 else if (for_eh_or_skip >= 0
2519 && opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2521 unsigned r = (opc - DW_OP_reg0);
2522 r = DWARF2_FRAME_REG_OUT (r, for_eh_or_skip);
2523 gcc_assert (r <= 31);
2524 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2527 dw2_asm_output_data (1, opc,
2528 "%s", dwarf_stack_op_name (opc));
2530 /* Output the operand(s) (if any). */
2531 output_loc_operands (loc, for_eh_or_skip);
2535 /* Output location description stack opcode's operands (if any).
2536 The output is single bytes on a line, suitable for .cfi_escape. */
2539 output_loc_operands_raw (dw_loc_descr_ref loc)
2541 dw_val_ref val1 = &loc->dw_loc_oprnd1;
2542 dw_val_ref val2 = &loc->dw_loc_oprnd2;
2544 switch (loc->dw_loc_opc)
2547 case DW_OP_GNU_addr_index:
2549 case DW_OP_GNU_const_index:
2551 case DW_OP_implicit_value:
2552 /* We cannot output addresses in .cfi_escape, only bytes. */
2558 case DW_OP_deref_size:
2559 case DW_OP_xderef_size:
2560 fputc (',', asm_out_file);
2561 dw2_asm_output_data_raw (1, val1->v.val_int);
2566 fputc (',', asm_out_file);
2567 dw2_asm_output_data_raw (2, val1->v.val_int);
2572 fputc (',', asm_out_file);
2573 dw2_asm_output_data_raw (4, val1->v.val_int);
2578 gcc_assert (HOST_BITS_PER_WIDE_INT >= 64);
2579 fputc (',', asm_out_file);
2580 dw2_asm_output_data_raw (8, val1->v.val_int);
2588 gcc_assert (val1->val_class == dw_val_class_loc);
2589 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
2591 fputc (',', asm_out_file);
2592 dw2_asm_output_data_raw (2, offset);
2598 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2599 gcc_assert (size_of_uleb128 (r)
2600 == size_of_uleb128 (val1->v.val_unsigned));
2601 fputc (',', asm_out_file);
2602 dw2_asm_output_data_uleb128_raw (r);
2607 case DW_OP_plus_uconst:
2609 fputc (',', asm_out_file);
2610 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2613 case DW_OP_bit_piece:
2614 fputc (',', asm_out_file);
2615 dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned);
2616 dw2_asm_output_data_uleb128_raw (val2->v.val_unsigned);
2653 fputc (',', asm_out_file);
2654 dw2_asm_output_data_sleb128_raw (val1->v.val_int);
2659 unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1);
2660 gcc_assert (size_of_uleb128 (r)
2661 == size_of_uleb128 (val1->v.val_unsigned));
2662 fputc (',', asm_out_file);
2663 dw2_asm_output_data_uleb128_raw (r);
2664 fputc (',', asm_out_file);
2665 dw2_asm_output_data_sleb128_raw (val2->v.val_int);
2669 case DW_OP_implicit_pointer:
2670 case DW_OP_entry_value:
2671 case DW_OP_const_type:
2672 case DW_OP_regval_type:
2673 case DW_OP_deref_type:
2675 case DW_OP_reinterpret:
2676 case DW_OP_GNU_implicit_pointer:
2677 case DW_OP_GNU_entry_value:
2678 case DW_OP_GNU_const_type:
2679 case DW_OP_GNU_regval_type:
2680 case DW_OP_GNU_deref_type:
2681 case DW_OP_GNU_convert:
2682 case DW_OP_GNU_reinterpret:
2683 case DW_OP_GNU_parameter_ref:
2688 /* Other codes have no operands. */
2694 output_loc_sequence_raw (dw_loc_descr_ref loc)
2698 enum dwarf_location_atom opc = loc->dw_loc_opc;
2699 /* Output the opcode. */
2700 if (opc >= DW_OP_breg0 && opc <= DW_OP_breg31)
2702 unsigned r = (opc - DW_OP_breg0);
2703 r = DWARF2_FRAME_REG_OUT (r, 1);
2704 gcc_assert (r <= 31);
2705 opc = (enum dwarf_location_atom) (DW_OP_breg0 + r);
2707 else if (opc >= DW_OP_reg0 && opc <= DW_OP_reg31)
2709 unsigned r = (opc - DW_OP_reg0);
2710 r = DWARF2_FRAME_REG_OUT (r, 1);
2711 gcc_assert (r <= 31);
2712 opc = (enum dwarf_location_atom) (DW_OP_reg0 + r);
2714 /* Output the opcode. */
2715 fprintf (asm_out_file, "%#x", opc);
2716 output_loc_operands_raw (loc);
2718 if (!loc->dw_loc_next)
2720 loc = loc->dw_loc_next;
2722 fputc (',', asm_out_file);
2726 /* This function builds a dwarf location descriptor sequence from a
2727 dw_cfa_location, adding the given OFFSET to the result of the
2730 struct dw_loc_descr_node *
2731 build_cfa_loc (dw_cfa_location *cfa, poly_int64 offset)
2733 struct dw_loc_descr_node *head, *tmp;
2735 offset += cfa->offset;
2739 head = new_reg_loc_descr (cfa->reg, cfa->base_offset);
2740 head->dw_loc_oprnd1.val_class = dw_val_class_const;
2741 head->dw_loc_oprnd1.val_entry = NULL;
2742 tmp = new_loc_descr (DW_OP_deref, 0, 0);
2743 add_loc_descr (&head, tmp);
2744 loc_descr_plus_const (&head, offset);
2747 head = new_reg_loc_descr (cfa->reg, offset);
2752 /* This function builds a dwarf location descriptor sequence for
2753 the address at OFFSET from the CFA when stack is aligned to
2756 struct dw_loc_descr_node *
2757 build_cfa_aligned_loc (dw_cfa_location *cfa,
2758 poly_int64 offset, HOST_WIDE_INT alignment)
2760 struct dw_loc_descr_node *head;
2761 unsigned int dwarf_fp
2762 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
2764 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2765 if (cfa->reg == HARD_FRAME_POINTER_REGNUM && cfa->indirect == 0)
2767 head = new_reg_loc_descr (dwarf_fp, 0);
2768 add_loc_descr (&head, int_loc_descriptor (alignment));
2769 add_loc_descr (&head, new_loc_descr (DW_OP_and, 0, 0));
2770 loc_descr_plus_const (&head, offset);
2773 head = new_reg_loc_descr (dwarf_fp, offset);
2777 /* And now, the support for symbolic debugging information. */
2779 /* .debug_str support. */
2781 static void dwarf2out_init (const char *);
2782 static void dwarf2out_finish (const char *);
2783 static void dwarf2out_early_finish (const char *);
2784 static void dwarf2out_assembly_start (void);
2785 static void dwarf2out_define (unsigned int, const char *);
2786 static void dwarf2out_undef (unsigned int, const char *);
2787 static void dwarf2out_start_source_file (unsigned, const char *);
2788 static void dwarf2out_end_source_file (unsigned);
2789 static void dwarf2out_function_decl (tree);
2790 static void dwarf2out_begin_block (unsigned, unsigned);
2791 static void dwarf2out_end_block (unsigned, unsigned);
2792 static bool dwarf2out_ignore_block (const_tree);
2793 static void dwarf2out_early_global_decl (tree);
2794 static void dwarf2out_late_global_decl (tree);
2795 static void dwarf2out_type_decl (tree, int);
2796 static void dwarf2out_imported_module_or_decl (tree, tree, tree, bool, bool);
2797 static void dwarf2out_imported_module_or_decl_1 (tree, tree, tree,
2799 static void dwarf2out_abstract_function (tree);
2800 static void dwarf2out_var_location (rtx_insn *);
2801 static void dwarf2out_inline_entry (tree);
2802 static void dwarf2out_size_function (tree);
2803 static void dwarf2out_begin_function (tree);
2804 static void dwarf2out_end_function (unsigned int);
2805 static void dwarf2out_register_main_translation_unit (tree unit);
2806 static void dwarf2out_set_name (tree, tree);
2807 static void dwarf2out_register_external_die (tree decl, const char *sym,
2808 unsigned HOST_WIDE_INT off);
2809 static bool dwarf2out_die_ref_for_decl (tree decl, const char **sym,
2810 unsigned HOST_WIDE_INT *off);
2812 /* The debug hooks structure. */
2814 const struct gcc_debug_hooks dwarf2_debug_hooks =
2818 dwarf2out_early_finish,
2819 dwarf2out_assembly_start,
2822 dwarf2out_start_source_file,
2823 dwarf2out_end_source_file,
2824 dwarf2out_begin_block,
2825 dwarf2out_end_block,
2826 dwarf2out_ignore_block,
2827 dwarf2out_source_line,
2828 dwarf2out_begin_prologue,
2829 #if VMS_DEBUGGING_INFO
2830 dwarf2out_vms_end_prologue,
2831 dwarf2out_vms_begin_epilogue,
2833 debug_nothing_int_charstar,
2834 debug_nothing_int_charstar,
2836 dwarf2out_end_epilogue,
2837 dwarf2out_begin_function,
2838 dwarf2out_end_function, /* end_function */
2839 dwarf2out_register_main_translation_unit,
2840 dwarf2out_function_decl, /* function_decl */
2841 dwarf2out_early_global_decl,
2842 dwarf2out_late_global_decl,
2843 dwarf2out_type_decl, /* type_decl */
2844 dwarf2out_imported_module_or_decl,
2845 dwarf2out_die_ref_for_decl,
2846 dwarf2out_register_external_die,
2847 debug_nothing_tree, /* deferred_inline_function */
2848 /* The DWARF 2 backend tries to reduce debugging bloat by not
2849 emitting the abstract description of inline functions until
2850 something tries to reference them. */
2851 dwarf2out_abstract_function, /* outlining_inline_function */
2852 debug_nothing_rtx_code_label, /* label */
2853 debug_nothing_int, /* handle_pch */
2854 dwarf2out_var_location,
2855 dwarf2out_inline_entry, /* inline_entry */
2856 dwarf2out_size_function, /* size_function */
2857 dwarf2out_switch_text_section,
2859 1, /* start_end_main_source_file */
2860 TYPE_SYMTAB_IS_DIE /* tree_type_symtab_field */
2863 const struct gcc_debug_hooks dwarf2_lineno_debug_hooks =
2866 debug_nothing_charstar,
2867 debug_nothing_charstar,
2868 dwarf2out_assembly_start,
2869 debug_nothing_int_charstar,
2870 debug_nothing_int_charstar,
2871 debug_nothing_int_charstar,
2873 debug_nothing_int_int, /* begin_block */
2874 debug_nothing_int_int, /* end_block */
2875 debug_true_const_tree, /* ignore_block */
2876 dwarf2out_source_line, /* source_line */
2877 debug_nothing_int_int_charstar, /* begin_prologue */
2878 debug_nothing_int_charstar, /* end_prologue */
2879 debug_nothing_int_charstar, /* begin_epilogue */
2880 debug_nothing_int_charstar, /* end_epilogue */
2881 debug_nothing_tree, /* begin_function */
2882 debug_nothing_int, /* end_function */
2883 debug_nothing_tree, /* register_main_translation_unit */
2884 debug_nothing_tree, /* function_decl */
2885 debug_nothing_tree, /* early_global_decl */
2886 debug_nothing_tree, /* late_global_decl */
2887 debug_nothing_tree_int, /* type_decl */
2888 debug_nothing_tree_tree_tree_bool_bool,/* imported_module_or_decl */
2889 debug_false_tree_charstarstar_uhwistar,/* die_ref_for_decl */
2890 debug_nothing_tree_charstar_uhwi, /* register_external_die */
2891 debug_nothing_tree, /* deferred_inline_function */
2892 debug_nothing_tree, /* outlining_inline_function */
2893 debug_nothing_rtx_code_label, /* label */
2894 debug_nothing_int, /* handle_pch */
2895 debug_nothing_rtx_insn, /* var_location */
2896 debug_nothing_tree, /* inline_entry */
2897 debug_nothing_tree, /* size_function */
2898 debug_nothing_void, /* switch_text_section */
2899 debug_nothing_tree_tree, /* set_name */
2900 0, /* start_end_main_source_file */
2901 TYPE_SYMTAB_IS_ADDRESS /* tree_type_symtab_field */
2904 /* NOTE: In the comments in this file, many references are made to
2905 "Debugging Information Entries". This term is abbreviated as `DIE'
2906 throughout the remainder of this file. */
2908 /* An internal representation of the DWARF output is built, and then
2909 walked to generate the DWARF debugging info. The walk of the internal
2910 representation is done after the entire program has been compiled.
2911 The types below are used to describe the internal representation. */
2913 /* Whether to put type DIEs into their own section .debug_types instead
2914 of making them part of the .debug_info section. Only supported for
2915 Dwarf V4 or higher and the user didn't disable them through
2916 -fno-debug-types-section. It is more efficient to put them in a
2917 separate comdat sections since the linker will then be able to
2918 remove duplicates. But not all tools support .debug_types sections
2919 yet. For Dwarf V5 or higher .debug_types doesn't exist any more,
2920 it is DW_UT_type unit type in .debug_info section. For late LTO
2921 debug there should be almost no types emitted so avoid enabling
2922 -fdebug-types-section there. */
2924 #define use_debug_types (dwarf_version >= 4 \
2925 && flag_debug_types_section \
2928 /* Various DIE's use offsets relative to the beginning of the
2929 .debug_info section to refer to each other. */
2931 typedef long int dw_offset;
2933 struct comdat_type_node;
2935 /* The entries in the line_info table more-or-less mirror the opcodes
2936 that are used in the real dwarf line table. Arrays of these entries
2937 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2940 enum dw_line_info_opcode {
2941 /* Emit DW_LNE_set_address; the operand is the label index. */
2944 /* Emit a row to the matrix with the given line. This may be done
2945 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2949 /* Emit a DW_LNS_set_file. */
2952 /* Emit a DW_LNS_set_column. */
2955 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2958 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2959 LI_set_prologue_end,
2960 LI_set_epilogue_begin,
2962 /* Emit a DW_LNE_set_discriminator. */
2963 LI_set_discriminator,
2965 /* Output a Fixed Advance PC; the target PC is the label index; the
2966 base PC is the previous LI_adv_address or LI_set_address entry.
2967 We only use this when emitting debug views without assembler
2968 support, at explicit user request. Ideally, we should only use
2969 it when the offset might be zero but we can't tell: it's the only
2970 way to maybe change the PC without resetting the view number. */
2974 typedef struct GTY(()) dw_line_info_struct {
2975 enum dw_line_info_opcode opcode;
2977 } dw_line_info_entry;
2980 struct GTY(()) dw_line_info_table {
2981 /* The label that marks the end of this section. */
2982 const char *end_label;
2984 /* The values for the last row of the matrix, as collected in the table.
2985 These are used to minimize the changes to the next row. */
2986 unsigned int file_num;
2987 unsigned int line_num;
2988 unsigned int column_num;
2993 /* This denotes the NEXT view number.
2995 If it is 0, it is known that the NEXT view will be the first view
2998 If it is -1, we're forcing the view number to be reset, e.g. at a
3001 The meaning of other nonzero values depends on whether we're
3002 computing views internally or leaving it for the assembler to do
3003 so. If we're emitting them internally, view denotes the view
3004 number since the last known advance of PC. If we're leaving it
3005 for the assembler, it denotes the LVU label number that we're
3006 going to ask the assembler to assign. */
3009 /* This counts the number of symbolic views emitted in this table
3010 since the latest view reset. Its max value, over all tables,
3011 sets symview_upper_bound. */
3012 var_loc_view symviews_since_reset;
3014 #define FORCE_RESET_NEXT_VIEW(x) ((x) = (var_loc_view)-1)
3015 #define RESET_NEXT_VIEW(x) ((x) = (var_loc_view)0)
3016 #define FORCE_RESETTING_VIEW_P(x) ((x) == (var_loc_view)-1)
3017 #define RESETTING_VIEW_P(x) ((x) == (var_loc_view)0 || FORCE_RESETTING_VIEW_P (x))
3019 vec<dw_line_info_entry, va_gc> *entries;
3022 /* This is an upper bound for view numbers that the assembler may
3023 assign to symbolic views output in this translation. It is used to
3024 decide how big a field to use to represent view numbers in
3025 symview-classed attributes. */
3027 static var_loc_view symview_upper_bound;
3029 /* If we're keep track of location views and their reset points, and
3030 INSN is a reset point (i.e., it necessarily advances the PC), mark
3031 the next view in TABLE as reset. */
3034 maybe_reset_location_view (rtx_insn *insn, dw_line_info_table *table)
3036 if (!debug_internal_reset_location_views)
3039 /* Maybe turn (part of?) this test into a default target hook. */
3042 if (targetm.reset_location_view)
3043 reset = targetm.reset_location_view (insn);
3047 else if (JUMP_TABLE_DATA_P (insn))
3049 else if (GET_CODE (insn) == USE
3050 || GET_CODE (insn) == CLOBBER
3051 || GET_CODE (insn) == ASM_INPUT
3052 || asm_noperands (insn) >= 0)
3054 else if (get_attr_min_length (insn) > 0)
3057 if (reset > 0 && !RESETTING_VIEW_P (table->view))
3058 RESET_NEXT_VIEW (table->view);
3061 /* Each DIE attribute has a field specifying the attribute kind,
3062 a link to the next attribute in the chain, and an attribute value.
3063 Attributes are typically linked below the DIE they modify. */
3065 typedef struct GTY(()) dw_attr_struct {
3066 enum dwarf_attribute dw_attr;
3067 dw_val_node dw_attr_val;
3072 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
3073 The children of each node form a circular list linked by
3074 die_sib. die_child points to the node *before* the "first" child node. */
3076 typedef struct GTY((chain_circular ("%h.die_sib"), for_user)) die_struct {
3077 union die_symbol_or_type_node
3079 const char * GTY ((tag ("0"))) die_symbol;
3080 comdat_type_node *GTY ((tag ("1"))) die_type_node;
3082 GTY ((desc ("%0.comdat_type_p"))) die_id;
3083 vec<dw_attr_node, va_gc> *die_attr;
3084 dw_die_ref die_parent;
3085 dw_die_ref die_child;
3087 dw_die_ref die_definition; /* ref from a specification to its definition */
3088 dw_offset die_offset;
3089 unsigned long die_abbrev;
3091 unsigned int decl_id;
3092 enum dwarf_tag die_tag;
3093 /* Die is used and must not be pruned as unused. */
3094 BOOL_BITFIELD die_perennial_p : 1;
3095 BOOL_BITFIELD comdat_type_p : 1; /* DIE has a type signature */
3096 /* For an external ref to die_symbol if die_offset contains an extra
3097 offset to that symbol. */
3098 BOOL_BITFIELD with_offset : 1;
3099 /* Whether this DIE was removed from the DIE tree, for example via
3100 prune_unused_types. We don't consider those present from the
3101 DIE lookup routines. */
3102 BOOL_BITFIELD removed : 1;
3103 /* Lots of spare bits. */
3107 /* Set to TRUE while dwarf2out_early_global_decl is running. */
3108 static bool early_dwarf;
3109 static bool early_dwarf_finished;
3110 class set_early_dwarf {
3113 set_early_dwarf () : saved(early_dwarf)
3115 gcc_assert (! early_dwarf_finished);
3118 ~set_early_dwarf () { early_dwarf = saved; }
3121 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
3122 #define FOR_EACH_CHILD(die, c, expr) do { \
3123 c = die->die_child; \
3127 } while (c != die->die_child); \
3130 /* The pubname structure */
3132 typedef struct GTY(()) pubname_struct {
3139 struct GTY(()) dw_ranges {
3141 /* If this is positive, it's a block number, otherwise it's a
3142 bitwise-negated index into dw_ranges_by_label. */
3144 /* Index for the range list for DW_FORM_rnglistx. */
3145 unsigned int idx : 31;
3146 /* True if this range might be possibly in a different section
3147 from previous entry. */
3148 unsigned int maybe_new_sec : 1;
3151 /* A structure to hold a macinfo entry. */
3153 typedef struct GTY(()) macinfo_struct {
3155 unsigned HOST_WIDE_INT lineno;
3161 struct GTY(()) dw_ranges_by_label {
3166 /* The comdat type node structure. */
3167 struct GTY(()) comdat_type_node
3169 dw_die_ref root_die;
3170 dw_die_ref type_die;
3171 dw_die_ref skeleton_die;
3172 char signature[DWARF_TYPE_SIGNATURE_SIZE];
3173 comdat_type_node *next;
3176 /* A list of DIEs for which we can't determine ancestry (parent_die
3177 field) just yet. Later in dwarf2out_finish we will fill in the
3179 typedef struct GTY(()) limbo_die_struct {
3181 /* The tree for which this DIE was created. We use this to
3182 determine ancestry later. */
3184 struct limbo_die_struct *next;
3188 typedef struct skeleton_chain_struct
3192 struct skeleton_chain_struct *parent;
3194 skeleton_chain_node;
3196 /* Define a macro which returns nonzero for a TYPE_DECL which was
3197 implicitly generated for a type.
3199 Note that, unlike the C front-end (which generates a NULL named
3200 TYPE_DECL node for each complete tagged type, each array type,
3201 and each function type node created) the C++ front-end generates
3202 a _named_ TYPE_DECL node for each tagged type node created.
3203 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3204 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
3205 front-end, but for each type, tagged or not. */
3207 #define TYPE_DECL_IS_STUB(decl) \
3208 (DECL_NAME (decl) == NULL_TREE \
3209 || (DECL_ARTIFICIAL (decl) \
3210 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3211 /* This is necessary for stub decls that \
3212 appear in nested inline functions. */ \
3213 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3214 && (decl_ultimate_origin (decl) \
3215 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3217 /* Information concerning the compilation unit's programming
3218 language, and compiler version. */
3220 /* Fixed size portion of the DWARF compilation unit header. */
3221 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3222 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE \
3223 + (dwarf_version >= 5 ? 4 : 3))
3225 /* Fixed size portion of the DWARF comdat type unit header. */
3226 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
3227 (DWARF_COMPILE_UNIT_HEADER_SIZE \
3228 + DWARF_TYPE_SIGNATURE_SIZE + DWARF_OFFSET_SIZE)
3230 /* Fixed size portion of the DWARF skeleton compilation unit header. */
3231 #define DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE \
3232 (DWARF_COMPILE_UNIT_HEADER_SIZE + (dwarf_version >= 5 ? 8 : 0))
3234 /* Fixed size portion of public names info. */
3235 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3237 /* Fixed size portion of the address range info. */
3238 #define DWARF_ARANGES_HEADER_SIZE \
3239 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3240 DWARF2_ADDR_SIZE * 2) \
3241 - DWARF_INITIAL_LENGTH_SIZE)
3243 /* Size of padding portion in the address range info. It must be
3244 aligned to twice the pointer size. */
3245 #define DWARF_ARANGES_PAD_SIZE \
3246 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3247 DWARF2_ADDR_SIZE * 2) \
3248 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3250 /* Use assembler line directives if available. */
3251 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3252 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3253 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3255 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3259 /* Use assembler views in line directives if available. */
3260 #ifndef DWARF2_ASM_VIEW_DEBUG_INFO
3261 #ifdef HAVE_AS_DWARF2_DEBUG_VIEW
3262 #define DWARF2_ASM_VIEW_DEBUG_INFO 1
3264 #define DWARF2_ASM_VIEW_DEBUG_INFO 0
3268 /* Return true if GCC configure detected assembler support for .loc. */
3271 dwarf2out_default_as_loc_support (void)
3273 return DWARF2_ASM_LINE_DEBUG_INFO;
3274 #if (GCC_VERSION >= 3000)
3275 # undef DWARF2_ASM_LINE_DEBUG_INFO
3276 # pragma GCC poison DWARF2_ASM_LINE_DEBUG_INFO
3280 /* Return true if GCC configure detected assembler support for views
3281 in .loc directives. */
3284 dwarf2out_default_as_locview_support (void)
3286 return DWARF2_ASM_VIEW_DEBUG_INFO;
3287 #if (GCC_VERSION >= 3000)
3288 # undef DWARF2_ASM_VIEW_DEBUG_INFO
3289 # pragma GCC poison DWARF2_ASM_VIEW_DEBUG_INFO
3293 /* A bit is set in ZERO_VIEW_P if we are using the assembler-supported
3294 view computation, and it refers to a view identifier for which we
3295 will not emit a label because it is known to map to a view number
3296 zero. We won't allocate the bitmap if we're not using assembler
3297 support for location views, but we have to make the variable
3298 visible for GGC and for code that will be optimized out for lack of
3299 support but that's still parsed and compiled. We could abstract it
3300 out with macros, but it's not worth it. */
3301 static GTY(()) bitmap zero_view_p;
3303 /* Evaluate to TRUE iff N is known to identify the first location view
3304 at its PC. When not using assembler location view computation,
3305 that must be view number zero. Otherwise, ZERO_VIEW_P is allocated
3306 and views label numbers recorded in it are the ones known to be
3308 #define ZERO_VIEW_P(N) ((N) == (var_loc_view)0 \
3309 || (N) == (var_loc_view)-1 \
3311 && bitmap_bit_p (zero_view_p, (N))))
3313 /* Return true iff we're to emit .loc directives for the assembler to
3314 generate line number sections.
3316 When we're not emitting views, all we need from the assembler is
3317 support for .loc directives.
3319 If we are emitting views, we can only use the assembler's .loc
3320 support if it also supports views.
3322 When the compiler is emitting the line number programs and
3323 computing view numbers itself, it resets view numbers at known PC
3324 changes and counts from that, and then it emits view numbers as
3325 literal constants in locviewlists. There are cases in which the
3326 compiler is not sure about PC changes, e.g. when extra alignment is
3327 requested for a label. In these cases, the compiler may not reset
3328 the view counter, and the potential PC advance in the line number
3329 program will use an opcode that does not reset the view counter
3330 even if the PC actually changes, so that compiler and debug info
3331 consumer can keep view numbers in sync.
3333 When the compiler defers view computation to the assembler, it
3334 emits symbolic view numbers in locviewlists, with the exception of
3335 views known to be zero (forced resets, or reset after
3336 compiler-visible PC changes): instead of emitting symbols for
3337 these, we emit literal zero and assert the assembler agrees with
3338 the compiler's assessment. We could use symbolic views everywhere,
3339 instead of special-casing zero views, but then we'd be unable to
3340 optimize out locviewlists that contain only zeros. */
3343 output_asm_line_debug_info (void)
3345 return (dwarf2out_as_loc_support
3346 && (dwarf2out_as_locview_support
3347 || !debug_variable_location_views));
3350 /* Minimum line offset in a special line info. opcode.
3351 This value was chosen to give a reasonable range of values. */
3352 #define DWARF_LINE_BASE -10
3354 /* First special line opcode - leave room for the standard opcodes. */
3355 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
3357 /* Range of line offsets in a special line info. opcode. */
3358 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3360 /* Flag that indicates the initial value of the is_stmt_start flag.
3361 In the present implementation, we do not mark any lines as
3362 the beginning of a source statement, because that information
3363 is not made available by the GCC front-end. */
3364 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3366 /* Maximum number of operations per instruction bundle. */
3367 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
3368 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
3371 /* This location is used by calc_die_sizes() to keep track
3372 the offset of each DIE within the .debug_info section. */
3373 static unsigned long next_die_offset;
3375 /* Record the root of the DIE's built for the current compilation unit. */
3376 static GTY(()) dw_die_ref single_comp_unit_die;
3378 /* A list of type DIEs that have been separated into comdat sections. */
3379 static GTY(()) comdat_type_node *comdat_type_list;
3381 /* A list of CU DIEs that have been separated. */
3382 static GTY(()) limbo_die_node *cu_die_list;
3384 /* A list of DIEs with a NULL parent waiting to be relocated. */
3385 static GTY(()) limbo_die_node *limbo_die_list;
3387 /* A list of DIEs for which we may have to generate
3388 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
3389 static GTY(()) limbo_die_node *deferred_asm_name;
3391 struct dwarf_file_hasher : ggc_ptr_hash<dwarf_file_data>
3393 typedef const char *compare_type;
3395 static hashval_t hash (dwarf_file_data *);
3396 static bool equal (dwarf_file_data *, const char *);
3399 /* Filenames referenced by this compilation unit. */
3400 static GTY(()) hash_table<dwarf_file_hasher> *file_table;
3402 struct decl_die_hasher : ggc_ptr_hash<die_node>
3404 typedef tree compare_type;
3406 static hashval_t hash (die_node *);
3407 static bool equal (die_node *, tree);
3409 /* A hash table of references to DIE's that describe declarations.
3410 The key is a DECL_UID() which is a unique number identifying each decl. */
3411 static GTY (()) hash_table<decl_die_hasher> *decl_die_table;
3413 struct GTY ((for_user)) variable_value_struct {
3414 unsigned int decl_id;
3415 vec<dw_die_ref, va_gc> *dies;
3418 struct variable_value_hasher : ggc_ptr_hash<variable_value_struct>
3420 typedef tree compare_type;
3422 static hashval_t hash (variable_value_struct *);
3423 static bool equal (variable_value_struct *, tree);
3425 /* A hash table of DIEs that contain DW_OP_GNU_variable_value with
3426 dw_val_class_decl_ref class, indexed by FUNCTION_DECLs which is
3427 DECL_CONTEXT of the referenced VAR_DECLs. */
3428 static GTY (()) hash_table<variable_value_hasher> *variable_value_hash;
3430 struct block_die_hasher : ggc_ptr_hash<die_struct>
3432 static hashval_t hash (die_struct *);
3433 static bool equal (die_struct *, die_struct *);
3436 /* A hash table of references to DIE's that describe COMMON blocks.
3437 The key is DECL_UID() ^ die_parent. */
3438 static GTY (()) hash_table<block_die_hasher> *common_block_die_table;
3440 typedef struct GTY(()) die_arg_entry_struct {
3446 /* Node of the variable location list. */
3447 struct GTY ((chain_next ("%h.next"))) var_loc_node {
3448 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
3449 EXPR_LIST chain. For small bitsizes, bitsize is encoded
3450 in mode of the EXPR_LIST node and first EXPR_LIST operand
3451 is either NOTE_INSN_VAR_LOCATION for a piece with a known
3452 location or NULL for padding. For larger bitsizes,
3453 mode is 0 and first operand is a CONCAT with bitsize
3454 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
3455 NULL as second operand. */
3457 const char * GTY (()) label;
3458 struct var_loc_node * GTY (()) next;
3462 /* Variable location list. */
3463 struct GTY ((for_user)) var_loc_list_def {
3464 struct var_loc_node * GTY (()) first;
3466 /* Pointer to the last but one or last element of the
3467 chained list. If the list is empty, both first and
3468 last are NULL, if the list contains just one node
3469 or the last node certainly is not redundant, it points
3470 to the last node, otherwise points to the last but one.
3471 Do not mark it for GC because it is marked through the chain. */
3472 struct var_loc_node * GTY ((skip ("%h"))) last;
3474 /* Pointer to the last element before section switch,
3475 if NULL, either sections weren't switched or first
3476 is after section switch. */
3477 struct var_loc_node * GTY ((skip ("%h"))) last_before_switch;
3479 /* DECL_UID of the variable decl. */
3480 unsigned int decl_id;
3482 typedef struct var_loc_list_def var_loc_list;
3484 /* Call argument location list. */
3485 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node {
3486 rtx GTY (()) call_arg_loc_note;
3487 const char * GTY (()) label;
3488 tree GTY (()) block;
3490 rtx GTY (()) symbol_ref;
3491 struct call_arg_loc_node * GTY (()) next;
3495 struct decl_loc_hasher : ggc_ptr_hash<var_loc_list>
3497 typedef const_tree compare_type;
3499 static hashval_t hash (var_loc_list *);
3500 static bool equal (var_loc_list *, const_tree);
3503 /* Table of decl location linked lists. */
3504 static GTY (()) hash_table<decl_loc_hasher> *decl_loc_table;
3506 /* Head and tail of call_arg_loc chain. */
3507 static GTY (()) struct call_arg_loc_node *call_arg_locations;
3508 static struct call_arg_loc_node *call_arg_loc_last;
3510 /* Number of call sites in the current function. */
3511 static int call_site_count = -1;
3512 /* Number of tail call sites in the current function. */
3513 static int tail_call_site_count = -1;
3515 /* A cached location list. */
3516 struct GTY ((for_user)) cached_dw_loc_list_def {
3517 /* The DECL_UID of the decl that this entry describes. */
3518 unsigned int decl_id;
3520 /* The cached location list. */
3521 dw_loc_list_ref loc_list;
3523 typedef struct cached_dw_loc_list_def cached_dw_loc_list;
3525 struct dw_loc_list_hasher : ggc_ptr_hash<cached_dw_loc_list>
3528 typedef const_tree compare_type;
3530 static hashval_t hash (cached_dw_loc_list *);
3531 static bool equal (cached_dw_loc_list *, const_tree);
3534 /* Table of cached location lists. */
3535 static GTY (()) hash_table<dw_loc_list_hasher> *cached_dw_loc_list_table;
3537 /* A vector of references to DIE's that are uniquely identified by their tag,
3538 presence/absence of children DIE's, and list of attribute/value pairs. */
3539 static GTY(()) vec<dw_die_ref, va_gc> *abbrev_die_table;
3541 /* A hash map to remember the stack usage for DWARF procedures. The value
3542 stored is the stack size difference between before the DWARF procedure
3543 invokation and after it returned. In other words, for a DWARF procedure
3544 that consumes N stack slots and that pushes M ones, this stores M - N. */
3545 static hash_map<dw_die_ref, int> *dwarf_proc_stack_usage_map;
3547 /* A global counter for generating labels for line number data. */
3548 static unsigned int line_info_label_num;
3550 /* The current table to which we should emit line number information
3551 for the current function. This will be set up at the beginning of
3552 assembly for the function. */
3553 static GTY(()) dw_line_info_table *cur_line_info_table;
3555 /* The two default tables of line number info. */
3556 static GTY(()) dw_line_info_table *text_section_line_info;
3557 static GTY(()) dw_line_info_table *cold_text_section_line_info;
3559 /* The set of all non-default tables of line number info. */
3560 static GTY(()) vec<dw_line_info_table *, va_gc> *separate_line_info;
3562 /* A flag to tell pubnames/types export if there is an info section to
3564 static bool info_section_emitted;
3566 /* A pointer to the base of a table that contains a list of publicly
3567 accessible names. */
3568 static GTY (()) vec<pubname_entry, va_gc> *pubname_table;
3570 /* A pointer to the base of a table that contains a list of publicly
3571 accessible types. */
3572 static GTY (()) vec<pubname_entry, va_gc> *pubtype_table;
3574 /* A pointer to the base of a table that contains a list of macro
3575 defines/undefines (and file start/end markers). */
3576 static GTY (()) vec<macinfo_entry, va_gc> *macinfo_table;
3578 /* True if .debug_macinfo or .debug_macros section is going to be
3580 #define have_macinfo \
3581 ((!XCOFF_DEBUGGING_INFO || HAVE_XCOFF_DWARF_EXTRAS) \
3582 && debug_info_level >= DINFO_LEVEL_VERBOSE \
3583 && !macinfo_table->is_empty ())
3585 /* Vector of dies for which we should generate .debug_ranges info. */
3586 static GTY (()) vec<dw_ranges, va_gc> *ranges_table;
3588 /* Vector of pairs of labels referenced in ranges_table. */
3589 static GTY (()) vec<dw_ranges_by_label, va_gc> *ranges_by_label;
3591 /* Whether we have location lists that need outputting */
3592 static GTY(()) bool have_location_lists;
3594 /* Unique label counter. */
3595 static GTY(()) unsigned int loclabel_num;
3597 /* Unique label counter for point-of-call tables. */
3598 static GTY(()) unsigned int poc_label_num;
3600 /* The last file entry emitted by maybe_emit_file(). */
3601 static GTY(()) struct dwarf_file_data * last_emitted_file;
3603 /* Number of internal labels generated by gen_internal_sym(). */
3604 static GTY(()) int label_num;
3606 static GTY(()) vec<die_arg_entry, va_gc> *tmpl_value_parm_die_table;
3608 /* Instances of generic types for which we need to generate debug
3609 info that describe their generic parameters and arguments. That
3610 generation needs to happen once all types are properly laid out so
3611 we do it at the end of compilation. */
3612 static GTY(()) vec<tree, va_gc> *generic_type_instances;
3614 /* Offset from the "steady-state frame pointer" to the frame base,
3615 within the current function. */
3616 static poly_int64 frame_pointer_fb_offset;
3617 static bool frame_pointer_fb_offset_valid;
3619 static vec<dw_die_ref> base_types;
3621 /* Flags to represent a set of attribute classes for attributes that represent
3622 a scalar value (bounds, pointers, ...). */
3625 dw_scalar_form_constant = 0x01,
3626 dw_scalar_form_exprloc = 0x02,
3627 dw_scalar_form_reference = 0x04
3630 /* Forward declarations for functions defined in this file. */
3632 static int is_pseudo_reg (const_rtx);
3633 static tree type_main_variant (tree);
3634 static int is_tagged_type (const_tree);
3635 static const char *dwarf_tag_name (unsigned);
3636 static const char *dwarf_attr_name (unsigned);
3637 static const char *dwarf_form_name (unsigned);
3638 static tree decl_ultimate_origin (const_tree);
3639 static tree decl_class_context (tree);
3640 static void add_dwarf_attr (dw_die_ref, dw_attr_node *);
3641 static inline enum dw_val_class AT_class (dw_attr_node *);
3642 static inline unsigned int AT_index (dw_attr_node *);
3643 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3644 static inline unsigned AT_flag (dw_attr_node *);
3645 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3646 static inline HOST_WIDE_INT AT_int (dw_attr_node *);
3647 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3648 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_node *);
3649 static void add_AT_double (dw_die_ref, enum dwarf_attribute,
3650 HOST_WIDE_INT, unsigned HOST_WIDE_INT);
3651 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
3652 unsigned int, unsigned char *);
3653 static void add_AT_data8 (dw_die_ref, enum dwarf_attribute, unsigned char *);
3654 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3655 static inline const char *AT_string (dw_attr_node *);
3656 static enum dwarf_form AT_string_form (dw_attr_node *);
3657 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3658 static void add_AT_specification (dw_die_ref, dw_die_ref);
3659 static inline dw_die_ref AT_ref (dw_attr_node *);
3660 static inline int AT_ref_external (dw_attr_node *);
3661 static inline void set_AT_ref_external (dw_attr_node *, int);
3662 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3663 static inline dw_loc_descr_ref AT_loc (dw_attr_node *);
3664 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3666 static inline dw_loc_list_ref AT_loc_list (dw_attr_node *);
3667 static void add_AT_view_list (dw_die_ref, enum dwarf_attribute);
3668 static inline dw_loc_list_ref AT_loc_list (dw_attr_node *);
3669 static addr_table_entry *add_addr_table_entry (void *, enum ate_kind);
3670 static void remove_addr_table_entry (addr_table_entry *);
3671 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx, bool);
3672 static inline rtx AT_addr (dw_attr_node *);
3673 static void add_AT_symview (dw_die_ref, enum dwarf_attribute, const char *);
3674 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3675 static void add_AT_lineptr (dw_die_ref, enum dwarf_attribute, const char *);
3676 static void add_AT_macptr (dw_die_ref, enum dwarf_attribute, const char *);
3677 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3678 unsigned long, bool);
3679 static inline const char *AT_lbl (dw_attr_node *);
3680 static dw_attr_node *get_AT (dw_die_ref, enum dwarf_attribute);
3681 static const char *get_AT_low_pc (dw_die_ref);
3682 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3683 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
3684 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
3685 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
3686 static bool is_c (void);
3687 static bool is_cxx (void);
3688 static bool is_cxx (const_tree);
3689 static bool is_fortran (void);
3690 static bool is_ada (void);
3691 static bool remove_AT (dw_die_ref, enum dwarf_attribute);
3692 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
3693 static void add_child_die (dw_die_ref, dw_die_ref);
3694 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
3695 static dw_die_ref lookup_type_die (tree);
3696 static dw_die_ref strip_naming_typedef (tree, dw_die_ref);
3697 static dw_die_ref lookup_type_die_strip_naming_typedef (tree);
3698 static void equate_type_number_to_die (tree, dw_die_ref);
3699 static dw_die_ref lookup_decl_die (tree);
3700 static var_loc_list *lookup_decl_loc (const_tree);
3701 static void equate_decl_number_to_die (tree, dw_die_ref);
3702 static struct var_loc_node *add_var_loc_to_decl (tree, rtx, const char *, var_loc_view);
3703 static void print_spaces (FILE *);
3704 static void print_die (dw_die_ref, FILE *);
3705 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
3706 static void attr_checksum (dw_attr_node *, struct md5_ctx *, int *);
3707 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
3708 static void checksum_sleb128 (HOST_WIDE_INT, struct md5_ctx *);
3709 static void checksum_uleb128 (unsigned HOST_WIDE_INT, struct md5_ctx *);
3710 static void loc_checksum_ordered (dw_loc_descr_ref, struct md5_ctx *);
3711 static void attr_checksum_ordered (enum dwarf_tag, dw_attr_node *,
3712 struct md5_ctx *, int *);
3713 struct checksum_attributes;
3714 static void collect_checksum_attributes (struct checksum_attributes *, dw_die_ref);
3715 static void die_checksum_ordered (dw_die_ref, struct md5_ctx *, int *);
3716 static void checksum_die_context (dw_die_ref, struct md5_ctx *);
3717 static void generate_type_signature (dw_die_ref, comdat_type_node *);
3718 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
3719 static int same_dw_val_p (const dw_val_node *, const dw_val_node *, int *);
3720 static int same_attr_p (dw_attr_node *, dw_attr_node *, int *);
3721 static int same_die_p (dw_die_ref, dw_die_ref, int *);
3722 static int is_type_die (dw_die_ref);
3723 static inline bool is_template_instantiation (dw_die_ref);
3724 static int is_declaration_die (dw_die_ref);
3725 static int should_move_die_to_comdat (dw_die_ref);
3726 static dw_die_ref clone_as_declaration (dw_die_ref);
3727 static dw_die_ref clone_die (dw_die_ref);
3728 static dw_die_ref clone_tree (dw_die_ref);
3729 static dw_die_ref copy_declaration_context (dw_die_ref, dw_die_ref);
3730 static void generate_skeleton_ancestor_tree (skeleton_chain_node *);
3731 static void generate_skeleton_bottom_up (skeleton_chain_node *);
3732 static dw_die_ref generate_skeleton (dw_die_ref);
3733 static dw_die_ref remove_child_or_replace_with_skeleton (dw_die_ref,
3736 static void break_out_comdat_types (dw_die_ref);
3737 static void copy_decls_for_unworthy_types (dw_die_ref);
3739 static void add_sibling_attributes (dw_die_ref);
3740 static void output_location_lists (dw_die_ref);
3741 static int constant_size (unsigned HOST_WIDE_INT);
3742 static unsigned long size_of_die (dw_die_ref);
3743 static void calc_die_sizes (dw_die_ref);
3744 static void calc_base_type_die_sizes (void);
3745 static void mark_dies (dw_die_ref);
3746 static void unmark_dies (dw_die_ref);
3747 static void unmark_all_dies (dw_die_ref);
3748 static unsigned long size_of_pubnames (vec<pubname_entry, va_gc> *);
3749 static unsigned long size_of_aranges (void);
3750 static enum dwarf_form value_format (dw_attr_node *);
3751 static void output_value_format (dw_attr_node *);
3752 static void output_abbrev_section (void);
3753 static void output_die_abbrevs (unsigned long, dw_die_ref);
3754 static void output_die (dw_die_ref);
3755 static void output_compilation_unit_header (enum dwarf_unit_type);
3756 static void output_comp_unit (dw_die_ref, int, const unsigned char *);
3757 static void output_comdat_type_unit (comdat_type_node *, bool);
3758 static const char *dwarf2_name (tree, int);
3759 static void add_pubname (tree, dw_die_ref);
3760 static void add_enumerator_pubname (const char *, dw_die_ref);
3761 static void add_pubname_string (const char *, dw_die_ref);
3762 static void add_pubtype (tree, dw_die_ref);
3763 static void output_pubnames (vec<pubname_entry, va_gc> *);
3764 static void output_aranges (void);
3765 static unsigned int add_ranges (const_tree, bool = false);
3766 static void add_ranges_by_labels (dw_die_ref, const char *, const char *,
3768 static void output_ranges (void);
3769 static dw_line_info_table *new_line_info_table (void);
3770 static void output_line_info (bool);
3771 static void output_file_names (void);
3772 static dw_die_ref base_type_die (tree, bool);
3773 static int is_base_type (tree);
3774 static dw_die_ref subrange_type_die (tree, tree, tree, tree, dw_die_ref);
3775 static int decl_quals (const_tree);
3776 static dw_die_ref modified_type_die (tree, int, bool, dw_die_ref);
3777 static dw_die_ref generic_parameter_die (tree, tree, bool, dw_die_ref);
3778 static dw_die_ref template_parameter_pack_die (tree, tree, dw_die_ref);
3779 static unsigned int dbx_reg_number (const_rtx);
3780 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
3781 static dw_loc_descr_ref reg_loc_descriptor (rtx, enum var_init_status);
3782 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int,
3783 enum var_init_status);
3784 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx,
3785 enum var_init_status);
3786 static dw_loc_descr_ref based_loc_descr (rtx, poly_int64,
3787 enum var_init_status);
3788 static int is_based_loc (const_rtx);
3789 static bool resolve_one_addr (rtx *);
3790 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx,
3791 enum var_init_status);
3792 static dw_loc_descr_ref loc_descriptor (rtx, machine_mode mode,
3793 enum var_init_status);
3794 struct loc_descr_context;
3795 static void add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref);
3796 static void add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list);
3797 static dw_loc_list_ref loc_list_from_tree (tree, int,
3798 struct loc_descr_context *);
3799 static dw_loc_descr_ref loc_descriptor_from_tree (tree, int,
3800 struct loc_descr_context *);
3801 static tree field_type (const_tree);
3802 static unsigned int simple_type_align_in_bits (const_tree);
3803 static unsigned int simple_decl_align_in_bits (const_tree);
3804 static unsigned HOST_WIDE_INT simple_type_size_in_bits (const_tree);
3806 static dw_loc_descr_ref field_byte_offset (const_tree, struct vlr_context *,
3808 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
3810 static void add_data_member_location_attribute (dw_die_ref, tree,
3811 struct vlr_context *);
3812 static bool add_const_value_attribute (dw_die_ref, rtx);
3813 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
3814 static void insert_wide_int (const wide_int &, unsigned char *, int);
3815 static void insert_float (const_rtx, unsigned char *);
3816 static rtx rtl_for_decl_location (tree);
3817 static bool add_location_or_const_value_attribute (dw_die_ref, tree, bool);
3818 static bool tree_add_const_value_attribute (dw_die_ref, tree);
3819 static bool tree_add_const_value_attribute_for_decl (dw_die_ref, tree);
3820 static void add_name_attribute (dw_die_ref, const char *);
3821 static void add_desc_attribute (dw_die_ref, tree);
3822 static void add_gnat_descriptive_type_attribute (dw_die_ref, tree, dw_die_ref);
3823 static void add_comp_dir_attribute (dw_die_ref);
3824 static void add_scalar_info (dw_die_ref, enum dwarf_attribute, tree, int,
3825 struct loc_descr_context *);
3826 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree,
3827 struct loc_descr_context *);
3828 static void add_subscript_info (dw_die_ref, tree, bool);
3829 static void add_byte_size_attribute (dw_die_ref, tree);
3830 static void add_alignment_attribute (dw_die_ref, tree);
3831 static void add_bit_offset_attribute (dw_die_ref, tree);
3832 static void add_bit_size_attribute (dw_die_ref, tree);
3833 static void add_prototyped_attribute (dw_die_ref, tree);
3834 static void add_abstract_origin_attribute (dw_die_ref, tree);
3835 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
3836 static void add_src_coords_attributes (dw_die_ref, tree);
3837 static void add_name_and_src_coords_attributes (dw_die_ref, tree, bool = false);
3838 static void add_discr_value (dw_die_ref, dw_discr_value *);
3839 static void add_discr_list (dw_die_ref, dw_discr_list_ref);
3840 static inline dw_discr_list_ref AT_discr_list (dw_attr_node *);
3841 static dw_die_ref scope_die_for (tree, dw_die_ref);
3842 static inline int local_scope_p (dw_die_ref);
3843 static inline int class_scope_p (dw_die_ref);
3844 static inline int class_or_namespace_scope_p (dw_die_ref);
3845 static void add_type_attribute (dw_die_ref, tree, int, bool, dw_die_ref);
3846 static void add_calling_convention_attribute (dw_die_ref, tree);
3847 static const char *type_tag (const_tree);
3848 static tree member_declared_type (const_tree);
3850 static const char *decl_start_label (tree);
3852 static void gen_array_type_die (tree, dw_die_ref);
3853 static void gen_descr_array_type_die (tree, struct array_descr_info *, dw_die_ref);
3855 static void gen_entry_point_die (tree, dw_die_ref);
3857 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
3858 static dw_die_ref gen_formal_parameter_die (tree, tree, bool, dw_die_ref);
3859 static dw_die_ref gen_formal_parameter_pack_die (tree, tree, dw_die_ref, tree*);
3860 static void gen_unspecified_parameters_die (tree, dw_die_ref);
3861 static void gen_formal_types_die (tree, dw_die_ref);
3862 static void gen_subprogram_die (tree, dw_die_ref);
3863 static void gen_variable_die (tree, tree, dw_die_ref);
3864 static void gen_const_die (tree, dw_die_ref);
3865 static void gen_label_die (tree, dw_die_ref);
3866 static void gen_lexical_block_die (tree, dw_die_ref);
3867 static void gen_inlined_subroutine_die (tree, dw_die_ref);
3868 static void gen_field_die (tree, struct vlr_context *, dw_die_ref);
3869 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
3870 static dw_die_ref gen_compile_unit_die (const char *);
3871 static void gen_inheritance_die (tree, tree, tree, dw_die_ref);
3872 static void gen_member_die (tree, dw_die_ref);
3873 static void gen_struct_or_union_type_die (tree, dw_die_ref,
3874 enum debug_info_usage);
3875 static void gen_subroutine_type_die (tree, dw_die_ref);
3876 static void gen_typedef_die (tree, dw_die_ref);
3877 static void gen_type_die (tree, dw_die_ref);
3878 static void gen_block_die (tree, dw_die_ref);
3879 static void decls_for_scope (tree, dw_die_ref, bool = true);
3880 static bool is_naming_typedef_decl (const_tree);
3881 static inline dw_die_ref get_context_die (tree);
3882 static void gen_namespace_die (tree, dw_die_ref);
3883 static dw_die_ref gen_namelist_decl (tree, dw_die_ref, tree);
3884 static dw_die_ref gen_decl_die (tree, tree, struct vlr_context *, dw_die_ref);
3885 static dw_die_ref force_decl_die (tree);
3886 static dw_die_ref force_type_die (tree);
3887 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
3888 static dw_die_ref declare_in_namespace (tree, dw_die_ref);
3889 static struct dwarf_file_data * lookup_filename (const char *);
3890 static void retry_incomplete_types (void);
3891 static void gen_type_die_for_member (tree, tree, dw_die_ref);
3892 static void gen_generic_params_dies (tree);
3893 static void gen_tagged_type_die (tree, dw_die_ref, enum debug_info_usage);
3894 static void gen_type_die_with_usage (tree, dw_die_ref, enum debug_info_usage);
3895 static void splice_child_die (dw_die_ref, dw_die_ref);
3896 static int file_info_cmp (const void *, const void *);
3897 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *, var_loc_view,
3898 const char *, var_loc_view, const char *);
3899 static void output_loc_list (dw_loc_list_ref);
3900 static char *gen_internal_sym (const char *);
3901 static bool want_pubnames (void);
3903 static void prune_unmark_dies (dw_die_ref);
3904 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref);
3905 static void prune_unused_types_mark (dw_die_ref, int);
3906 static void prune_unused_types_walk (dw_die_ref);
3907 static void prune_unused_types_walk_attribs (dw_die_ref);
3908 static void prune_unused_types_prune (dw_die_ref);
3909 static void prune_unused_types (void);
3910 static int maybe_emit_file (struct dwarf_file_data *fd);
3911 static inline const char *AT_vms_delta1 (dw_attr_node *);
3912 static inline const char *AT_vms_delta2 (dw_attr_node *);
3913 static inline void add_AT_vms_delta (dw_die_ref, enum dwarf_attribute,
3914 const char *, const char *);
3915 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref, tree);
3916 static void gen_remaining_tmpl_value_param_die_attribute (void);
3917 static bool generic_type_p (tree);
3918 static void schedule_generic_params_dies_gen (tree t);
3919 static void gen_scheduled_generic_parms_dies (void);
3920 static void resolve_variable_values (void);
3922 static const char *comp_dir_string (void);
3924 static void hash_loc_operands (dw_loc_descr_ref, inchash::hash &);
3926 /* enum for tracking thread-local variables whose address is really an offset
3927 relative to the TLS pointer, which will need link-time relocation, but will
3928 not need relocation by the DWARF consumer. */
3936 /* Return the operator to use for an address of a variable. For dtprel_true, we
3937 use DW_OP_const*. For regular variables, which need both link-time
3938 relocation and consumer-level relocation (e.g., to account for shared objects
3939 loaded at a random address), we use DW_OP_addr*. */
3941 static inline enum dwarf_location_atom
3942 dw_addr_op (enum dtprel_bool dtprel)
3944 if (dtprel == dtprel_true)
3945 return (dwarf_split_debug_info ? dwarf_OP (DW_OP_constx)
3946 : (DWARF2_ADDR_SIZE == 4 ? DW_OP_const4u : DW_OP_const8u));
3948 return dwarf_split_debug_info ? dwarf_OP (DW_OP_addrx) : DW_OP_addr;
3951 /* Return a pointer to a newly allocated address location description. If
3952 dwarf_split_debug_info is true, then record the address with the appropriate
3954 static inline dw_loc_descr_ref
3955 new_addr_loc_descr (rtx addr, enum dtprel_bool dtprel)
3957 dw_loc_descr_ref ref = new_loc_descr (dw_addr_op (dtprel), 0, 0);
3959 ref->dw_loc_oprnd1.val_class = dw_val_class_addr;
3960 ref->dw_loc_oprnd1.v.val_addr = addr;
3961 ref->dtprel = dtprel;
3962 if (dwarf_split_debug_info)
3963 ref->dw_loc_oprnd1.val_entry
3964 = add_addr_table_entry (addr,
3965 dtprel ? ate_kind_rtx_dtprel : ate_kind_rtx);
3967 ref->dw_loc_oprnd1.val_entry = NULL;
3972 /* Section names used to hold DWARF debugging information. */
3974 #ifndef DEBUG_INFO_SECTION
3975 #define DEBUG_INFO_SECTION ".debug_info"
3977 #ifndef DEBUG_DWO_INFO_SECTION
3978 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3980 #ifndef DEBUG_LTO_INFO_SECTION
3981 #define DEBUG_LTO_INFO_SECTION ".gnu.debuglto_.debug_info"
3983 #ifndef DEBUG_LTO_DWO_INFO_SECTION
3984 #define DEBUG_LTO_DWO_INFO_SECTION ".gnu.debuglto_.debug_info.dwo"
3986 #ifndef DEBUG_ABBREV_SECTION
3987 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3989 #ifndef DEBUG_LTO_ABBREV_SECTION
3990 #define DEBUG_LTO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev"
3992 #ifndef DEBUG_DWO_ABBREV_SECTION
3993 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3995 #ifndef DEBUG_LTO_DWO_ABBREV_SECTION
3996 #define DEBUG_LTO_DWO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev.dwo"
3998 #ifndef DEBUG_ARANGES_SECTION
3999 #define DEBUG_ARANGES_SECTION ".debug_aranges"
4001 #ifndef DEBUG_ADDR_SECTION
4002 #define DEBUG_ADDR_SECTION ".debug_addr"
4004 #ifndef DEBUG_MACINFO_SECTION
4005 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
4007 #ifndef DEBUG_LTO_MACINFO_SECTION
4008 #define DEBUG_LTO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo"
4010 #ifndef DEBUG_DWO_MACINFO_SECTION
4011 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
4013 #ifndef DEBUG_LTO_DWO_MACINFO_SECTION
4014 #define DEBUG_LTO_DWO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo.dwo"
4016 #ifndef DEBUG_MACRO_SECTION
4017 #define DEBUG_MACRO_SECTION ".debug_macro"
4019 #ifndef DEBUG_LTO_MACRO_SECTION
4020 #define DEBUG_LTO_MACRO_SECTION ".gnu.debuglto_.debug_macro"
4022 #ifndef DEBUG_DWO_MACRO_SECTION
4023 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
4025 #ifndef DEBUG_LTO_DWO_MACRO_SECTION
4026 #define DEBUG_LTO_DWO_MACRO_SECTION ".gnu.debuglto_.debug_macro.dwo"
4028 #ifndef DEBUG_LINE_SECTION
4029 #define DEBUG_LINE_SECTION ".debug_line"
4031 #ifndef DEBUG_LTO_LINE_SECTION
4032 #define DEBUG_LTO_LINE_SECTION ".gnu.debuglto_.debug_line"
4034 #ifndef DEBUG_DWO_LINE_SECTION
4035 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
4037 #ifndef DEBUG_LTO_DWO_LINE_SECTION
4038 #define DEBUG_LTO_DWO_LINE_SECTION ".gnu.debuglto_.debug_line.dwo"
4040 #ifndef DEBUG_LOC_SECTION
4041 #define DEBUG_LOC_SECTION ".debug_loc"
4043 #ifndef DEBUG_DWO_LOC_SECTION
4044 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
4046 #ifndef DEBUG_LOCLISTS_SECTION
4047 #define DEBUG_LOCLISTS_SECTION ".debug_loclists"
4049 #ifndef DEBUG_DWO_LOCLISTS_SECTION
4050 #define DEBUG_DWO_LOCLISTS_SECTION ".debug_loclists.dwo"
4052 #ifndef DEBUG_PUBNAMES_SECTION
4053 #define DEBUG_PUBNAMES_SECTION \
4054 ((debug_generate_pub_sections == 2) \
4055 ? ".debug_gnu_pubnames" : ".debug_pubnames")
4057 #ifndef DEBUG_PUBTYPES_SECTION
4058 #define DEBUG_PUBTYPES_SECTION \
4059 ((debug_generate_pub_sections == 2) \
4060 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
4062 #ifndef DEBUG_STR_OFFSETS_SECTION
4063 #define DEBUG_STR_OFFSETS_SECTION ".debug_str_offsets"
4065 #ifndef DEBUG_DWO_STR_OFFSETS_SECTION
4066 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
4068 #ifndef DEBUG_LTO_DWO_STR_OFFSETS_SECTION
4069 #define DEBUG_LTO_DWO_STR_OFFSETS_SECTION ".gnu.debuglto_.debug_str_offsets.dwo"
4071 #ifndef DEBUG_STR_SECTION
4072 #define DEBUG_STR_SECTION ".debug_str"
4074 #ifndef DEBUG_LTO_STR_SECTION
4075 #define DEBUG_LTO_STR_SECTION ".gnu.debuglto_.debug_str"
4077 #ifndef DEBUG_STR_DWO_SECTION
4078 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
4080 #ifndef DEBUG_LTO_STR_DWO_SECTION
4081 #define DEBUG_LTO_STR_DWO_SECTION ".gnu.debuglto_.debug_str.dwo"
4083 #ifndef DEBUG_RANGES_SECTION
4084 #define DEBUG_RANGES_SECTION ".debug_ranges"
4086 #ifndef DEBUG_RNGLISTS_SECTION
4087 #define DEBUG_RNGLISTS_SECTION ".debug_rnglists"
4089 #ifndef DEBUG_LINE_STR_SECTION
4090 #define DEBUG_LINE_STR_SECTION ".debug_line_str"
4092 #ifndef DEBUG_LTO_LINE_STR_SECTION
4093 #define DEBUG_LTO_LINE_STR_SECTION ".gnu.debuglto_.debug_line_str"
4096 /* Standard ELF section names for compiled code and data. */
4097 #ifndef TEXT_SECTION_NAME
4098 #define TEXT_SECTION_NAME ".text"
4101 /* Section flags for .debug_str section. */
4102 #define DEBUG_STR_SECTION_FLAGS \
4103 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
4104 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4107 /* Section flags for .debug_str.dwo section. */
4108 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
4110 /* Attribute used to refer to the macro section. */
4111 #define DEBUG_MACRO_ATTRIBUTE (dwarf_version >= 5 ? DW_AT_macros \
4112 : dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros)
4114 /* Labels we insert at beginning sections we can reference instead of
4115 the section names themselves. */
4117 #ifndef TEXT_SECTION_LABEL
4118 #define TEXT_SECTION_LABEL "Ltext"
4120 #ifndef COLD_TEXT_SECTION_LABEL
4121 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
4123 #ifndef DEBUG_LINE_SECTION_LABEL
4124 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4126 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
4127 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
4129 #ifndef DEBUG_INFO_SECTION_LABEL
4130 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4132 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
4133 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
4135 #ifndef DEBUG_ABBREV_SECTION_LABEL
4136 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4138 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
4139 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
4141 #ifndef DEBUG_ADDR_SECTION_LABEL
4142 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
4144 #ifndef DEBUG_LOC_SECTION_LABEL
4145 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4147 #ifndef DEBUG_RANGES_SECTION_LABEL
4148 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4150 #ifndef DEBUG_MACINFO_SECTION_LABEL
4151 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4153 #ifndef DEBUG_MACRO_SECTION_LABEL
4154 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
4156 #define SKELETON_COMP_DIE_ABBREV 1
4157 #define SKELETON_TYPE_DIE_ABBREV 2
4159 /* Definitions of defaults for formats and names of various special
4160 (artificial) labels which may be generated within this file (when the -g
4161 options is used and DWARF2_DEBUGGING_INFO is in effect.
4162 If necessary, these may be overridden from within the tm.h file, but
4163 typically, overriding these defaults is unnecessary. */
4165 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4166 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4167 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4168 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4169 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4170 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4171 static char debug_skeleton_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4172 static char debug_skeleton_abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4173 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4174 static char debug_addr_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4175 static char debug_skeleton_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4176 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4177 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4178 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4179 static char ranges_base_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4181 #ifndef TEXT_END_LABEL
4182 #define TEXT_END_LABEL "Letext"
4184 #ifndef COLD_END_LABEL
4185 #define COLD_END_LABEL "Letext_cold"
4187 #ifndef BLOCK_BEGIN_LABEL
4188 #define BLOCK_BEGIN_LABEL "LBB"
4190 #ifndef BLOCK_INLINE_ENTRY_LABEL
4191 #define BLOCK_INLINE_ENTRY_LABEL "LBI"
4193 #ifndef BLOCK_END_LABEL
4194 #define BLOCK_END_LABEL "LBE"
4196 #ifndef LINE_CODE_LABEL
4197 #define LINE_CODE_LABEL "LM"
4201 /* Return the root of the DIE's built for the current compilation unit. */
4203 comp_unit_die (void)
4205 if (!single_comp_unit_die)
4206 single_comp_unit_die = gen_compile_unit_die (NULL);
4207 return single_comp_unit_die;
4210 /* We allow a language front-end to designate a function that is to be
4211 called to "demangle" any name before it is put into a DIE. */
4213 static const char *(*demangle_name_func) (const char *);
4216 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
4218 demangle_name_func = func;
4221 /* Test if rtl node points to a pseudo register. */
4224 is_pseudo_reg (const_rtx rtl)
4226 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
4227 || (GET_CODE (rtl) == SUBREG
4228 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
4231 /* Return a reference to a type, with its const and volatile qualifiers
4235 type_main_variant (tree type)
4237 type = TYPE_MAIN_VARIANT (type);
4239 /* ??? There really should be only one main variant among any group of
4240 variants of a given type (and all of the MAIN_VARIANT values for all
4241 members of the group should point to that one type) but sometimes the C
4242 front-end messes this up for array types, so we work around that bug
4244 if (TREE_CODE (type) == ARRAY_TYPE)
4245 while (type != TYPE_MAIN_VARIANT (type))
4246 type = TYPE_MAIN_VARIANT (type);
4251 /* Return nonzero if the given type node represents a tagged type. */
4254 is_tagged_type (const_tree type)
4256 enum tree_code code = TREE_CODE (type);
4258 return (code == RECORD_TYPE || code == UNION_TYPE
4259 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4262 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
4265 get_ref_die_offset_label (char *label, dw_die_ref ref)
4267 sprintf (label, "%s+%ld", debug_info_section_label, ref->die_offset);
4270 /* Return die_offset of a DIE reference to a base type. */
4272 static unsigned long int
4273 get_base_type_offset (dw_die_ref ref)
4275 if (ref->die_offset)
4276 return ref->die_offset;
4277 if (comp_unit_die ()->die_abbrev)
4279 calc_base_type_die_sizes ();
4280 gcc_assert (ref->die_offset);
4282 return ref->die_offset;
4285 /* Return die_offset of a DIE reference other than base type. */
4287 static unsigned long int
4288 get_ref_die_offset (dw_die_ref ref)
4290 gcc_assert (ref->die_offset);
4291 return ref->die_offset;
4294 /* Convert a DIE tag into its string name. */
4297 dwarf_tag_name (unsigned int tag)
4299 const char *name = get_DW_TAG_name (tag);
4304 return "DW_TAG_<unknown>";
4307 /* Convert a DWARF attribute code into its string name. */
4310 dwarf_attr_name (unsigned int attr)
4316 #if VMS_DEBUGGING_INFO
4317 case DW_AT_HP_prologue:
4318 return "DW_AT_HP_prologue";
4320 case DW_AT_MIPS_loop_unroll_factor:
4321 return "DW_AT_MIPS_loop_unroll_factor";
4324 #if VMS_DEBUGGING_INFO
4325 case DW_AT_HP_epilogue:
4326 return "DW_AT_HP_epilogue";
4328 case DW_AT_MIPS_stride:
4329 return "DW_AT_MIPS_stride";
4333 name = get_DW_AT_name (attr);
4338 return "DW_AT_<unknown>";
4341 /* Convert a DWARF value form code into its string name. */
4344 dwarf_form_name (unsigned int form)
4346 const char *name = get_DW_FORM_name (form);
4351 return "DW_FORM_<unknown>";
4354 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4355 instance of an inlined instance of a decl which is local to an inline
4356 function, so we have to trace all of the way back through the origin chain
4357 to find out what sort of node actually served as the original seed for the
4361 decl_ultimate_origin (const_tree decl)
4363 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
4366 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
4367 we're trying to output the abstract instance of this function. */
4368 if (DECL_ABSTRACT_P (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4371 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4372 most distant ancestor, this should never happen. */
4373 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4375 return DECL_ABSTRACT_ORIGIN (decl);
4378 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4379 of a virtual function may refer to a base class, so we check the 'this'
4383 decl_class_context (tree decl)
4385 tree context = NULL_TREE;
4387 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4388 context = DECL_CONTEXT (decl);
4390 context = TYPE_MAIN_VARIANT
4391 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4393 if (context && !TYPE_P (context))
4394 context = NULL_TREE;
4399 /* Add an attribute/value pair to a DIE. */
4402 add_dwarf_attr (dw_die_ref die, dw_attr_node *attr)
4404 /* Maybe this should be an assert? */
4410 /* Check we do not add duplicate attrs. Can't use get_AT here
4411 because that recurses to the specification/abstract origin DIE. */
4414 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
4415 gcc_assert (a->dw_attr != attr->dw_attr);
4418 vec_safe_reserve (die->die_attr, 1);
4419 vec_safe_push (die->die_attr, *attr);
4422 static inline enum dw_val_class
4423 AT_class (dw_attr_node *a)
4425 return a->dw_attr_val.val_class;
4428 /* Return the index for any attribute that will be referenced with a
4429 DW_FORM_addrx/GNU_addr_index or DW_FORM_strx/GNU_str_index. String
4430 indices are stored in dw_attr_val.v.val_str for reference counting
4433 static inline unsigned int
4434 AT_index (dw_attr_node *a)
4436 if (AT_class (a) == dw_val_class_str)
4437 return a->dw_attr_val.v.val_str->index;
4438 else if (a->dw_attr_val.val_entry != NULL)
4439 return a->dw_attr_val.val_entry->index;
4443 /* Add a flag value attribute to a DIE. */
4446 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4450 attr.dw_attr = attr_kind;
4451 attr.dw_attr_val.val_class = dw_val_class_flag;
4452 attr.dw_attr_val.val_entry = NULL;
4453 attr.dw_attr_val.v.val_flag = flag;
4454 add_dwarf_attr (die, &attr);
4457 static inline unsigned
4458 AT_flag (dw_attr_node *a)
4460 gcc_assert (a && AT_class (a) == dw_val_class_flag);
4461 return a->dw_attr_val.v.val_flag;
4464 /* Add a signed integer attribute value to a DIE. */
4467 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4471 attr.dw_attr = attr_kind;
4472 attr.dw_attr_val.val_class = dw_val_class_const;
4473 attr.dw_attr_val.val_entry = NULL;
4474 attr.dw_attr_val.v.val_int = int_val;
4475 add_dwarf_attr (die, &attr);
4478 static inline HOST_WIDE_INT
4479 AT_int (dw_attr_node *a)
4481 gcc_assert (a && (AT_class (a) == dw_val_class_const
4482 || AT_class (a) == dw_val_class_const_implicit));
4483 return a->dw_attr_val.v.val_int;
4486 /* Add an unsigned integer attribute value to a DIE. */
4489 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4490 unsigned HOST_WIDE_INT unsigned_val)
4494 attr.dw_attr = attr_kind;
4495 attr.dw_attr_val.val_class = dw_val_class_unsigned_const;
4496 attr.dw_attr_val.val_entry = NULL;
4497 attr.dw_attr_val.v.val_unsigned = unsigned_val;
4498 add_dwarf_attr (die, &attr);
4501 static inline unsigned HOST_WIDE_INT
4502 AT_unsigned (dw_attr_node *a)
4504 gcc_assert (a && (AT_class (a) == dw_val_class_unsigned_const
4505 || AT_class (a) == dw_val_class_unsigned_const_implicit));
4506 return a->dw_attr_val.v.val_unsigned;
4509 /* Add an unsigned wide integer attribute value to a DIE. */
4512 add_AT_wide (dw_die_ref die, enum dwarf_attribute attr_kind,
4517 attr.dw_attr = attr_kind;
4518 attr.dw_attr_val.val_class = dw_val_class_wide_int;
4519 attr.dw_attr_val.val_entry = NULL;
4520 attr.dw_attr_val.v.val_wide = ggc_alloc<wide_int> ();
4521 *attr.dw_attr_val.v.val_wide = w;
4522 add_dwarf_attr (die, &attr);
4525 /* Add an unsigned double integer attribute value to a DIE. */
4528 add_AT_double (dw_die_ref die, enum dwarf_attribute attr_kind,
4529 HOST_WIDE_INT high, unsigned HOST_WIDE_INT low)
4533 attr.dw_attr = attr_kind;
4534 attr.dw_attr_val.val_class = dw_val_class_const_double;
4535 attr.dw_attr_val.val_entry = NULL;
4536 attr.dw_attr_val.v.val_double.high = high;
4537 attr.dw_attr_val.v.val_double.low = low;
4538 add_dwarf_attr (die, &attr);
4541 /* Add a floating point attribute value to a DIE and return it. */
4544 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
4545 unsigned int length, unsigned int elt_size, unsigned char *array)
4549 attr.dw_attr = attr_kind;
4550 attr.dw_attr_val.val_class = dw_val_class_vec;
4551 attr.dw_attr_val.val_entry = NULL;
4552 attr.dw_attr_val.v.val_vec.length = length;
4553 attr.dw_attr_val.v.val_vec.elt_size = elt_size;
4554 attr.dw_attr_val.v.val_vec.array = array;
4555 add_dwarf_attr (die, &attr);
4558 /* Add an 8-byte data attribute value to a DIE. */
4561 add_AT_data8 (dw_die_ref die, enum dwarf_attribute attr_kind,
4562 unsigned char data8[8])
4566 attr.dw_attr = attr_kind;
4567 attr.dw_attr_val.val_class = dw_val_class_data8;
4568 attr.dw_attr_val.val_entry = NULL;
4569 memcpy (attr.dw_attr_val.v.val_data8, data8, 8);
4570 add_dwarf_attr (die, &attr);
4573 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
4574 dwarf_split_debug_info, address attributes in dies destined for the
4575 final executable have force_direct set to avoid using indexed
4579 add_AT_low_high_pc (dw_die_ref die, const char *lbl_low, const char *lbl_high,
4585 lbl_id = xstrdup (lbl_low);
4586 attr.dw_attr = DW_AT_low_pc;
4587 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
4588 attr.dw_attr_val.v.val_lbl_id = lbl_id;
4589 if (dwarf_split_debug_info && !force_direct)
4590 attr.dw_attr_val.val_entry
4591 = add_addr_table_entry (lbl_id, ate_kind_label);
4593 attr.dw_attr_val.val_entry = NULL;
4594 add_dwarf_attr (die, &attr);
4596 attr.dw_attr = DW_AT_high_pc;
4597 if (dwarf_version < 4)
4598 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
4600 attr.dw_attr_val.val_class = dw_val_class_high_pc;
4601 lbl_id = xstrdup (lbl_high);
4602 attr.dw_attr_val.v.val_lbl_id = lbl_id;
4603 if (attr.dw_attr_val.val_class == dw_val_class_lbl_id
4604 && dwarf_split_debug_info && !force_direct)
4605 attr.dw_attr_val.val_entry
4606 = add_addr_table_entry (lbl_id, ate_kind_label);
4608 attr.dw_attr_val.val_entry = NULL;
4609 add_dwarf_attr (die, &attr);
4612 /* Hash and equality functions for debug_str_hash. */
4615 indirect_string_hasher::hash (indirect_string_node *x)
4617 return htab_hash_string (x->str);
4621 indirect_string_hasher::equal (indirect_string_node *x1, const char *x2)
4623 return strcmp (x1->str, x2) == 0;
4626 /* Add STR to the given string hash table. */
4628 static struct indirect_string_node *
4629 find_AT_string_in_table (const char *str,
4630 hash_table<indirect_string_hasher> *table,
4631 enum insert_option insert = INSERT)
4633 struct indirect_string_node *node;
4635 indirect_string_node **slot
4636 = table->find_slot_with_hash (str, htab_hash_string (str), insert);
4639 node = ggc_cleared_alloc<indirect_string_node> ();
4640 node->str = ggc_strdup (str);
4650 /* Add STR to the indirect string hash table. */
4652 static struct indirect_string_node *
4653 find_AT_string (const char *str, enum insert_option insert = INSERT)
4655 if (! debug_str_hash)
4656 debug_str_hash = hash_table<indirect_string_hasher>::create_ggc (10);
4658 return find_AT_string_in_table (str, debug_str_hash, insert);
4661 /* Add a string attribute value to a DIE. */
4664 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
4667 struct indirect_string_node *node;
4669 node = find_AT_string (str);
4671 attr.dw_attr = attr_kind;
4672 attr.dw_attr_val.val_class = dw_val_class_str;
4673 attr.dw_attr_val.val_entry = NULL;
4674 attr.dw_attr_val.v.val_str = node;
4675 add_dwarf_attr (die, &attr);
4678 static inline const char *
4679 AT_string (dw_attr_node *a)
4681 gcc_assert (a && AT_class (a) == dw_val_class_str);
4682 return a->dw_attr_val.v.val_str->str;
4685 /* Call this function directly to bypass AT_string_form's logic to put
4686 the string inline in the die. */
4689 set_indirect_string (struct indirect_string_node *node)
4691 char label[MAX_ARTIFICIAL_LABEL_BYTES];
4692 /* Already indirect is a no op. */
4693 if (node->form == DW_FORM_strp
4694 || node->form == DW_FORM_line_strp
4695 || node->form == dwarf_FORM (DW_FORM_strx))
4697 gcc_assert (node->label);
4700 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
4701 ++dw2_string_counter;
4702 node->label = xstrdup (label);
4704 if (!dwarf_split_debug_info)
4706 node->form = DW_FORM_strp;
4707 node->index = NOT_INDEXED;
4711 node->form = dwarf_FORM (DW_FORM_strx);
4712 node->index = NO_INDEX_ASSIGNED;
4716 /* A helper function for dwarf2out_finish, called to reset indirect
4717 string decisions done for early LTO dwarf output before fat object
4721 reset_indirect_string (indirect_string_node **h, void *)
4723 struct indirect_string_node *node = *h;
4724 if (node->form == DW_FORM_strp || node->form == dwarf_FORM (DW_FORM_strx))
4728 node->form = (dwarf_form) 0;
4734 /* Find out whether a string should be output inline in DIE
4735 or out-of-line in .debug_str section. */
4737 static enum dwarf_form
4738 find_string_form (struct indirect_string_node *node)
4745 len = strlen (node->str) + 1;
4747 /* If the string is shorter or equal to the size of the reference, it is
4748 always better to put it inline. */
4749 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
4750 return node->form = DW_FORM_string;
4752 /* If we cannot expect the linker to merge strings in .debug_str
4753 section, only put it into .debug_str if it is worth even in this
4755 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4756 || ((debug_str_section->common.flags & SECTION_MERGE) == 0
4757 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len))
4758 return node->form = DW_FORM_string;
4760 set_indirect_string (node);
4765 /* Find out whether the string referenced from the attribute should be
4766 output inline in DIE or out-of-line in .debug_str section. */
4768 static enum dwarf_form
4769 AT_string_form (dw_attr_node *a)
4771 gcc_assert (a && AT_class (a) == dw_val_class_str);
4772 return find_string_form (a->dw_attr_val.v.val_str);
4775 /* Add a DIE reference attribute value to a DIE. */
4778 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
4781 gcc_checking_assert (targ_die != NULL);
4783 /* With LTO we can end up trying to reference something we didn't create
4784 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4785 if (targ_die == NULL)
4788 attr.dw_attr = attr_kind;
4789 attr.dw_attr_val.val_class = dw_val_class_die_ref;
4790 attr.dw_attr_val.val_entry = NULL;
4791 attr.dw_attr_val.v.val_die_ref.die = targ_die;
4792 attr.dw_attr_val.v.val_die_ref.external = 0;
4793 add_dwarf_attr (die, &attr);
4796 /* Change DIE reference REF to point to NEW_DIE instead. */
4799 change_AT_die_ref (dw_attr_node *ref, dw_die_ref new_die)
4801 gcc_assert (ref->dw_attr_val.val_class == dw_val_class_die_ref);
4802 ref->dw_attr_val.v.val_die_ref.die = new_die;
4803 ref->dw_attr_val.v.val_die_ref.external = 0;
4806 /* Add an AT_specification attribute to a DIE, and also make the back
4807 pointer from the specification to the definition. */
4810 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
4812 add_AT_die_ref (die, DW_AT_specification, targ_die);
4813 gcc_assert (!targ_die->die_definition);
4814 targ_die->die_definition = die;
4817 static inline dw_die_ref
4818 AT_ref (dw_attr_node *a)
4820 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
4821 return a->dw_attr_val.v.val_die_ref.die;
4825 AT_ref_external (dw_attr_node *a)
4827 if (a && AT_class (a) == dw_val_class_die_ref)
4828 return a->dw_attr_val.v.val_die_ref.external;
4834 set_AT_ref_external (dw_attr_node *a, int i)
4836 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
4837 a->dw_attr_val.v.val_die_ref.external = i;
4840 /* Add a location description attribute value to a DIE. */
4843 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
4847 attr.dw_attr = attr_kind;
4848 attr.dw_attr_val.val_class = dw_val_class_loc;
4849 attr.dw_attr_val.val_entry = NULL;
4850 attr.dw_attr_val.v.val_loc = loc;
4851 add_dwarf_attr (die, &attr);
4854 static inline dw_loc_descr_ref
4855 AT_loc (dw_attr_node *a)
4857 gcc_assert (a && AT_class (a) == dw_val_class_loc);
4858 return a->dw_attr_val.v.val_loc;
4862 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
4866 if (XCOFF_DEBUGGING_INFO && !HAVE_XCOFF_DWARF_EXTRAS)
4869 attr.dw_attr = attr_kind;
4870 attr.dw_attr_val.val_class = dw_val_class_loc_list;
4871 attr.dw_attr_val.val_entry = NULL;
4872 attr.dw_attr_val.v.val_loc_list = loc_list;
4873 add_dwarf_attr (die, &attr);
4874 have_location_lists = true;
4877 static inline dw_loc_list_ref
4878 AT_loc_list (dw_attr_node *a)
4880 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
4881 return a->dw_attr_val.v.val_loc_list;
4884 /* Add a view list attribute to DIE. It must have a DW_AT_location
4885 attribute, because the view list complements the location list. */
4888 add_AT_view_list (dw_die_ref die, enum dwarf_attribute attr_kind)
4892 if (XCOFF_DEBUGGING_INFO && !HAVE_XCOFF_DWARF_EXTRAS)
4895 attr.dw_attr = attr_kind;
4896 attr.dw_attr_val.val_class = dw_val_class_view_list;
4897 attr.dw_attr_val.val_entry = NULL;
4898 attr.dw_attr_val.v.val_view_list = die;
4899 add_dwarf_attr (die, &attr);
4900 gcc_checking_assert (get_AT (die, DW_AT_location));
4901 gcc_assert (have_location_lists);
4904 /* Return a pointer to the location list referenced by the attribute.
4905 If the named attribute is a view list, look up the corresponding
4906 DW_AT_location attribute and return its location list. */
4908 static inline dw_loc_list_ref *
4909 AT_loc_list_ptr (dw_attr_node *a)
4912 switch (AT_class (a))
4914 case dw_val_class_loc_list:
4915 return &a->dw_attr_val.v.val_loc_list;
4916 case dw_val_class_view_list:
4919 l = get_AT (a->dw_attr_val.v.val_view_list, DW_AT_location);
4922 gcc_checking_assert (l + 1 == a);
4923 return AT_loc_list_ptr (l);
4930 /* Return the location attribute value associated with a view list
4933 static inline dw_val_node *
4934 view_list_to_loc_list_val_node (dw_val_node *val)
4936 gcc_assert (val->val_class == dw_val_class_view_list);
4937 dw_attr_node *loc = get_AT (val->v.val_view_list, DW_AT_location);
4940 gcc_checking_assert (&(loc + 1)->dw_attr_val == val);
4941 gcc_assert (AT_class (loc) == dw_val_class_loc_list);
4942 return &loc->dw_attr_val;
4945 struct addr_hasher : ggc_ptr_hash<addr_table_entry>
4947 static hashval_t hash (addr_table_entry *);
4948 static bool equal (addr_table_entry *, addr_table_entry *);
4951 /* Table of entries into the .debug_addr section. */
4953 static GTY (()) hash_table<addr_hasher> *addr_index_table;
4955 /* Hash an address_table_entry. */
4958 addr_hasher::hash (addr_table_entry *a)
4960 inchash::hash hstate;
4966 case ate_kind_rtx_dtprel:
4969 case ate_kind_label:
4970 return htab_hash_string (a->addr.label);
4974 inchash::add_rtx (a->addr.rtl, hstate);
4975 return hstate.end ();
4978 /* Determine equality for two address_table_entries. */
4981 addr_hasher::equal (addr_table_entry *a1, addr_table_entry *a2)
4983 if (a1->kind != a2->kind)
4988 case ate_kind_rtx_dtprel:
4989 return rtx_equal_p (a1->addr.rtl, a2->addr.rtl);
4990 case ate_kind_label:
4991 return strcmp (a1->addr.label, a2->addr.label) == 0;
4997 /* Initialize an addr_table_entry. */
5000 init_addr_table_entry (addr_table_entry *e, enum ate_kind kind, void *addr)
5006 case ate_kind_rtx_dtprel:
5007 e->addr.rtl = (rtx) addr;
5009 case ate_kind_label:
5010 e->addr.label = (char *) addr;
5014 e->index = NO_INDEX_ASSIGNED;
5017 /* Add attr to the address table entry to the table. Defer setting an
5018 index until output time. */
5020 static addr_table_entry *
5021 add_addr_table_entry (void *addr, enum ate_kind kind)
5023 addr_table_entry *node;
5024 addr_table_entry finder;
5026 gcc_assert (dwarf_split_debug_info);
5027 if (! addr_index_table)
5028 addr_index_table = hash_table<addr_hasher>::create_ggc (10);
5029 init_addr_table_entry (&finder, kind, addr);
5030 addr_table_entry **slot = addr_index_table->find_slot (&finder, INSERT);
5032 if (*slot == HTAB_EMPTY_ENTRY)
5034 node = ggc_cleared_alloc<addr_table_entry> ();
5035 init_addr_table_entry (node, kind, addr);
5045 /* Remove an entry from the addr table by decrementing its refcount.
5046 Strictly, decrementing the refcount would be enough, but the
5047 assertion that the entry is actually in the table has found
5051 remove_addr_table_entry (addr_table_entry *entry)
5053 gcc_assert (dwarf_split_debug_info && addr_index_table);
5054 /* After an index is assigned, the table is frozen. */
5055 gcc_assert (entry->refcount > 0 && entry->index == NO_INDEX_ASSIGNED);
5059 /* Given a location list, remove all addresses it refers to from the
5063 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr)
5065 for (; descr; descr = descr->dw_loc_next)
5066 if (descr->dw_loc_oprnd1.val_entry != NULL)
5068 gcc_assert (descr->dw_loc_oprnd1.val_entry->index == NO_INDEX_ASSIGNED);
5069 remove_addr_table_entry (descr->dw_loc_oprnd1.val_entry);
5073 /* A helper function for dwarf2out_finish called through
5074 htab_traverse. Assign an addr_table_entry its index. All entries
5075 must be collected into the table when this function is called,
5076 because the indexing code relies on htab_traverse to traverse nodes
5077 in the same order for each run. */
5080 index_addr_table_entry (addr_table_entry **h, unsigned int *index)
5082 addr_table_entry *node = *h;
5084 /* Don't index unreferenced nodes. */
5085 if (node->refcount == 0)
5088 gcc_assert (node->index == NO_INDEX_ASSIGNED);
5089 node->index = *index;
5095 /* Add an address constant attribute value to a DIE. When using
5096 dwarf_split_debug_info, address attributes in dies destined for the
5097 final executable should be direct references--setting the parameter
5098 force_direct ensures this behavior. */
5101 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr,
5106 attr.dw_attr = attr_kind;
5107 attr.dw_attr_val.val_class = dw_val_class_addr;
5108 attr.dw_attr_val.v.val_addr = addr;
5109 if (dwarf_split_debug_info && !force_direct)
5110 attr.dw_attr_val.val_entry = add_addr_table_entry (addr, ate_kind_rtx);
5112 attr.dw_attr_val.val_entry = NULL;
5113 add_dwarf_attr (die, &attr);
5116 /* Get the RTX from to an address DIE attribute. */
5119 AT_addr (dw_attr_node *a)
5121 gcc_assert (a && AT_class (a) == dw_val_class_addr);
5122 return a->dw_attr_val.v.val_addr;
5125 /* Add a file attribute value to a DIE. */
5128 add_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind,
5129 struct dwarf_file_data *fd)
5133 attr.dw_attr = attr_kind;
5134 attr.dw_attr_val.val_class = dw_val_class_file;
5135 attr.dw_attr_val.val_entry = NULL;
5136 attr.dw_attr_val.v.val_file = fd;
5137 add_dwarf_attr (die, &attr);
5140 /* Get the dwarf_file_data from a file DIE attribute. */
5142 static inline struct dwarf_file_data *
5143 AT_file (dw_attr_node *a)
5145 gcc_assert (a && (AT_class (a) == dw_val_class_file
5146 || AT_class (a) == dw_val_class_file_implicit));
5147 return a->dw_attr_val.v.val_file;
5150 /* Add a vms delta attribute value to a DIE. */
5153 add_AT_vms_delta (dw_die_ref die, enum dwarf_attribute attr_kind,
5154 const char *lbl1, const char *lbl2)
5158 attr.dw_attr = attr_kind;
5159 attr.dw_attr_val.val_class = dw_val_class_vms_delta;
5160 attr.dw_attr_val.val_entry = NULL;
5161 attr.dw_attr_val.v.val_vms_delta.lbl1 = xstrdup (lbl1);
5162 attr.dw_attr_val.v.val_vms_delta.lbl2 = xstrdup (lbl2);
5163 add_dwarf_attr (die, &attr);
5166 /* Add a symbolic view identifier attribute value to a DIE. */
5169 add_AT_symview (dw_die_ref die, enum dwarf_attribute attr_kind,
5170 const char *view_label)
5174 attr.dw_attr = attr_kind;
5175 attr.dw_attr_val.val_class = dw_val_class_symview;
5176 attr.dw_attr_val.val_entry = NULL;
5177 attr.dw_attr_val.v.val_symbolic_view = xstrdup (view_label);
5178 add_dwarf_attr (die, &attr);
5181 /* Add a label identifier attribute value to a DIE. */
5184 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind,
5189 attr.dw_attr = attr_kind;
5190 attr.dw_attr_val.val_class = dw_val_class_lbl_id;
5191 attr.dw_attr_val.val_entry = NULL;
5192 attr.dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
5193 if (dwarf_split_debug_info)
5194 attr.dw_attr_val.val_entry
5195 = add_addr_table_entry (attr.dw_attr_val.v.val_lbl_id,
5197 add_dwarf_attr (die, &attr);
5200 /* Add a section offset attribute value to a DIE, an offset into the
5201 debug_line section. */
5204 add_AT_lineptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5209 attr.dw_attr = attr_kind;
5210 attr.dw_attr_val.val_class = dw_val_class_lineptr;
5211 attr.dw_attr_val.val_entry = NULL;
5212 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5213 add_dwarf_attr (die, &attr);
5216 /* Add a section offset attribute value to a DIE, an offset into the
5217 debug_macinfo section. */
5220 add_AT_macptr (dw_die_ref die, enum dwarf_attribute attr_kind,
5225 attr.dw_attr = attr_kind;
5226 attr.dw_attr_val.val_class = dw_val_class_macptr;
5227 attr.dw_attr_val.val_entry = NULL;
5228 attr.dw_attr_val.v.val_lbl_id = xstrdup (label);
5229 add_dwarf_attr (die, &attr);
5232 /* Add a range_list attribute value to a DIE. When using
5233 dwarf_split_debug_info, address attributes in dies destined for the
5234 final executable should be direct references--setting the parameter
5235 force_direct ensures this behavior. */
5237 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
5238 #define RELOCATED_OFFSET (NULL)
5241 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
5242 long unsigned int offset, bool force_direct)
5246 attr.dw_attr = attr_kind;
5247 attr.dw_attr_val.val_class = dw_val_class_range_list;
5248 /* For the range_list attribute, use val_entry to store whether the
5249 offset should follow split-debug-info or normal semantics. This
5250 value is read in output_range_list_offset. */
5251 if (dwarf_split_debug_info && !force_direct)
5252 attr.dw_attr_val.val_entry = UNRELOCATED_OFFSET;
5254 attr.dw_attr_val.val_entry = RELOCATED_OFFSET;
5255 attr.dw_attr_val.v.val_offset = offset;
5256 add_dwarf_attr (die, &attr);
5259 /* Return the start label of a delta attribute. */
5261 static inline const char *
5262 AT_vms_delta1 (dw_attr_node *a)
5264 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
5265 return a->dw_attr_val.v.val_vms_delta.lbl1;
5268 /* Return the end label of a delta attribute. */
5270 static inline const char *
5271 AT_vms_delta2 (dw_attr_node *a)
5273 gcc_assert (a && (AT_class (a) == dw_val_class_vms_delta));
5274 return a->dw_attr_val.v.val_vms_delta.lbl2;
5277 static inline const char *
5278 AT_lbl (dw_attr_node *a)
5280 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
5281 || AT_class (a) == dw_val_class_lineptr
5282 || AT_class (a) == dw_val_class_macptr
5283 || AT_class (a) == dw_val_class_loclistsptr
5284 || AT_class (a) == dw_val_class_high_pc));
5285 return a->dw_attr_val.v.val_lbl_id;
5288 /* Get the attribute of type attr_kind. */
5290 static dw_attr_node *
5291 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5295 dw_die_ref spec = NULL;
5300 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
5301 if (a->dw_attr == attr_kind)
5303 else if (a->dw_attr == DW_AT_specification
5304 || a->dw_attr == DW_AT_abstract_origin)
5308 return get_AT (spec, attr_kind);
5313 /* Returns the parent of the declaration of DIE. */
5316 get_die_parent (dw_die_ref die)
5323 if ((t = get_AT_ref (die, DW_AT_abstract_origin))
5324 || (t = get_AT_ref (die, DW_AT_specification)))
5327 return die->die_parent;
5330 /* Return the "low pc" attribute value, typically associated with a subprogram
5331 DIE. Return null if the "low pc" attribute is either not present, or if it
5332 cannot be represented as an assembler label identifier. */
5334 static inline const char *
5335 get_AT_low_pc (dw_die_ref die)
5337 dw_attr_node *a = get_AT (die, DW_AT_low_pc);
5339 return a ? AT_lbl (a) : NULL;
5342 /* Return the value of the string attribute designated by ATTR_KIND, or
5343 NULL if it is not present. */
5345 static inline const char *
5346 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
5348 dw_attr_node *a = get_AT (die, attr_kind);
5350 return a ? AT_string (a) : NULL;
5353 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5354 if it is not present. */
5357 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
5359 dw_attr_node *a = get_AT (die, attr_kind);
5361 return a ? AT_flag (a) : 0;
5364 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5365 if it is not present. */
5367 static inline unsigned
5368 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
5370 dw_attr_node *a = get_AT (die, attr_kind);
5372 return a ? AT_unsigned (a) : 0;
5375 static inline dw_die_ref
5376 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
5378 dw_attr_node *a = get_AT (die, attr_kind);
5380 return a ? AT_ref (a) : NULL;
5383 static inline struct dwarf_file_data *
5384 get_AT_file (dw_die_ref die, enum dwarf_attribute attr_kind)
5386 dw_attr_node *a = get_AT (die, attr_kind);
5388 return a ? AT_file (a) : NULL;
5391 /* Return TRUE if the language is C. */
5396 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
5398 return (lang == DW_LANG_C || lang == DW_LANG_C89 || lang == DW_LANG_C99
5399 || lang == DW_LANG_C11 || lang == DW_LANG_ObjC);
5404 /* Return TRUE if the language is C++. */
5409 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
5411 return (lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus
5412 || lang == DW_LANG_C_plus_plus_11 || lang == DW_LANG_C_plus_plus_14);
5415 /* Return TRUE if DECL was created by the C++ frontend. */
5418 is_cxx (const_tree decl)
5422 const_tree context = get_ultimate_context (decl);
5423 if (context && TRANSLATION_UNIT_LANGUAGE (context))
5424 return strncmp (TRANSLATION_UNIT_LANGUAGE (context), "GNU C++", 7) == 0;
5429 /* Return TRUE if the language is Fortran. */
5434 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
5436 return (lang == DW_LANG_Fortran77
5437 || lang == DW_LANG_Fortran90
5438 || lang == DW_LANG_Fortran95
5439 || lang == DW_LANG_Fortran03
5440 || lang == DW_LANG_Fortran08);
5444 is_fortran (const_tree decl)
5448 const_tree context = get_ultimate_context (decl);
5449 if (context && TRANSLATION_UNIT_LANGUAGE (context))
5450 return (strncmp (TRANSLATION_UNIT_LANGUAGE (context),
5451 "GNU Fortran", 11) == 0
5452 || strcmp (TRANSLATION_UNIT_LANGUAGE (context),
5455 return is_fortran ();
5458 /* Return TRUE if the language is Ada. */
5463 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
5465 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
5468 /* Return TRUE if the language is D. */
5473 unsigned int lang = get_AT_unsigned (comp_unit_die (), DW_AT_language);
5475 return lang == DW_LANG_D;
5478 /* Remove the specified attribute if present. Return TRUE if removal
5482 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5490 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
5491 if (a->dw_attr == attr_kind)
5493 if (AT_class (a) == dw_val_class_str)
5494 if (a->dw_attr_val.v.val_str->refcount)
5495 a->dw_attr_val.v.val_str->refcount--;
5497 /* vec::ordered_remove should help reduce the number of abbrevs
5499 die->die_attr->ordered_remove (ix);
5505 /* Remove CHILD from its parent. PREV must have the property that
5506 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
5509 remove_child_with_prev (dw_die_ref child, dw_die_ref prev)
5511 gcc_assert (child->die_parent == prev->die_parent);
5512 gcc_assert (prev->die_sib == child);
5515 gcc_assert (child->die_parent->die_child == child);
5519 prev->die_sib = child->die_sib;
5520 if (child->die_parent->die_child == child)
5521 child->die_parent->die_child = prev;
5522 child->die_sib = NULL;
5525 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
5526 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
5529 replace_child (dw_die_ref old_child, dw_die_ref new_child, dw_die_ref prev)
5531 dw_die_ref parent = old_child->die_parent;
5533 gcc_assert (parent == prev->die_parent);
5534 gcc_assert (prev->die_sib == old_child);
5536 new_child->die_parent = parent;
5537 if (prev == old_child)
5539 gcc_assert (parent->die_child == old_child);
5540 new_child->die_sib = new_child;
5544 prev->die_sib = new_child;
5545 new_child->die_sib = old_child->die_sib;
5547 if (old_child->die_parent->die_child == old_child)
5548 old_child->die_parent->die_child = new_child;
5549 old_child->die_sib = NULL;
5552 /* Move all children from OLD_PARENT to NEW_PARENT. */
5555 move_all_children (dw_die_ref old_parent, dw_die_ref new_parent)
5558 new_parent->die_child = old_parent->die_child;
5559 old_parent->die_child = NULL;
5560 FOR_EACH_CHILD (new_parent, c, c->die_parent = new_parent);
5563 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
5567 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
5573 dw_die_ref prev = c;
5575 while (c->die_tag == tag)
5577 remove_child_with_prev (c, prev);
5578 c->die_parent = NULL;
5579 /* Might have removed every child. */
5580 if (die->die_child == NULL)
5584 } while (c != die->die_child);
5587 /* Add a CHILD_DIE as the last child of DIE. */
5590 add_child_die (dw_die_ref die, dw_die_ref child_die)
5592 /* FIXME this should probably be an assert. */
5593 if (! die || ! child_die)
5595 gcc_assert (die != child_die);
5597 child_die->die_parent = die;
5600 child_die->die_sib = die->die_child->die_sib;
5601 die->die_child->die_sib = child_die;
5604 child_die->die_sib = child_die;
5605 die->die_child = child_die;
5608 /* Like add_child_die, but put CHILD_DIE after AFTER_DIE. */
5611 add_child_die_after (dw_die_ref die, dw_die_ref child_die,
5612 dw_die_ref after_die)
5618 && die != child_die);
5620 child_die->die_parent = die;
5621 child_die->die_sib = after_die->die_sib;
5622 after_die->die_sib = child_die;
5623 if (die->die_child == after_die)
5624 die->die_child = child_die;
5627 /* Unassociate CHILD from its parent, and make its parent be
5631 reparent_child (dw_die_ref child, dw_die_ref new_parent)
5633 for (dw_die_ref p = child->die_parent->die_child; ; p = p->die_sib)
5634 if (p->die_sib == child)
5636 remove_child_with_prev (child, p);
5639 add_child_die (new_parent, child);
5642 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5643 is the specification, to the end of PARENT's list of children.
5644 This is done by removing and re-adding it. */
5647 splice_child_die (dw_die_ref parent, dw_die_ref child)
5649 /* We want the declaration DIE from inside the class, not the
5650 specification DIE at toplevel. */
5651 if (child->die_parent != parent)
5653 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5659 gcc_assert (child->die_parent == parent
5660 || (child->die_parent
5661 == get_AT_ref (parent, DW_AT_specification)));
5663 reparent_child (child, parent);
5666 /* Create and return a new die with TAG_VALUE as tag. */
5668 static inline dw_die_ref
5669 new_die_raw (enum dwarf_tag tag_value)
5671 dw_die_ref die = ggc_cleared_alloc<die_node> ();
5672 die->die_tag = tag_value;
5676 /* Create and return a new die with a parent of PARENT_DIE. If
5677 PARENT_DIE is NULL, the new DIE is placed in limbo and an
5678 associated tree T must be supplied to determine parenthood
5681 static inline dw_die_ref
5682 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5684 dw_die_ref die = new_die_raw (tag_value);
5686 if (parent_die != NULL)
5687 add_child_die (parent_die, die);
5690 limbo_die_node *limbo_node;
5692 /* No DIEs created after early dwarf should end up in limbo,
5693 because the limbo list should not persist past LTO
5695 if (tag_value != DW_TAG_compile_unit
5696 /* These are allowed because they're generated while
5697 breaking out COMDAT units late. */
5698 && tag_value != DW_TAG_type_unit
5699 && tag_value != DW_TAG_skeleton_unit
5701 /* Allow nested functions to live in limbo because they will
5702 only temporarily live there, as decls_for_scope will fix
5704 && (TREE_CODE (t) != FUNCTION_DECL
5705 || !decl_function_context (t))
5706 /* Same as nested functions above but for types. Types that
5707 are local to a function will be fixed in
5709 && (!RECORD_OR_UNION_TYPE_P (t)
5710 || !TYPE_CONTEXT (t)
5711 || TREE_CODE (TYPE_CONTEXT (t)) != FUNCTION_DECL)
5712 /* FIXME debug-early: Allow late limbo DIE creation for LTO,
5713 especially in the ltrans stage, but once we implement LTO
5714 dwarf streaming, we should remove this exception. */
5717 fprintf (stderr, "symbol ended up in limbo too late:");
5718 debug_generic_stmt (t);
5722 limbo_node = ggc_cleared_alloc<limbo_die_node> ();
5723 limbo_node->die = die;
5724 limbo_node->created_for = t;
5725 limbo_node->next = limbo_die_list;
5726 limbo_die_list = limbo_node;
5732 /* Return the DIE associated with the given type specifier. */
5734 static inline dw_die_ref
5735 lookup_type_die (tree type)
5737 dw_die_ref die = TYPE_SYMTAB_DIE (type);
5738 if (die && die->removed)
5740 TYPE_SYMTAB_DIE (type) = NULL;
5746 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
5747 anonymous type named by the typedef TYPE_DIE, return the DIE of the
5748 anonymous type instead the one of the naming typedef. */
5750 static inline dw_die_ref
5751 strip_naming_typedef (tree type, dw_die_ref type_die)
5754 && TREE_CODE (type) == RECORD_TYPE
5756 && type_die->die_tag == DW_TAG_typedef
5757 && is_naming_typedef_decl (TYPE_NAME (type)))
5758 type_die = get_AT_ref (type_die, DW_AT_type);
5762 /* Like lookup_type_die, but if type is an anonymous type named by a
5763 typedef[1], return the DIE of the anonymous type instead the one of
5764 the naming typedef. This is because in gen_typedef_die, we did
5765 equate the anonymous struct named by the typedef with the DIE of
5766 the naming typedef. So by default, lookup_type_die on an anonymous
5767 struct yields the DIE of the naming typedef.
5769 [1]: Read the comment of is_naming_typedef_decl to learn about what
5770 a naming typedef is. */
5772 static inline dw_die_ref
5773 lookup_type_die_strip_naming_typedef (tree type)
5775 dw_die_ref die = lookup_type_die (type);
5776 return strip_naming_typedef (type, die);
5779 /* Equate a DIE to a given type specifier. */
5782 equate_type_number_to_die (tree type, dw_die_ref type_die)
5784 TYPE_SYMTAB_DIE (type) = type_die;
5787 static dw_die_ref maybe_create_die_with_external_ref (tree);
5788 struct GTY(()) sym_off_pair
5790 const char * GTY((skip)) sym;
5791 unsigned HOST_WIDE_INT off;
5793 static GTY(()) hash_map<tree, sym_off_pair> *external_die_map;
5795 /* Returns a hash value for X (which really is a die_struct). */
5798 decl_die_hasher::hash (die_node *x)
5800 return (hashval_t) x->decl_id;
5803 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5806 decl_die_hasher::equal (die_node *x, tree y)
5808 return (x->decl_id == DECL_UID (y));
5811 /* Return the DIE associated with a given declaration. */
5813 static inline dw_die_ref
5814 lookup_decl_die (tree decl)
5816 dw_die_ref *die = decl_die_table->find_slot_with_hash (decl, DECL_UID (decl),
5821 return maybe_create_die_with_external_ref (decl);
5824 if ((*die)->removed)
5826 decl_die_table->clear_slot (die);
5833 /* Return the DIE associated with BLOCK. */
5835 static inline dw_die_ref
5836 lookup_block_die (tree block)
5838 dw_die_ref die = BLOCK_DIE (block);
5839 if (!die && in_lto_p)
5840 return maybe_create_die_with_external_ref (block);
5844 /* Associate DIE with BLOCK. */
5847 equate_block_to_die (tree block, dw_die_ref die)
5849 BLOCK_DIE (block) = die;
5854 /* For DECL which might have early dwarf output query a SYMBOL + OFFSET
5855 style reference. Return true if we found one refering to a DIE for
5856 DECL, otherwise return false. */
5859 dwarf2out_die_ref_for_decl (tree decl, const char **sym,
5860 unsigned HOST_WIDE_INT *off)
5866 /* During WPA stage and incremental linking we use a hash-map
5867 to store the decl <-> label + offset map. */
5868 if (!external_die_map)
5870 sym_off_pair *desc = external_die_map->get (decl);
5878 if (TREE_CODE (decl) == BLOCK)
5879 die = lookup_block_die (decl);
5881 die = lookup_decl_die (decl);
5885 /* Similar to get_ref_die_offset_label, but using the "correct"
5887 *off = die->die_offset;
5888 while (die->die_parent)
5889 die = die->die_parent;
5890 /* For the containing CU DIE we compute a die_symbol in
5891 compute_comp_unit_symbol. */
5892 gcc_assert (die->die_tag == DW_TAG_compile_unit
5893 && die->die_id.die_symbol != NULL);
5894 *sym = die->die_id.die_symbol;
5898 /* Add a reference of kind ATTR_KIND to a DIE at SYMBOL + OFFSET to DIE. */
5901 add_AT_external_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind,
5902 const char *symbol, HOST_WIDE_INT offset)
5904 /* Create a fake DIE that contains the reference. Don't use
5905 new_die because we don't want to end up in the limbo list. */
5906 /* ??? We probably want to share these, thus put a ref to the DIE
5907 we create here to the external_die_map entry. */
5908 dw_die_ref ref = new_die_raw (die->die_tag);
5909 ref->die_id.die_symbol = symbol;
5910 ref->die_offset = offset;
5911 ref->with_offset = 1;
5912 add_AT_die_ref (die, attr_kind, ref);
5915 /* Create a DIE for DECL if required and add a reference to a DIE
5916 at SYMBOL + OFFSET which contains attributes dumped early. */
5919 dwarf2out_register_external_die (tree decl, const char *sym,
5920 unsigned HOST_WIDE_INT off)
5922 if (debug_info_level == DINFO_LEVEL_NONE)
5925 if (!external_die_map)
5926 external_die_map = hash_map<tree, sym_off_pair>::create_ggc (1000);
5927 gcc_checking_assert (!external_die_map->get (decl));
5928 sym_off_pair p = { IDENTIFIER_POINTER (get_identifier (sym)), off };
5929 external_die_map->put (decl, p);
5932 /* If we have a registered external DIE for DECL return a new DIE for
5933 the concrete instance with an appropriate abstract origin. */
5936 maybe_create_die_with_external_ref (tree decl)
5938 if (!external_die_map)
5940 sym_off_pair *desc = external_die_map->get (decl);
5944 const char *sym = desc->sym;
5945 unsigned HOST_WIDE_INT off = desc->off;
5948 dw_die_ref die = (TREE_CODE (decl) == BLOCK
5949 ? lookup_block_die (decl) : lookup_decl_die (decl));
5954 dw_die_ref parent = NULL;
5955 /* Need to lookup a DIE for the decls context - the containing
5956 function or translation unit. */
5957 if (TREE_CODE (decl) == BLOCK)
5959 ctx = BLOCK_SUPERCONTEXT (decl);
5960 /* ??? We do not output DIEs for all scopes thus skip as
5961 many DIEs as needed. */
5962 while (TREE_CODE (ctx) == BLOCK
5963 && !lookup_block_die (ctx))
5964 ctx = BLOCK_SUPERCONTEXT (ctx);
5967 ctx = DECL_CONTEXT (decl);
5968 /* Peel types in the context stack. */
5969 while (ctx && TYPE_P (ctx))
5970 ctx = TYPE_CONTEXT (ctx);
5971 /* Likewise namespaces in case we do not want to emit DIEs for them. */
5972 if (debug_info_level <= DINFO_LEVEL_TERSE)
5973 while (ctx && TREE_CODE (ctx) == NAMESPACE_DECL)
5974 ctx = DECL_CONTEXT (ctx);
5977 if (TREE_CODE (ctx) == BLOCK)
5978 parent = lookup_block_die (ctx);
5979 else if (TREE_CODE (ctx) == TRANSLATION_UNIT_DECL
5980 /* Keep the 1:1 association during WPA. */
5982 && flag_incremental_link != INCREMENTAL_LINK_LTO)
5983 /* Otherwise all late annotations go to the main CU which
5984 imports the original CUs. */
5985 parent = comp_unit_die ();
5986 else if (TREE_CODE (ctx) == FUNCTION_DECL
5987 && TREE_CODE (decl) != FUNCTION_DECL
5988 && TREE_CODE (decl) != PARM_DECL
5989 && TREE_CODE (decl) != RESULT_DECL
5990 && TREE_CODE (decl) != BLOCK)
5991 /* Leave function local entities parent determination to when
5992 we process scope vars. */
5995 parent = lookup_decl_die (ctx);
5998 /* In some cases the FEs fail to set DECL_CONTEXT properly.
5999 Handle this case gracefully by globalizing stuff. */
6000 parent = comp_unit_die ();
6001 /* Create a DIE "stub". */
6002 switch (TREE_CODE (decl))
6004 case TRANSLATION_UNIT_DECL:
6006 die = comp_unit_die ();
6007 /* We re-target all CU decls to the LTRANS CU DIE, so no need
6008 to create a DIE for the original CUs. */
6011 case NAMESPACE_DECL:
6012 if (is_fortran (decl))
6013 die = new_die (DW_TAG_module, parent, decl);
6015 die = new_die (DW_TAG_namespace, parent, decl);
6018 die = new_die (DW_TAG_subprogram, parent, decl);
6021 die = new_die (DW_TAG_variable, parent, decl);
6024 die = new_die (DW_TAG_variable, parent, decl);
6027 die = new_die (DW_TAG_formal_parameter, parent, decl);
6030 die = new_die (DW_TAG_constant, parent, decl);
6033 die = new_die (DW_TAG_label, parent, decl);
6036 die = new_die (DW_TAG_lexical_block, parent, decl);
6041 if (TREE_CODE (decl) == BLOCK)
6042 equate_block_to_die (decl, die);
6044 equate_decl_number_to_die (decl, die);
6046 add_desc_attribute (die, decl);
6048 /* Add a reference to the DIE providing early debug at $sym + off. */
6049 add_AT_external_die_ref (die, DW_AT_abstract_origin, sym, off);
6054 /* Returns a hash value for X (which really is a var_loc_list). */
6057 decl_loc_hasher::hash (var_loc_list *x)
6059 return (hashval_t) x->decl_id;
6062 /* Return nonzero if decl_id of var_loc_list X is the same as
6066 decl_loc_hasher::equal (var_loc_list *x, const_tree y)
6068 return (x->decl_id == DECL_UID (y));
6071 /* Return the var_loc list associated with a given declaration. */
6073 static inline var_loc_list *
6074 lookup_decl_loc (const_tree decl)
6076 if (!decl_loc_table)
6078 return decl_loc_table->find_with_hash (decl, DECL_UID (decl));
6081 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
6084 dw_loc_list_hasher::hash (cached_dw_loc_list *x)
6086 return (hashval_t) x->decl_id;
6089 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
6093 dw_loc_list_hasher::equal (cached_dw_loc_list *x, const_tree y)
6095 return (x->decl_id == DECL_UID (y));
6098 /* Equate a DIE to a particular declaration. */
6101 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
6103 unsigned int decl_id = DECL_UID (decl);
6105 *decl_die_table->find_slot_with_hash (decl, decl_id, INSERT) = decl_die;
6106 decl_die->decl_id = decl_id;
6109 /* Return how many bits covers PIECE EXPR_LIST. */
6111 static HOST_WIDE_INT
6112 decl_piece_bitsize (rtx piece)
6114 int ret = (int) GET_MODE (piece);
6117 gcc_assert (GET_CODE (XEXP (piece, 0)) == CONCAT
6118 && CONST_INT_P (XEXP (XEXP (piece, 0), 0)));
6119 return INTVAL (XEXP (XEXP (piece, 0), 0));
6122 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
6125 decl_piece_varloc_ptr (rtx piece)
6127 if ((int) GET_MODE (piece))
6128 return &XEXP (piece, 0);
6130 return &XEXP (XEXP (piece, 0), 1);
6133 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
6134 Next is the chain of following piece nodes. */
6136 static rtx_expr_list *
6137 decl_piece_node (rtx loc_note, HOST_WIDE_INT bitsize, rtx next)
6139 if (bitsize > 0 && bitsize <= (int) MAX_MACHINE_MODE)
6140 return alloc_EXPR_LIST (bitsize, loc_note, next);
6142 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode,
6147 /* Return rtx that should be stored into loc field for
6148 LOC_NOTE and BITPOS/BITSIZE. */
6151 construct_piece_list (rtx loc_note, HOST_WIDE_INT bitpos,
6152 HOST_WIDE_INT bitsize)
6156 loc_note = decl_piece_node (loc_note, bitsize, NULL_RTX);
6158 loc_note = decl_piece_node (NULL_RTX, bitpos, loc_note);
6163 /* This function either modifies location piece list *DEST in
6164 place (if SRC and INNER is NULL), or copies location piece list
6165 *SRC to *DEST while modifying it. Location BITPOS is modified
6166 to contain LOC_NOTE, any pieces overlapping it are removed resp.
6167 not copied and if needed some padding around it is added.
6168 When modifying in place, DEST should point to EXPR_LIST where
6169 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
6170 to the start of the whole list and INNER points to the EXPR_LIST
6171 where earlier pieces cover PIECE_BITPOS bits. */
6174 adjust_piece_list (rtx *dest, rtx *src, rtx *inner,
6175 HOST_WIDE_INT bitpos, HOST_WIDE_INT piece_bitpos,
6176 HOST_WIDE_INT bitsize, rtx loc_note)
6179 bool copy = inner != NULL;
6183 /* First copy all nodes preceding the current bitpos. */
6184 while (src != inner)
6186 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
6187 decl_piece_bitsize (*src), NULL_RTX);
6188 dest = &XEXP (*dest, 1);
6189 src = &XEXP (*src, 1);
6192 /* Add padding if needed. */
6193 if (bitpos != piece_bitpos)
6195 *dest = decl_piece_node (NULL_RTX, bitpos - piece_bitpos,
6196 copy ? NULL_RTX : *dest);
6197 dest = &XEXP (*dest, 1);
6199 else if (*dest && decl_piece_bitsize (*dest) == bitsize)
6202 /* A piece with correct bitpos and bitsize already exist,
6203 just update the location for it and return. */
6204 *decl_piece_varloc_ptr (*dest) = loc_note;
6207 /* Add the piece that changed. */
6208 *dest = decl_piece_node (loc_note, bitsize, copy ? NULL_RTX : *dest);
6209 dest = &XEXP (*dest, 1);
6210 /* Skip over pieces that overlap it. */
6211 diff = bitpos - piece_bitpos + bitsize;
6214 while (diff > 0 && *src)
6217 diff -= decl_piece_bitsize (piece);
6219 src = &XEXP (piece, 1);
6222 *src = XEXP (piece, 1);
6223 free_EXPR_LIST_node (piece);
6226 /* Add padding if needed. */
6227 if (diff < 0 && *src)
6231 *dest = decl_piece_node (NULL_RTX, -diff, copy ? NULL_RTX : *dest);
6232 dest = &XEXP (*dest, 1);
6236 /* Finally copy all nodes following it. */
6239 *dest = decl_piece_node (*decl_piece_varloc_ptr (*src),
6240 decl_piece_bitsize (*src), NULL_RTX);
6241 dest = &XEXP (*dest, 1);
6242 src = &XEXP (*src, 1);
6246 /* Add a variable location node to the linked list for DECL. */
6248 static struct var_loc_node *
6249 add_var_loc_to_decl (tree decl, rtx loc_note, const char *label, var_loc_view view)
6251 unsigned int decl_id;
6253 struct var_loc_node *loc = NULL;
6254 HOST_WIDE_INT bitsize = -1, bitpos = -1;
6256 if (VAR_P (decl) && DECL_HAS_DEBUG_EXPR_P (decl))
6258 tree realdecl = DECL_DEBUG_EXPR (decl);
6259 if (handled_component_p (realdecl)
6260 || (TREE_CODE (realdecl) == MEM_REF
6261 && TREE_CODE (TREE_OPERAND (realdecl, 0)) == ADDR_EXPR))
6264 tree innerdecl = get_ref_base_and_extent_hwi (realdecl, &bitpos,
6265 &bitsize, &reverse);
6267 || !DECL_P (innerdecl)
6268 || DECL_IGNORED_P (innerdecl)
6269 || TREE_STATIC (innerdecl)
6271 || bitpos + bitsize > 256)
6277 decl_id = DECL_UID (decl);
6279 = decl_loc_table->find_slot_with_hash (decl, decl_id, INSERT);
6282 temp = ggc_cleared_alloc<var_loc_list> ();
6283 temp->decl_id = decl_id;
6289 /* For PARM_DECLs try to keep around the original incoming value,
6290 even if that means we'll emit a zero-range .debug_loc entry. */
6292 && temp->first == temp->last
6293 && TREE_CODE (decl) == PARM_DECL
6294 && NOTE_P (temp->first->loc)
6295 && NOTE_VAR_LOCATION_DECL (temp->first->loc) == decl
6296 && DECL_INCOMING_RTL (decl)
6297 && NOTE_VAR_LOCATION_LOC (temp->first->loc)
6298 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp->first->loc))
6299 == GET_CODE (DECL_INCOMING_RTL (decl))
6300 && prev_real_insn (as_a<rtx_insn *> (temp->first->loc)) == NULL_RTX
6302 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->first->loc),
6303 NOTE_VAR_LOCATION_LOC (loc_note))
6304 || (NOTE_VAR_LOCATION_STATUS (temp->first->loc)
6305 != NOTE_VAR_LOCATION_STATUS (loc_note))))
6307 loc = ggc_cleared_alloc<var_loc_node> ();
6308 temp->first->next = loc;
6310 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
6312 else if (temp->last)
6314 struct var_loc_node *last = temp->last, *unused = NULL;
6315 rtx *piece_loc = NULL, last_loc_note;
6316 HOST_WIDE_INT piece_bitpos = 0;
6320 gcc_assert (last->next == NULL);
6322 if (bitsize != -1 && GET_CODE (last->loc) == EXPR_LIST)
6324 piece_loc = &last->loc;
6327 HOST_WIDE_INT cur_bitsize = decl_piece_bitsize (*piece_loc);
6328 if (piece_bitpos + cur_bitsize > bitpos)
6330 piece_bitpos += cur_bitsize;
6331 piece_loc = &XEXP (*piece_loc, 1);
6335 /* TEMP->LAST here is either pointer to the last but one or
6336 last element in the chained list, LAST is pointer to the
6338 if (label && strcmp (last->label, label) == 0 && last->view == view)
6340 /* For SRA optimized variables if there weren't any real
6341 insns since last note, just modify the last node. */
6342 if (piece_loc != NULL)
6344 adjust_piece_list (piece_loc, NULL, NULL,
6345 bitpos, piece_bitpos, bitsize, loc_note);
6348 /* If the last note doesn't cover any instructions, remove it. */
6349 if (temp->last != last)
6351 temp->last->next = NULL;
6354 gcc_assert (strcmp (last->label, label) != 0 || last->view != view);
6358 gcc_assert (temp->first == temp->last
6359 || (temp->first->next == temp->last
6360 && TREE_CODE (decl) == PARM_DECL));
6361 memset (temp->last, '\0', sizeof (*temp->last));
6362 temp->last->loc = construct_piece_list (loc_note, bitpos, bitsize);
6366 if (bitsize == -1 && NOTE_P (last->loc))
6367 last_loc_note = last->loc;
6368 else if (piece_loc != NULL
6369 && *piece_loc != NULL_RTX
6370 && piece_bitpos == bitpos
6371 && decl_piece_bitsize (*piece_loc) == bitsize)
6372 last_loc_note = *decl_piece_varloc_ptr (*piece_loc);
6374 last_loc_note = NULL_RTX;
6375 /* If the current location is the same as the end of the list,
6376 and either both or neither of the locations is uninitialized,
6377 we have nothing to do. */
6378 if (last_loc_note == NULL_RTX
6379 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note),
6380 NOTE_VAR_LOCATION_LOC (loc_note)))
6381 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
6382 != NOTE_VAR_LOCATION_STATUS (loc_note))
6383 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note)
6384 == VAR_INIT_STATUS_UNINITIALIZED)
6385 || (NOTE_VAR_LOCATION_STATUS (loc_note)
6386 == VAR_INIT_STATUS_UNINITIALIZED))))
6388 /* Add LOC to the end of list and update LAST. If the last
6389 element of the list has been removed above, reuse its
6390 memory for the new node, otherwise allocate a new one. */
6394 memset (loc, '\0', sizeof (*loc));
6397 loc = ggc_cleared_alloc<var_loc_node> ();
6398 if (bitsize == -1 || piece_loc == NULL)
6399 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
6401 adjust_piece_list (&loc->loc, &last->loc, piece_loc,
6402 bitpos, piece_bitpos, bitsize, loc_note);
6404 /* Ensure TEMP->LAST will point either to the new last but one
6405 element of the chain, or to the last element in it. */
6406 if (last != temp->last)
6414 loc = ggc_cleared_alloc<var_loc_node> ();
6417 loc->loc = construct_piece_list (loc_note, bitpos, bitsize);
6422 /* Keep track of the number of spaces used to indent the
6423 output of the debugging routines that print the structure of
6424 the DIE internal representation. */
6425 static int print_indent;
6427 /* Indent the line the number of spaces given by print_indent. */
6430 print_spaces (FILE *outfile)
6432 fprintf (outfile, "%*s", print_indent, "");
6435 /* Print a type signature in hex. */
6438 print_signature (FILE *outfile, char *sig)
6442 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
6443 fprintf (outfile, "%02x", sig[i] & 0xff);
6447 print_discr_value (FILE *outfile, dw_discr_value *discr_value)
6449 if (discr_value->pos)
6450 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, discr_value->v.sval);
6452 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, discr_value->v.uval);
6455 static void print_loc_descr (dw_loc_descr_ref, FILE *);
6457 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
6458 RECURSE, output location descriptor operations. */
6461 print_dw_val (dw_val_node *val, bool recurse, FILE *outfile)
6463 switch (val->val_class)
6465 case dw_val_class_addr:
6466 fprintf (outfile, "address");
6468 case dw_val_class_offset:
6469 fprintf (outfile, "offset");
6471 case dw_val_class_loc:
6472 fprintf (outfile, "location descriptor");
6473 if (val->v.val_loc == NULL)
6474 fprintf (outfile, " -> <null>\n");
6477 fprintf (outfile, ":\n");
6479 print_loc_descr (val->v.val_loc, outfile);
6484 if (flag_dump_noaddr || flag_dump_unnumbered)
6485 fprintf (outfile, " #\n");
6487 fprintf (outfile, " (%p)\n", (void *) val->v.val_loc);
6490 case dw_val_class_loc_list:
6491 fprintf (outfile, "location list -> label:%s",
6492 val->v.val_loc_list->ll_symbol);
6494 case dw_val_class_view_list:
6495 val = view_list_to_loc_list_val_node (val);
6496 fprintf (outfile, "location list with views -> labels:%s and %s",
6497 val->v.val_loc_list->ll_symbol,
6498 val->v.val_loc_list->vl_symbol);
6500 case dw_val_class_range_list:
6501 fprintf (outfile, "range list");
6503 case dw_val_class_const:
6504 case dw_val_class_const_implicit:
6505 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, val->v.val_int);
6507 case dw_val_class_unsigned_const:
6508 case dw_val_class_unsigned_const_implicit:
6509 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, val->v.val_unsigned);
6511 case dw_val_class_const_double:
6512 fprintf (outfile, "constant (" HOST_WIDE_INT_PRINT_DEC","\
6513 HOST_WIDE_INT_PRINT_UNSIGNED")",
6514 val->v.val_double.high,
6515 val->v.val_double.low);
6517 case dw_val_class_wide_int:
6519 int i = val->v.val_wide->get_len ();
6520 fprintf (outfile, "constant (");
6522 if (val->v.val_wide->elt (i - 1) == 0)
6523 fprintf (outfile, "0x");
6524 fprintf (outfile, HOST_WIDE_INT_PRINT_HEX,
6525 val->v.val_wide->elt (--i));
6527 fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX,
6528 val->v.val_wide->elt (i));
6529 fprintf (outfile, ")");
6532 case dw_val_class_vec:
6533 fprintf (outfile, "floating-point or vector constant");
6535 case dw_val_class_flag:
6536 fprintf (outfile, "%u", val->v.val_flag);
6538 case dw_val_class_die_ref:
6539 if (val->v.val_die_ref.die != NULL)
6541 dw_die_ref die = val->v.val_die_ref.die;
6543 if (die->comdat_type_p)
6545 fprintf (outfile, "die -> signature: ");
6546 print_signature (outfile,
6547 die->die_id.die_type_node->signature);
6549 else if (die->die_id.die_symbol)
6551 fprintf (outfile, "die -> label: %s", die->die_id.die_symbol);
6552 if (die->with_offset)
6553 fprintf (outfile, " + %ld", die->die_offset);
6556 fprintf (outfile, "die -> %ld", die->die_offset);
6557 if (flag_dump_noaddr || flag_dump_unnumbered)
6558 fprintf (outfile, " #");
6560 fprintf (outfile, " (%p)", (void *) die);
6563 fprintf (outfile, "die -> <null>");
6565 case dw_val_class_vms_delta:
6566 fprintf (outfile, "delta: @slotcount(%s-%s)",
6567 val->v.val_vms_delta.lbl2, val->v.val_vms_delta.lbl1);
6569 case dw_val_class_symview:
6570 fprintf (outfile, "view: %s", val->v.val_symbolic_view);
6572 case dw_val_class_lbl_id:
6573 case dw_val_class_lineptr:
6574 case dw_val_class_macptr:
6575 case dw_val_class_loclistsptr:
6576 case dw_val_class_high_pc:
6577 fprintf (outfile, "label: %s", val->v.val_lbl_id);
6579 case dw_val_class_str:
6580 if (val->v.val_str->str != NULL)
6581 fprintf (outfile, "\"%s\"", val->v.val_str->str);
6583 fprintf (outfile, "<null>");
6585 case dw_val_class_file:
6586 case dw_val_class_file_implicit:
6587 fprintf (outfile, "\"%s\" (%d)", val->v.val_file->filename,
6588 val->v.val_file->emitted_number);
6590 case dw_val_class_data8:
6594 for (i = 0; i < 8; i++)
6595 fprintf (outfile, "%02x", val->v.val_data8[i]);
6598 case dw_val_class_discr_value:
6599 print_discr_value (outfile, &val->v.val_discr_value);
6601 case dw_val_class_discr_list:
6602 for (dw_discr_list_ref node = val->v.val_discr_list;
6604 node = node->dw_discr_next)
6606 if (node->dw_discr_range)
6608 fprintf (outfile, " .. ");
6609 print_discr_value (outfile, &node->dw_discr_lower_bound);
6610 print_discr_value (outfile, &node->dw_discr_upper_bound);
6613 print_discr_value (outfile, &node->dw_discr_lower_bound);
6615 if (node->dw_discr_next != NULL)
6616 fprintf (outfile, " | ");
6623 /* Likewise, for a DIE attribute. */
6626 print_attribute (dw_attr_node *a, bool recurse, FILE *outfile)
6628 print_dw_val (&a->dw_attr_val, recurse, outfile);
6632 /* Print the list of operands in the LOC location description to OUTFILE. This
6633 routine is a debugging aid only. */
6636 print_loc_descr (dw_loc_descr_ref loc, FILE *outfile)
6638 dw_loc_descr_ref l = loc;
6642 print_spaces (outfile);
6643 fprintf (outfile, "<null>\n");
6647 for (l = loc; l != NULL; l = l->dw_loc_next)
6649 print_spaces (outfile);
6650 if (flag_dump_noaddr || flag_dump_unnumbered)
6651 fprintf (outfile, "#");
6653 fprintf (outfile, "(%p)", (void *) l);
6654 fprintf (outfile, " %s",
6655 dwarf_stack_op_name (l->dw_loc_opc));
6656 if (l->dw_loc_oprnd1.val_class != dw_val_class_none)
6658 fprintf (outfile, " ");
6659 print_dw_val (&l->dw_loc_oprnd1, false, outfile);
6661 if (l->dw_loc_oprnd2.val_class != dw_val_class_none)
6663 fprintf (outfile, ", ");
6664 print_dw_val (&l->dw_loc_oprnd2, false, outfile);
6666 fprintf (outfile, "\n");
6670 /* Print the information associated with a given DIE, and its children.
6671 This routine is a debugging aid only. */
6674 print_die (dw_die_ref die, FILE *outfile)
6680 print_spaces (outfile);
6681 fprintf (outfile, "DIE %4ld: %s ",
6682 die->die_offset, dwarf_tag_name (die->die_tag));
6683 if (flag_dump_noaddr || flag_dump_unnumbered)
6684 fprintf (outfile, "#\n");
6686 fprintf (outfile, "(%p)\n", (void*) die);
6687 print_spaces (outfile);
6688 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
6689 fprintf (outfile, " offset: %ld", die->die_offset);
6690 fprintf (outfile, " mark: %d\n", die->die_mark);
6692 if (die->comdat_type_p)
6694 print_spaces (outfile);
6695 fprintf (outfile, " signature: ");
6696 print_signature (outfile, die->die_id.die_type_node->signature);
6697 fprintf (outfile, "\n");
6700 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
6702 print_spaces (outfile);
6703 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
6705 print_attribute (a, true, outfile);
6706 fprintf (outfile, "\n");
6709 if (die->die_child != NULL)
6712 FOR_EACH_CHILD (die, c, print_die (c, outfile));
6715 if (print_indent == 0)
6716 fprintf (outfile, "\n");
6719 /* Print the list of operations in the LOC location description. */
6722 debug_dwarf_loc_descr (dw_loc_descr_ref loc)
6724 print_loc_descr (loc, stderr);
6727 /* Print the information collected for a given DIE. */
6730 debug_dwarf_die (dw_die_ref die)
6732 print_die (die, stderr);
6736 debug (die_struct &ref)
6738 print_die (&ref, stderr);
6742 debug (die_struct *ptr)
6747 fprintf (stderr, "<nil>\n");
6751 /* Print all DWARF information collected for the compilation unit.
6752 This routine is a debugging aid only. */
6758 print_die (comp_unit_die (), stderr);
6761 /* Verify the DIE tree structure. */
6764 verify_die (dw_die_ref die)
6766 gcc_assert (!die->die_mark);
6767 if (die->die_parent == NULL
6768 && die->die_sib == NULL)
6770 /* Verify the die_sib list is cyclic. */
6777 while (x && !x->die_mark);
6778 gcc_assert (x == die);
6782 /* Verify all dies have the same parent. */
6783 gcc_assert (x->die_parent == die->die_parent);
6786 /* Verify the child has the proper parent and recurse. */
6787 gcc_assert (x->die_child->die_parent == x);
6788 verify_die (x->die_child);
6793 while (x && x->die_mark);
6796 /* Sanity checks on DIEs. */
6799 check_die (dw_die_ref die)
6803 bool inline_found = false;
6804 int n_location = 0, n_low_pc = 0, n_high_pc = 0, n_artificial = 0;
6805 int n_decl_line = 0, n_decl_column = 0, n_decl_file = 0;
6806 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
6811 if (a->dw_attr_val.v.val_unsigned)
6812 inline_found = true;
6814 case DW_AT_location:
6823 case DW_AT_artificial:
6826 case DW_AT_decl_column:
6829 case DW_AT_decl_line:
6832 case DW_AT_decl_file:
6839 if (n_location > 1 || n_low_pc > 1 || n_high_pc > 1 || n_artificial > 1
6840 || n_decl_column > 1 || n_decl_line > 1 || n_decl_file > 1)
6842 fprintf (stderr, "Duplicate attributes in DIE:\n");
6843 debug_dwarf_die (die);
6848 /* A debugging information entry that is a member of an abstract
6849 instance tree [that has DW_AT_inline] should not contain any
6850 attributes which describe aspects of the subroutine which vary
6851 between distinct inlined expansions or distinct out-of-line
6853 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
6854 gcc_assert (a->dw_attr != DW_AT_low_pc
6855 && a->dw_attr != DW_AT_high_pc
6856 && a->dw_attr != DW_AT_location
6857 && a->dw_attr != DW_AT_frame_base
6858 && a->dw_attr != DW_AT_call_all_calls
6859 && a->dw_attr != DW_AT_GNU_all_call_sites);
6863 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6864 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6865 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
6867 /* Calculate the checksum of a location expression. */
6870 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
6873 inchash::hash hstate;
6876 tem = (loc->dtprel << 8) | ((unsigned int) loc->dw_loc_opc);
6878 hash_loc_operands (loc, hstate);
6879 hash = hstate.end();
6883 /* Calculate the checksum of an attribute. */
6886 attr_checksum (dw_attr_node *at, struct md5_ctx *ctx, int *mark)
6888 dw_loc_descr_ref loc;
6891 CHECKSUM (at->dw_attr);
6893 /* We don't care that this was compiled with a different compiler
6894 snapshot; if the output is the same, that's what matters. */
6895 if (at->dw_attr == DW_AT_producer)
6898 switch (AT_class (at))
6900 case dw_val_class_const:
6901 case dw_val_class_const_implicit:
6902 CHECKSUM (at->dw_attr_val.v.val_int);
6904 case dw_val_class_unsigned_const:
6905 case dw_val_class_unsigned_const_implicit:
6906 CHECKSUM (at->dw_attr_val.v.val_unsigned);
6908 case dw_val_class_const_double:
6909 CHECKSUM (at->dw_attr_val.v.val_double);
6911 case dw_val_class_wide_int:
6912 CHECKSUM_BLOCK (at->dw_attr_val.v.val_wide->get_val (),
6913 get_full_len (*at->dw_attr_val.v.val_wide)
6914 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
6916 case dw_val_class_vec:
6917 CHECKSUM_BLOCK (at->dw_attr_val.v.val_vec.array,
6918 (at->dw_attr_val.v.val_vec.length
6919 * at->dw_attr_val.v.val_vec.elt_size));
6921 case dw_val_class_flag:
6922 CHECKSUM (at->dw_attr_val.v.val_flag);
6924 case dw_val_class_str:
6925 CHECKSUM_STRING (AT_string (at));
6928 case dw_val_class_addr:
6930 gcc_assert (GET_CODE (r) == SYMBOL_REF);
6931 CHECKSUM_STRING (XSTR (r, 0));
6934 case dw_val_class_offset:
6935 CHECKSUM (at->dw_attr_val.v.val_offset);
6938 case dw_val_class_loc:
6939 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
6940 loc_checksum (loc, ctx);
6943 case dw_val_class_die_ref:
6944 die_checksum (AT_ref (at), ctx, mark);
6947 case dw_val_class_fde_ref:
6948 case dw_val_class_vms_delta:
6949 case dw_val_class_symview:
6950 case dw_val_class_lbl_id:
6951 case dw_val_class_lineptr:
6952 case dw_val_class_macptr:
6953 case dw_val_class_loclistsptr:
6954 case dw_val_class_high_pc:
6957 case dw_val_class_file:
6958 case dw_val_class_file_implicit:
6959 CHECKSUM_STRING (AT_file (at)->filename);
6962 case dw_val_class_data8:
6963 CHECKSUM (at->dw_attr_val.v.val_data8);
6971 /* Calculate the checksum of a DIE. */
6974 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
6980 /* To avoid infinite recursion. */
6983 CHECKSUM (die->die_mark);
6986 die->die_mark = ++(*mark);
6988 CHECKSUM (die->die_tag);
6990 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
6991 attr_checksum (a, ctx, mark);
6993 FOR_EACH_CHILD (die, c, die_checksum (c, ctx, mark));
6997 #undef CHECKSUM_BLOCK
6998 #undef CHECKSUM_STRING
7000 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
7001 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
7002 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
7003 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
7004 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
7005 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
7006 #define CHECKSUM_ATTR(FOO) \
7007 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
7009 /* Calculate the checksum of a number in signed LEB128 format. */
7012 checksum_sleb128 (HOST_WIDE_INT value, struct md5_ctx *ctx)
7019 byte = (value & 0x7f);
7021 more = !((value == 0 && (byte & 0x40) == 0)
7022 || (value == -1 && (byte & 0x40) != 0));
7031 /* Calculate the checksum of a number in unsigned LEB128 format. */
7034 checksum_uleb128 (unsigned HOST_WIDE_INT value, struct md5_ctx *ctx)
7038 unsigned char byte = (value & 0x7f);
7041 /* More bytes to follow. */
7049 /* Checksum the context of the DIE. This adds the names of any
7050 surrounding namespaces or structures to the checksum. */
7053 checksum_die_context (dw_die_ref die, struct md5_ctx *ctx)
7057 int tag = die->die_tag;
7059 if (tag != DW_TAG_namespace
7060 && tag != DW_TAG_structure_type
7061 && tag != DW_TAG_class_type)
7064 name = get_AT_string (die, DW_AT_name);
7066 spec = get_AT_ref (die, DW_AT_specification);
7070 if (die->die_parent != NULL)
7071 checksum_die_context (die->die_parent, ctx);
7073 CHECKSUM_ULEB128 ('C');
7074 CHECKSUM_ULEB128 (tag);
7076 CHECKSUM_STRING (name);
7079 /* Calculate the checksum of a location expression. */
7082 loc_checksum_ordered (dw_loc_descr_ref loc, struct md5_ctx *ctx)
7084 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
7085 were emitted as a DW_FORM_sdata instead of a location expression. */
7086 if (loc->dw_loc_opc == DW_OP_plus_uconst && loc->dw_loc_next == NULL)
7088 CHECKSUM_ULEB128 (DW_FORM_sdata);
7089 CHECKSUM_SLEB128 ((HOST_WIDE_INT) loc->dw_loc_oprnd1.v.val_unsigned);
7093 /* Otherwise, just checksum the raw location expression. */
7096 inchash::hash hstate;
7099 CHECKSUM_ULEB128 (loc->dtprel);
7100 CHECKSUM_ULEB128 (loc->dw_loc_opc);
7101 hash_loc_operands (loc, hstate);
7102 hash = hstate.end ();
7104 loc = loc->dw_loc_next;
7108 /* Calculate the checksum of an attribute. */
7111 attr_checksum_ordered (enum dwarf_tag tag, dw_attr_node *at,
7112 struct md5_ctx *ctx, int *mark)
7114 dw_loc_descr_ref loc;
7117 if (AT_class (at) == dw_val_class_die_ref)
7119 dw_die_ref target_die = AT_ref (at);
7121 /* For pointer and reference types, we checksum only the (qualified)
7122 name of the target type (if there is a name). For friend entries,
7123 we checksum only the (qualified) name of the target type or function.
7124 This allows the checksum to remain the same whether the target type
7125 is complete or not. */
7126 if ((at->dw_attr == DW_AT_type
7127 && (tag == DW_TAG_pointer_type
7128 || tag == DW_TAG_reference_type
7129 || tag == DW_TAG_rvalue_reference_type
7130 || tag == DW_TAG_ptr_to_member_type))
7131 || (at->dw_attr == DW_AT_friend
7132 && tag == DW_TAG_friend))
7134 dw_attr_node *name_attr = get_AT (target_die, DW_AT_name);
7136 if (name_attr != NULL)
7138 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
7142 CHECKSUM_ULEB128 ('N');
7143 CHECKSUM_ULEB128 (at->dw_attr);
7144 if (decl->die_parent != NULL)
7145 checksum_die_context (decl->die_parent, ctx);
7146 CHECKSUM_ULEB128 ('E');
7147 CHECKSUM_STRING (AT_string (name_attr));
7152 /* For all other references to another DIE, we check to see if the
7153 target DIE has already been visited. If it has, we emit a
7154 backward reference; if not, we descend recursively. */
7155 if (target_die->die_mark > 0)
7157 CHECKSUM_ULEB128 ('R');
7158 CHECKSUM_ULEB128 (at->dw_attr);
7159 CHECKSUM_ULEB128 (target_die->die_mark);
7163 dw_die_ref decl = get_AT_ref (target_die, DW_AT_specification);
7167 target_die->die_mark = ++(*mark);
7168 CHECKSUM_ULEB128 ('T');
7169 CHECKSUM_ULEB128 (at->dw_attr);
7170 if (decl->die_parent != NULL)
7171 checksum_die_context (decl->die_parent, ctx);
7172 die_checksum_ordered (target_die, ctx, mark);
7177 CHECKSUM_ULEB128 ('A');
7178 CHECKSUM_ULEB128 (at->dw_attr);
7180 switch (AT_class (at))
7182 case dw_val_class_const:
7183 case dw_val_class_const_implicit:
7184 CHECKSUM_ULEB128 (DW_FORM_sdata);
7185 CHECKSUM_SLEB128 (at->dw_attr_val.v.val_int);
7188 case dw_val_class_unsigned_const:
7189 case dw_val_class_unsigned_const_implicit:
7190 CHECKSUM_ULEB128 (DW_FORM_sdata);
7191 CHECKSUM_SLEB128 ((int) at->dw_attr_val.v.val_unsigned);
7194 case dw_val_class_const_double:
7195 CHECKSUM_ULEB128 (DW_FORM_block);
7196 CHECKSUM_ULEB128 (sizeof (at->dw_attr_val.v.val_double));
7197 CHECKSUM (at->dw_attr_val.v.val_double);
7200 case dw_val_class_wide_int:
7201 CHECKSUM_ULEB128 (DW_FORM_block);
7202 CHECKSUM_ULEB128 (get_full_len (*at->dw_attr_val.v.val_wide)
7203 * HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
7204 CHECKSUM_BLOCK (at->dw_attr_val.v.val_wide->get_val (),
7205 get_full_len (*at->dw_attr_val.v.val_wide)
7206 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
7209 case dw_val_class_vec:
7210 CHECKSUM_ULEB128 (DW_FORM_block);
7211 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_vec.length
7212 * at->dw_attr_val.v.val_vec.elt_size);
7213 CHECKSUM_BLOCK (at->dw_attr_val.v.val_vec.array,
7214 (at->dw_attr_val.v.val_vec.length
7215 * at->dw_attr_val.v.val_vec.elt_size));
7218 case dw_val_class_flag:
7219 CHECKSUM_ULEB128 (DW_FORM_flag);
7220 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_flag ? 1 : 0);
7223 case dw_val_class_str:
7224 CHECKSUM_ULEB128 (DW_FORM_string);
7225 CHECKSUM_STRING (AT_string (at));
7228 case dw_val_class_addr:
7230 gcc_assert (GET_CODE (r) == SYMBOL_REF);
7231 CHECKSUM_ULEB128 (DW_FORM_string);
7232 CHECKSUM_STRING (XSTR (r, 0));
7235 case dw_val_class_offset:
7236 CHECKSUM_ULEB128 (DW_FORM_sdata);
7237 CHECKSUM_ULEB128 (at->dw_attr_val.v.val_offset);
7240 case dw_val_class_loc:
7241 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
7242 loc_checksum_ordered (loc, ctx);
7245 case dw_val_class_fde_ref:
7246 case dw_val_class_symview:
7247 case dw_val_class_lbl_id:
7248 case dw_val_class_lineptr:
7249 case dw_val_class_macptr:
7250 case dw_val_class_loclistsptr:
7251 case dw_val_class_high_pc:
7254 case dw_val_class_file:
7255 case dw_val_class_file_implicit:
7256 CHECKSUM_ULEB128 (DW_FORM_string);
7257 CHECKSUM_STRING (AT_file (at)->filename);
7260 case dw_val_class_data8:
7261 CHECKSUM (at->dw_attr_val.v.val_data8);
7269 struct checksum_attributes
7271 dw_attr_node *at_name;
7272 dw_attr_node *at_type;
7273 dw_attr_node *at_friend;
7274 dw_attr_node *at_accessibility;
7275 dw_attr_node *at_address_class;
7276 dw_attr_node *at_alignment;
7277 dw_attr_node *at_allocated;
7278 dw_attr_node *at_artificial;
7279 dw_attr_node *at_associated;
7280 dw_attr_node *at_binary_scale;
7281 dw_attr_node *at_bit_offset;
7282 dw_attr_node *at_bit_size;
7283 dw_attr_node *at_bit_stride;
7284 dw_attr_node *at_byte_size;
7285 dw_attr_node *at_byte_stride;
7286 dw_attr_node *at_const_value;
7287 dw_attr_node *at_containing_type;
7288 dw_attr_node *at_count;
7289 dw_attr_node *at_data_location;
7290 dw_attr_node *at_data_member_location;
7291 dw_attr_node *at_decimal_scale;
7292 dw_attr_node *at_decimal_sign;
7293 dw_attr_node *at_default_value;
7294 dw_attr_node *at_digit_count;
7295 dw_attr_node *at_discr;
7296 dw_attr_node *at_discr_list;
7297 dw_attr_node *at_discr_value;
7298 dw_attr_node *at_encoding;
7299 dw_attr_node *at_endianity;
7300 dw_attr_node *at_explicit;
7301 dw_attr_node *at_is_optional;
7302 dw_attr_node *at_location;
7303 dw_attr_node *at_lower_bound;
7304 dw_attr_node *at_mutable;
7305 dw_attr_node *at_ordering;
7306 dw_attr_node *at_picture_string;
7307 dw_attr_node *at_prototyped;
7308 dw_attr_node *at_small;
7309 dw_attr_node *at_segment;
7310 dw_attr_node *at_string_length;
7311 dw_attr_node *at_string_length_bit_size;
7312 dw_attr_node *at_string_length_byte_size;
7313 dw_attr_node *at_threads_scaled;
7314 dw_attr_node *at_upper_bound;
7315 dw_attr_node *at_use_location;
7316 dw_attr_node *at_use_UTF8;
7317 dw_attr_node *at_variable_parameter;
7318 dw_attr_node *at_virtuality;
7319 dw_attr_node *at_visibility;
7320 dw_attr_node *at_vtable_elem_location;
7323 /* Collect the attributes that we will want to use for the checksum. */
7326 collect_checksum_attributes (struct checksum_attributes *attrs, dw_die_ref die)
7331 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7342 attrs->at_friend = a;
7344 case DW_AT_accessibility:
7345 attrs->at_accessibility = a;
7347 case DW_AT_address_class:
7348 attrs->at_address_class = a;
7350 case DW_AT_alignment:
7351 attrs->at_alignment = a;
7353 case DW_AT_allocated:
7354 attrs->at_allocated = a;
7356 case DW_AT_artificial:
7357 attrs->at_artificial = a;
7359 case DW_AT_associated:
7360 attrs->at_associated = a;
7362 case DW_AT_binary_scale:
7363 attrs->at_binary_scale = a;
7365 case DW_AT_bit_offset:
7366 attrs->at_bit_offset = a;
7368 case DW_AT_bit_size:
7369 attrs->at_bit_size = a;
7371 case DW_AT_bit_stride:
7372 attrs->at_bit_stride = a;
7374 case DW_AT_byte_size:
7375 attrs->at_byte_size = a;
7377 case DW_AT_byte_stride:
7378 attrs->at_byte_stride = a;
7380 case DW_AT_const_value:
7381 attrs->at_const_value = a;
7383 case DW_AT_containing_type:
7384 attrs->at_containing_type = a;
7387 attrs->at_count = a;
7389 case DW_AT_data_location:
7390 attrs->at_data_location = a;
7392 case DW_AT_data_member_location:
7393 attrs->at_data_member_location = a;
7395 case DW_AT_decimal_scale:
7396 attrs->at_decimal_scale = a;
7398 case DW_AT_decimal_sign:
7399 attrs->at_decimal_sign = a;
7401 case DW_AT_default_value:
7402 attrs->at_default_value = a;
7404 case DW_AT_digit_count:
7405 attrs->at_digit_count = a;
7408 attrs->at_discr = a;
7410 case DW_AT_discr_list:
7411 attrs->at_discr_list = a;
7413 case DW_AT_discr_value:
7414 attrs->at_discr_value = a;
7416 case DW_AT_encoding:
7417 attrs->at_encoding = a;
7419 case DW_AT_endianity:
7420 attrs->at_endianity = a;
7422 case DW_AT_explicit:
7423 attrs->at_explicit = a;
7425 case DW_AT_is_optional:
7426 attrs->at_is_optional = a;
7428 case DW_AT_location:
7429 attrs->at_location = a;
7431 case DW_AT_lower_bound:
7432 attrs->at_lower_bound = a;
7435 attrs->at_mutable = a;
7437 case DW_AT_ordering:
7438 attrs->at_ordering = a;
7440 case DW_AT_picture_string:
7441 attrs->at_picture_string = a;
7443 case DW_AT_prototyped:
7444 attrs->at_prototyped = a;
7447 attrs->at_small = a;
7450 attrs->at_segment = a;
7452 case DW_AT_string_length:
7453 attrs->at_string_length = a;
7455 case DW_AT_string_length_bit_size:
7456 attrs->at_string_length_bit_size = a;
7458 case DW_AT_string_length_byte_size:
7459 attrs->at_string_length_byte_size = a;
7461 case DW_AT_threads_scaled:
7462 attrs->at_threads_scaled = a;
7464 case DW_AT_upper_bound:
7465 attrs->at_upper_bound = a;
7467 case DW_AT_use_location:
7468 attrs->at_use_location = a;
7470 case DW_AT_use_UTF8:
7471 attrs->at_use_UTF8 = a;
7473 case DW_AT_variable_parameter:
7474 attrs->at_variable_parameter = a;
7476 case DW_AT_virtuality:
7477 attrs->at_virtuality = a;
7479 case DW_AT_visibility:
7480 attrs->at_visibility = a;
7482 case DW_AT_vtable_elem_location:
7483 attrs->at_vtable_elem_location = a;
7491 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
7494 die_checksum_ordered (dw_die_ref die, struct md5_ctx *ctx, int *mark)
7498 struct checksum_attributes attrs;
7500 CHECKSUM_ULEB128 ('D');
7501 CHECKSUM_ULEB128 (die->die_tag);
7503 memset (&attrs, 0, sizeof (attrs));
7505 decl = get_AT_ref (die, DW_AT_specification);
7507 collect_checksum_attributes (&attrs, decl);
7508 collect_checksum_attributes (&attrs, die);
7510 CHECKSUM_ATTR (attrs.at_name);
7511 CHECKSUM_ATTR (attrs.at_accessibility);
7512 CHECKSUM_ATTR (attrs.at_address_class);
7513 CHECKSUM_ATTR (attrs.at_allocated);
7514 CHECKSUM_ATTR (attrs.at_artificial);
7515 CHECKSUM_ATTR (attrs.at_associated);
7516 CHECKSUM_ATTR (attrs.at_binary_scale);
7517 CHECKSUM_ATTR (attrs.at_bit_offset);
7518 CHECKSUM_ATTR (attrs.at_bit_size);
7519 CHECKSUM_ATTR (attrs.at_bit_stride);
7520 CHECKSUM_ATTR (attrs.at_byte_size);
7521 CHECKSUM_ATTR (attrs.at_byte_stride);
7522 CHECKSUM_ATTR (attrs.at_const_value);
7523 CHECKSUM_ATTR (attrs.at_containing_type);
7524 CHECKSUM_ATTR (attrs.at_count);
7525 CHECKSUM_ATTR (attrs.at_data_location);
7526 CHECKSUM_ATTR (attrs.at_data_member_location);
7527 CHECKSUM_ATTR (attrs.at_decimal_scale);
7528 CHECKSUM_ATTR (attrs.at_decimal_sign);
7529 CHECKSUM_ATTR (attrs.at_default_value);
7530 CHECKSUM_ATTR (attrs.at_digit_count);
7531 CHECKSUM_ATTR (attrs.at_discr);
7532 CHECKSUM_ATTR (attrs.at_discr_list);
7533 CHECKSUM_ATTR (attrs.at_discr_value);
7534 CHECKSUM_ATTR (attrs.at_encoding);
7535 CHECKSUM_ATTR (attrs.at_endianity);
7536 CHECKSUM_ATTR (attrs.at_explicit);
7537 CHECKSUM_ATTR (attrs.at_is_optional);
7538 CHECKSUM_ATTR (attrs.at_location);
7539 CHECKSUM_ATTR (attrs.at_lower_bound);
7540 CHECKSUM_ATTR (attrs.at_mutable);
7541 CHECKSUM_ATTR (attrs.at_ordering);
7542 CHECKSUM_ATTR (attrs.at_picture_string);
7543 CHECKSUM_ATTR (attrs.at_prototyped);
7544 CHECKSUM_ATTR (attrs.at_small);
7545 CHECKSUM_ATTR (attrs.at_segment);
7546 CHECKSUM_ATTR (attrs.at_string_length);
7547 CHECKSUM_ATTR (attrs.at_string_length_bit_size);
7548 CHECKSUM_ATTR (attrs.at_string_length_byte_size);
7549 CHECKSUM_ATTR (attrs.at_threads_scaled);
7550 CHECKSUM_ATTR (attrs.at_upper_bound);
7551 CHECKSUM_ATTR (attrs.at_use_location);
7552 CHECKSUM_ATTR (attrs.at_use_UTF8);
7553 CHECKSUM_ATTR (attrs.at_variable_parameter);
7554 CHECKSUM_ATTR (attrs.at_virtuality);
7555 CHECKSUM_ATTR (attrs.at_visibility);
7556 CHECKSUM_ATTR (attrs.at_vtable_elem_location);
7557 CHECKSUM_ATTR (attrs.at_type);
7558 CHECKSUM_ATTR (attrs.at_friend);
7559 CHECKSUM_ATTR (attrs.at_alignment);
7561 /* Checksum the child DIEs. */
7564 dw_attr_node *name_attr;
7567 name_attr = get_AT (c, DW_AT_name);
7568 if (is_template_instantiation (c))
7570 /* Ignore instantiations of member type and function templates. */
7572 else if (name_attr != NULL
7573 && (is_type_die (c) || c->die_tag == DW_TAG_subprogram))
7575 /* Use a shallow checksum for named nested types and member
7577 CHECKSUM_ULEB128 ('S');
7578 CHECKSUM_ULEB128 (c->die_tag);
7579 CHECKSUM_STRING (AT_string (name_attr));
7583 /* Use a deep checksum for other children. */
7584 /* Mark this DIE so it gets processed when unmarking. */
7585 if (c->die_mark == 0)
7587 die_checksum_ordered (c, ctx, mark);
7589 } while (c != die->die_child);
7591 CHECKSUM_ULEB128 (0);
7594 /* Add a type name and tag to a hash. */
7596 die_odr_checksum (int tag, const char *name, md5_ctx *ctx)
7598 CHECKSUM_ULEB128 (tag);
7599 CHECKSUM_STRING (name);
7603 #undef CHECKSUM_STRING
7604 #undef CHECKSUM_ATTR
7605 #undef CHECKSUM_LEB128
7606 #undef CHECKSUM_ULEB128
7608 /* Generate the type signature for DIE. This is computed by generating an
7609 MD5 checksum over the DIE's tag, its relevant attributes, and its
7610 children. Attributes that are references to other DIEs are processed
7611 by recursion, using the MARK field to prevent infinite recursion.
7612 If the DIE is nested inside a namespace or another type, we also
7613 need to include that context in the signature. The lower 64 bits
7614 of the resulting MD5 checksum comprise the signature. */
7617 generate_type_signature (dw_die_ref die, comdat_type_node *type_node)
7621 unsigned char checksum[16];
7626 name = get_AT_string (die, DW_AT_name);
7627 decl = get_AT_ref (die, DW_AT_specification);
7628 parent = get_die_parent (die);
7630 /* First, compute a signature for just the type name (and its surrounding
7631 context, if any. This is stored in the type unit DIE for link-time
7632 ODR (one-definition rule) checking. */
7634 if (is_cxx () && name != NULL)
7636 md5_init_ctx (&ctx);
7638 /* Checksum the names of surrounding namespaces and structures. */
7640 checksum_die_context (parent, &ctx);
7642 /* Checksum the current DIE. */
7643 die_odr_checksum (die->die_tag, name, &ctx);
7644 md5_finish_ctx (&ctx, checksum);
7646 add_AT_data8 (type_node->root_die, DW_AT_GNU_odr_signature, &checksum[8]);
7649 /* Next, compute the complete type signature. */
7651 md5_init_ctx (&ctx);
7653 die->die_mark = mark;
7655 /* Checksum the names of surrounding namespaces and structures. */
7657 checksum_die_context (parent, &ctx);
7659 /* Checksum the DIE and its children. */
7660 die_checksum_ordered (die, &ctx, &mark);
7661 unmark_all_dies (die);
7662 md5_finish_ctx (&ctx, checksum);
7664 /* Store the signature in the type node and link the type DIE and the
7665 type node together. */
7666 memcpy (type_node->signature, &checksum[16 - DWARF_TYPE_SIGNATURE_SIZE],
7667 DWARF_TYPE_SIGNATURE_SIZE);
7668 die->comdat_type_p = true;
7669 die->die_id.die_type_node = type_node;
7670 type_node->type_die = die;
7672 /* If the DIE is a specification, link its declaration to the type node
7676 decl->comdat_type_p = true;
7677 decl->die_id.die_type_node = type_node;
7681 /* Do the location expressions look same? */
7683 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
7685 return loc1->dw_loc_opc == loc2->dw_loc_opc
7686 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
7687 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
7690 /* Do the values look the same? */
7692 same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark)
7694 dw_loc_descr_ref loc1, loc2;
7697 if (v1->val_class != v2->val_class)
7700 switch (v1->val_class)
7702 case dw_val_class_const:
7703 case dw_val_class_const_implicit:
7704 return v1->v.val_int == v2->v.val_int;
7705 case dw_val_class_unsigned_const:
7706 case dw_val_class_unsigned_const_implicit:
7707 return v1->v.val_unsigned == v2->v.val_unsigned;
7708 case dw_val_class_const_double:
7709 return v1->v.val_double.high == v2->v.val_double.high
7710 && v1->v.val_double.low == v2->v.val_double.low;
7711 case dw_val_class_wide_int:
7712 return *v1->v.val_wide == *v2->v.val_wide;
7713 case dw_val_class_vec:
7714 if (v1->v.val_vec.length != v2->v.val_vec.length
7715 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
7717 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
7718 v1->v.val_vec.length * v1->v.val_vec.elt_size))
7721 case dw_val_class_flag:
7722 return v1->v.val_flag == v2->v.val_flag;
7723 case dw_val_class_str:
7724 return !strcmp (v1->v.val_str->str, v2->v.val_str->str);
7726 case dw_val_class_addr:
7727 r1 = v1->v.val_addr;
7728 r2 = v2->v.val_addr;
7729 if (GET_CODE (r1) != GET_CODE (r2))
7731 return !rtx_equal_p (r1, r2);
7733 case dw_val_class_offset:
7734 return v1->v.val_offset == v2->v.val_offset;
7736 case dw_val_class_loc:
7737 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
7739 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
7740 if (!same_loc_p (loc1, loc2, mark))
7742 return !loc1 && !loc2;
7744 case dw_val_class_die_ref:
7745 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
7747 case dw_val_class_symview:
7748 return strcmp (v1->v.val_symbolic_view, v2->v.val_symbolic_view) == 0;
7750 case dw_val_class_fde_ref:
7751 case dw_val_class_vms_delta:
7752 case dw_val_class_lbl_id:
7753 case dw_val_class_lineptr:
7754 case dw_val_class_macptr:
7755 case dw_val_class_loclistsptr:
7756 case dw_val_class_high_pc:
7759 case dw_val_class_file:
7760 case dw_val_class_file_implicit:
7761 return v1->v.val_file == v2->v.val_file;
7763 case dw_val_class_data8:
7764 return !memcmp (v1->v.val_data8, v2->v.val_data8, 8);
7771 /* Do the attributes look the same? */
7774 same_attr_p (dw_attr_node *at1, dw_attr_node *at2, int *mark)
7776 if (at1->dw_attr != at2->dw_attr)
7779 /* We don't care that this was compiled with a different compiler
7780 snapshot; if the output is the same, that's what matters. */
7781 if (at1->dw_attr == DW_AT_producer)
7784 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
7787 /* Do the dies look the same? */
7790 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
7796 /* To avoid infinite recursion. */
7798 return die1->die_mark == die2->die_mark;
7799 die1->die_mark = die2->die_mark = ++(*mark);
7801 if (die1->die_tag != die2->die_tag)
7804 if (vec_safe_length (die1->die_attr) != vec_safe_length (die2->die_attr))
7807 FOR_EACH_VEC_SAFE_ELT (die1->die_attr, ix, a1)
7808 if (!same_attr_p (a1, &(*die2->die_attr)[ix], mark))
7811 c1 = die1->die_child;
7812 c2 = die2->die_child;
7821 if (!same_die_p (c1, c2, mark))
7825 if (c1 == die1->die_child)
7827 if (c2 == die2->die_child)
7837 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7838 children, and set die_symbol. */
7841 compute_comp_unit_symbol (dw_die_ref unit_die)
7843 const char *die_name = get_AT_string (unit_die, DW_AT_name);
7844 const char *base = die_name ? lbasename (die_name) : "anonymous";
7845 char *name = XALLOCAVEC (char, strlen (base) + 64);
7848 unsigned char checksum[16];
7851 /* Compute the checksum of the DIE, then append part of it as hex digits to
7852 the name filename of the unit. */
7854 md5_init_ctx (&ctx);
7856 die_checksum (unit_die, &ctx, &mark);
7857 unmark_all_dies (unit_die);
7858 md5_finish_ctx (&ctx, checksum);
7860 /* When we this for comp_unit_die () we have a DW_AT_name that might
7861 not start with a letter but with anything valid for filenames and
7862 clean_symbol_name doesn't fix that up. Prepend 'g' if the first
7863 character is not a letter. */
7864 sprintf (name, "%s%s.", ISALPHA (*base) ? "" : "g", base);
7865 clean_symbol_name (name);
7867 p = name + strlen (name);
7868 for (i = 0; i < 4; i++)
7870 sprintf (p, "%.2x", checksum[i]);
7874 unit_die->die_id.die_symbol = xstrdup (name);
7877 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7880 is_type_die (dw_die_ref die)
7882 switch (die->die_tag)
7884 case DW_TAG_array_type:
7885 case DW_TAG_class_type:
7886 case DW_TAG_interface_type:
7887 case DW_TAG_enumeration_type:
7888 case DW_TAG_pointer_type:
7889 case DW_TAG_reference_type:
7890 case DW_TAG_rvalue_reference_type:
7891 case DW_TAG_string_type:
7892 case DW_TAG_structure_type:
7893 case DW_TAG_subroutine_type:
7894 case DW_TAG_union_type:
7895 case DW_TAG_ptr_to_member_type:
7896 case DW_TAG_set_type:
7897 case DW_TAG_subrange_type:
7898 case DW_TAG_base_type:
7899 case DW_TAG_const_type:
7900 case DW_TAG_file_type:
7901 case DW_TAG_packed_type:
7902 case DW_TAG_volatile_type:
7903 case DW_TAG_typedef:
7910 /* Returns true iff C is a compile-unit DIE. */
7913 is_cu_die (dw_die_ref c)
7915 return c && (c->die_tag == DW_TAG_compile_unit
7916 || c->die_tag == DW_TAG_skeleton_unit);
7919 /* Returns true iff C is a unit DIE of some sort. */
7922 is_unit_die (dw_die_ref c)
7924 return c && (c->die_tag == DW_TAG_compile_unit
7925 || c->die_tag == DW_TAG_partial_unit
7926 || c->die_tag == DW_TAG_type_unit
7927 || c->die_tag == DW_TAG_skeleton_unit);
7930 /* Returns true iff C is a namespace DIE. */
7933 is_namespace_die (dw_die_ref c)
7935 return c && c->die_tag == DW_TAG_namespace;
7938 /* Return non-zero if this DIE is a template parameter. */
7941 is_template_parameter (dw_die_ref die)
7943 switch (die->die_tag)
7945 case DW_TAG_template_type_param:
7946 case DW_TAG_template_value_param:
7947 case DW_TAG_GNU_template_template_param:
7948 case DW_TAG_GNU_template_parameter_pack:
7955 /* Return non-zero if this DIE represents a template instantiation. */
7958 is_template_instantiation (dw_die_ref die)
7962 if (!is_type_die (die) && die->die_tag != DW_TAG_subprogram)
7964 FOR_EACH_CHILD (die, c, if (is_template_parameter (c)) return true);
7969 gen_internal_sym (const char *prefix)
7971 char buf[MAX_ARTIFICIAL_LABEL_BYTES];
7973 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
7974 return xstrdup (buf);
7977 /* Return non-zero if this DIE is a declaration. */
7980 is_declaration_die (dw_die_ref die)
7985 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
7986 if (a->dw_attr == DW_AT_declaration)
7992 /* Return non-zero if this DIE is nested inside a subprogram. */
7995 is_nested_in_subprogram (dw_die_ref die)
7997 dw_die_ref decl = get_AT_ref (die, DW_AT_specification);
8001 return local_scope_p (decl);
8004 /* Return non-zero if this DIE contains a defining declaration of a
8008 contains_subprogram_definition (dw_die_ref die)
8012 if (die->die_tag == DW_TAG_subprogram && ! is_declaration_die (die))
8014 FOR_EACH_CHILD (die, c, if (contains_subprogram_definition (c)) return 1);
8018 /* Return non-zero if this is a type DIE that should be moved to a
8019 COMDAT .debug_types section or .debug_info section with DW_UT_*type
8023 should_move_die_to_comdat (dw_die_ref die)
8025 switch (die->die_tag)
8027 case DW_TAG_class_type:
8028 case DW_TAG_structure_type:
8029 case DW_TAG_enumeration_type:
8030 case DW_TAG_union_type:
8031 /* Don't move declarations, inlined instances, types nested in a
8032 subprogram, or types that contain subprogram definitions. */
8033 if (is_declaration_die (die)
8034 || get_AT (die, DW_AT_abstract_origin)
8035 || is_nested_in_subprogram (die)
8036 || contains_subprogram_definition (die))
8039 case DW_TAG_array_type:
8040 case DW_TAG_interface_type:
8041 case DW_TAG_pointer_type:
8042 case DW_TAG_reference_type:
8043 case DW_TAG_rvalue_reference_type:
8044 case DW_TAG_string_type:
8045 case DW_TAG_subroutine_type:
8046 case DW_TAG_ptr_to_member_type:
8047 case DW_TAG_set_type:
8048 case DW_TAG_subrange_type:
8049 case DW_TAG_base_type:
8050 case DW_TAG_const_type:
8051 case DW_TAG_file_type:
8052 case DW_TAG_packed_type:
8053 case DW_TAG_volatile_type:
8054 case DW_TAG_typedef:
8060 /* Make a clone of DIE. */
8063 clone_die (dw_die_ref die)
8065 dw_die_ref clone = new_die_raw (die->die_tag);
8069 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8070 add_dwarf_attr (clone, a);
8075 /* Make a clone of the tree rooted at DIE. */
8078 clone_tree (dw_die_ref die)
8081 dw_die_ref clone = clone_die (die);
8083 FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree (c)));
8088 /* Make a clone of DIE as a declaration. */
8091 clone_as_declaration (dw_die_ref die)
8098 /* If the DIE is already a declaration, just clone it. */
8099 if (is_declaration_die (die))
8100 return clone_die (die);
8102 /* If the DIE is a specification, just clone its declaration DIE. */
8103 decl = get_AT_ref (die, DW_AT_specification);
8106 clone = clone_die (decl);
8107 if (die->comdat_type_p)
8108 add_AT_die_ref (clone, DW_AT_signature, die);
8112 clone = new_die_raw (die->die_tag);
8114 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8116 /* We don't want to copy over all attributes.
8117 For example we don't want DW_AT_byte_size because otherwise we will no
8118 longer have a declaration and GDB will treat it as a definition. */
8122 case DW_AT_abstract_origin:
8123 case DW_AT_artificial:
8124 case DW_AT_containing_type:
8125 case DW_AT_external:
8128 case DW_AT_virtuality:
8129 case DW_AT_linkage_name:
8130 case DW_AT_MIPS_linkage_name:
8131 add_dwarf_attr (clone, a);
8133 case DW_AT_byte_size:
8134 case DW_AT_alignment:
8140 if (die->comdat_type_p)
8141 add_AT_die_ref (clone, DW_AT_signature, die);
8143 add_AT_flag (clone, DW_AT_declaration, 1);
8148 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
8150 struct decl_table_entry
8156 /* Helpers to manipulate hash table of copied declarations. */
8158 /* Hashtable helpers. */
8160 struct decl_table_entry_hasher : free_ptr_hash <decl_table_entry>
8162 typedef die_struct *compare_type;
8163 static inline hashval_t hash (const decl_table_entry *);
8164 static inline bool equal (const decl_table_entry *, const die_struct *);
8168 decl_table_entry_hasher::hash (const decl_table_entry *entry)
8170 return htab_hash_pointer (entry->orig);
8174 decl_table_entry_hasher::equal (const decl_table_entry *entry1,
8175 const die_struct *entry2)
8177 return entry1->orig == entry2;
8180 typedef hash_table<decl_table_entry_hasher> decl_hash_type;
8182 /* Copy DIE and its ancestors, up to, but not including, the compile unit
8183 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
8184 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
8185 to check if the ancestor has already been copied into UNIT. */
8188 copy_ancestor_tree (dw_die_ref unit, dw_die_ref die,
8189 decl_hash_type *decl_table)
8191 dw_die_ref parent = die->die_parent;
8192 dw_die_ref new_parent = unit;
8194 decl_table_entry **slot = NULL;
8195 struct decl_table_entry *entry = NULL;
8197 /* If DIE refers to a stub unfold that so we get the appropriate
8198 DIE registered as orig in decl_table. */
8199 if (dw_die_ref c = get_AT_ref (die, DW_AT_signature))
8204 /* Check if the entry has already been copied to UNIT. */
8205 slot = decl_table->find_slot_with_hash (die, htab_hash_pointer (die),
8207 if (*slot != HTAB_EMPTY_ENTRY)
8213 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
8214 entry = XCNEW (struct decl_table_entry);
8222 dw_die_ref spec = get_AT_ref (parent, DW_AT_specification);
8225 if (!is_unit_die (parent))
8226 new_parent = copy_ancestor_tree (unit, parent, decl_table);
8229 copy = clone_as_declaration (die);
8230 add_child_die (new_parent, copy);
8234 /* Record the pointer to the copy. */
8240 /* Copy the declaration context to the new type unit DIE. This includes
8241 any surrounding namespace or type declarations. If the DIE has an
8242 AT_specification attribute, it also includes attributes and children
8243 attached to the specification, and returns a pointer to the original
8244 parent of the declaration DIE. Returns NULL otherwise. */
8247 copy_declaration_context (dw_die_ref unit, dw_die_ref die)
8250 dw_die_ref new_decl;
8251 dw_die_ref orig_parent = NULL;
8253 decl = get_AT_ref (die, DW_AT_specification);
8262 /* The original DIE will be changed to a declaration, and must
8263 be moved to be a child of the original declaration DIE. */
8264 orig_parent = decl->die_parent;
8266 /* Copy the type node pointer from the new DIE to the original
8267 declaration DIE so we can forward references later. */
8268 decl->comdat_type_p = true;
8269 decl->die_id.die_type_node = die->die_id.die_type_node;
8271 remove_AT (die, DW_AT_specification);
8273 FOR_EACH_VEC_SAFE_ELT (decl->die_attr, ix, a)
8275 if (a->dw_attr != DW_AT_name
8276 && a->dw_attr != DW_AT_declaration
8277 && a->dw_attr != DW_AT_external)
8278 add_dwarf_attr (die, a);
8281 FOR_EACH_CHILD (decl, c, add_child_die (die, clone_tree (c)));
8284 if (decl->die_parent != NULL
8285 && !is_unit_die (decl->die_parent))
8287 new_decl = copy_ancestor_tree (unit, decl, NULL);
8288 if (new_decl != NULL)
8290 remove_AT (new_decl, DW_AT_signature);
8291 add_AT_specification (die, new_decl);
8298 /* Generate the skeleton ancestor tree for the given NODE, then clone
8299 the DIE and add the clone into the tree. */
8302 generate_skeleton_ancestor_tree (skeleton_chain_node *node)
8304 if (node->new_die != NULL)
8307 node->new_die = clone_as_declaration (node->old_die);
8309 if (node->parent != NULL)
8311 generate_skeleton_ancestor_tree (node->parent);
8312 add_child_die (node->parent->new_die, node->new_die);
8316 /* Generate a skeleton tree of DIEs containing any declarations that are
8317 found in the original tree. We traverse the tree looking for declaration
8318 DIEs, and construct the skeleton from the bottom up whenever we find one. */
8321 generate_skeleton_bottom_up (skeleton_chain_node *parent)
8323 skeleton_chain_node node;
8326 dw_die_ref prev = NULL;
8327 dw_die_ref next = NULL;
8329 node.parent = parent;
8331 first = c = parent->old_die->die_child;
8335 if (prev == NULL || prev->die_sib == c)
8338 next = (c == first ? NULL : c->die_sib);
8340 node.new_die = NULL;
8341 if (is_declaration_die (c))
8343 if (is_template_instantiation (c))
8345 /* Instantiated templates do not need to be cloned into the
8346 type unit. Just move the DIE and its children back to
8347 the skeleton tree (in the main CU). */
8348 remove_child_with_prev (c, prev);
8349 add_child_die (parent->new_die, c);
8352 else if (c->comdat_type_p)
8354 /* This is the skeleton of earlier break_out_comdat_types
8355 type. Clone the existing DIE, but keep the children
8356 under the original (which is in the main CU). */
8357 dw_die_ref clone = clone_die (c);
8359 replace_child (c, clone, prev);
8360 generate_skeleton_ancestor_tree (parent);
8361 add_child_die (parent->new_die, c);
8367 /* Clone the existing DIE, move the original to the skeleton
8368 tree (which is in the main CU), and put the clone, with
8369 all the original's children, where the original came from
8370 (which is about to be moved to the type unit). */
8371 dw_die_ref clone = clone_die (c);
8372 move_all_children (c, clone);
8374 /* If the original has a DW_AT_object_pointer attribute,
8375 it would now point to a child DIE just moved to the
8376 cloned tree, so we need to remove that attribute from
8378 remove_AT (c, DW_AT_object_pointer);
8380 replace_child (c, clone, prev);
8381 generate_skeleton_ancestor_tree (parent);
8382 add_child_die (parent->new_die, c);
8383 node.old_die = clone;
8388 generate_skeleton_bottom_up (&node);
8389 } while (next != NULL);
8392 /* Wrapper function for generate_skeleton_bottom_up. */
8395 generate_skeleton (dw_die_ref die)
8397 skeleton_chain_node node;
8400 node.new_die = NULL;
8403 /* If this type definition is nested inside another type,
8404 and is not an instantiation of a template, always leave
8405 at least a declaration in its place. */
8406 if (die->die_parent != NULL
8407 && is_type_die (die->die_parent)
8408 && !is_template_instantiation (die))
8409 node.new_die = clone_as_declaration (die);
8411 generate_skeleton_bottom_up (&node);
8412 return node.new_die;
8415 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
8416 declaration. The original DIE is moved to a new compile unit so that
8417 existing references to it follow it to the new location. If any of the
8418 original DIE's descendants is a declaration, we need to replace the
8419 original DIE with a skeleton tree and move the declarations back into the
8423 remove_child_or_replace_with_skeleton (dw_die_ref unit, dw_die_ref child,
8426 dw_die_ref skeleton, orig_parent;
8428 /* Copy the declaration context to the type unit DIE. If the returned
8429 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
8431 orig_parent = copy_declaration_context (unit, child);
8433 skeleton = generate_skeleton (child);
8434 if (skeleton == NULL)
8435 remove_child_with_prev (child, prev);
8438 skeleton->comdat_type_p = true;
8439 skeleton->die_id.die_type_node = child->die_id.die_type_node;
8441 /* If the original DIE was a specification, we need to put
8442 the skeleton under the parent DIE of the declaration.
8443 This leaves the original declaration in the tree, but
8444 it will be pruned later since there are no longer any
8445 references to it. */
8446 if (orig_parent != NULL)
8448 remove_child_with_prev (child, prev);
8449 add_child_die (orig_parent, skeleton);
8452 replace_child (child, skeleton, prev);
8459 copy_dwarf_procs_ref_in_attrs (dw_die_ref die,
8460 comdat_type_node *type_node,
8461 hash_map<dw_die_ref, dw_die_ref> &copied_dwarf_procs);
8463 /* Helper for copy_dwarf_procs_ref_in_dies. Make a copy of the DIE DWARF
8464 procedure, put it under TYPE_NODE and return the copy. Continue looking for
8465 DWARF procedure references in the DW_AT_location attribute. */
8468 copy_dwarf_procedure (dw_die_ref die,
8469 comdat_type_node *type_node,
8470 hash_map<dw_die_ref, dw_die_ref> &copied_dwarf_procs)
8472 gcc_assert (die->die_tag == DW_TAG_dwarf_procedure);
8474 /* DWARF procedures are not supposed to have children... */
8475 gcc_assert (die->die_child == NULL);
8477 /* ... and they are supposed to have only one attribute: DW_AT_location. */
8478 gcc_assert (vec_safe_length (die->die_attr) == 1
8479 && ((*die->die_attr)[0].dw_attr == DW_AT_location));
8481 /* Do not copy more than once DWARF procedures. */
8483 dw_die_ref &die_copy = copied_dwarf_procs.get_or_insert (die, &existed);
8487 die_copy = clone_die (die);
8488 add_child_die (type_node->root_die, die_copy);
8489 copy_dwarf_procs_ref_in_attrs (die_copy, type_node, copied_dwarf_procs);
8493 /* Helper for copy_dwarf_procs_ref_in_dies. Look for references to DWARF
8494 procedures in DIE's attributes. */
8497 copy_dwarf_procs_ref_in_attrs (dw_die_ref die,
8498 comdat_type_node *type_node,
8499 hash_map<dw_die_ref, dw_die_ref> &copied_dwarf_procs)
8504 FOR_EACH_VEC_SAFE_ELT (die->die_attr, i, a)
8506 dw_loc_descr_ref loc;
8508 if (a->dw_attr_val.val_class != dw_val_class_loc)
8511 for (loc = a->dw_attr_val.v.val_loc; loc != NULL; loc = loc->dw_loc_next)
8513 switch (loc->dw_loc_opc)
8517 case DW_OP_call_ref:
8518 gcc_assert (loc->dw_loc_oprnd1.val_class
8519 == dw_val_class_die_ref);
8520 loc->dw_loc_oprnd1.v.val_die_ref.die
8521 = copy_dwarf_procedure (loc->dw_loc_oprnd1.v.val_die_ref.die,
8523 copied_dwarf_procs);
8532 /* Copy DWARF procedures that are referenced by the DIE tree to TREE_NODE and
8533 rewrite references to point to the copies.
8535 References are looked for in DIE's attributes and recursively in all its
8536 children attributes that are location descriptions. COPIED_DWARF_PROCS is a
8537 mapping from old DWARF procedures to their copy. It is used not to copy
8538 twice the same DWARF procedure under TYPE_NODE. */
8541 copy_dwarf_procs_ref_in_dies (dw_die_ref die,
8542 comdat_type_node *type_node,
8543 hash_map<dw_die_ref, dw_die_ref> &copied_dwarf_procs)
8547 copy_dwarf_procs_ref_in_attrs (die, type_node, copied_dwarf_procs);
8548 FOR_EACH_CHILD (die, c, copy_dwarf_procs_ref_in_dies (c,
8550 copied_dwarf_procs));
8553 /* Traverse the DIE and set up additional .debug_types or .debug_info
8554 DW_UT_*type sections for each type worthy of being placed in a COMDAT
8558 break_out_comdat_types (dw_die_ref die)
8562 dw_die_ref prev = NULL;
8563 dw_die_ref next = NULL;
8564 dw_die_ref unit = NULL;
8566 first = c = die->die_child;
8570 if (prev == NULL || prev->die_sib == c)
8573 next = (c == first ? NULL : c->die_sib);
8574 if (should_move_die_to_comdat (c))
8576 dw_die_ref replacement;
8577 comdat_type_node *type_node;
8579 /* Break out nested types into their own type units. */
8580 break_out_comdat_types (c);
8582 /* Create a new type unit DIE as the root for the new tree. */
8583 unit = new_die (DW_TAG_type_unit, NULL, NULL);
8584 add_AT_unsigned (unit, DW_AT_language,
8585 get_AT_unsigned (comp_unit_die (), DW_AT_language));
8587 /* Add the new unit's type DIE into the comdat type list. */
8588 type_node = ggc_cleared_alloc<comdat_type_node> ();
8589 type_node->root_die = unit;
8590 type_node->next = comdat_type_list;
8591 comdat_type_list = type_node;
8593 /* Generate the type signature. */
8594 generate_type_signature (c, type_node);
8596 /* Copy the declaration context, attributes, and children of the
8597 declaration into the new type unit DIE, then remove this DIE
8598 from the main CU (or replace it with a skeleton if necessary). */
8599 replacement = remove_child_or_replace_with_skeleton (unit, c, prev);
8600 type_node->skeleton_die = replacement;
8602 /* Add the DIE to the new compunit. */
8603 add_child_die (unit, c);
8605 /* Types can reference DWARF procedures for type size or data location
8606 expressions. Calls in DWARF expressions cannot target procedures
8607 that are not in the same section. So we must copy DWARF procedures
8608 along with this type and then rewrite references to them. */
8609 hash_map<dw_die_ref, dw_die_ref> copied_dwarf_procs;
8610 copy_dwarf_procs_ref_in_dies (c, type_node, copied_dwarf_procs);
8612 if (replacement != NULL)
8615 else if (c->die_tag == DW_TAG_namespace
8616 || c->die_tag == DW_TAG_class_type
8617 || c->die_tag == DW_TAG_structure_type
8618 || c->die_tag == DW_TAG_union_type)
8620 /* Look for nested types that can be broken out. */
8621 break_out_comdat_types (c);
8623 } while (next != NULL);
8626 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
8627 Enter all the cloned children into the hash table decl_table. */
8630 clone_tree_partial (dw_die_ref die, decl_hash_type *decl_table)
8634 struct decl_table_entry *entry;
8635 decl_table_entry **slot;
8637 if (die->die_tag == DW_TAG_subprogram)
8638 clone = clone_as_declaration (die);
8640 clone = clone_die (die);
8642 slot = decl_table->find_slot_with_hash (die,
8643 htab_hash_pointer (die), INSERT);
8645 /* Assert that DIE isn't in the hash table yet. If it would be there
8646 before, the ancestors would be necessarily there as well, therefore
8647 clone_tree_partial wouldn't be called. */
8648 gcc_assert (*slot == HTAB_EMPTY_ENTRY);
8650 entry = XCNEW (struct decl_table_entry);
8652 entry->copy = clone;
8655 if (die->die_tag != DW_TAG_subprogram)
8656 FOR_EACH_CHILD (die, c,
8657 add_child_die (clone, clone_tree_partial (c, decl_table)));
8662 /* Walk the DIE and its children, looking for references to incomplete
8663 or trivial types that are unmarked (i.e., that are not in the current
8667 copy_decls_walk (dw_die_ref unit, dw_die_ref die, decl_hash_type *decl_table)
8673 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8675 if (AT_class (a) == dw_val_class_die_ref)
8677 dw_die_ref targ = AT_ref (a);
8678 decl_table_entry **slot;
8679 struct decl_table_entry *entry;
8681 if (targ->die_mark != 0 || targ->comdat_type_p)
8684 slot = decl_table->find_slot_with_hash (targ,
8685 htab_hash_pointer (targ),
8688 if (*slot != HTAB_EMPTY_ENTRY)
8690 /* TARG has already been copied, so we just need to
8691 modify the reference to point to the copy. */
8693 a->dw_attr_val.v.val_die_ref.die = entry->copy;
8697 dw_die_ref parent = unit;
8698 dw_die_ref copy = clone_die (targ);
8700 /* Record in DECL_TABLE that TARG has been copied.
8701 Need to do this now, before the recursive call,
8702 because DECL_TABLE may be expanded and SLOT
8703 would no longer be a valid pointer. */
8704 entry = XCNEW (struct decl_table_entry);
8709 /* If TARG is not a declaration DIE, we need to copy its
8711 if (!is_declaration_die (targ))
8715 add_child_die (copy,
8716 clone_tree_partial (c, decl_table)));
8719 /* Make sure the cloned tree is marked as part of the
8723 /* If TARG has surrounding context, copy its ancestor tree
8724 into the new type unit. */
8725 if (targ->die_parent != NULL
8726 && !is_unit_die (targ->die_parent))
8727 parent = copy_ancestor_tree (unit, targ->die_parent,
8730 add_child_die (parent, copy);
8731 a->dw_attr_val.v.val_die_ref.die = copy;
8733 /* Make sure the newly-copied DIE is walked. If it was
8734 installed in a previously-added context, it won't
8735 get visited otherwise. */
8738 /* Find the highest point of the newly-added tree,
8739 mark each node along the way, and walk from there. */
8740 parent->die_mark = 1;
8741 while (parent->die_parent
8742 && parent->die_parent->die_mark == 0)
8744 parent = parent->die_parent;
8745 parent->die_mark = 1;
8747 copy_decls_walk (unit, parent, decl_table);
8753 FOR_EACH_CHILD (die, c, copy_decls_walk (unit, c, decl_table));
8756 /* Collect skeleton dies in DIE created by break_out_comdat_types already
8757 and record them in DECL_TABLE. */
8760 collect_skeleton_dies (dw_die_ref die, decl_hash_type *decl_table)
8764 if (dw_attr_node *a = get_AT (die, DW_AT_signature))
8766 dw_die_ref targ = AT_ref (a);
8767 gcc_assert (targ->die_mark == 0 && targ->comdat_type_p);
8768 decl_table_entry **slot
8769 = decl_table->find_slot_with_hash (targ,
8770 htab_hash_pointer (targ),
8772 gcc_assert (*slot == HTAB_EMPTY_ENTRY);
8773 /* Record in DECL_TABLE that TARG has been already copied
8774 by remove_child_or_replace_with_skeleton. */
8775 decl_table_entry *entry = XCNEW (struct decl_table_entry);
8780 FOR_EACH_CHILD (die, c, collect_skeleton_dies (c, decl_table));
8783 /* Copy declarations for "unworthy" types into the new comdat section.
8784 Incomplete types, modified types, and certain other types aren't broken
8785 out into comdat sections of their own, so they don't have a signature,
8786 and we need to copy the declaration into the same section so that we
8787 don't have an external reference. */
8790 copy_decls_for_unworthy_types (dw_die_ref unit)
8793 decl_hash_type decl_table (10);
8794 collect_skeleton_dies (unit, &decl_table);
8795 copy_decls_walk (unit, unit, &decl_table);
8799 /* Traverse the DIE and add a sibling attribute if it may have the
8800 effect of speeding up access to siblings. To save some space,
8801 avoid generating sibling attributes for DIE's without children. */
8804 add_sibling_attributes (dw_die_ref die)
8808 if (! die->die_child)
8811 if (die->die_parent && die != die->die_parent->die_child)
8812 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
8814 FOR_EACH_CHILD (die, c, add_sibling_attributes (c));
8817 /* Output all location lists for the DIE and its children. */
8820 output_location_lists (dw_die_ref die)
8826 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8827 if (AT_class (a) == dw_val_class_loc_list)
8828 output_loc_list (AT_loc_list (a));
8830 FOR_EACH_CHILD (die, c, output_location_lists (c));
8833 /* During assign_location_list_indexes and output_loclists_offset the
8834 current index, after it the number of assigned indexes (i.e. how
8835 large the .debug_loclists* offset table should be). */
8836 static unsigned int loc_list_idx;
8838 /* Output all location list offsets for the DIE and its children. */
8841 output_loclists_offsets (dw_die_ref die)
8847 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8848 if (AT_class (a) == dw_val_class_loc_list)
8850 dw_loc_list_ref l = AT_loc_list (a);
8851 if (l->offset_emitted)
8853 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l->ll_symbol,
8854 loc_section_label, NULL);
8855 gcc_assert (l->hash == loc_list_idx);
8857 l->offset_emitted = true;
8860 FOR_EACH_CHILD (die, c, output_loclists_offsets (c));
8863 /* Recursively set indexes of location lists. */
8866 assign_location_list_indexes (dw_die_ref die)
8872 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8873 if (AT_class (a) == dw_val_class_loc_list)
8875 dw_loc_list_ref list = AT_loc_list (a);
8876 if (!list->num_assigned)
8878 list->num_assigned = true;
8879 list->hash = loc_list_idx++;
8883 FOR_EACH_CHILD (die, c, assign_location_list_indexes (c));
8886 /* We want to limit the number of external references, because they are
8887 larger than local references: a relocation takes multiple words, and
8888 even a sig8 reference is always eight bytes, whereas a local reference
8889 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
8890 So if we encounter multiple external references to the same type DIE, we
8891 make a local typedef stub for it and redirect all references there.
8893 This is the element of the hash table for keeping track of these
8903 /* Hashtable helpers. */
8905 struct external_ref_hasher : free_ptr_hash <external_ref>
8907 static inline hashval_t hash (const external_ref *);
8908 static inline bool equal (const external_ref *, const external_ref *);
8912 external_ref_hasher::hash (const external_ref *r)
8914 dw_die_ref die = r->type;
8917 /* We can't use the address of the DIE for hashing, because
8918 that will make the order of the stub DIEs non-deterministic. */
8919 if (! die->comdat_type_p)
8920 /* We have a symbol; use it to compute a hash. */
8921 h = htab_hash_string (die->die_id.die_symbol);
8924 /* We have a type signature; use a subset of the bits as the hash.
8925 The 8-byte signature is at least as large as hashval_t. */
8926 comdat_type_node *type_node = die->die_id.die_type_node;
8927 memcpy (&h, type_node->signature, sizeof (h));
8933 external_ref_hasher::equal (const external_ref *r1, const external_ref *r2)
8935 return r1->type == r2->type;
8938 typedef hash_table<external_ref_hasher> external_ref_hash_type;
8940 /* Return a pointer to the external_ref for references to DIE. */
8942 static struct external_ref *
8943 lookup_external_ref (external_ref_hash_type *map, dw_die_ref die)
8945 struct external_ref ref, *ref_p;
8946 external_ref **slot;
8949 slot = map->find_slot (&ref, INSERT);
8950 if (*slot != HTAB_EMPTY_ENTRY)
8953 ref_p = XCNEW (struct external_ref);
8959 /* Subroutine of optimize_external_refs, below.
8961 If we see a type skeleton, record it as our stub. If we see external
8962 references, remember how many we've seen. */
8965 optimize_external_refs_1 (dw_die_ref die, external_ref_hash_type *map)
8970 struct external_ref *ref_p;
8972 if (is_type_die (die)
8973 && (c = get_AT_ref (die, DW_AT_signature)))
8975 /* This is a local skeleton; use it for local references. */
8976 ref_p = lookup_external_ref (map, c);
8980 /* Scan the DIE references, and remember any that refer to DIEs from
8981 other CUs (i.e. those which are not marked). */
8982 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
8983 if (AT_class (a) == dw_val_class_die_ref
8984 && (c = AT_ref (a))->die_mark == 0
8987 ref_p = lookup_external_ref (map, c);
8991 FOR_EACH_CHILD (die, c, optimize_external_refs_1 (c, map));
8994 /* htab_traverse callback function for optimize_external_refs, below. SLOT
8995 points to an external_ref, DATA is the CU we're processing. If we don't
8996 already have a local stub, and we have multiple refs, build a stub. */
8999 dwarf2_build_local_stub (external_ref **slot, dw_die_ref data)
9001 struct external_ref *ref_p = *slot;
9003 if (ref_p->stub == NULL && ref_p->n_refs > 1 && !dwarf_strict)
9005 /* We have multiple references to this type, so build a small stub.
9006 Both of these forms are a bit dodgy from the perspective of the
9007 DWARF standard, since technically they should have names. */
9008 dw_die_ref cu = data;
9009 dw_die_ref type = ref_p->type;
9010 dw_die_ref stub = NULL;
9012 if (type->comdat_type_p)
9014 /* If we refer to this type via sig8, use AT_signature. */
9015 stub = new_die (type->die_tag, cu, NULL_TREE);
9016 add_AT_die_ref (stub, DW_AT_signature, type);
9020 /* Otherwise, use a typedef with no name. */
9021 stub = new_die (DW_TAG_typedef, cu, NULL_TREE);
9022 add_AT_die_ref (stub, DW_AT_type, type);
9031 /* DIE is a unit; look through all the DIE references to see if there are
9032 any external references to types, and if so, create local stubs for
9033 them which will be applied in build_abbrev_table. This is useful because
9034 references to local DIEs are smaller. */
9036 static external_ref_hash_type *
9037 optimize_external_refs (dw_die_ref die)
9039 external_ref_hash_type *map = new external_ref_hash_type (10);
9040 optimize_external_refs_1 (die, map);
9041 map->traverse <dw_die_ref, dwarf2_build_local_stub> (die);
9045 /* The following 3 variables are temporaries that are computed only during the
9046 build_abbrev_table call and used and released during the following
9047 optimize_abbrev_table call. */
9049 /* First abbrev_id that can be optimized based on usage. */
9050 static unsigned int abbrev_opt_start;
9052 /* Maximum abbrev_id of a base type plus one (we can't optimize DIEs with
9053 abbrev_id smaller than this, because they must be already sized
9054 during build_abbrev_table). */
9055 static unsigned int abbrev_opt_base_type_end;
9057 /* Vector of usage counts during build_abbrev_table. Indexed by
9058 abbrev_id - abbrev_opt_start. */
9059 static vec<unsigned int> abbrev_usage_count;
9061 /* Vector of all DIEs added with die_abbrev >= abbrev_opt_start. */
9062 static vec<dw_die_ref> sorted_abbrev_dies;
9064 /* The format of each DIE (and its attribute value pairs) is encoded in an
9065 abbreviation table. This routine builds the abbreviation table and assigns
9066 a unique abbreviation id for each abbreviation entry. The children of each
9067 die are visited recursively. */
9070 build_abbrev_table (dw_die_ref die, external_ref_hash_type *extern_map)
9072 unsigned int abbrev_id = 0;
9078 /* Scan the DIE references, and replace any that refer to
9079 DIEs from other CUs (i.e. those which are not marked) with
9080 the local stubs we built in optimize_external_refs. */
9081 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
9082 if (AT_class (a) == dw_val_class_die_ref
9083 && (c = AT_ref (a))->die_mark == 0)
9085 struct external_ref *ref_p;
9086 gcc_assert (AT_ref (a)->comdat_type_p || AT_ref (a)->die_id.die_symbol);
9089 && (ref_p = lookup_external_ref (extern_map, c))
9090 && ref_p->stub && ref_p->stub != die)
9092 gcc_assert (a->dw_attr != DW_AT_signature);
9093 change_AT_die_ref (a, ref_p->stub);
9096 /* We aren't changing this reference, so mark it external. */
9097 set_AT_ref_external (a, 1);
9100 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table, abbrev_id, abbrev)
9102 dw_attr_node *die_a, *abbrev_a;
9108 if (abbrev->die_tag != die->die_tag)
9110 if ((abbrev->die_child != NULL) != (die->die_child != NULL))
9113 if (vec_safe_length (abbrev->die_attr) != vec_safe_length (die->die_attr))
9116 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, die_a)
9118 abbrev_a = &(*abbrev->die_attr)[ix];
9119 if ((abbrev_a->dw_attr != die_a->dw_attr)
9120 || (value_format (abbrev_a) != value_format (die_a)))
9130 if (abbrev_id >= vec_safe_length (abbrev_die_table))
9132 vec_safe_push (abbrev_die_table, die);
9133 if (abbrev_opt_start)
9134 abbrev_usage_count.safe_push (0);
9136 if (abbrev_opt_start && abbrev_id >= abbrev_opt_start)
9138 abbrev_usage_count[abbrev_id - abbrev_opt_start]++;
9139 sorted_abbrev_dies.safe_push (die);
9142 die->die_abbrev = abbrev_id;
9143 FOR_EACH_CHILD (die, c, build_abbrev_table (c, extern_map));
9146 /* Callback function for sorted_abbrev_dies vector sorting. We sort
9147 by die_abbrev's usage count, from the most commonly used
9148 abbreviation to the least. */
9151 die_abbrev_cmp (const void *p1, const void *p2)
9153 dw_die_ref die1 = *(const dw_die_ref *) p1;
9154 dw_die_ref die2 = *(const dw_die_ref *) p2;
9156 gcc_checking_assert (die1->die_abbrev >= abbrev_opt_start);
9157 gcc_checking_assert (die2->die_abbrev >= abbrev_opt_start);
9159 if (die1->die_abbrev >= abbrev_opt_base_type_end
9160 && die2->die_abbrev >= abbrev_opt_base_type_end)
9162 if (abbrev_usage_count[die1->die_abbrev - abbrev_opt_start]
9163 > abbrev_usage_count[die2->die_abbrev - abbrev_opt_start])
9165 if (abbrev_usage_count[die1->die_abbrev - abbrev_opt_start]
9166 < abbrev_usage_count[die2->die_abbrev - abbrev_opt_start])
9170 /* Stabilize the sort. */
9171 if (die1->die_abbrev < die2->die_abbrev)
9173 if (die1->die_abbrev > die2->die_abbrev)
9179 /* Convert dw_val_class_const and dw_val_class_unsigned_const class attributes
9180 of DIEs in between sorted_abbrev_dies[first_id] and abbrev_dies[end_id - 1]
9181 into dw_val_class_const_implicit or
9182 dw_val_class_unsigned_const_implicit. */
9185 optimize_implicit_const (unsigned int first_id, unsigned int end,
9186 vec<bool> &implicit_consts)
9188 /* It never makes sense if there is just one DIE using the abbreviation. */
9189 if (end < first_id + 2)
9194 dw_die_ref die = sorted_abbrev_dies[first_id];
9195 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
9196 if (implicit_consts[ix])
9198 enum dw_val_class new_class = dw_val_class_none;
9199 switch (AT_class (a))
9201 case dw_val_class_unsigned_const:
9202 if ((HOST_WIDE_INT) AT_unsigned (a) < 0)
9205 /* The .debug_abbrev section will grow by
9206 size_of_sleb128 (AT_unsigned (a)) and we avoid the constants
9207 in all the DIEs using that abbreviation. */
9208 if (constant_size (AT_unsigned (a)) * (end - first_id)
9209 <= (unsigned) size_of_sleb128 (AT_unsigned (a)))
9212 new_class = dw_val_class_unsigned_const_implicit;
9215 case dw_val_class_const:
9216 new_class = dw_val_class_const_implicit;
9219 case dw_val_class_file:
9220 new_class = dw_val_class_file_implicit;
9226 for (i = first_id; i < end; i++)
9227 (*sorted_abbrev_dies[i]->die_attr)[ix].dw_attr_val.val_class
9232 /* Attempt to optimize abbreviation table from abbrev_opt_start
9233 abbreviation above. */
9236 optimize_abbrev_table (void)
9238 if (abbrev_opt_start
9239 && vec_safe_length (abbrev_die_table) > abbrev_opt_start
9240 && (dwarf_version >= 5 || vec_safe_length (abbrev_die_table) > 127))
9242 auto_vec<bool, 32> implicit_consts;
9243 sorted_abbrev_dies.qsort (die_abbrev_cmp);
9245 unsigned int abbrev_id = abbrev_opt_start - 1;
9246 unsigned int first_id = ~0U;
9247 unsigned int last_abbrev_id = 0;
9250 if (abbrev_opt_base_type_end > abbrev_opt_start)
9251 abbrev_id = abbrev_opt_base_type_end - 1;
9252 /* Reassign abbreviation ids from abbrev_opt_start above, so that
9253 most commonly used abbreviations come first. */
9254 FOR_EACH_VEC_ELT (sorted_abbrev_dies, i, die)
9259 /* If calc_base_type_die_sizes has been called, the CU and
9260 base types after it can't be optimized, because we've already
9261 calculated their DIE offsets. We've sorted them first. */
9262 if (die->die_abbrev < abbrev_opt_base_type_end)
9264 if (die->die_abbrev != last_abbrev_id)
9266 last_abbrev_id = die->die_abbrev;
9267 if (dwarf_version >= 5 && first_id != ~0U)
9268 optimize_implicit_const (first_id, i, implicit_consts);
9270 (*abbrev_die_table)[abbrev_id] = die;
9271 if (dwarf_version >= 5)
9274 implicit_consts.truncate (0);
9276 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
9277 switch (AT_class (a))
9279 case dw_val_class_const:
9280 case dw_val_class_unsigned_const:
9281 case dw_val_class_file:
9282 implicit_consts.safe_push (true);
9285 implicit_consts.safe_push (false);
9290 else if (dwarf_version >= 5)
9292 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
9293 if (!implicit_consts[ix])
9297 dw_attr_node *other_a
9298 = &(*(*abbrev_die_table)[abbrev_id]->die_attr)[ix];
9299 if (!dw_val_equal_p (&a->dw_attr_val,
9300 &other_a->dw_attr_val))
9301 implicit_consts[ix] = false;
9304 die->die_abbrev = abbrev_id;
9306 gcc_assert (abbrev_id == vec_safe_length (abbrev_die_table) - 1);
9307 if (dwarf_version >= 5 && first_id != ~0U)
9308 optimize_implicit_const (first_id, i, implicit_consts);
9311 abbrev_opt_start = 0;
9312 abbrev_opt_base_type_end = 0;
9313 abbrev_usage_count.release ();
9314 sorted_abbrev_dies.release ();
9317 /* Return the power-of-two number of bytes necessary to represent VALUE. */
9320 constant_size (unsigned HOST_WIDE_INT value)
9327 log = floor_log2 (value);
9330 log = 1 << (floor_log2 (log) + 1);
9335 /* Return the size of a DIE as it is represented in the
9336 .debug_info section. */
9338 static unsigned long
9339 size_of_die (dw_die_ref die)
9341 unsigned long size = 0;
9344 enum dwarf_form form;
9346 size += size_of_uleb128 (die->die_abbrev);
9347 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
9349 switch (AT_class (a))
9351 case dw_val_class_addr:
9352 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
9354 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED);
9355 size += size_of_uleb128 (AT_index (a));
9358 size += DWARF2_ADDR_SIZE;
9360 case dw_val_class_offset:
9361 size += DWARF_OFFSET_SIZE;
9363 case dw_val_class_loc:
9365 unsigned long lsize = size_of_locs (AT_loc (a));
9368 if (dwarf_version >= 4)
9369 size += size_of_uleb128 (lsize);
9371 size += constant_size (lsize);
9375 case dw_val_class_loc_list:
9376 if (dwarf_split_debug_info && dwarf_version >= 5)
9378 gcc_assert (AT_loc_list (a)->num_assigned);
9379 size += size_of_uleb128 (AT_loc_list (a)->hash);
9382 size += DWARF_OFFSET_SIZE;
9384 case dw_val_class_view_list:
9385 size += DWARF_OFFSET_SIZE;
9387 case dw_val_class_range_list:
9388 if (value_format (a) == DW_FORM_rnglistx)
9390 gcc_assert (rnglist_idx);
9391 dw_ranges *r = &(*ranges_table)[a->dw_attr_val.v.val_offset];
9392 size += size_of_uleb128 (r->idx);
9395 size += DWARF_OFFSET_SIZE;
9397 case dw_val_class_const:
9398 size += size_of_sleb128 (AT_int (a));
9400 case dw_val_class_unsigned_const:
9402 int csize = constant_size (AT_unsigned (a));
9403 if (dwarf_version == 3
9404 && a->dw_attr == DW_AT_data_member_location
9406 size += size_of_uleb128 (AT_unsigned (a));
9411 case dw_val_class_symview:
9412 if (symview_upper_bound <= 0xff)
9414 else if (symview_upper_bound <= 0xffff)
9416 else if (symview_upper_bound <= 0xffffffff)
9421 case dw_val_class_const_implicit:
9422 case dw_val_class_unsigned_const_implicit:
9423 case dw_val_class_file_implicit:
9424 /* These occupy no size in the DIE, just an extra sleb128 in
9427 case dw_val_class_const_double:
9428 size += HOST_BITS_PER_DOUBLE_INT / HOST_BITS_PER_CHAR;
9429 if (HOST_BITS_PER_WIDE_INT >= DWARF_LARGEST_DATA_FORM_BITS)
9432 case dw_val_class_wide_int:
9433 size += (get_full_len (*a->dw_attr_val.v.val_wide)
9434 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
9435 if (get_full_len (*a->dw_attr_val.v.val_wide)
9436 * HOST_BITS_PER_WIDE_INT > DWARF_LARGEST_DATA_FORM_BITS)
9439 case dw_val_class_vec:
9440 size += constant_size (a->dw_attr_val.v.val_vec.length
9441 * a->dw_attr_val.v.val_vec.elt_size)
9442 + a->dw_attr_val.v.val_vec.length
9443 * a->dw_attr_val.v.val_vec.elt_size; /* block */
9445 case dw_val_class_flag:
9446 if (dwarf_version >= 4)
9447 /* Currently all add_AT_flag calls pass in 1 as last argument,
9448 so DW_FORM_flag_present can be used. If that ever changes,
9449 we'll need to use DW_FORM_flag and have some optimization
9450 in build_abbrev_table that will change those to
9451 DW_FORM_flag_present if it is set to 1 in all DIEs using
9452 the same abbrev entry. */
9453 gcc_assert (a->dw_attr_val.v.val_flag == 1);
9457 case dw_val_class_die_ref:
9458 if (AT_ref_external (a))
9460 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
9461 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
9462 is sized by target address length, whereas in DWARF3
9463 it's always sized as an offset. */
9464 if (AT_ref (a)->comdat_type_p)
9465 size += DWARF_TYPE_SIGNATURE_SIZE;
9466 else if (dwarf_version == 2)
9467 size += DWARF2_ADDR_SIZE;
9469 size += DWARF_OFFSET_SIZE;
9472 size += DWARF_OFFSET_SIZE;
9474 case dw_val_class_fde_ref:
9475 size += DWARF_OFFSET_SIZE;
9477 case dw_val_class_lbl_id:
9478 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
9480 gcc_assert (AT_index (a) != NO_INDEX_ASSIGNED);
9481 size += size_of_uleb128 (AT_index (a));
9484 size += DWARF2_ADDR_SIZE;
9486 case dw_val_class_lineptr:
9487 case dw_val_class_macptr:
9488 case dw_val_class_loclistsptr:
9489 size += DWARF_OFFSET_SIZE;
9491 case dw_val_class_str:
9492 form = AT_string_form (a);
9493 if (form == DW_FORM_strp || form == DW_FORM_line_strp)
9494 size += DWARF_OFFSET_SIZE;
9495 else if (form == dwarf_FORM (DW_FORM_strx))
9496 size += size_of_uleb128 (AT_index (a));
9498 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
9500 case dw_val_class_file:
9501 size += constant_size (maybe_emit_file (a->dw_attr_val.v.val_file));
9503 case dw_val_class_data8:
9506 case dw_val_class_vms_delta:
9507 size += DWARF_OFFSET_SIZE;
9509 case dw_val_class_high_pc:
9510 size += DWARF2_ADDR_SIZE;
9512 case dw_val_class_discr_value:
9513 size += size_of_discr_value (&a->dw_attr_val.v.val_discr_value);
9515 case dw_val_class_discr_list:
9517 unsigned block_size = size_of_discr_list (AT_discr_list (a));
9519 /* This is a block, so we have the block length and then its
9521 size += constant_size (block_size) + block_size;
9532 /* Size the debugging information associated with a given DIE. Visits the
9533 DIE's children recursively. Updates the global variable next_die_offset, on
9534 each time through. Uses the current value of next_die_offset to update the
9535 die_offset field in each DIE. */
9538 calc_die_sizes (dw_die_ref die)
9542 gcc_assert (die->die_offset == 0
9543 || (unsigned long int) die->die_offset == next_die_offset);
9544 die->die_offset = next_die_offset;
9545 next_die_offset += size_of_die (die);
9547 FOR_EACH_CHILD (die, c, calc_die_sizes (c));
9549 if (die->die_child != NULL)
9550 /* Count the null byte used to terminate sibling lists. */
9551 next_die_offset += 1;
9554 /* Size just the base type children at the start of the CU.
9555 This is needed because build_abbrev needs to size locs
9556 and sizing of type based stack ops needs to know die_offset
9557 values for the base types. */
9560 calc_base_type_die_sizes (void)
9562 unsigned long die_offset = (dwarf_split_debug_info
9563 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
9564 : DWARF_COMPILE_UNIT_HEADER_SIZE);
9566 dw_die_ref base_type;
9567 #if ENABLE_ASSERT_CHECKING
9568 dw_die_ref prev = comp_unit_die ()->die_child;
9571 die_offset += size_of_die (comp_unit_die ());
9572 for (i = 0; base_types.iterate (i, &base_type); i++)
9574 #if ENABLE_ASSERT_CHECKING
9575 gcc_assert (base_type->die_offset == 0
9576 && prev->die_sib == base_type
9577 && base_type->die_child == NULL
9578 && base_type->die_abbrev);
9581 if (abbrev_opt_start
9582 && base_type->die_abbrev >= abbrev_opt_base_type_end)
9583 abbrev_opt_base_type_end = base_type->die_abbrev + 1;
9584 base_type->die_offset = die_offset;
9585 die_offset += size_of_die (base_type);
9589 /* Set the marks for a die and its children. We do this so
9590 that we know whether or not a reference needs to use FORM_ref_addr; only
9591 DIEs in the same CU will be marked. We used to clear out the offset
9592 and use that as the flag, but ran into ordering problems. */
9595 mark_dies (dw_die_ref die)
9599 gcc_assert (!die->die_mark);
9602 FOR_EACH_CHILD (die, c, mark_dies (c));
9605 /* Clear the marks for a die and its children. */
9608 unmark_dies (dw_die_ref die)
9612 if (! use_debug_types)
9613 gcc_assert (die->die_mark);
9616 FOR_EACH_CHILD (die, c, unmark_dies (c));
9619 /* Clear the marks for a die, its children and referred dies. */
9622 unmark_all_dies (dw_die_ref die)
9632 FOR_EACH_CHILD (die, c, unmark_all_dies (c));
9634 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
9635 if (AT_class (a) == dw_val_class_die_ref)
9636 unmark_all_dies (AT_ref (a));
9639 /* Calculate if the entry should appear in the final output file. It may be
9640 from a pruned a type. */
9643 include_pubname_in_output (vec<pubname_entry, va_gc> *table, pubname_entry *p)
9645 /* By limiting gnu pubnames to definitions only, gold can generate a
9646 gdb index without entries for declarations, which don't include
9647 enough information to be useful. */
9648 if (debug_generate_pub_sections == 2 && is_declaration_die (p->die))
9651 if (table == pubname_table)
9653 /* Enumerator names are part of the pubname table, but the
9654 parent DW_TAG_enumeration_type die may have been pruned.
9655 Don't output them if that is the case. */
9656 if (p->die->die_tag == DW_TAG_enumerator &&
9657 (p->die->die_parent == NULL
9658 || !p->die->die_parent->die_perennial_p))
9661 /* Everything else in the pubname table is included. */
9665 /* The pubtypes table shouldn't include types that have been
9667 return (p->die->die_offset != 0
9668 || !flag_eliminate_unused_debug_types);
9671 /* Return the size of the .debug_pubnames or .debug_pubtypes table
9672 generated for the compilation unit. */
9674 static unsigned long
9675 size_of_pubnames (vec<pubname_entry, va_gc> *names)
9680 int space_for_flags = (debug_generate_pub_sections == 2) ? 1 : 0;
9682 size = DWARF_PUBNAMES_HEADER_SIZE;
9683 FOR_EACH_VEC_ELT (*names, i, p)
9684 if (include_pubname_in_output (names, p))
9685 size += strlen (p->name) + DWARF_OFFSET_SIZE + 1 + space_for_flags;
9687 size += DWARF_OFFSET_SIZE;
9691 /* Return the size of the information in the .debug_aranges section. */
9693 static unsigned long
9694 size_of_aranges (void)
9698 size = DWARF_ARANGES_HEADER_SIZE;
9700 /* Count the address/length pair for this compilation unit. */
9701 if (text_section_used)
9702 size += 2 * DWARF2_ADDR_SIZE;
9703 if (cold_text_section_used)
9704 size += 2 * DWARF2_ADDR_SIZE;
9705 if (have_multiple_function_sections)
9710 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde)
9712 if (DECL_IGNORED_P (fde->decl))
9714 if (!fde->in_std_section)
9715 size += 2 * DWARF2_ADDR_SIZE;
9716 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
9717 size += 2 * DWARF2_ADDR_SIZE;
9721 /* Count the two zero words used to terminated the address range table. */
9722 size += 2 * DWARF2_ADDR_SIZE;
9726 /* Select the encoding of an attribute value. */
9728 static enum dwarf_form
9729 value_format (dw_attr_node *a)
9731 switch (AT_class (a))
9733 case dw_val_class_addr:
9734 /* Only very few attributes allow DW_FORM_addr. */
9739 case DW_AT_entry_pc:
9740 case DW_AT_trampoline:
9741 return (AT_index (a) == NOT_INDEXED
9742 ? DW_FORM_addr : dwarf_FORM (DW_FORM_addrx));
9746 switch (DWARF2_ADDR_SIZE)
9749 return DW_FORM_data1;
9751 return DW_FORM_data2;
9753 return DW_FORM_data4;
9755 return DW_FORM_data8;
9759 case dw_val_class_loc_list:
9760 if (dwarf_split_debug_info
9761 && dwarf_version >= 5
9762 && AT_loc_list (a)->num_assigned)
9763 return DW_FORM_loclistx;
9765 case dw_val_class_view_list:
9766 case dw_val_class_range_list:
9767 /* For range lists in DWARF 5, use DW_FORM_rnglistx from .debug_info.dwo
9768 but in .debug_info use DW_FORM_sec_offset, which is shorter if we
9769 care about sizes of .debug* sections in shared libraries and
9770 executables and don't take into account relocations that affect just
9771 relocatable objects - for DW_FORM_rnglistx we'd have to emit offset
9772 table in the .debug_rnglists section. */
9773 if (dwarf_split_debug_info
9774 && dwarf_version >= 5
9775 && AT_class (a) == dw_val_class_range_list
9777 && a->dw_attr_val.val_entry != RELOCATED_OFFSET)
9778 return DW_FORM_rnglistx;
9779 if (dwarf_version >= 4)
9780 return DW_FORM_sec_offset;
9782 case dw_val_class_vms_delta:
9783 case dw_val_class_offset:
9784 switch (DWARF_OFFSET_SIZE)
9787 return DW_FORM_data4;
9789 return DW_FORM_data8;
9793 case dw_val_class_loc:
9794 if (dwarf_version >= 4)
9795 return DW_FORM_exprloc;
9796 switch (constant_size (size_of_locs (AT_loc (a))))
9799 return DW_FORM_block1;
9801 return DW_FORM_block2;
9803 return DW_FORM_block4;
9807 case dw_val_class_const:
9808 return DW_FORM_sdata;
9809 case dw_val_class_unsigned_const:
9810 switch (constant_size (AT_unsigned (a)))
9813 return DW_FORM_data1;
9815 return DW_FORM_data2;
9817 /* In DWARF3 DW_AT_data_member_location with
9818 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
9819 constant, so we need to use DW_FORM_udata if we need
9820 a large constant. */
9821 if (dwarf_version == 3 && a->dw_attr == DW_AT_data_member_location)
9822 return DW_FORM_udata;
9823 return DW_FORM_data4;
9825 if (dwarf_version == 3 && a->dw_attr == DW_AT_data_member_location)
9826 return DW_FORM_udata;
9827 return DW_FORM_data8;
9831 case dw_val_class_const_implicit:
9832 case dw_val_class_unsigned_const_implicit:
9833 case dw_val_class_file_implicit:
9834 return DW_FORM_implicit_const;
9835 case dw_val_class_const_double:
9836 switch (HOST_BITS_PER_WIDE_INT)
9839 return DW_FORM_data2;
9841 return DW_FORM_data4;
9843 return DW_FORM_data8;
9845 if (dwarf_version >= 5)
9846 return DW_FORM_data16;
9849 return DW_FORM_block1;
9851 case dw_val_class_wide_int:
9852 switch (get_full_len (*a->dw_attr_val.v.val_wide) * HOST_BITS_PER_WIDE_INT)
9855 return DW_FORM_data1;
9857 return DW_FORM_data2;
9859 return DW_FORM_data4;
9861 return DW_FORM_data8;
9863 if (dwarf_version >= 5)
9864 return DW_FORM_data16;
9867 return DW_FORM_block1;
9869 case dw_val_class_symview:
9870 /* ??? We might use uleb128, but then we'd have to compute
9871 .debug_info offsets in the assembler. */
9872 if (symview_upper_bound <= 0xff)
9873 return DW_FORM_data1;
9874 else if (symview_upper_bound <= 0xffff)
9875 return DW_FORM_data2;
9876 else if (symview_upper_bound <= 0xffffffff)
9877 return DW_FORM_data4;
9879 return DW_FORM_data8;
9880 case dw_val_class_vec:
9881 switch (constant_size (a->dw_attr_val.v.val_vec.length
9882 * a->dw_attr_val.v.val_vec.elt_size))
9885 return DW_FORM_block1;
9887 return DW_FORM_block2;
9889 return DW_FORM_block4;
9893 case dw_val_class_flag:
9894 if (dwarf_version >= 4)
9896 /* Currently all add_AT_flag calls pass in 1 as last argument,
9897 so DW_FORM_flag_present can be used. If that ever changes,
9898 we'll need to use DW_FORM_flag and have some optimization
9899 in build_abbrev_table that will change those to
9900 DW_FORM_flag_present if it is set to 1 in all DIEs using
9901 the same abbrev entry. */
9902 gcc_assert (a->dw_attr_val.v.val_flag == 1);
9903 return DW_FORM_flag_present;
9905 return DW_FORM_flag;
9906 case dw_val_class_die_ref:
9907 if (AT_ref_external (a))
9909 if (AT_ref (a)->comdat_type_p)
9910 return DW_FORM_ref_sig8;
9912 return DW_FORM_ref_addr;
9916 case dw_val_class_fde_ref:
9917 return DW_FORM_data;
9918 case dw_val_class_lbl_id:
9919 return (AT_index (a) == NOT_INDEXED
9920 ? DW_FORM_addr : dwarf_FORM (DW_FORM_addrx));
9921 case dw_val_class_lineptr:
9922 case dw_val_class_macptr:
9923 case dw_val_class_loclistsptr:
9924 return dwarf_version >= 4 ? DW_FORM_sec_offset : DW_FORM_data;
9925 case dw_val_class_str:
9926 return AT_string_form (a);
9927 case dw_val_class_file:
9928 switch (constant_size (maybe_emit_file (a->dw_attr_val.v.val_file)))
9931 return DW_FORM_data1;
9933 return DW_FORM_data2;
9935 return DW_FORM_data4;
9940 case dw_val_class_data8:
9941 return DW_FORM_data8;
9943 case dw_val_class_high_pc:
9944 switch (DWARF2_ADDR_SIZE)
9947 return DW_FORM_data1;
9949 return DW_FORM_data2;
9951 return DW_FORM_data4;
9953 return DW_FORM_data8;
9958 case dw_val_class_discr_value:
9959 return (a->dw_attr_val.v.val_discr_value.pos
9962 case dw_val_class_discr_list:
9963 switch (constant_size (size_of_discr_list (AT_discr_list (a))))
9966 return DW_FORM_block1;
9968 return DW_FORM_block2;
9970 return DW_FORM_block4;
9980 /* Output the encoding of an attribute value. */
9983 output_value_format (dw_attr_node *a)
9985 enum dwarf_form form = value_format (a);
9987 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
9990 /* Given a die and id, produce the appropriate abbreviations. */
9993 output_die_abbrevs (unsigned long abbrev_id, dw_die_ref abbrev)
9996 dw_attr_node *a_attr;
9998 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
9999 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
10000 dwarf_tag_name (abbrev->die_tag));
10002 if (abbrev->die_child != NULL)
10003 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
10005 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
10007 for (ix = 0; vec_safe_iterate (abbrev->die_attr, ix, &a_attr); ix++)
10009 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
10010 dwarf_attr_name (a_attr->dw_attr));
10011 output_value_format (a_attr);
10012 if (value_format (a_attr) == DW_FORM_implicit_const)
10014 if (AT_class (a_attr) == dw_val_class_file_implicit)
10016 int f = maybe_emit_file (a_attr->dw_attr_val.v.val_file);
10017 const char *filename = a_attr->dw_attr_val.v.val_file->filename;
10018 dw2_asm_output_data_sleb128 (f, "(%s)", filename);
10021 dw2_asm_output_data_sleb128 (a_attr->dw_attr_val.v.val_int, NULL);
10025 dw2_asm_output_data (1, 0, NULL);
10026 dw2_asm_output_data (1, 0, NULL);
10030 /* Output the .debug_abbrev section which defines the DIE abbreviation
10034 output_abbrev_section (void)
10036 unsigned int abbrev_id;
10039 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table, abbrev_id, abbrev)
10040 if (abbrev_id != 0)
10041 output_die_abbrevs (abbrev_id, abbrev);
10043 /* Terminate the table. */
10044 dw2_asm_output_data (1, 0, NULL);
10047 /* Return a new location list, given the begin and end range, and the
10050 static inline dw_loc_list_ref
10051 new_loc_list (dw_loc_descr_ref expr, const char *begin, var_loc_view vbegin,
10052 const char *end, var_loc_view vend,
10053 const char *section)
10055 dw_loc_list_ref retlist = ggc_cleared_alloc<dw_loc_list_node> ();
10057 retlist->begin = begin;
10058 retlist->begin_entry = NULL;
10059 retlist->end = end;
10060 retlist->expr = expr;
10061 retlist->section = section;
10062 retlist->vbegin = vbegin;
10063 retlist->vend = vend;
10068 /* Return true iff there's any nonzero view number in the loc list.
10070 ??? When views are not enabled, we'll often extend a single range
10071 to the entire function, so that we emit a single location
10072 expression rather than a location list. With views, even with a
10073 single range, we'll output a list if start or end have a nonzero
10074 view. If we change this, we may want to stop splitting a single
10075 range in dw_loc_list just because of a nonzero view, even if it
10076 straddles across hot/cold partitions. */
10079 loc_list_has_views (dw_loc_list_ref list)
10081 if (!debug_variable_location_views)
10084 for (dw_loc_list_ref loc = list;
10085 loc != NULL; loc = loc->dw_loc_next)
10086 if (!ZERO_VIEW_P (loc->vbegin) || !ZERO_VIEW_P (loc->vend))
10092 /* Generate a new internal symbol for this location list node, if it
10093 hasn't got one yet. */
10096 gen_llsym (dw_loc_list_ref list)
10098 gcc_assert (!list->ll_symbol);
10099 list->ll_symbol = gen_internal_sym ("LLST");
10101 if (!loc_list_has_views (list))
10104 if (dwarf2out_locviews_in_attribute ())
10106 /* Use the same label_num for the view list. */
10108 list->vl_symbol = gen_internal_sym ("LVUS");
10111 list->vl_symbol = list->ll_symbol;
10114 /* Generate a symbol for the list, but only if we really want to emit
10118 maybe_gen_llsym (dw_loc_list_ref list)
10120 if (!list || (!list->dw_loc_next && !loc_list_has_views (list)))
10126 /* Determine whether or not to skip loc_list entry CURR. If SIZEP is
10127 NULL, don't consider size of the location expression. If we're not
10128 to skip it, and SIZEP is non-null, store the size of CURR->expr's
10129 representation in *SIZEP. */
10132 skip_loc_list_entry (dw_loc_list_ref curr, unsigned long *sizep = NULL)
10134 /* Don't output an entry that starts and ends at the same address. */
10135 if (strcmp (curr->begin, curr->end) == 0
10136 && curr->vbegin == curr->vend && !curr->force)
10142 unsigned long size = size_of_locs (curr->expr);
10144 /* If the expression is too large, drop it on the floor. We could
10145 perhaps put it into DW_TAG_dwarf_procedure and refer to that
10146 in the expression, but >= 64KB expressions for a single value
10147 in a single range are unlikely very useful. */
10148 if (dwarf_version < 5 && size > 0xffff)
10156 /* Output a view pair loclist entry for CURR, if it requires one. */
10159 dwarf2out_maybe_output_loclist_view_pair (dw_loc_list_ref curr)
10161 if (!dwarf2out_locviews_in_loclist ())
10164 if (ZERO_VIEW_P (curr->vbegin) && ZERO_VIEW_P (curr->vend))
10167 #ifdef DW_LLE_view_pair
10168 dw2_asm_output_data (1, DW_LLE_view_pair, "DW_LLE_view_pair");
10170 if (dwarf2out_as_locview_support)
10172 if (ZERO_VIEW_P (curr->vbegin))
10173 dw2_asm_output_data_uleb128 (0, "Location view begin");
10176 char label[MAX_ARTIFICIAL_LABEL_BYTES];
10177 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", curr->vbegin);
10178 dw2_asm_output_symname_uleb128 (label, "Location view begin");
10181 if (ZERO_VIEW_P (curr->vend))
10182 dw2_asm_output_data_uleb128 (0, "Location view end");
10185 char label[MAX_ARTIFICIAL_LABEL_BYTES];
10186 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", curr->vend);
10187 dw2_asm_output_symname_uleb128 (label, "Location view end");
10192 dw2_asm_output_data_uleb128 (curr->vbegin, "Location view begin");
10193 dw2_asm_output_data_uleb128 (curr->vend, "Location view end");
10195 #endif /* DW_LLE_view_pair */
10200 /* Output the location list given to us. */
10203 output_loc_list (dw_loc_list_ref list_head)
10205 int vcount = 0, lcount = 0;
10207 if (list_head->emitted)
10209 list_head->emitted = true;
10211 if (list_head->vl_symbol && dwarf2out_locviews_in_attribute ())
10213 ASM_OUTPUT_LABEL (asm_out_file, list_head->vl_symbol);
10215 for (dw_loc_list_ref curr = list_head; curr != NULL;
10216 curr = curr->dw_loc_next)
10218 unsigned long size;
10220 if (skip_loc_list_entry (curr, &size))
10225 /* ?? dwarf_split_debug_info? */
10226 if (dwarf2out_as_locview_support)
10228 char label[MAX_ARTIFICIAL_LABEL_BYTES];
10230 if (!ZERO_VIEW_P (curr->vbegin))
10232 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", curr->vbegin);
10233 dw2_asm_output_symname_uleb128 (label,
10234 "View list begin (%s)",
10235 list_head->vl_symbol);
10238 dw2_asm_output_data_uleb128 (0,
10239 "View list begin (%s)",
10240 list_head->vl_symbol);
10242 if (!ZERO_VIEW_P (curr->vend))
10244 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", curr->vend);
10245 dw2_asm_output_symname_uleb128 (label,
10246 "View list end (%s)",
10247 list_head->vl_symbol);
10250 dw2_asm_output_data_uleb128 (0,
10251 "View list end (%s)",
10252 list_head->vl_symbol);
10256 dw2_asm_output_data_uleb128 (curr->vbegin,
10257 "View list begin (%s)",
10258 list_head->vl_symbol);
10259 dw2_asm_output_data_uleb128 (curr->vend,
10260 "View list end (%s)",
10261 list_head->vl_symbol);
10266 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
10268 const char *last_section = NULL;
10269 const char *base_label = NULL;
10271 /* Walk the location list, and output each range + expression. */
10272 for (dw_loc_list_ref curr = list_head; curr != NULL;
10273 curr = curr->dw_loc_next)
10275 unsigned long size;
10277 /* Skip this entry? If we skip it here, we must skip it in the
10278 view list above as well. */
10279 if (skip_loc_list_entry (curr, &size))
10284 if (dwarf_version >= 5)
10286 if (dwarf_split_debug_info)
10288 dwarf2out_maybe_output_loclist_view_pair (curr);
10289 /* For -gsplit-dwarf, emit DW_LLE_starx_length, which has
10290 uleb128 index into .debug_addr and uleb128 length. */
10291 dw2_asm_output_data (1, DW_LLE_startx_length,
10292 "DW_LLE_startx_length (%s)",
10293 list_head->ll_symbol);
10294 dw2_asm_output_data_uleb128 (curr->begin_entry->index,
10295 "Location list range start index "
10296 "(%s)", curr->begin);
10297 /* FIXME: This will ICE ifndef HAVE_AS_LEB128.
10298 For that case we probably need to emit DW_LLE_startx_endx,
10299 but we'd need 2 .debug_addr entries rather than just one. */
10300 dw2_asm_output_delta_uleb128 (curr->end, curr->begin,
10301 "Location list length (%s)",
10302 list_head->ll_symbol);
10304 else if (!have_multiple_function_sections && HAVE_AS_LEB128)
10306 dwarf2out_maybe_output_loclist_view_pair (curr);
10307 /* If all code is in .text section, the base address is
10308 already provided by the CU attributes. Use
10309 DW_LLE_offset_pair where both addresses are uleb128 encoded
10310 offsets against that base. */
10311 dw2_asm_output_data (1, DW_LLE_offset_pair,
10312 "DW_LLE_offset_pair (%s)",
10313 list_head->ll_symbol);
10314 dw2_asm_output_delta_uleb128 (curr->begin, curr->section,
10315 "Location list begin address (%s)",
10316 list_head->ll_symbol);
10317 dw2_asm_output_delta_uleb128 (curr->end, curr->section,
10318 "Location list end address (%s)",
10319 list_head->ll_symbol);
10321 else if (HAVE_AS_LEB128)
10323 /* Otherwise, find out how many consecutive entries could share
10324 the same base entry. If just one, emit DW_LLE_start_length,
10325 otherwise emit DW_LLE_base_address for the base address
10326 followed by a series of DW_LLE_offset_pair. */
10327 if (last_section == NULL || curr->section != last_section)
10329 dw_loc_list_ref curr2;
10330 for (curr2 = curr->dw_loc_next; curr2 != NULL;
10331 curr2 = curr2->dw_loc_next)
10333 if (strcmp (curr2->begin, curr2->end) == 0
10338 if (curr2 == NULL || curr->section != curr2->section)
10339 last_section = NULL;
10342 last_section = curr->section;
10343 base_label = curr->begin;
10344 dw2_asm_output_data (1, DW_LLE_base_address,
10345 "DW_LLE_base_address (%s)",
10346 list_head->ll_symbol);
10347 dw2_asm_output_addr (DWARF2_ADDR_SIZE, base_label,
10348 "Base address (%s)",
10349 list_head->ll_symbol);
10352 /* Only one entry with the same base address. Use
10353 DW_LLE_start_length with absolute address and uleb128
10355 if (last_section == NULL)
10357 dwarf2out_maybe_output_loclist_view_pair (curr);
10358 dw2_asm_output_data (1, DW_LLE_start_length,
10359 "DW_LLE_start_length (%s)",
10360 list_head->ll_symbol);
10361 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
10362 "Location list begin address (%s)",
10363 list_head->ll_symbol);
10364 dw2_asm_output_delta_uleb128 (curr->end, curr->begin,
10365 "Location list length "
10366 "(%s)", list_head->ll_symbol);
10368 /* Otherwise emit DW_LLE_offset_pair, relative to above emitted
10369 DW_LLE_base_address. */
10372 dwarf2out_maybe_output_loclist_view_pair (curr);
10373 dw2_asm_output_data (1, DW_LLE_offset_pair,
10374 "DW_LLE_offset_pair (%s)",
10375 list_head->ll_symbol);
10376 dw2_asm_output_delta_uleb128 (curr->begin, base_label,
10377 "Location list begin address "
10378 "(%s)", list_head->ll_symbol);
10379 dw2_asm_output_delta_uleb128 (curr->end, base_label,
10380 "Location list end address "
10381 "(%s)", list_head->ll_symbol);
10384 /* The assembler does not support .uleb128 directive. Emit
10385 DW_LLE_start_end with a pair of absolute addresses. */
10388 dwarf2out_maybe_output_loclist_view_pair (curr);
10389 dw2_asm_output_data (1, DW_LLE_start_end,
10390 "DW_LLE_start_end (%s)",
10391 list_head->ll_symbol);
10392 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
10393 "Location list begin address (%s)",
10394 list_head->ll_symbol);
10395 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
10396 "Location list end address (%s)",
10397 list_head->ll_symbol);
10400 else if (dwarf_split_debug_info)
10402 /* For -gsplit-dwarf -gdwarf-{2,3,4} emit index into .debug_addr
10403 and 4 byte length. */
10404 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry,
10405 "Location list start/length entry (%s)",
10406 list_head->ll_symbol);
10407 dw2_asm_output_data_uleb128 (curr->begin_entry->index,
10408 "Location list range start index (%s)",
10410 /* The length field is 4 bytes. If we ever need to support
10411 an 8-byte length, we can add a new DW_LLE code or fall back
10412 to DW_LLE_GNU_start_end_entry. */
10413 dw2_asm_output_delta (4, curr->end, curr->begin,
10414 "Location list range length (%s)",
10415 list_head->ll_symbol);
10417 else if (!have_multiple_function_sections)
10419 /* Pair of relative addresses against start of text section. */
10420 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
10421 "Location list begin address (%s)",
10422 list_head->ll_symbol);
10423 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
10424 "Location list end address (%s)",
10425 list_head->ll_symbol);
10429 /* Pair of absolute addresses. */
10430 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
10431 "Location list begin address (%s)",
10432 list_head->ll_symbol);
10433 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
10434 "Location list end address (%s)",
10435 list_head->ll_symbol);
10438 /* Output the block length for this list of location operations. */
10439 if (dwarf_version >= 5)
10440 dw2_asm_output_data_uleb128 (size, "Location expression size");
10443 gcc_assert (size <= 0xffff);
10444 dw2_asm_output_data (2, size, "Location expression size");
10447 output_loc_sequence (curr->expr, -1);
10450 /* And finally list termination. */
10451 if (dwarf_version >= 5)
10452 dw2_asm_output_data (1, DW_LLE_end_of_list,
10453 "DW_LLE_end_of_list (%s)", list_head->ll_symbol);
10454 else if (dwarf_split_debug_info)
10455 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry,
10456 "Location list terminator (%s)",
10457 list_head->ll_symbol);
10460 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
10461 "Location list terminator begin (%s)",
10462 list_head->ll_symbol);
10463 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
10464 "Location list terminator end (%s)",
10465 list_head->ll_symbol);
10468 gcc_assert (!list_head->vl_symbol
10469 || vcount == lcount * (dwarf2out_locviews_in_attribute () ? 1 : 0));
10472 /* Output a range_list offset into the .debug_ranges or .debug_rnglists
10473 section. Emit a relocated reference if val_entry is NULL, otherwise,
10474 emit an indirect reference. */
10477 output_range_list_offset (dw_attr_node *a)
10479 const char *name = dwarf_attr_name (a->dw_attr);
10481 if (a->dw_attr_val.val_entry == RELOCATED_OFFSET)
10483 if (dwarf_version >= 5)
10485 dw_ranges *r = &(*ranges_table)[a->dw_attr_val.v.val_offset];
10486 dw2_asm_output_offset (DWARF_OFFSET_SIZE, r->label,
10487 debug_ranges_section, "%s", name);
10491 char *p = strchr (ranges_section_label, '\0');
10492 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
10493 a->dw_attr_val.v.val_offset * 2 * DWARF2_ADDR_SIZE);
10494 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
10495 debug_ranges_section, "%s", name);
10499 else if (dwarf_version >= 5)
10501 dw_ranges *r = &(*ranges_table)[a->dw_attr_val.v.val_offset];
10502 gcc_assert (rnglist_idx);
10503 dw2_asm_output_data_uleb128 (r->idx, "%s", name);
10506 dw2_asm_output_data (DWARF_OFFSET_SIZE,
10507 a->dw_attr_val.v.val_offset * 2 * DWARF2_ADDR_SIZE,
10508 "%s (offset from %s)", name, ranges_section_label);
10511 /* Output the offset into the debug_loc section. */
10514 output_loc_list_offset (dw_attr_node *a)
10516 char *sym = AT_loc_list (a)->ll_symbol;
10519 if (!dwarf_split_debug_info)
10520 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
10521 "%s", dwarf_attr_name (a->dw_attr));
10522 else if (dwarf_version >= 5)
10524 gcc_assert (AT_loc_list (a)->num_assigned);
10525 dw2_asm_output_data_uleb128 (AT_loc_list (a)->hash, "%s (%s)",
10526 dwarf_attr_name (a->dw_attr),
10530 dw2_asm_output_delta (DWARF_OFFSET_SIZE, sym, loc_section_label,
10531 "%s", dwarf_attr_name (a->dw_attr));
10534 /* Output the offset into the debug_loc section. */
10537 output_view_list_offset (dw_attr_node *a)
10539 char *sym = (*AT_loc_list_ptr (a))->vl_symbol;
10542 if (dwarf_split_debug_info)
10543 dw2_asm_output_delta (DWARF_OFFSET_SIZE, sym, loc_section_label,
10544 "%s", dwarf_attr_name (a->dw_attr));
10546 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, debug_loc_section,
10547 "%s", dwarf_attr_name (a->dw_attr));
10550 /* Output an attribute's index or value appropriately. */
10553 output_attr_index_or_value (dw_attr_node *a)
10555 const char *name = dwarf_attr_name (a->dw_attr);
10557 if (dwarf_split_debug_info && AT_index (a) != NOT_INDEXED)
10559 dw2_asm_output_data_uleb128 (AT_index (a), "%s", name);
10562 switch (AT_class (a))
10564 case dw_val_class_addr:
10565 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
10567 case dw_val_class_high_pc:
10568 case dw_val_class_lbl_id:
10569 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
10572 gcc_unreachable ();
10576 /* Output a type signature. */
10579 output_signature (const char *sig, const char *name)
10583 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
10584 dw2_asm_output_data (1, sig[i], i == 0 ? "%s" : NULL, name);
10587 /* Output a discriminant value. */
10590 output_discr_value (dw_discr_value *discr_value, const char *name)
10592 if (discr_value->pos)
10593 dw2_asm_output_data_uleb128 (discr_value->v.uval, "%s", name);
10595 dw2_asm_output_data_sleb128 (discr_value->v.sval, "%s", name);
10598 /* Output the DIE and its attributes. Called recursively to generate
10599 the definitions of each child DIE. */
10602 output_die (dw_die_ref die)
10606 unsigned long size;
10609 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (%#lx) %s)",
10610 (unsigned long)die->die_offset,
10611 dwarf_tag_name (die->die_tag));
10613 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
10615 const char *name = dwarf_attr_name (a->dw_attr);
10617 switch (AT_class (a))
10619 case dw_val_class_addr:
10620 output_attr_index_or_value (a);
10623 case dw_val_class_offset:
10624 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
10628 case dw_val_class_range_list:
10629 output_range_list_offset (a);
10632 case dw_val_class_loc:
10633 size = size_of_locs (AT_loc (a));
10635 /* Output the block length for this list of location operations. */
10636 if (dwarf_version >= 4)
10637 dw2_asm_output_data_uleb128 (size, "%s", name);
10639 dw2_asm_output_data (constant_size (size), size, "%s", name);
10641 output_loc_sequence (AT_loc (a), -1);
10644 case dw_val_class_const:
10645 /* ??? It would be slightly more efficient to use a scheme like is
10646 used for unsigned constants below, but gdb 4.x does not sign
10647 extend. Gdb 5.x does sign extend. */
10648 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
10651 case dw_val_class_unsigned_const:
10653 int csize = constant_size (AT_unsigned (a));
10654 if (dwarf_version == 3
10655 && a->dw_attr == DW_AT_data_member_location
10657 dw2_asm_output_data_uleb128 (AT_unsigned (a), "%s", name);
10659 dw2_asm_output_data (csize, AT_unsigned (a), "%s", name);
10663 case dw_val_class_symview:
10666 if (symview_upper_bound <= 0xff)
10668 else if (symview_upper_bound <= 0xffff)
10670 else if (symview_upper_bound <= 0xffffffff)
10674 dw2_asm_output_addr (vsize, a->dw_attr_val.v.val_symbolic_view,
10679 case dw_val_class_const_implicit:
10680 if (flag_debug_asm)
10681 fprintf (asm_out_file, "\t\t\t%s %s ("
10682 HOST_WIDE_INT_PRINT_DEC ")\n",
10683 ASM_COMMENT_START, name, AT_int (a));
10686 case dw_val_class_unsigned_const_implicit:
10687 if (flag_debug_asm)
10688 fprintf (asm_out_file, "\t\t\t%s %s ("
10689 HOST_WIDE_INT_PRINT_HEX ")\n",
10690 ASM_COMMENT_START, name, AT_unsigned (a));
10693 case dw_val_class_const_double:
10695 unsigned HOST_WIDE_INT first, second;
10697 if (HOST_BITS_PER_WIDE_INT >= DWARF_LARGEST_DATA_FORM_BITS)
10698 dw2_asm_output_data (1,
10699 HOST_BITS_PER_DOUBLE_INT
10700 / HOST_BITS_PER_CHAR,
10703 if (WORDS_BIG_ENDIAN)
10705 first = a->dw_attr_val.v.val_double.high;
10706 second = a->dw_attr_val.v.val_double.low;
10710 first = a->dw_attr_val.v.val_double.low;
10711 second = a->dw_attr_val.v.val_double.high;
10714 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
10715 first, "%s", name);
10716 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR,
10721 case dw_val_class_wide_int:
10724 int len = get_full_len (*a->dw_attr_val.v.val_wide);
10725 int l = HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
10726 if (len * HOST_BITS_PER_WIDE_INT > DWARF_LARGEST_DATA_FORM_BITS)
10727 dw2_asm_output_data (1, get_full_len (*a->dw_attr_val.v.val_wide)
10730 if (WORDS_BIG_ENDIAN)
10731 for (i = len - 1; i >= 0; --i)
10733 dw2_asm_output_data (l, a->dw_attr_val.v.val_wide->elt (i),
10738 for (i = 0; i < len; ++i)
10740 dw2_asm_output_data (l, a->dw_attr_val.v.val_wide->elt (i),
10747 case dw_val_class_vec:
10749 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
10750 unsigned int len = a->dw_attr_val.v.val_vec.length;
10754 dw2_asm_output_data (constant_size (len * elt_size),
10755 len * elt_size, "%s", name);
10756 if (elt_size > sizeof (HOST_WIDE_INT))
10761 for (i = 0, p = (unsigned char *) a->dw_attr_val.v.val_vec.array;
10763 i++, p += elt_size)
10764 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
10765 "fp or vector constant word %u", i);
10769 case dw_val_class_flag:
10770 if (dwarf_version >= 4)
10772 /* Currently all add_AT_flag calls pass in 1 as last argument,
10773 so DW_FORM_flag_present can be used. If that ever changes,
10774 we'll need to use DW_FORM_flag and have some optimization
10775 in build_abbrev_table that will change those to
10776 DW_FORM_flag_present if it is set to 1 in all DIEs using
10777 the same abbrev entry. */
10778 gcc_assert (AT_flag (a) == 1);
10779 if (flag_debug_asm)
10780 fprintf (asm_out_file, "\t\t\t%s %s\n",
10781 ASM_COMMENT_START, name);
10784 dw2_asm_output_data (1, AT_flag (a), "%s", name);
10787 case dw_val_class_loc_list:
10788 output_loc_list_offset (a);
10791 case dw_val_class_view_list:
10792 output_view_list_offset (a);
10795 case dw_val_class_die_ref:
10796 if (AT_ref_external (a))
10798 if (AT_ref (a)->comdat_type_p)
10800 comdat_type_node *type_node
10801 = AT_ref (a)->die_id.die_type_node;
10803 gcc_assert (type_node);
10804 output_signature (type_node->signature, name);
10808 const char *sym = AT_ref (a)->die_id.die_symbol;
10812 /* In DWARF2, DW_FORM_ref_addr is sized by target address
10813 length, whereas in DWARF3 it's always sized as an
10815 if (dwarf_version == 2)
10816 size = DWARF2_ADDR_SIZE;
10818 size = DWARF_OFFSET_SIZE;
10819 /* ??? We cannot unconditionally output die_offset if
10820 non-zero - others might create references to those
10822 And we do not clear its DIE offset after outputting it
10823 (and the label refers to the actual DIEs, not the
10824 DWARF CU unit header which is when using label + offset
10825 would be the correct thing to do).
10826 ??? This is the reason for the with_offset flag. */
10827 if (AT_ref (a)->with_offset)
10828 dw2_asm_output_offset (size, sym, AT_ref (a)->die_offset,
10829 debug_info_section, "%s", name);
10831 dw2_asm_output_offset (size, sym, debug_info_section, "%s",
10837 gcc_assert (AT_ref (a)->die_offset);
10838 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
10843 case dw_val_class_fde_ref:
10845 char l1[MAX_ARTIFICIAL_LABEL_BYTES];
10847 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
10848 a->dw_attr_val.v.val_fde_index * 2);
10849 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, debug_frame_section,
10854 case dw_val_class_vms_delta:
10855 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
10856 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE,
10857 AT_vms_delta2 (a), AT_vms_delta1 (a),
10860 dw2_asm_output_delta (DWARF_OFFSET_SIZE,
10861 AT_vms_delta2 (a), AT_vms_delta1 (a),
10866 case dw_val_class_lbl_id:
10867 output_attr_index_or_value (a);
10870 case dw_val_class_lineptr:
10871 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
10872 debug_line_section, "%s", name);
10875 case dw_val_class_macptr:
10876 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
10877 debug_macinfo_section, "%s", name);
10880 case dw_val_class_loclistsptr:
10881 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a),
10882 debug_loc_section, "%s", name);
10885 case dw_val_class_str:
10886 if (a->dw_attr_val.v.val_str->form == DW_FORM_strp)
10887 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
10888 a->dw_attr_val.v.val_str->label,
10890 "%s: \"%s\"", name, AT_string (a));
10891 else if (a->dw_attr_val.v.val_str->form == DW_FORM_line_strp)
10892 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
10893 a->dw_attr_val.v.val_str->label,
10894 debug_line_str_section,
10895 "%s: \"%s\"", name, AT_string (a));
10896 else if (a->dw_attr_val.v.val_str->form == dwarf_FORM (DW_FORM_strx))
10897 dw2_asm_output_data_uleb128 (AT_index (a),
10898 "%s: \"%s\"", name, AT_string (a));
10900 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
10903 case dw_val_class_file:
10905 int f = maybe_emit_file (a->dw_attr_val.v.val_file);
10907 dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
10908 a->dw_attr_val.v.val_file->filename);
10912 case dw_val_class_file_implicit:
10913 if (flag_debug_asm)
10914 fprintf (asm_out_file, "\t\t\t%s %s (%d, %s)\n",
10915 ASM_COMMENT_START, name,
10916 maybe_emit_file (a->dw_attr_val.v.val_file),
10917 a->dw_attr_val.v.val_file->filename);
10920 case dw_val_class_data8:
10924 for (i = 0; i < 8; i++)
10925 dw2_asm_output_data (1, a->dw_attr_val.v.val_data8[i],
10926 i == 0 ? "%s" : NULL, name);
10930 case dw_val_class_high_pc:
10931 dw2_asm_output_delta (DWARF2_ADDR_SIZE, AT_lbl (a),
10932 get_AT_low_pc (die), "DW_AT_high_pc");
10935 case dw_val_class_discr_value:
10936 output_discr_value (&a->dw_attr_val.v.val_discr_value, name);
10939 case dw_val_class_discr_list:
10941 dw_discr_list_ref list = AT_discr_list (a);
10942 const int size = size_of_discr_list (list);
10944 /* This is a block, so output its length first. */
10945 dw2_asm_output_data (constant_size (size), size,
10946 "%s: block size", name);
10948 for (; list != NULL; list = list->dw_discr_next)
10950 /* One byte for the discriminant value descriptor, and then as
10951 many LEB128 numbers as required. */
10952 if (list->dw_discr_range)
10953 dw2_asm_output_data (1, DW_DSC_range,
10954 "%s: DW_DSC_range", name);
10956 dw2_asm_output_data (1, DW_DSC_label,
10957 "%s: DW_DSC_label", name);
10959 output_discr_value (&list->dw_discr_lower_bound, name);
10960 if (list->dw_discr_range)
10961 output_discr_value (&list->dw_discr_upper_bound, name);
10967 gcc_unreachable ();
10971 FOR_EACH_CHILD (die, c, output_die (c));
10973 /* Add null byte to terminate sibling list. */
10974 if (die->die_child != NULL)
10975 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
10976 (unsigned long) die->die_offset);
10979 /* Output the dwarf version number. */
10982 output_dwarf_version ()
10984 /* ??? For now, if -gdwarf-6 is specified, we output version 5 with
10985 views in loclist. That will change eventually. */
10986 if (dwarf_version == 6)
10991 warning (0, "%<-gdwarf-6%> is output as version 5 with "
10992 "incompatibilities");
10995 dw2_asm_output_data (2, 5, "DWARF version number");
10998 dw2_asm_output_data (2, dwarf_version, "DWARF version number");
11001 /* Output the compilation unit that appears at the beginning of the
11002 .debug_info section, and precedes the DIE descriptions. */
11005 output_compilation_unit_header (enum dwarf_unit_type ut)
11007 if (!XCOFF_DEBUGGING_INFO)
11009 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11010 dw2_asm_output_data (4, 0xffffffff,
11011 "Initial length escape value indicating 64-bit DWARF extension");
11012 dw2_asm_output_data (DWARF_OFFSET_SIZE,
11013 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
11014 "Length of Compilation Unit Info");
11017 output_dwarf_version ();
11018 if (dwarf_version >= 5)
11023 case DW_UT_compile: name = "DW_UT_compile"; break;
11024 case DW_UT_type: name = "DW_UT_type"; break;
11025 case DW_UT_split_compile: name = "DW_UT_split_compile"; break;
11026 case DW_UT_split_type: name = "DW_UT_split_type"; break;
11027 default: gcc_unreachable ();
11029 dw2_asm_output_data (1, ut, "%s", name);
11030 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
11032 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
11033 debug_abbrev_section,
11034 "Offset Into Abbrev. Section");
11035 if (dwarf_version < 5)
11036 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
11039 /* Output the compilation unit DIE and its children. */
11042 output_comp_unit (dw_die_ref die, int output_if_empty,
11043 const unsigned char *dwo_id)
11045 const char *secname, *oldsym;
11048 /* Unless we are outputting main CU, we may throw away empty ones. */
11049 if (!output_if_empty && die->die_child == NULL)
11052 /* Even if there are no children of this DIE, we must output the information
11053 about the compilation unit. Otherwise, on an empty translation unit, we
11054 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
11055 will then complain when examining the file. First mark all the DIEs in
11056 this CU so we know which get local refs. */
11059 external_ref_hash_type *extern_map = optimize_external_refs (die);
11061 /* For now, optimize only the main CU, in order to optimize the rest
11062 we'd need to see all of them earlier. Leave the rest for post-linking
11064 if (die == comp_unit_die ())
11065 abbrev_opt_start = vec_safe_length (abbrev_die_table);
11067 build_abbrev_table (die, extern_map);
11069 optimize_abbrev_table ();
11073 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11074 next_die_offset = (dwo_id
11075 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11076 : DWARF_COMPILE_UNIT_HEADER_SIZE);
11077 calc_die_sizes (die);
11079 oldsym = die->die_id.die_symbol;
11080 if (oldsym && die->comdat_type_p)
11082 tmp = XALLOCAVEC (char, strlen (oldsym) + 24);
11084 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
11086 die->die_id.die_symbol = NULL;
11087 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
11091 switch_to_section (debug_info_section);
11092 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
11093 info_section_emitted = true;
11096 /* For LTO cross unit DIE refs we want a symbol on the start of the
11097 debuginfo section, not on the CU DIE. */
11098 if ((flag_generate_lto || flag_generate_offload) && oldsym)
11100 /* ??? No way to get visibility assembled without a decl. */
11101 tree decl = build_decl (UNKNOWN_LOCATION, VAR_DECL,
11102 get_identifier (oldsym), char_type_node);
11103 TREE_PUBLIC (decl) = true;
11104 TREE_STATIC (decl) = true;
11105 DECL_ARTIFICIAL (decl) = true;
11106 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
11107 DECL_VISIBILITY_SPECIFIED (decl) = true;
11108 targetm.asm_out.assemble_visibility (decl, VISIBILITY_HIDDEN);
11109 #ifdef ASM_WEAKEN_LABEL
11110 /* We prefer a .weak because that handles duplicates from duplicate
11111 archive members in a graceful way. */
11112 ASM_WEAKEN_LABEL (asm_out_file, oldsym);
11114 targetm.asm_out.globalize_label (asm_out_file, oldsym);
11116 ASM_OUTPUT_LABEL (asm_out_file, oldsym);
11119 /* Output debugging information. */
11120 output_compilation_unit_header (dwo_id
11121 ? DW_UT_split_compile : DW_UT_compile);
11122 if (dwarf_version >= 5)
11124 if (dwo_id != NULL)
11125 for (int i = 0; i < 8; i++)
11126 dw2_asm_output_data (1, dwo_id[i], i == 0 ? "DWO id" : NULL);
11130 /* Leave the marks on the main CU, so we can check them in
11131 output_pubnames. */
11135 die->die_id.die_symbol = oldsym;
11139 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
11140 and .debug_pubtypes. This is configured per-target, but can be
11141 overridden by the -gpubnames or -gno-pubnames options. */
11144 want_pubnames (void)
11146 if (debug_info_level <= DINFO_LEVEL_TERSE
11147 /* Names and types go to the early debug part only. */
11150 if (debug_generate_pub_sections != -1)
11151 return debug_generate_pub_sections;
11152 return targetm.want_debug_pub_sections;
11155 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
11158 add_AT_pubnames (dw_die_ref die)
11160 if (want_pubnames ())
11161 add_AT_flag (die, DW_AT_GNU_pubnames, 1);
11164 /* Add a string attribute value to a skeleton DIE. */
11167 add_skeleton_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind,
11171 struct indirect_string_node *node;
11173 if (! skeleton_debug_str_hash)
11174 skeleton_debug_str_hash
11175 = hash_table<indirect_string_hasher>::create_ggc (10);
11177 node = find_AT_string_in_table (str, skeleton_debug_str_hash);
11178 find_string_form (node);
11179 if (node->form == dwarf_FORM (DW_FORM_strx))
11180 node->form = DW_FORM_strp;
11182 attr.dw_attr = attr_kind;
11183 attr.dw_attr_val.val_class = dw_val_class_str;
11184 attr.dw_attr_val.val_entry = NULL;
11185 attr.dw_attr_val.v.val_str = node;
11186 add_dwarf_attr (die, &attr);
11189 /* Helper function to generate top-level dies for skeleton debug_info and
11193 add_top_level_skeleton_die_attrs (dw_die_ref die)
11195 const char *dwo_file_name = concat (aux_base_name, ".dwo", NULL);
11196 const char *comp_dir = comp_dir_string ();
11198 add_skeleton_AT_string (die, dwarf_AT (DW_AT_dwo_name), dwo_file_name);
11199 if (comp_dir != NULL)
11200 add_skeleton_AT_string (die, DW_AT_comp_dir, comp_dir);
11201 add_AT_pubnames (die);
11202 if (addr_index_table != NULL && addr_index_table->size () > 0)
11203 add_AT_lineptr (die, dwarf_AT (DW_AT_addr_base), debug_addr_section_label);
11206 /* Output skeleton debug sections that point to the dwo file. */
11209 output_skeleton_debug_sections (dw_die_ref comp_unit,
11210 const unsigned char *dwo_id)
11212 /* These attributes will be found in the full debug_info section. */
11213 remove_AT (comp_unit, DW_AT_producer);
11214 remove_AT (comp_unit, DW_AT_language);
11216 switch_to_section (debug_skeleton_info_section);
11217 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_info_section_label);
11219 /* Produce the skeleton compilation-unit header. This one differs enough from
11220 a normal CU header that it's better not to call output_compilation_unit
11222 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11223 dw2_asm_output_data (4, 0xffffffff,
11224 "Initial length escape value indicating 64-bit "
11225 "DWARF extension");
11227 dw2_asm_output_data (DWARF_OFFSET_SIZE,
11228 DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11229 - DWARF_INITIAL_LENGTH_SIZE
11230 + size_of_die (comp_unit),
11231 "Length of Compilation Unit Info");
11232 output_dwarf_version ();
11233 if (dwarf_version >= 5)
11235 dw2_asm_output_data (1, DW_UT_skeleton, "DW_UT_skeleton");
11236 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
11238 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_abbrev_section_label,
11239 debug_skeleton_abbrev_section,
11240 "Offset Into Abbrev. Section");
11241 if (dwarf_version < 5)
11242 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
11244 for (int i = 0; i < 8; i++)
11245 dw2_asm_output_data (1, dwo_id[i], i == 0 ? "DWO id" : NULL);
11247 comp_unit->die_abbrev = SKELETON_COMP_DIE_ABBREV;
11248 output_die (comp_unit);
11250 /* Build the skeleton debug_abbrev section. */
11251 switch_to_section (debug_skeleton_abbrev_section);
11252 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_abbrev_section_label);
11254 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV, comp_unit);
11256 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
11259 /* Output a comdat type unit DIE and its children. */
11262 output_comdat_type_unit (comdat_type_node *node,
11263 bool early_lto_debug ATTRIBUTE_UNUSED)
11265 const char *secname;
11268 #if defined (OBJECT_FORMAT_ELF)
11272 /* First mark all the DIEs in this CU so we know which get local refs. */
11273 mark_dies (node->root_die);
11275 external_ref_hash_type *extern_map = optimize_external_refs (node->root_die);
11277 build_abbrev_table (node->root_die, extern_map);
11282 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11283 next_die_offset = DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE;
11284 calc_die_sizes (node->root_die);
11286 #if defined (OBJECT_FORMAT_ELF)
11287 if (dwarf_version >= 5)
11289 if (!dwarf_split_debug_info)
11290 secname = early_lto_debug ? DEBUG_LTO_INFO_SECTION : DEBUG_INFO_SECTION;
11292 secname = (early_lto_debug
11293 ? DEBUG_LTO_DWO_INFO_SECTION : DEBUG_DWO_INFO_SECTION);
11295 else if (!dwarf_split_debug_info)
11296 secname = early_lto_debug ? ".gnu.debuglto_.debug_types" : ".debug_types";
11298 secname = (early_lto_debug
11299 ? ".gnu.debuglto_.debug_types.dwo" : ".debug_types.dwo");
11301 tmp = XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE * 2);
11302 sprintf (tmp, dwarf_version >= 5 ? "wi." : "wt.");
11303 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
11304 sprintf (tmp + 3 + i * 2, "%02x", node->signature[i] & 0xff);
11305 comdat_key = get_identifier (tmp);
11306 targetm.asm_out.named_section (secname,
11307 SECTION_DEBUG | SECTION_LINKONCE,
11310 tmp = XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE * 2);
11311 sprintf (tmp, (dwarf_version >= 5
11312 ? ".gnu.linkonce.wi." : ".gnu.linkonce.wt."));
11313 for (i = 0; i < DWARF_TYPE_SIGNATURE_SIZE; i++)
11314 sprintf (tmp + 17 + i * 2, "%02x", node->signature[i] & 0xff);
11316 switch_to_section (get_section (secname, SECTION_DEBUG, NULL));
11319 /* Output debugging information. */
11320 output_compilation_unit_header (dwarf_split_debug_info
11321 ? DW_UT_split_type : DW_UT_type);
11322 output_signature (node->signature, "Type Signature");
11323 dw2_asm_output_data (DWARF_OFFSET_SIZE, node->type_die->die_offset,
11324 "Offset to Type DIE");
11325 output_die (node->root_die);
11327 unmark_dies (node->root_die);
11330 /* Return the DWARF2/3 pubname associated with a decl. */
11332 static const char *
11333 dwarf2_name (tree decl, int scope)
11335 if (DECL_NAMELESS (decl))
11337 return lang_hooks.dwarf_name (decl, scope ? 1 : 0);
11340 /* Add a new entry to .debug_pubnames if appropriate. */
11343 add_pubname_string (const char *str, dw_die_ref die)
11348 e.name = xstrdup (str);
11349 vec_safe_push (pubname_table, e);
11353 add_pubname (tree decl, dw_die_ref die)
11355 if (!want_pubnames ())
11358 /* Don't add items to the table when we expect that the consumer will have
11359 just read the enclosing die. For example, if the consumer is looking at a
11360 class_member, it will either be inside the class already, or will have just
11361 looked up the class to find the member. Either way, searching the class is
11362 faster than searching the index. */
11363 if ((TREE_PUBLIC (decl) && !class_scope_p (die->die_parent))
11364 || is_cu_die (die->die_parent) || is_namespace_die (die->die_parent))
11366 const char *name = dwarf2_name (decl, 1);
11369 add_pubname_string (name, die);
11373 /* Add an enumerator to the pubnames section. */
11376 add_enumerator_pubname (const char *scope_name, dw_die_ref die)
11380 gcc_assert (scope_name);
11381 e.name = concat (scope_name, get_AT_string (die, DW_AT_name), NULL);
11383 vec_safe_push (pubname_table, e);
11386 /* Add a new entry to .debug_pubtypes if appropriate. */
11389 add_pubtype (tree decl, dw_die_ref die)
11393 if (!want_pubnames ())
11396 if ((TREE_PUBLIC (decl)
11397 || is_cu_die (die->die_parent) || is_namespace_die (die->die_parent))
11398 && (die->die_tag == DW_TAG_typedef || COMPLETE_TYPE_P (decl)))
11401 const char *scope_name = "";
11402 const char *sep = is_cxx () ? "::" : ".";
11405 scope = TYPE_P (decl) ? TYPE_CONTEXT (decl) : NULL;
11406 if (scope && TREE_CODE (scope) == NAMESPACE_DECL)
11408 scope_name = lang_hooks.dwarf_name (scope, 1);
11409 if (scope_name != NULL && scope_name[0] != '\0')
11410 scope_name = concat (scope_name, sep, NULL);
11416 name = type_tag (decl);
11418 name = lang_hooks.dwarf_name (decl, 1);
11420 /* If we don't have a name for the type, there's no point in adding
11421 it to the table. */
11422 if (name != NULL && name[0] != '\0')
11425 e.name = concat (scope_name, name, NULL);
11426 vec_safe_push (pubtype_table, e);
11429 /* Although it might be more consistent to add the pubinfo for the
11430 enumerators as their dies are created, they should only be added if the
11431 enum type meets the criteria above. So rather than re-check the parent
11432 enum type whenever an enumerator die is created, just output them all
11433 here. This isn't protected by the name conditional because anonymous
11434 enums don't have names. */
11435 if (die->die_tag == DW_TAG_enumeration_type)
11439 FOR_EACH_CHILD (die, c, add_enumerator_pubname (scope_name, c));
11444 /* Output a single entry in the pubnames table. */
11447 output_pubname (dw_offset die_offset, pubname_entry *entry)
11449 dw_die_ref die = entry->die;
11450 int is_static = get_AT_flag (die, DW_AT_external) ? 0 : 1;
11452 dw2_asm_output_data (DWARF_OFFSET_SIZE, die_offset, "DIE offset");
11454 if (debug_generate_pub_sections == 2)
11456 /* This logic follows gdb's method for determining the value of the flag
11458 uint32_t flags = GDB_INDEX_SYMBOL_KIND_NONE;
11459 switch (die->die_tag)
11461 case DW_TAG_typedef:
11462 case DW_TAG_base_type:
11463 case DW_TAG_subrange_type:
11464 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
11465 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
11467 case DW_TAG_enumerator:
11468 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
11469 GDB_INDEX_SYMBOL_KIND_VARIABLE);
11471 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
11473 case DW_TAG_subprogram:
11474 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
11475 GDB_INDEX_SYMBOL_KIND_FUNCTION);
11477 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static);
11479 case DW_TAG_constant:
11480 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
11481 GDB_INDEX_SYMBOL_KIND_VARIABLE);
11482 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static);
11484 case DW_TAG_variable:
11485 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags,
11486 GDB_INDEX_SYMBOL_KIND_VARIABLE);
11487 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, is_static);
11489 case DW_TAG_namespace:
11490 case DW_TAG_imported_declaration:
11491 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
11493 case DW_TAG_class_type:
11494 case DW_TAG_interface_type:
11495 case DW_TAG_structure_type:
11496 case DW_TAG_union_type:
11497 case DW_TAG_enumeration_type:
11498 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags, GDB_INDEX_SYMBOL_KIND_TYPE);
11500 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags, 1);
11503 /* An unusual tag. Leave the flag-byte empty. */
11506 dw2_asm_output_data (1, flags >> GDB_INDEX_CU_BITSIZE,
11507 "GDB-index flags");
11510 dw2_asm_output_nstring (entry->name, -1, "external name");
11514 /* Output the public names table used to speed up access to externally
11515 visible names; or the public types table used to find type definitions. */
11518 output_pubnames (vec<pubname_entry, va_gc> *names)
11521 unsigned long pubnames_length = size_of_pubnames (names);
11522 pubname_entry *pub;
11524 if (!XCOFF_DEBUGGING_INFO)
11526 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11527 dw2_asm_output_data (4, 0xffffffff,
11528 "Initial length escape value indicating 64-bit DWARF extension");
11529 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
11530 "Pub Info Length");
11533 /* Version number for pubnames/pubtypes is independent of dwarf version. */
11534 dw2_asm_output_data (2, 2, "DWARF pubnames/pubtypes version");
11536 if (dwarf_split_debug_info)
11537 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_info_section_label,
11538 debug_skeleton_info_section,
11539 "Offset of Compilation Unit Info");
11541 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
11542 debug_info_section,
11543 "Offset of Compilation Unit Info");
11544 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
11545 "Compilation Unit Length");
11547 FOR_EACH_VEC_ELT (*names, i, pub)
11549 if (include_pubname_in_output (names, pub))
11551 dw_offset die_offset = pub->die->die_offset;
11553 /* We shouldn't see pubnames for DIEs outside of the main CU. */
11554 if (names == pubname_table && pub->die->die_tag != DW_TAG_enumerator)
11555 gcc_assert (pub->die->die_mark);
11557 /* If we're putting types in their own .debug_types sections,
11558 the .debug_pubtypes table will still point to the compile
11559 unit (not the type unit), so we want to use the offset of
11560 the skeleton DIE (if there is one). */
11561 if (pub->die->comdat_type_p && names == pubtype_table)
11563 comdat_type_node *type_node = pub->die->die_id.die_type_node;
11565 if (type_node != NULL)
11566 die_offset = (type_node->skeleton_die != NULL
11567 ? type_node->skeleton_die->die_offset
11568 : comp_unit_die ()->die_offset);
11571 output_pubname (die_offset, pub);
11575 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
11578 /* Output public names and types tables if necessary. */
11581 output_pubtables (void)
11583 if (!want_pubnames () || !info_section_emitted)
11586 switch_to_section (debug_pubnames_section);
11587 output_pubnames (pubname_table);
11588 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
11589 It shouldn't hurt to emit it always, since pure DWARF2 consumers
11590 simply won't look for the section. */
11591 switch_to_section (debug_pubtypes_section);
11592 output_pubnames (pubtype_table);
11596 /* Output the information that goes into the .debug_aranges table.
11597 Namely, define the beginning and ending address range of the
11598 text section generated for this compilation unit. */
11601 output_aranges (void)
11604 unsigned long aranges_length = size_of_aranges ();
11606 if (!XCOFF_DEBUGGING_INFO)
11608 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11609 dw2_asm_output_data (4, 0xffffffff,
11610 "Initial length escape value indicating 64-bit DWARF extension");
11611 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
11612 "Length of Address Ranges Info");
11615 /* Version number for aranges is still 2, even up to DWARF5. */
11616 dw2_asm_output_data (2, 2, "DWARF aranges version");
11617 if (dwarf_split_debug_info)
11618 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_skeleton_info_section_label,
11619 debug_skeleton_info_section,
11620 "Offset of Compilation Unit Info");
11622 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
11623 debug_info_section,
11624 "Offset of Compilation Unit Info");
11625 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
11626 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
11628 /* We need to align to twice the pointer size here. */
11629 if (DWARF_ARANGES_PAD_SIZE)
11631 /* Pad using a 2 byte words so that padding is correct for any
11633 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
11634 2 * DWARF2_ADDR_SIZE);
11635 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
11636 dw2_asm_output_data (2, 0, NULL);
11639 /* It is necessary not to output these entries if the sections were
11640 not used; if the sections were not used, the length will be 0 and
11641 the address may end up as 0 if the section is discarded by ld
11642 --gc-sections, leaving an invalid (0, 0) entry that can be
11643 confused with the terminator. */
11644 if (text_section_used)
11646 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
11647 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
11648 text_section_label, "Length");
11650 if (cold_text_section_used)
11652 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
11654 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
11655 cold_text_section_label, "Length");
11658 if (have_multiple_function_sections)
11663 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde)
11665 if (DECL_IGNORED_P (fde->decl))
11667 if (!fde->in_std_section)
11669 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
11671 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_end,
11672 fde->dw_fde_begin, "Length");
11674 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
11676 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_second_begin,
11678 dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_second_end,
11679 fde->dw_fde_second_begin, "Length");
11684 /* Output the terminator words. */
11685 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11686 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11689 /* Add a new entry to .debug_ranges. Return its index into
11690 ranges_table vector. */
11692 static unsigned int
11693 add_ranges_num (int num, bool maybe_new_sec)
11695 dw_ranges r = { NULL, num, 0, maybe_new_sec };
11696 vec_safe_push (ranges_table, r);
11697 return vec_safe_length (ranges_table) - 1;
11700 /* Add a new entry to .debug_ranges corresponding to a block, or a
11701 range terminator if BLOCK is NULL. MAYBE_NEW_SEC is true if
11702 this entry might be in a different section from previous range. */
11704 static unsigned int
11705 add_ranges (const_tree block, bool maybe_new_sec)
11707 return add_ranges_num (block ? BLOCK_NUMBER (block) : 0, maybe_new_sec);
11710 /* Note that (*rnglist_table)[offset] is either a head of a rnglist
11711 chain, or middle entry of a chain that will be directly referred to. */
11714 note_rnglist_head (unsigned int offset)
11716 if (dwarf_version < 5 || (*ranges_table)[offset].label)
11718 (*ranges_table)[offset].label = gen_internal_sym ("LLRL");
11721 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
11722 When using dwarf_split_debug_info, address attributes in dies destined
11723 for the final executable should be direct references--setting the
11724 parameter force_direct ensures this behavior. */
11727 add_ranges_by_labels (dw_die_ref die, const char *begin, const char *end,
11728 bool *added, bool force_direct)
11730 unsigned int in_use = vec_safe_length (ranges_by_label);
11731 unsigned int offset;
11732 dw_ranges_by_label rbl = { begin, end };
11733 vec_safe_push (ranges_by_label, rbl);
11734 offset = add_ranges_num (-(int)in_use - 1, true);
11737 add_AT_range_list (die, DW_AT_ranges, offset, force_direct);
11739 note_rnglist_head (offset);
11743 /* Emit .debug_ranges section. */
11746 output_ranges (void)
11749 static const char *const start_fmt = "Offset %#x";
11750 const char *fmt = start_fmt;
11753 switch_to_section (debug_ranges_section);
11754 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
11755 FOR_EACH_VEC_SAFE_ELT (ranges_table, i, r)
11757 int block_num = r->num;
11761 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
11762 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
11764 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
11765 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
11767 /* If all code is in the text section, then the compilation
11768 unit base address defaults to DW_AT_low_pc, which is the
11769 base of the text section. */
11770 if (!have_multiple_function_sections)
11772 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
11773 text_section_label,
11774 fmt, i * 2 * DWARF2_ADDR_SIZE);
11775 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
11776 text_section_label, NULL);
11779 /* Otherwise, the compilation unit base address is zero,
11780 which allows us to use absolute addresses, and not worry
11781 about whether the target supports cross-section
11785 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
11786 fmt, i * 2 * DWARF2_ADDR_SIZE);
11787 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
11793 /* Negative block_num stands for an index into ranges_by_label. */
11794 else if (block_num < 0)
11796 int lab_idx = - block_num - 1;
11798 if (!have_multiple_function_sections)
11800 gcc_unreachable ();
11802 /* If we ever use add_ranges_by_labels () for a single
11803 function section, all we have to do is to take out
11804 the #if 0 above. */
11805 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
11806 (*ranges_by_label)[lab_idx].begin,
11807 text_section_label,
11808 fmt, i * 2 * DWARF2_ADDR_SIZE);
11809 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
11810 (*ranges_by_label)[lab_idx].end,
11811 text_section_label, NULL);
11816 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
11817 (*ranges_by_label)[lab_idx].begin,
11818 fmt, i * 2 * DWARF2_ADDR_SIZE);
11819 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
11820 (*ranges_by_label)[lab_idx].end,
11826 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11827 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
11833 /* Non-zero if .debug_line_str should be used for .debug_line section
11834 strings or strings that are likely shareable with those. */
11835 #define DWARF5_USE_DEBUG_LINE_STR \
11836 (!DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET \
11837 && (DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) != 0 \
11838 /* FIXME: there is no .debug_line_str.dwo section, \
11839 for -gsplit-dwarf we should use DW_FORM_strx instead. */ \
11840 && !dwarf_split_debug_info)
11842 /* Assign .debug_rnglists indexes. */
11845 index_rnglists (void)
11850 FOR_EACH_VEC_SAFE_ELT (ranges_table, i, r)
11852 r->idx = rnglist_idx++;
11855 /* Emit .debug_rnglists section. */
11858 output_rnglists (unsigned generation)
11862 char l1[MAX_ARTIFICIAL_LABEL_BYTES];
11863 char l2[MAX_ARTIFICIAL_LABEL_BYTES];
11864 char basebuf[MAX_ARTIFICIAL_LABEL_BYTES];
11866 switch_to_section (debug_ranges_section);
11867 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
11868 /* There are up to 4 unique ranges labels per generation.
11869 See also init_sections_and_labels. */
11870 ASM_GENERATE_INTERNAL_LABEL (l1, DEBUG_RANGES_SECTION_LABEL,
11871 2 + generation * 4);
11872 ASM_GENERATE_INTERNAL_LABEL (l2, DEBUG_RANGES_SECTION_LABEL,
11873 3 + generation * 4);
11874 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
11875 dw2_asm_output_data (4, 0xffffffff,
11876 "Initial length escape value indicating "
11877 "64-bit DWARF extension");
11878 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
11879 "Length of Range Lists");
11880 ASM_OUTPUT_LABEL (asm_out_file, l1);
11881 output_dwarf_version ();
11882 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Address Size");
11883 dw2_asm_output_data (1, 0, "Segment Size");
11884 /* Emit the offset table only for -gsplit-dwarf. If we don't care
11885 about relocation sizes and primarily care about the size of .debug*
11886 sections in linked shared libraries and executables, then
11887 the offset table plus corresponding DW_FORM_rnglistx uleb128 indexes
11888 into it are usually larger than just DW_FORM_sec_offset offsets
11889 into the .debug_rnglists section. */
11890 dw2_asm_output_data (4, dwarf_split_debug_info ? rnglist_idx : 0,
11891 "Offset Entry Count");
11892 if (dwarf_split_debug_info)
11894 ASM_OUTPUT_LABEL (asm_out_file, ranges_base_label);
11895 FOR_EACH_VEC_SAFE_ELT (ranges_table, i, r)
11897 dw2_asm_output_delta (DWARF_OFFSET_SIZE, r->label,
11898 ranges_base_label, NULL);
11901 const char *lab = "";
11902 unsigned int len = vec_safe_length (ranges_table);
11903 const char *base = NULL;
11904 FOR_EACH_VEC_SAFE_ELT (ranges_table, i, r)
11906 int block_num = r->num;
11910 ASM_OUTPUT_LABEL (asm_out_file, r->label);
11913 if (HAVE_AS_LEB128 && (r->label || r->maybe_new_sec))
11917 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
11918 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
11920 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
11921 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
11923 if (HAVE_AS_LEB128)
11925 /* If all code is in the text section, then the compilation
11926 unit base address defaults to DW_AT_low_pc, which is the
11927 base of the text section. */
11928 if (!have_multiple_function_sections)
11930 dw2_asm_output_data (1, DW_RLE_offset_pair,
11931 "DW_RLE_offset_pair (%s)", lab);
11932 dw2_asm_output_delta_uleb128 (blabel, text_section_label,
11933 "Range begin address (%s)", lab);
11934 dw2_asm_output_delta_uleb128 (elabel, text_section_label,
11935 "Range end address (%s)", lab);
11940 dw_ranges *r2 = NULL;
11942 r2 = &(*ranges_table)[i + 1];
11945 && r2->label == NULL
11946 && !r2->maybe_new_sec)
11948 dw2_asm_output_data (1, DW_RLE_base_address,
11949 "DW_RLE_base_address (%s)", lab);
11950 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
11951 "Base address (%s)", lab);
11952 strcpy (basebuf, blabel);
11958 dw2_asm_output_data (1, DW_RLE_offset_pair,
11959 "DW_RLE_offset_pair (%s)", lab);
11960 dw2_asm_output_delta_uleb128 (blabel, base,
11961 "Range begin address (%s)", lab);
11962 dw2_asm_output_delta_uleb128 (elabel, base,
11963 "Range end address (%s)", lab);
11966 dw2_asm_output_data (1, DW_RLE_start_length,
11967 "DW_RLE_start_length (%s)", lab);
11968 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
11969 "Range begin address (%s)", lab);
11970 dw2_asm_output_delta_uleb128 (elabel, blabel,
11971 "Range length (%s)", lab);
11975 dw2_asm_output_data (1, DW_RLE_start_end,
11976 "DW_RLE_start_end (%s)", lab);
11977 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
11978 "Range begin address (%s)", lab);
11979 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel,
11980 "Range end address (%s)", lab);
11984 /* Negative block_num stands for an index into ranges_by_label. */
11985 else if (block_num < 0)
11987 int lab_idx = - block_num - 1;
11988 const char *blabel = (*ranges_by_label)[lab_idx].begin;
11989 const char *elabel = (*ranges_by_label)[lab_idx].end;
11991 if (!have_multiple_function_sections)
11992 gcc_unreachable ();
11993 if (HAVE_AS_LEB128)
11995 dw2_asm_output_data (1, DW_RLE_start_length,
11996 "DW_RLE_start_length (%s)", lab);
11997 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
11998 "Range begin address (%s)", lab);
11999 dw2_asm_output_delta_uleb128 (elabel, blabel,
12000 "Range length (%s)", lab);
12004 dw2_asm_output_data (1, DW_RLE_start_end,
12005 "DW_RLE_start_end (%s)", lab);
12006 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
12007 "Range begin address (%s)", lab);
12008 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel,
12009 "Range end address (%s)", lab);
12013 dw2_asm_output_data (1, DW_RLE_end_of_list,
12014 "DW_RLE_end_of_list (%s)", lab);
12016 ASM_OUTPUT_LABEL (asm_out_file, l2);
12019 /* Data structure containing information about input files. */
12022 const char *path; /* Complete file name. */
12023 const char *fname; /* File name part. */
12024 int length; /* Length of entire string. */
12025 struct dwarf_file_data * file_idx; /* Index in input file table. */
12026 int dir_idx; /* Index in directory table. */
12029 /* Data structure containing information about directories with source
12033 const char *path; /* Path including directory name. */
12034 int length; /* Path length. */
12035 int prefix; /* Index of directory entry which is a prefix. */
12036 int count; /* Number of files in this directory. */
12037 int dir_idx; /* Index of directory used as base. */
12040 /* Callback function for file_info comparison. We sort by looking at
12041 the directories in the path. */
12044 file_info_cmp (const void *p1, const void *p2)
12046 const struct file_info *const s1 = (const struct file_info *) p1;
12047 const struct file_info *const s2 = (const struct file_info *) p2;
12048 const unsigned char *cp1;
12049 const unsigned char *cp2;
12051 /* Take care of file names without directories. We need to make sure that
12052 we return consistent values to qsort since some will get confused if
12053 we return the same value when identical operands are passed in opposite
12054 orders. So if neither has a directory, return 0 and otherwise return
12055 1 or -1 depending on which one has the directory. We want the one with
12056 the directory to sort after the one without, so all no directory files
12057 are at the start (normally only the compilation unit file). */
12058 if ((s1->path == s1->fname || s2->path == s2->fname))
12059 return (s2->path == s2->fname) - (s1->path == s1->fname);
12061 cp1 = (const unsigned char *) s1->path;
12062 cp2 = (const unsigned char *) s2->path;
12068 /* Reached the end of the first path? If so, handle like above,
12069 but now we want longer directory prefixes before shorter ones. */
12070 if ((cp1 == (const unsigned char *) s1->fname)
12071 || (cp2 == (const unsigned char *) s2->fname))
12072 return ((cp1 == (const unsigned char *) s1->fname)
12073 - (cp2 == (const unsigned char *) s2->fname));
12075 /* Character of current path component the same? */
12076 else if (*cp1 != *cp2)
12077 return *cp1 - *cp2;
12081 struct file_name_acquire_data
12083 struct file_info *files;
12088 /* Traversal function for the hash table. */
12091 file_name_acquire (dwarf_file_data **slot, file_name_acquire_data *fnad)
12093 struct dwarf_file_data *d = *slot;
12094 struct file_info *fi;
12097 gcc_assert (fnad->max_files >= d->emitted_number);
12099 if (! d->emitted_number)
12102 gcc_assert (fnad->max_files != fnad->used_files);
12104 fi = fnad->files + fnad->used_files++;
12106 f = remap_debug_filename (d->filename);
12108 /* Skip all leading "./". */
12109 while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
12112 /* Create a new array entry. */
12114 fi->length = strlen (f);
12117 /* Search for the file name part. */
12118 f = strrchr (f, DIR_SEPARATOR);
12119 #if defined (DIR_SEPARATOR_2)
12121 char *g = strrchr (fi->path, DIR_SEPARATOR_2);
12125 if (f == NULL || f < g)
12131 fi->fname = f == NULL ? fi->path : f + 1;
12135 /* Helper function for output_file_names. Emit a FORM encoded
12136 string STR, with assembly comment start ENTRY_KIND and
12140 output_line_string (enum dwarf_form form, const char *str,
12141 const char *entry_kind, unsigned int idx)
12145 case DW_FORM_string:
12146 dw2_asm_output_nstring (str, -1, "%s: %#x", entry_kind, idx);
12148 case DW_FORM_line_strp:
12149 if (!debug_line_str_hash)
12150 debug_line_str_hash
12151 = hash_table<indirect_string_hasher>::create_ggc (10);
12153 struct indirect_string_node *node;
12154 node = find_AT_string_in_table (str, debug_line_str_hash);
12155 set_indirect_string (node);
12157 dw2_asm_output_offset (DWARF_OFFSET_SIZE, node->label,
12158 debug_line_str_section, "%s: %#x: \"%s\"",
12159 entry_kind, 0, node->str);
12162 gcc_unreachable ();
12166 /* Output the directory table and the file name table. We try to minimize
12167 the total amount of memory needed. A heuristic is used to avoid large
12168 slowdowns with many input files. */
12171 output_file_names (void)
12173 struct file_name_acquire_data fnad;
12175 struct file_info *files;
12176 struct dir_info *dirs;
12184 if (!last_emitted_file)
12186 if (dwarf_version >= 5)
12188 dw2_asm_output_data (1, 0, "Directory entry format count");
12189 dw2_asm_output_data_uleb128 (0, "Directories count");
12190 dw2_asm_output_data (1, 0, "File name entry format count");
12191 dw2_asm_output_data_uleb128 (0, "File names count");
12195 dw2_asm_output_data (1, 0, "End directory table");
12196 dw2_asm_output_data (1, 0, "End file name table");
12201 numfiles = last_emitted_file->emitted_number;
12203 /* Allocate the various arrays we need. */
12204 files = XALLOCAVEC (struct file_info, numfiles);
12205 dirs = XALLOCAVEC (struct dir_info, numfiles);
12207 fnad.files = files;
12208 fnad.used_files = 0;
12209 fnad.max_files = numfiles;
12210 file_table->traverse<file_name_acquire_data *, file_name_acquire> (&fnad);
12211 gcc_assert (fnad.used_files == fnad.max_files);
12213 qsort (files, numfiles, sizeof (files[0]), file_info_cmp);
12215 /* Find all the different directories used. */
12216 dirs[0].path = files[0].path;
12217 dirs[0].length = files[0].fname - files[0].path;
12218 dirs[0].prefix = -1;
12220 dirs[0].dir_idx = 0;
12221 files[0].dir_idx = 0;
12224 for (i = 1; i < numfiles; i++)
12225 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
12226 && memcmp (dirs[ndirs - 1].path, files[i].path,
12227 dirs[ndirs - 1].length) == 0)
12229 /* Same directory as last entry. */
12230 files[i].dir_idx = ndirs - 1;
12231 ++dirs[ndirs - 1].count;
12237 /* This is a new directory. */
12238 dirs[ndirs].path = files[i].path;
12239 dirs[ndirs].length = files[i].fname - files[i].path;
12240 dirs[ndirs].count = 1;
12241 dirs[ndirs].dir_idx = ndirs;
12242 files[i].dir_idx = ndirs;
12244 /* Search for a prefix. */
12245 dirs[ndirs].prefix = -1;
12246 for (j = 0; j < ndirs; j++)
12247 if (dirs[j].length < dirs[ndirs].length
12248 && dirs[j].length > 1
12249 && (dirs[ndirs].prefix == -1
12250 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
12251 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
12252 dirs[ndirs].prefix = j;
12257 /* Now to the actual work. We have to find a subset of the directories which
12258 allow expressing the file name using references to the directory table
12259 with the least amount of characters. We do not do an exhaustive search
12260 where we would have to check out every combination of every single
12261 possible prefix. Instead we use a heuristic which provides nearly optimal
12262 results in most cases and never is much off. */
12263 saved = XALLOCAVEC (int, ndirs);
12264 savehere = XALLOCAVEC (int, ndirs);
12266 memset (saved, '\0', ndirs * sizeof (saved[0]));
12267 for (i = 0; i < ndirs; i++)
12272 /* We can always save some space for the current directory. But this
12273 does not mean it will be enough to justify adding the directory. */
12274 savehere[i] = dirs[i].length;
12275 total = (savehere[i] - saved[i]) * dirs[i].count;
12277 for (j = i + 1; j < ndirs; j++)
12280 if (saved[j] < dirs[i].length)
12282 /* Determine whether the dirs[i] path is a prefix of the
12286 k = dirs[j].prefix;
12287 while (k != -1 && k != (int) i)
12288 k = dirs[k].prefix;
12292 /* Yes it is. We can possibly save some memory by
12293 writing the filenames in dirs[j] relative to
12295 savehere[j] = dirs[i].length;
12296 total += (savehere[j] - saved[j]) * dirs[j].count;
12301 /* Check whether we can save enough to justify adding the dirs[i]
12303 if (total > dirs[i].length + 1)
12305 /* It's worthwhile adding. */
12306 for (j = i; j < ndirs; j++)
12307 if (savehere[j] > 0)
12309 /* Remember how much we saved for this directory so far. */
12310 saved[j] = savehere[j];
12312 /* Remember the prefix directory. */
12313 dirs[j].dir_idx = i;
12318 /* Emit the directory name table. */
12319 idx_offset = dirs[0].length > 0 ? 1 : 0;
12320 enum dwarf_form str_form = DW_FORM_string;
12321 enum dwarf_form idx_form = DW_FORM_udata;
12322 if (dwarf_version >= 5)
12324 const char *comp_dir = comp_dir_string ();
12325 if (comp_dir == NULL)
12327 dw2_asm_output_data (1, 1, "Directory entry format count");
12328 if (DWARF5_USE_DEBUG_LINE_STR)
12329 str_form = DW_FORM_line_strp;
12330 dw2_asm_output_data_uleb128 (DW_LNCT_path, "DW_LNCT_path");
12331 dw2_asm_output_data_uleb128 (str_form, "%s",
12332 get_DW_FORM_name (str_form));
12333 dw2_asm_output_data_uleb128 (ndirs + idx_offset, "Directories count");
12334 if (str_form == DW_FORM_string)
12336 dw2_asm_output_nstring (comp_dir, -1, "Directory Entry: %#x", 0);
12337 for (i = 1 - idx_offset; i < ndirs; i++)
12338 dw2_asm_output_nstring (dirs[i].path,
12340 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR,
12341 "Directory Entry: %#x", i + idx_offset);
12345 output_line_string (str_form, comp_dir, "Directory Entry", 0);
12346 for (i = 1 - idx_offset; i < ndirs; i++)
12349 = ggc_alloc_string (dirs[i].path,
12351 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR);
12352 output_line_string (str_form, str, "Directory Entry",
12353 (unsigned) i + idx_offset);
12359 for (i = 1 - idx_offset; i < ndirs; i++)
12360 dw2_asm_output_nstring (dirs[i].path,
12362 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR,
12363 "Directory Entry: %#x", i + idx_offset);
12365 dw2_asm_output_data (1, 0, "End directory table");
12368 /* We have to emit them in the order of emitted_number since that's
12369 used in the debug info generation. To do this efficiently we
12370 generate a back-mapping of the indices first. */
12371 backmap = XALLOCAVEC (int, numfiles);
12372 for (i = 0; i < numfiles; i++)
12373 backmap[files[i].file_idx->emitted_number - 1] = i;
12375 if (dwarf_version >= 5)
12377 const char *filename0 = get_AT_string (comp_unit_die (), DW_AT_name);
12378 if (filename0 == NULL)
12380 /* DW_LNCT_directory_index can use DW_FORM_udata, DW_FORM_data1 and
12381 DW_FORM_data2. Choose one based on the number of directories
12382 and how much space would they occupy in each encoding.
12383 If we have at most 256 directories, all indexes fit into
12384 a single byte, so DW_FORM_data1 is most compact (if there
12385 are at most 128 directories, DW_FORM_udata would be as
12386 compact as that, but not shorter and slower to decode). */
12387 if (ndirs + idx_offset <= 256)
12388 idx_form = DW_FORM_data1;
12389 /* If there are more than 65536 directories, we have to use
12390 DW_FORM_udata, DW_FORM_data2 can't refer to them.
12391 Otherwise, compute what space would occupy if all the indexes
12392 used DW_FORM_udata - sum - and compare that to how large would
12393 be DW_FORM_data2 encoding, and pick the more efficient one. */
12394 else if (ndirs + idx_offset <= 65536)
12396 unsigned HOST_WIDE_INT sum = 1;
12397 for (i = 0; i < numfiles; i++)
12399 int file_idx = backmap[i];
12400 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
12401 sum += size_of_uleb128 (dir_idx);
12403 if (sum >= HOST_WIDE_INT_UC (2) * (numfiles + 1))
12404 idx_form = DW_FORM_data2;
12406 #ifdef VMS_DEBUGGING_INFO
12407 dw2_asm_output_data (1, 4, "File name entry format count");
12409 dw2_asm_output_data (1, 2, "File name entry format count");
12411 dw2_asm_output_data_uleb128 (DW_LNCT_path, "DW_LNCT_path");
12412 dw2_asm_output_data_uleb128 (str_form, "%s",
12413 get_DW_FORM_name (str_form));
12414 dw2_asm_output_data_uleb128 (DW_LNCT_directory_index,
12415 "DW_LNCT_directory_index");
12416 dw2_asm_output_data_uleb128 (idx_form, "%s",
12417 get_DW_FORM_name (idx_form));
12418 #ifdef VMS_DEBUGGING_INFO
12419 dw2_asm_output_data_uleb128 (DW_LNCT_timestamp, "DW_LNCT_timestamp");
12420 dw2_asm_output_data_uleb128 (DW_FORM_udata, "DW_FORM_udata");
12421 dw2_asm_output_data_uleb128 (DW_LNCT_size, "DW_LNCT_size");
12422 dw2_asm_output_data_uleb128 (DW_FORM_udata, "DW_FORM_udata");
12424 dw2_asm_output_data_uleb128 (numfiles + 1, "File names count");
12426 output_line_string (str_form, filename0, "File Entry", 0);
12428 /* Include directory index. */
12429 if (idx_form != DW_FORM_udata)
12430 dw2_asm_output_data (idx_form == DW_FORM_data1 ? 1 : 2,
12433 dw2_asm_output_data_uleb128 (0, NULL);
12435 #ifdef VMS_DEBUGGING_INFO
12436 dw2_asm_output_data_uleb128 (0, NULL);
12437 dw2_asm_output_data_uleb128 (0, NULL);
12441 /* Now write all the file names. */
12442 for (i = 0; i < numfiles; i++)
12444 int file_idx = backmap[i];
12445 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
12447 #ifdef VMS_DEBUGGING_INFO
12448 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
12450 /* Setting these fields can lead to debugger miscomparisons,
12451 but VMS Debug requires them to be set correctly. */
12456 int maxfilelen = (strlen (files[file_idx].path)
12457 + dirs[dir_idx].length
12458 + MAX_VMS_VERSION_LEN + 1);
12459 char *filebuf = XALLOCAVEC (char, maxfilelen);
12461 vms_file_stats_name (files[file_idx].path, 0, 0, 0, &ver);
12462 snprintf (filebuf, maxfilelen, "%s;%d",
12463 files[file_idx].path + dirs[dir_idx].length, ver);
12465 output_line_string (str_form, filebuf, "File Entry", (unsigned) i + 1);
12467 /* Include directory index. */
12468 if (dwarf_version >= 5 && idx_form != DW_FORM_udata)
12469 dw2_asm_output_data (idx_form == DW_FORM_data1 ? 1 : 2,
12470 dir_idx + idx_offset, NULL);
12472 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
12474 /* Modification time. */
12475 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files[file_idx].path,
12476 &cdt, 0, 0, 0) == 0)
12479 /* File length in bytes. */
12480 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files[file_idx].path,
12481 0, &siz, 0, 0) == 0)
12484 output_line_string (str_form,
12485 files[file_idx].path + dirs[dir_idx].length,
12486 "File Entry", (unsigned) i + 1);
12488 /* Include directory index. */
12489 if (dwarf_version >= 5 && idx_form != DW_FORM_udata)
12490 dw2_asm_output_data (idx_form == DW_FORM_data1 ? 1 : 2,
12491 dir_idx + idx_offset, NULL);
12493 dw2_asm_output_data_uleb128 (dir_idx + idx_offset, NULL);
12495 if (dwarf_version >= 5)
12498 /* Modification time. */
12499 dw2_asm_output_data_uleb128 (0, NULL);
12501 /* File length in bytes. */
12502 dw2_asm_output_data_uleb128 (0, NULL);
12503 #endif /* VMS_DEBUGGING_INFO */
12506 if (dwarf_version < 5)
12507 dw2_asm_output_data (1, 0, "End file name table");
12511 /* Output one line number table into the .debug_line section. */
12514 output_one_line_info_table (dw_line_info_table *table)
12516 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
12517 unsigned int current_line = 1;
12518 bool current_is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
12519 dw_line_info_entry *ent, *prev_addr;
12525 FOR_EACH_VEC_SAFE_ELT (table->entries, i, ent)
12527 switch (ent->opcode)
12529 case LI_set_address:
12530 /* ??? Unfortunately, we have little choice here currently, and
12531 must always use the most general form. GCC does not know the
12532 address delta itself, so we can't use DW_LNS_advance_pc. Many
12533 ports do have length attributes which will give an upper bound
12534 on the address range. We could perhaps use length attributes
12535 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
12536 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, ent->val);
12540 /* This can handle any delta. This takes
12541 4+DWARF2_ADDR_SIZE bytes. */
12542 dw2_asm_output_data (1, 0, "set address %s%s", line_label,
12543 debug_variable_location_views
12544 ? ", reset view to 0" : "");
12545 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12546 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12547 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
12552 case LI_adv_address:
12554 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, ent->val);
12555 char prev_label[MAX_ARTIFICIAL_LABEL_BYTES];
12556 ASM_GENERATE_INTERNAL_LABEL (prev_label, LINE_CODE_LABEL, prev_addr->val);
12560 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, "fixed advance PC, increment view to %i", view);
12561 dw2_asm_output_delta (2, line_label, prev_label,
12562 "from %s to %s", prev_label, line_label);
12569 if (ent->val == current_line)
12571 /* We still need to start a new row, so output a copy insn. */
12572 dw2_asm_output_data (1, DW_LNS_copy,
12573 "copy line %u", current_line);
12577 int line_offset = ent->val - current_line;
12578 int line_delta = line_offset - DWARF_LINE_BASE;
12580 current_line = ent->val;
12581 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
12583 /* This can handle deltas from -10 to 234, using the current
12584 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
12585 This takes 1 byte. */
12586 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
12587 "line %u", current_line);
12591 /* This can handle any delta. This takes at least 4 bytes,
12592 depending on the value being encoded. */
12593 dw2_asm_output_data (1, DW_LNS_advance_line,
12594 "advance to line %u", current_line);
12595 dw2_asm_output_data_sleb128 (line_offset, NULL);
12596 dw2_asm_output_data (1, DW_LNS_copy, NULL);
12602 dw2_asm_output_data (1, DW_LNS_set_file, "set file %u", ent->val);
12603 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
12606 case LI_set_column:
12607 dw2_asm_output_data (1, DW_LNS_set_column, "column %u", ent->val);
12608 dw2_asm_output_data_uleb128 (ent->val, "%u", ent->val);
12611 case LI_negate_stmt:
12612 current_is_stmt = !current_is_stmt;
12613 dw2_asm_output_data (1, DW_LNS_negate_stmt,
12614 "is_stmt %d", current_is_stmt);
12617 case LI_set_prologue_end:
12618 dw2_asm_output_data (1, DW_LNS_set_prologue_end,
12619 "set prologue end");
12622 case LI_set_epilogue_begin:
12623 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin,
12624 "set epilogue begin");
12627 case LI_set_discriminator:
12628 dw2_asm_output_data (1, 0, "discriminator %u", ent->val);
12629 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent->val), NULL);
12630 dw2_asm_output_data (1, DW_LNE_set_discriminator, NULL);
12631 dw2_asm_output_data_uleb128 (ent->val, NULL);
12636 /* Emit debug info for the address of the end of the table. */
12637 dw2_asm_output_data (1, 0, "set address %s", table->end_label);
12638 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
12639 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
12640 dw2_asm_output_addr (DWARF2_ADDR_SIZE, table->end_label, NULL);
12642 dw2_asm_output_data (1, 0, "end sequence");
12643 dw2_asm_output_data_uleb128 (1, NULL);
12644 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
12647 /* Output the source line number correspondence information. This
12648 information goes into the .debug_line section. */
12651 output_line_info (bool prologue_only)
12653 static unsigned int generation;
12654 char l1[MAX_ARTIFICIAL_LABEL_BYTES], l2[MAX_ARTIFICIAL_LABEL_BYTES];
12655 char p1[MAX_ARTIFICIAL_LABEL_BYTES], p2[MAX_ARTIFICIAL_LABEL_BYTES];
12656 bool saw_one = false;
12659 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, generation);
12660 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, generation);
12661 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, generation);
12662 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, generation++);
12664 if (!XCOFF_DEBUGGING_INFO)
12666 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
12667 dw2_asm_output_data (4, 0xffffffff,
12668 "Initial length escape value indicating 64-bit DWARF extension");
12669 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
12670 "Length of Source Line Info");
12673 ASM_OUTPUT_LABEL (asm_out_file, l1);
12675 output_dwarf_version ();
12676 if (dwarf_version >= 5)
12678 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Address Size");
12679 dw2_asm_output_data (1, 0, "Segment Size");
12681 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
12682 ASM_OUTPUT_LABEL (asm_out_file, p1);
12684 /* Define the architecture-dependent minimum instruction length (in bytes).
12685 In this implementation of DWARF, this field is used for information
12686 purposes only. Since GCC generates assembly language, we have no
12687 a priori knowledge of how many instruction bytes are generated for each
12688 source line, and therefore can use only the DW_LNE_set_address and
12689 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
12690 this as '1', which is "correct enough" for all architectures,
12691 and don't let the target override. */
12692 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
12694 if (dwarf_version >= 4)
12695 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN,
12696 "Maximum Operations Per Instruction");
12697 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
12698 "Default is_stmt_start flag");
12699 dw2_asm_output_data (1, DWARF_LINE_BASE,
12700 "Line Base Value (Special Opcodes)");
12701 dw2_asm_output_data (1, DWARF_LINE_RANGE,
12702 "Line Range Value (Special Opcodes)");
12703 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
12704 "Special Opcode Base");
12706 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
12711 case DW_LNS_advance_pc:
12712 case DW_LNS_advance_line:
12713 case DW_LNS_set_file:
12714 case DW_LNS_set_column:
12715 case DW_LNS_fixed_advance_pc:
12716 case DW_LNS_set_isa:
12724 dw2_asm_output_data (1, n_op_args, "opcode: %#x has %d args",
12728 /* Write out the information about the files we use. */
12729 output_file_names ();
12730 ASM_OUTPUT_LABEL (asm_out_file, p2);
12733 /* Output the marker for the end of the line number info. */
12734 ASM_OUTPUT_LABEL (asm_out_file, l2);
12738 if (separate_line_info)
12740 dw_line_info_table *table;
12743 FOR_EACH_VEC_ELT (*separate_line_info, i, table)
12746 output_one_line_info_table (table);
12750 if (cold_text_section_line_info && cold_text_section_line_info->in_use)
12752 output_one_line_info_table (cold_text_section_line_info);
12756 /* ??? Some Darwin linkers crash on a .debug_line section with no
12757 sequences. Further, merely a DW_LNE_end_sequence entry is not
12758 sufficient -- the address column must also be initialized.
12759 Make sure to output at least one set_address/end_sequence pair,
12760 choosing .text since that section is always present. */
12761 if (text_section_line_info->in_use || !saw_one)
12762 output_one_line_info_table (text_section_line_info);
12764 /* Output the marker for the end of the line number info. */
12765 ASM_OUTPUT_LABEL (asm_out_file, l2);
12768 /* Return true if DW_AT_endianity should be emitted according to REVERSE. */
12771 need_endianity_attribute_p (bool reverse)
12773 return reverse && (dwarf_version >= 3 || !dwarf_strict);
12776 /* Given a pointer to a tree node for some base type, return a pointer to
12777 a DIE that describes the given type. REVERSE is true if the type is
12778 to be interpreted in the reverse storage order wrt the target order.
12780 This routine must only be called for GCC type nodes that correspond to
12781 Dwarf base (fundamental) types. */
12784 base_type_die (tree type, bool reverse)
12786 dw_die_ref base_type_result;
12787 enum dwarf_type encoding;
12788 bool fpt_used = false;
12789 struct fixed_point_type_info fpt_info;
12790 tree type_bias = NULL_TREE;
12792 /* If this is a subtype that should not be emitted as a subrange type,
12793 use the base type. See subrange_type_for_debug_p. */
12794 if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != NULL_TREE)
12795 type = TREE_TYPE (type);
12797 switch (TREE_CODE (type))
12800 if ((dwarf_version >= 4 || !dwarf_strict)
12801 && TYPE_NAME (type)
12802 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12803 && DECL_IS_BUILTIN (TYPE_NAME (type))
12804 && DECL_NAME (TYPE_NAME (type)))
12806 const char *name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
12807 if (strcmp (name, "char16_t") == 0
12808 || strcmp (name, "char32_t") == 0)
12810 encoding = DW_ATE_UTF;
12814 if ((dwarf_version >= 3 || !dwarf_strict)
12815 && lang_hooks.types.get_fixed_point_type_info)
12817 memset (&fpt_info, 0, sizeof (fpt_info));
12818 if (lang_hooks.types.get_fixed_point_type_info (type, &fpt_info))
12821 encoding = ((TYPE_UNSIGNED (type))
12822 ? DW_ATE_unsigned_fixed
12823 : DW_ATE_signed_fixed);
12827 if (TYPE_STRING_FLAG (type))
12829 if (TYPE_UNSIGNED (type))
12830 encoding = DW_ATE_unsigned_char;
12832 encoding = DW_ATE_signed_char;
12834 else if (TYPE_UNSIGNED (type))
12835 encoding = DW_ATE_unsigned;
12837 encoding = DW_ATE_signed;
12840 && lang_hooks.types.get_type_bias)
12841 type_bias = lang_hooks.types.get_type_bias (type);
12845 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type)))
12847 if (dwarf_version >= 3 || !dwarf_strict)
12848 encoding = DW_ATE_decimal_float;
12850 encoding = DW_ATE_lo_user;
12853 encoding = DW_ATE_float;
12856 case FIXED_POINT_TYPE:
12857 if (!(dwarf_version >= 3 || !dwarf_strict))
12858 encoding = DW_ATE_lo_user;
12859 else if (TYPE_UNSIGNED (type))
12860 encoding = DW_ATE_unsigned_fixed;
12862 encoding = DW_ATE_signed_fixed;
12865 /* Dwarf2 doesn't know anything about complex ints, so use
12866 a user defined type for it. */
12868 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
12869 encoding = DW_ATE_complex_float;
12871 encoding = DW_ATE_lo_user;
12875 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
12876 encoding = DW_ATE_boolean;
12880 /* No other TREE_CODEs are Dwarf fundamental types. */
12881 gcc_unreachable ();
12884 base_type_result = new_die_raw (DW_TAG_base_type);
12886 add_AT_unsigned (base_type_result, DW_AT_byte_size,
12887 int_size_in_bytes (type));
12888 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
12890 if (need_endianity_attribute_p (reverse))
12891 add_AT_unsigned (base_type_result, DW_AT_endianity,
12892 BYTES_BIG_ENDIAN ? DW_END_little : DW_END_big);
12894 add_alignment_attribute (base_type_result, type);
12898 switch (fpt_info.scale_factor_kind)
12900 case fixed_point_scale_factor_binary:
12901 add_AT_int (base_type_result, DW_AT_binary_scale,
12902 fpt_info.scale_factor.binary);
12905 case fixed_point_scale_factor_decimal:
12906 add_AT_int (base_type_result, DW_AT_decimal_scale,
12907 fpt_info.scale_factor.decimal);
12910 case fixed_point_scale_factor_arbitrary:
12911 /* Arbitrary scale factors cannot be described in standard DWARF,
12915 /* Describe the scale factor as a rational constant. */
12916 const dw_die_ref scale_factor
12917 = new_die (DW_TAG_constant, comp_unit_die (), type);
12919 add_AT_unsigned (scale_factor, DW_AT_GNU_numerator,
12920 fpt_info.scale_factor.arbitrary.numerator);
12921 add_AT_int (scale_factor, DW_AT_GNU_denominator,
12922 fpt_info.scale_factor.arbitrary.denominator);
12924 add_AT_die_ref (base_type_result, DW_AT_small, scale_factor);
12929 gcc_unreachable ();
12934 add_scalar_info (base_type_result, DW_AT_GNU_bias, type_bias,
12935 dw_scalar_form_constant
12936 | dw_scalar_form_exprloc
12937 | dw_scalar_form_reference,
12940 return base_type_result;
12943 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
12944 named 'auto' in its type: return true for it, false otherwise. */
12947 is_cxx_auto (tree type)
12951 tree name = TYPE_IDENTIFIER (type);
12952 if (name == get_identifier ("auto")
12953 || name == get_identifier ("decltype(auto)"))
12959 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
12960 given input type is a Dwarf "fundamental" type. Otherwise return null. */
12963 is_base_type (tree type)
12965 switch (TREE_CODE (type))
12969 case FIXED_POINT_TYPE:
12978 case QUAL_UNION_TYPE:
12979 case ENUMERAL_TYPE:
12980 case FUNCTION_TYPE:
12983 case REFERENCE_TYPE:
12991 if (is_cxx_auto (type))
12993 gcc_unreachable ();
12999 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
13000 node, return the size in bits for the type if it is a constant, or else
13001 return the alignment for the type if the type's size is not constant, or
13002 else return BITS_PER_WORD if the type actually turns out to be an
13003 ERROR_MARK node. */
13005 static inline unsigned HOST_WIDE_INT
13006 simple_type_size_in_bits (const_tree type)
13008 if (TREE_CODE (type) == ERROR_MARK)
13009 return BITS_PER_WORD;
13010 else if (TYPE_SIZE (type) == NULL_TREE)
13012 else if (tree_fits_uhwi_p (TYPE_SIZE (type)))
13013 return tree_to_uhwi (TYPE_SIZE (type));
13015 return TYPE_ALIGN (type);
13018 /* Similarly, but return an offset_int instead of UHWI. */
13020 static inline offset_int
13021 offset_int_type_size_in_bits (const_tree type)
13023 if (TREE_CODE (type) == ERROR_MARK)
13024 return BITS_PER_WORD;
13025 else if (TYPE_SIZE (type) == NULL_TREE)
13027 else if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
13028 return wi::to_offset (TYPE_SIZE (type));
13030 return TYPE_ALIGN (type);
13033 /* Given a pointer to a tree node for a subrange type, return a pointer
13034 to a DIE that describes the given type. */
13037 subrange_type_die (tree type, tree low, tree high, tree bias,
13038 dw_die_ref context_die)
13040 dw_die_ref subrange_die;
13041 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
13043 if (context_die == NULL)
13044 context_die = comp_unit_die ();
13046 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
13048 if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
13050 /* The size of the subrange type and its base type do not match,
13051 so we need to generate a size attribute for the subrange type. */
13052 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
13055 add_alignment_attribute (subrange_die, type);
13058 add_bound_info (subrange_die, DW_AT_lower_bound, low, NULL);
13060 add_bound_info (subrange_die, DW_AT_upper_bound, high, NULL);
13061 if (bias && !dwarf_strict)
13062 add_scalar_info (subrange_die, DW_AT_GNU_bias, bias,
13063 dw_scalar_form_constant
13064 | dw_scalar_form_exprloc
13065 | dw_scalar_form_reference,
13068 return subrange_die;
13071 /* Returns the (const and/or volatile) cv_qualifiers associated with
13072 the decl node. This will normally be augmented with the
13073 cv_qualifiers of the underlying type in add_type_attribute. */
13076 decl_quals (const_tree decl)
13078 return ((TREE_READONLY (decl)
13079 /* The C++ front-end correctly marks reference-typed
13080 variables as readonly, but from a language (and debug
13081 info) standpoint they are not const-qualified. */
13082 && TREE_CODE (TREE_TYPE (decl)) != REFERENCE_TYPE
13083 ? TYPE_QUAL_CONST : TYPE_UNQUALIFIED)
13084 | (TREE_THIS_VOLATILE (decl)
13085 ? TYPE_QUAL_VOLATILE : TYPE_UNQUALIFIED));
13088 /* Determine the TYPE whose qualifiers match the largest strict subset
13089 of the given TYPE_QUALS, and return its qualifiers. Ignore all
13090 qualifiers outside QUAL_MASK. */
13093 get_nearest_type_subqualifiers (tree type, int type_quals, int qual_mask)
13096 int best_rank = 0, best_qual = 0, max_rank;
13098 type_quals &= qual_mask;
13099 max_rank = popcount_hwi (type_quals) - 1;
13101 for (t = TYPE_MAIN_VARIANT (type); t && best_rank < max_rank;
13102 t = TYPE_NEXT_VARIANT (t))
13104 int q = TYPE_QUALS (t) & qual_mask;
13106 if ((q & type_quals) == q && q != type_quals
13107 && check_base_type (t, type))
13109 int rank = popcount_hwi (q);
13111 if (rank > best_rank)
13122 struct dwarf_qual_info_t { int q; enum dwarf_tag t; };
13123 static const dwarf_qual_info_t dwarf_qual_info[] =
13125 { TYPE_QUAL_CONST, DW_TAG_const_type },
13126 { TYPE_QUAL_VOLATILE, DW_TAG_volatile_type },
13127 { TYPE_QUAL_RESTRICT, DW_TAG_restrict_type },
13128 { TYPE_QUAL_ATOMIC, DW_TAG_atomic_type }
13130 static const unsigned int dwarf_qual_info_size
13131 = sizeof (dwarf_qual_info) / sizeof (dwarf_qual_info[0]);
13133 /* If DIE is a qualified DIE of some base DIE with the same parent,
13134 return the base DIE, otherwise return NULL. Set MASK to the
13135 qualifiers added compared to the returned DIE. */
13138 qualified_die_p (dw_die_ref die, int *mask, unsigned int depth)
13141 for (i = 0; i < dwarf_qual_info_size; i++)
13142 if (die->die_tag == dwarf_qual_info[i].t)
13144 if (i == dwarf_qual_info_size)
13146 if (vec_safe_length (die->die_attr) != 1)
13148 dw_die_ref type = get_AT_ref (die, DW_AT_type);
13149 if (type == NULL || type->die_parent != die->die_parent)
13151 *mask |= dwarf_qual_info[i].q;
13154 dw_die_ref ret = qualified_die_p (type, mask, depth - 1);
13161 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
13162 entry that chains the modifiers specified by CV_QUALS in front of the
13163 given type. REVERSE is true if the type is to be interpreted in the
13164 reverse storage order wrt the target order. */
13167 modified_type_die (tree type, int cv_quals, bool reverse,
13168 dw_die_ref context_die)
13170 enum tree_code code = TREE_CODE (type);
13171 dw_die_ref mod_type_die;
13172 dw_die_ref sub_die = NULL;
13173 tree item_type = NULL;
13174 tree qualified_type;
13175 tree name, low, high;
13176 dw_die_ref mod_scope;
13177 /* Only these cv-qualifiers are currently handled. */
13178 const int cv_qual_mask = (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE
13179 | TYPE_QUAL_RESTRICT | TYPE_QUAL_ATOMIC |
13180 ENCODE_QUAL_ADDR_SPACE(~0U));
13181 const bool reverse_base_type
13182 = need_endianity_attribute_p (reverse) && is_base_type (type);
13184 if (code == ERROR_MARK)
13187 if (lang_hooks.types.get_debug_type)
13189 tree debug_type = lang_hooks.types.get_debug_type (type);
13191 if (debug_type != NULL_TREE && debug_type != type)
13192 return modified_type_die (debug_type, cv_quals, reverse, context_die);
13195 cv_quals &= cv_qual_mask;
13197 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
13198 tag modifier (and not an attribute) old consumers won't be able
13200 if (dwarf_version < 3)
13201 cv_quals &= ~TYPE_QUAL_RESTRICT;
13203 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
13204 if (dwarf_version < 5)
13205 cv_quals &= ~TYPE_QUAL_ATOMIC;
13207 /* See if we already have the appropriately qualified variant of
13209 qualified_type = get_qualified_type (type, cv_quals);
13211 if (qualified_type == sizetype)
13213 /* Try not to expose the internal sizetype type's name. */
13214 if (TYPE_NAME (qualified_type)
13215 && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL)
13217 tree t = TREE_TYPE (TYPE_NAME (qualified_type));
13219 gcc_checking_assert (TREE_CODE (t) == INTEGER_TYPE
13220 && (TYPE_PRECISION (t)
13221 == TYPE_PRECISION (qualified_type))
13222 && (TYPE_UNSIGNED (t)
13223 == TYPE_UNSIGNED (qualified_type)));
13224 qualified_type = t;
13226 else if (qualified_type == sizetype
13227 && TREE_CODE (sizetype) == TREE_CODE (size_type_node)
13228 && TYPE_PRECISION (sizetype) == TYPE_PRECISION (size_type_node)
13229 && TYPE_UNSIGNED (sizetype) == TYPE_UNSIGNED (size_type_node))
13230 qualified_type = size_type_node;
13231 if (type == sizetype)
13232 type = qualified_type;
13235 /* If we do, then we can just use its DIE, if it exists. */
13236 if (qualified_type)
13238 mod_type_die = lookup_type_die (qualified_type);
13240 /* DW_AT_endianity doesn't come from a qualifier on the type, so it is
13241 dealt with specially: the DIE with the attribute, if it exists, is
13242 placed immediately after the regular DIE for the same base type. */
13244 && (!reverse_base_type
13245 || ((mod_type_die = mod_type_die->die_sib) != NULL
13246 && get_AT_unsigned (mod_type_die, DW_AT_endianity))))
13247 return mod_type_die;
13250 name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
13252 /* Handle C typedef types. */
13254 && TREE_CODE (name) == TYPE_DECL
13255 && DECL_ORIGINAL_TYPE (name)
13256 && !DECL_ARTIFICIAL (name))
13258 tree dtype = TREE_TYPE (name);
13260 /* Skip the typedef for base types with DW_AT_endianity, no big deal. */
13261 if (qualified_type == dtype && !reverse_base_type)
13263 tree origin = decl_ultimate_origin (name);
13265 /* Typedef variants that have an abstract origin don't get their own
13266 type DIE (see gen_typedef_die), so fall back on the ultimate
13267 abstract origin instead. */
13268 if (origin != NULL && origin != name)
13269 return modified_type_die (TREE_TYPE (origin), cv_quals, reverse,
13272 /* For a named type, use the typedef. */
13273 gen_type_die (qualified_type, context_die);
13274 return lookup_type_die (qualified_type);
13278 int dquals = TYPE_QUALS_NO_ADDR_SPACE (dtype);
13279 dquals &= cv_qual_mask;
13280 if ((dquals & ~cv_quals) != TYPE_UNQUALIFIED
13281 || (cv_quals == dquals && DECL_ORIGINAL_TYPE (name) != type))
13282 /* cv-unqualified version of named type. Just use
13283 the unnamed type to which it refers. */
13284 return modified_type_die (DECL_ORIGINAL_TYPE (name), cv_quals,
13285 reverse, context_die);
13286 /* Else cv-qualified version of named type; fall through. */
13290 mod_scope = scope_die_for (type, context_die);
13294 int sub_quals = 0, first_quals = 0;
13296 dw_die_ref first = NULL, last = NULL;
13298 /* Determine a lesser qualified type that most closely matches
13299 this one. Then generate DW_TAG_* entries for the remaining
13301 sub_quals = get_nearest_type_subqualifiers (type, cv_quals,
13303 if (sub_quals && use_debug_types)
13305 bool needed = false;
13306 /* If emitting type units, make sure the order of qualifiers
13307 is canonical. Thus, start from unqualified type if
13308 an earlier qualifier is missing in sub_quals, but some later
13309 one is present there. */
13310 for (i = 0; i < dwarf_qual_info_size; i++)
13311 if (dwarf_qual_info[i].q & cv_quals & ~sub_quals)
13313 else if (needed && (dwarf_qual_info[i].q & cv_quals))
13319 mod_type_die = modified_type_die (type, sub_quals, reverse, context_die);
13320 if (mod_scope && mod_type_die && mod_type_die->die_parent == mod_scope)
13322 /* As not all intermediate qualified DIEs have corresponding
13323 tree types, ensure that qualified DIEs in the same scope
13324 as their DW_AT_type are emitted after their DW_AT_type,
13325 only with other qualified DIEs for the same type possibly
13326 in between them. Determine the range of such qualified
13327 DIEs now (first being the base type, last being corresponding
13328 last qualified DIE for it). */
13329 unsigned int count = 0;
13330 first = qualified_die_p (mod_type_die, &first_quals,
13331 dwarf_qual_info_size);
13333 first = mod_type_die;
13334 gcc_assert ((first_quals & ~sub_quals) == 0);
13335 for (count = 0, last = first;
13336 count < (1U << dwarf_qual_info_size);
13337 count++, last = last->die_sib)
13340 if (last == mod_scope->die_child)
13342 if (qualified_die_p (last->die_sib, &quals, dwarf_qual_info_size)
13348 for (i = 0; i < dwarf_qual_info_size; i++)
13349 if (dwarf_qual_info[i].q & cv_quals & ~sub_quals)
13352 if (first && first != last)
13354 for (d = first->die_sib; ; d = d->die_sib)
13357 qualified_die_p (d, &quals, dwarf_qual_info_size);
13358 if (quals == (first_quals | dwarf_qual_info[i].q))
13374 d = new_die_raw (dwarf_qual_info[i].t);
13375 add_child_die_after (mod_scope, d, last);
13379 d = new_die (dwarf_qual_info[i].t, mod_scope, type);
13381 add_AT_die_ref (d, DW_AT_type, mod_type_die);
13383 first_quals |= dwarf_qual_info[i].q;
13386 else if (code == POINTER_TYPE || code == REFERENCE_TYPE)
13388 dwarf_tag tag = DW_TAG_pointer_type;
13389 if (code == REFERENCE_TYPE)
13391 if (TYPE_REF_IS_RVALUE (type) && dwarf_version >= 4)
13392 tag = DW_TAG_rvalue_reference_type;
13394 tag = DW_TAG_reference_type;
13396 mod_type_die = new_die (tag, mod_scope, type);
13398 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
13399 simple_type_size_in_bits (type) / BITS_PER_UNIT);
13400 add_alignment_attribute (mod_type_die, type);
13401 item_type = TREE_TYPE (type);
13403 addr_space_t as = TYPE_ADDR_SPACE (item_type);
13404 if (!ADDR_SPACE_GENERIC_P (as))
13406 int action = targetm.addr_space.debug (as);
13409 /* Positive values indicate an address_class. */
13410 add_AT_unsigned (mod_type_die, DW_AT_address_class, action);
13414 /* Negative values indicate an (inverted) segment base reg. */
13416 = one_reg_loc_descriptor (~action, VAR_INIT_STATUS_INITIALIZED);
13417 add_AT_loc (mod_type_die, DW_AT_segment, d);
13421 else if (code == INTEGER_TYPE
13422 && TREE_TYPE (type) != NULL_TREE
13423 && subrange_type_for_debug_p (type, &low, &high))
13425 tree bias = NULL_TREE;
13426 if (lang_hooks.types.get_type_bias)
13427 bias = lang_hooks.types.get_type_bias (type);
13428 mod_type_die = subrange_type_die (type, low, high, bias, context_die);
13429 item_type = TREE_TYPE (type);
13431 else if (is_base_type (type))
13433 mod_type_die = base_type_die (type, reverse);
13435 /* The DIE with DW_AT_endianity is placed right after the naked DIE. */
13436 if (reverse_base_type)
13438 dw_die_ref after_die
13439 = modified_type_die (type, cv_quals, false, context_die);
13440 add_child_die_after (comp_unit_die (), mod_type_die, after_die);
13443 add_child_die (comp_unit_die (), mod_type_die);
13445 add_pubtype (type, mod_type_die);
13449 gen_type_die (type, context_die);
13451 /* We have to get the type_main_variant here (and pass that to the
13452 `lookup_type_die' routine) because the ..._TYPE node we have
13453 might simply be a *copy* of some original type node (where the
13454 copy was created to help us keep track of typedef names) and
13455 that copy might have a different TYPE_UID from the original
13457 if (TREE_CODE (type) == FUNCTION_TYPE
13458 || TREE_CODE (type) == METHOD_TYPE)
13460 /* For function/method types, can't just use type_main_variant here,
13461 because that can have different ref-qualifiers for C++,
13462 but try to canonicalize. */
13463 tree main = TYPE_MAIN_VARIANT (type);
13464 for (tree t = main; t; t = TYPE_NEXT_VARIANT (t))
13465 if (TYPE_QUALS_NO_ADDR_SPACE (t) == 0
13466 && check_base_type (t, main)
13467 && check_lang_type (t, type))
13468 return lookup_type_die (t);
13469 return lookup_type_die (type);
13471 else if (TREE_CODE (type) != VECTOR_TYPE
13472 && TREE_CODE (type) != ARRAY_TYPE)
13473 return lookup_type_die (type_main_variant (type));
13475 /* Vectors have the debugging information in the type,
13476 not the main variant. */
13477 return lookup_type_die (type);
13480 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
13481 don't output a DW_TAG_typedef, since there isn't one in the
13482 user's program; just attach a DW_AT_name to the type.
13483 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
13484 if the base type already has the same name. */
13486 && ((TREE_CODE (name) != TYPE_DECL
13487 && (qualified_type == TYPE_MAIN_VARIANT (type)
13488 || (cv_quals == TYPE_UNQUALIFIED)))
13489 || (TREE_CODE (name) == TYPE_DECL
13490 && TREE_TYPE (name) == qualified_type
13491 && DECL_NAME (name))))
13493 if (TREE_CODE (name) == TYPE_DECL)
13494 /* Could just call add_name_and_src_coords_attributes here,
13495 but since this is a builtin type it doesn't have any
13496 useful source coordinates anyway. */
13497 name = DECL_NAME (name);
13498 add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
13500 /* This probably indicates a bug. */
13501 else if (mod_type_die && mod_type_die->die_tag == DW_TAG_base_type)
13503 name = TYPE_IDENTIFIER (type);
13504 add_name_attribute (mod_type_die,
13505 name ? IDENTIFIER_POINTER (name) : "__unknown__");
13508 if (qualified_type && !reverse_base_type)
13509 equate_type_number_to_die (qualified_type, mod_type_die);
13512 /* We must do this after the equate_type_number_to_die call, in case
13513 this is a recursive type. This ensures that the modified_type_die
13514 recursion will terminate even if the type is recursive. Recursive
13515 types are possible in Ada. */
13516 sub_die = modified_type_die (item_type,
13517 TYPE_QUALS_NO_ADDR_SPACE (item_type),
13521 if (sub_die != NULL)
13522 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
13524 add_gnat_descriptive_type_attribute (mod_type_die, type, context_die);
13525 if (TYPE_ARTIFICIAL (type))
13526 add_AT_flag (mod_type_die, DW_AT_artificial, 1);
13528 return mod_type_die;
13531 /* Generate DIEs for the generic parameters of T.
13532 T must be either a generic type or a generic function.
13533 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
13536 gen_generic_params_dies (tree t)
13540 dw_die_ref die = NULL;
13543 if (!t || (TYPE_P (t) && !COMPLETE_TYPE_P (t)))
13547 die = lookup_type_die (t);
13548 else if (DECL_P (t))
13549 die = lookup_decl_die (t);
13553 parms = lang_hooks.get_innermost_generic_parms (t);
13555 /* T has no generic parameter. It means T is neither a generic type
13556 or function. End of story. */
13559 parms_num = TREE_VEC_LENGTH (parms);
13560 args = lang_hooks.get_innermost_generic_args (t);
13561 if (TREE_CHAIN (args) && TREE_CODE (TREE_CHAIN (args)) == INTEGER_CST)
13562 non_default = int_cst_value (TREE_CHAIN (args));
13564 non_default = TREE_VEC_LENGTH (args);
13565 for (i = 0; i < parms_num; i++)
13567 tree parm, arg, arg_pack_elems;
13568 dw_die_ref parm_die;
13570 parm = TREE_VEC_ELT (parms, i);
13571 arg = TREE_VEC_ELT (args, i);
13572 arg_pack_elems = lang_hooks.types.get_argument_pack_elems (arg);
13573 gcc_assert (parm && TREE_VALUE (parm) && arg);
13575 if (parm && TREE_VALUE (parm) && arg)
13577 /* If PARM represents a template parameter pack,
13578 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
13579 by DW_TAG_template_*_parameter DIEs for the argument
13580 pack elements of ARG. Note that ARG would then be
13581 an argument pack. */
13582 if (arg_pack_elems)
13583 parm_die = template_parameter_pack_die (TREE_VALUE (parm),
13587 parm_die = generic_parameter_die (TREE_VALUE (parm), arg,
13588 true /* emit name */, die);
13589 if (i >= non_default)
13590 add_AT_flag (parm_die, DW_AT_default_value, 1);
13595 /* Create and return a DIE for PARM which should be
13596 the representation of a generic type parameter.
13597 For instance, in the C++ front end, PARM would be a template parameter.
13598 ARG is the argument to PARM.
13599 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
13601 PARENT_DIE is the parent DIE which the new created DIE should be added to,
13602 as a child node. */
13605 generic_parameter_die (tree parm, tree arg,
13607 dw_die_ref parent_die)
13609 dw_die_ref tmpl_die = NULL;
13610 const char *name = NULL;
13612 /* C++2a accepts class literals as template parameters, and var
13613 decls with initializers represent them. The VAR_DECLs would be
13614 rejected, but we can take the DECL_INITIAL constructor and
13615 attempt to expand it. */
13616 if (arg && VAR_P (arg))
13617 arg = DECL_INITIAL (arg);
13619 if (!parm || !DECL_NAME (parm) || !arg)
13622 /* We support non-type generic parameters and arguments,
13623 type generic parameters and arguments, as well as
13624 generic generic parameters (a.k.a. template template parameters in C++)
13626 if (TREE_CODE (parm) == PARM_DECL)
13627 /* PARM is a nontype generic parameter */
13628 tmpl_die = new_die (DW_TAG_template_value_param, parent_die, parm);
13629 else if (TREE_CODE (parm) == TYPE_DECL)
13630 /* PARM is a type generic parameter. */
13631 tmpl_die = new_die (DW_TAG_template_type_param, parent_die, parm);
13632 else if (lang_hooks.decls.generic_generic_parameter_decl_p (parm))
13633 /* PARM is a generic generic parameter.
13634 Its DIE is a GNU extension. It shall have a
13635 DW_AT_name attribute to represent the name of the template template
13636 parameter, and a DW_AT_GNU_template_name attribute to represent the
13637 name of the template template argument. */
13638 tmpl_die = new_die (DW_TAG_GNU_template_template_param,
13641 gcc_unreachable ();
13647 /* If PARM is a generic parameter pack, it means we are
13648 emitting debug info for a template argument pack element.
13649 In other terms, ARG is a template argument pack element.
13650 In that case, we don't emit any DW_AT_name attribute for
13654 name = IDENTIFIER_POINTER (DECL_NAME (parm));
13656 add_AT_string (tmpl_die, DW_AT_name, name);
13659 if (!lang_hooks.decls.generic_generic_parameter_decl_p (parm))
13661 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
13662 TMPL_DIE should have a child DW_AT_type attribute that is set
13663 to the type of the argument to PARM, which is ARG.
13664 If PARM is a type generic parameter, TMPL_DIE should have a
13665 child DW_AT_type that is set to ARG. */
13666 tmpl_type = TYPE_P (arg) ? arg : TREE_TYPE (arg);
13667 add_type_attribute (tmpl_die, tmpl_type,
13668 (TREE_THIS_VOLATILE (tmpl_type)
13669 ? TYPE_QUAL_VOLATILE : TYPE_UNQUALIFIED),
13670 false, parent_die);
13674 /* So TMPL_DIE is a DIE representing a
13675 a generic generic template parameter, a.k.a template template
13676 parameter in C++ and arg is a template. */
13678 /* The DW_AT_GNU_template_name attribute of the DIE must be set
13679 to the name of the argument. */
13680 name = dwarf2_name (TYPE_P (arg) ? TYPE_NAME (arg) : arg, 1);
13682 add_AT_string (tmpl_die, DW_AT_GNU_template_name, name);
13685 if (TREE_CODE (parm) == PARM_DECL)
13686 /* So PARM is a non-type generic parameter.
13687 DWARF3 5.6.8 says we must set a DW_AT_const_value child
13688 attribute of TMPL_DIE which value represents the value
13690 We must be careful here:
13691 The value of ARG might reference some function decls.
13692 We might currently be emitting debug info for a generic
13693 type and types are emitted before function decls, we don't
13694 know if the function decls referenced by ARG will actually be
13695 emitted after cgraph computations.
13696 So must defer the generation of the DW_AT_const_value to
13697 after cgraph is ready. */
13698 append_entry_to_tmpl_value_parm_die_table (tmpl_die, arg);
13704 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
13705 PARM_PACK must be a template parameter pack. The returned DIE
13706 will be child DIE of PARENT_DIE. */
13709 template_parameter_pack_die (tree parm_pack,
13710 tree parm_pack_args,
13711 dw_die_ref parent_die)
13716 gcc_assert (parent_die && parm_pack);
13718 die = new_die (DW_TAG_GNU_template_parameter_pack, parent_die, parm_pack);
13719 add_name_and_src_coords_attributes (die, parm_pack);
13720 for (j = 0; j < TREE_VEC_LENGTH (parm_pack_args); j++)
13721 generic_parameter_die (parm_pack,
13722 TREE_VEC_ELT (parm_pack_args, j),
13723 false /* Don't emit DW_AT_name */,
13728 /* Return the DBX register number described by a given RTL node. */
13730 static unsigned int
13731 dbx_reg_number (const_rtx rtl)
13733 unsigned regno = REGNO (rtl);
13735 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
13737 #ifdef LEAF_REG_REMAP
13738 if (crtl->uses_only_leaf_regs)
13740 int leaf_reg = LEAF_REG_REMAP (regno);
13741 if (leaf_reg != -1)
13742 regno = (unsigned) leaf_reg;
13746 regno = DBX_REGISTER_NUMBER (regno);
13747 gcc_assert (regno != INVALID_REGNUM);
13751 /* Optionally add a DW_OP_piece term to a location description expression.
13752 DW_OP_piece is only added if the location description expression already
13753 doesn't end with DW_OP_piece. */
13756 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
13758 dw_loc_descr_ref loc;
13760 if (*list_head != NULL)
13762 /* Find the end of the chain. */
13763 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
13766 if (loc->dw_loc_opc != DW_OP_piece)
13767 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
13771 /* Return a location descriptor that designates a machine register or
13772 zero if there is none. */
13774 static dw_loc_descr_ref
13775 reg_loc_descriptor (rtx rtl, enum var_init_status initialized)
13779 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
13782 /* We only use "frame base" when we're sure we're talking about the
13783 post-prologue local stack frame. We do this by *not* running
13784 register elimination until this point, and recognizing the special
13785 argument pointer and soft frame pointer rtx's.
13786 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
13787 if ((rtl == arg_pointer_rtx || rtl == frame_pointer_rtx)
13788 && eliminate_regs (rtl, VOIDmode, NULL_RTX) != rtl)
13790 dw_loc_descr_ref result = NULL;
13792 if (dwarf_version >= 4 || !dwarf_strict)
13794 result = mem_loc_descriptor (rtl, GET_MODE (rtl), VOIDmode,
13797 add_loc_descr (&result,
13798 new_loc_descr (DW_OP_stack_value, 0, 0));
13803 regs = targetm.dwarf_register_span (rtl);
13805 if (REG_NREGS (rtl) > 1 || regs)
13806 return multiple_reg_loc_descriptor (rtl, regs, initialized);
13809 unsigned int dbx_regnum = dbx_reg_number (rtl);
13810 if (dbx_regnum == IGNORED_DWARF_REGNUM)
13812 return one_reg_loc_descriptor (dbx_regnum, initialized);
13816 /* Return a location descriptor that designates a machine register for
13817 a given hard register number. */
13819 static dw_loc_descr_ref
13820 one_reg_loc_descriptor (unsigned int regno, enum var_init_status initialized)
13822 dw_loc_descr_ref reg_loc_descr;
13826 = new_loc_descr ((enum dwarf_location_atom) (DW_OP_reg0 + regno), 0, 0);
13828 reg_loc_descr = new_loc_descr (DW_OP_regx, regno, 0);
13830 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
13831 add_loc_descr (®_loc_descr, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13833 return reg_loc_descr;
13836 /* Given an RTL of a register, return a location descriptor that
13837 designates a value that spans more than one register. */
13839 static dw_loc_descr_ref
13840 multiple_reg_loc_descriptor (rtx rtl, rtx regs,
13841 enum var_init_status initialized)
13844 dw_loc_descr_ref loc_result = NULL;
13846 /* Simple, contiguous registers. */
13847 if (regs == NULL_RTX)
13849 unsigned reg = REGNO (rtl);
13852 #ifdef LEAF_REG_REMAP
13853 if (crtl->uses_only_leaf_regs)
13855 int leaf_reg = LEAF_REG_REMAP (reg);
13856 if (leaf_reg != -1)
13857 reg = (unsigned) leaf_reg;
13861 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
13862 nregs = REG_NREGS (rtl);
13864 /* At present we only track constant-sized pieces. */
13865 if (!GET_MODE_SIZE (GET_MODE (rtl)).is_constant (&size))
13872 dw_loc_descr_ref t;
13874 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg),
13875 VAR_INIT_STATUS_INITIALIZED);
13876 add_loc_descr (&loc_result, t);
13877 add_loc_descr_op_piece (&loc_result, size);
13883 /* Now onto stupid register sets in non contiguous locations. */
13885 gcc_assert (GET_CODE (regs) == PARALLEL);
13887 /* At present we only track constant-sized pieces. */
13888 if (!GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0))).is_constant (&size))
13892 for (i = 0; i < XVECLEN (regs, 0); ++i)
13894 dw_loc_descr_ref t;
13896 t = one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs, 0, i)),
13897 VAR_INIT_STATUS_INITIALIZED);
13898 add_loc_descr (&loc_result, t);
13899 add_loc_descr_op_piece (&loc_result, size);
13902 if (loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
13903 add_loc_descr (&loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
13907 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT);
13909 /* Return a location descriptor that designates a constant i,
13910 as a compound operation from constant (i >> shift), constant shift
13913 static dw_loc_descr_ref
13914 int_shift_loc_descriptor (HOST_WIDE_INT i, int shift)
13916 dw_loc_descr_ref ret = int_loc_descriptor (i >> shift);
13917 add_loc_descr (&ret, int_loc_descriptor (shift));
13918 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
13922 /* Return a location descriptor that designates constant POLY_I. */
13924 static dw_loc_descr_ref
13925 int_loc_descriptor (poly_int64 poly_i)
13927 enum dwarf_location_atom op;
13930 if (!poly_i.is_constant (&i))
13932 /* Create location descriptions for the non-constant part and
13933 add any constant offset at the end. */
13934 dw_loc_descr_ref ret = NULL;
13935 HOST_WIDE_INT constant = poly_i.coeffs[0];
13936 for (unsigned int j = 1; j < NUM_POLY_INT_COEFFS; ++j)
13938 HOST_WIDE_INT coeff = poly_i.coeffs[j];
13941 dw_loc_descr_ref start = ret;
13942 unsigned int factor;
13944 unsigned int regno = targetm.dwarf_poly_indeterminate_value
13945 (j, &factor, &bias);
13947 /* Add COEFF * ((REGNO / FACTOR) - BIAS) to the value:
13948 add COEFF * (REGNO / FACTOR) now and subtract
13949 COEFF * BIAS from the final constant part. */
13950 constant -= coeff * bias;
13951 add_loc_descr (&ret, new_reg_loc_descr (regno, 0));
13952 if (coeff % factor == 0)
13956 int amount = exact_log2 (factor);
13957 gcc_assert (amount >= 0);
13958 add_loc_descr (&ret, int_loc_descriptor (amount));
13959 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
13963 add_loc_descr (&ret, int_loc_descriptor (coeff));
13964 add_loc_descr (&ret, new_loc_descr (DW_OP_mul, 0, 0));
13967 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
13970 loc_descr_plus_const (&ret, constant);
13974 /* Pick the smallest representation of a constant, rather than just
13975 defaulting to the LEB encoding. */
13978 int clz = clz_hwi (i);
13979 int ctz = ctz_hwi (i);
13981 op = (enum dwarf_location_atom) (DW_OP_lit0 + i);
13982 else if (i <= 0xff)
13983 op = DW_OP_const1u;
13984 else if (i <= 0xffff)
13985 op = DW_OP_const2u;
13986 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 5
13987 && clz + 5 + 255 >= HOST_BITS_PER_WIDE_INT)
13988 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
13989 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
13990 while DW_OP_const4u is 5 bytes. */
13991 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 5);
13992 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
13993 && clz + 8 + 31 >= HOST_BITS_PER_WIDE_INT)
13994 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
13995 while DW_OP_const4u is 5 bytes. */
13996 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 8);
13998 else if (DWARF2_ADDR_SIZE == 4 && i > 0x7fffffff
13999 && size_of_int_loc_descriptor ((HOST_WIDE_INT) (int32_t) i)
14002 /* As i >= 2**31, the double cast above will yield a negative number.
14003 Since wrapping is defined in DWARF expressions we can output big
14004 positive integers as small negative ones, regardless of the size
14007 Here, since the evaluator will handle 32-bit values and since i >=
14008 2**31, we know it's going to be interpreted as a negative literal:
14009 store it this way if we can do better than 5 bytes this way. */
14010 return int_loc_descriptor ((HOST_WIDE_INT) (int32_t) i);
14012 else if (HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff)
14013 op = DW_OP_const4u;
14015 /* Past this point, i >= 0x100000000 and thus DW_OP_constu will take at
14016 least 6 bytes: see if we can do better before falling back to it. */
14017 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
14018 && clz + 8 + 255 >= HOST_BITS_PER_WIDE_INT)
14019 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes. */
14020 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 8);
14021 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 16
14022 && clz + 16 + (size_of_uleb128 (i) > 5 ? 255 : 31)
14023 >= HOST_BITS_PER_WIDE_INT)
14024 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
14025 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes. */
14026 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 16);
14027 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 32
14028 && clz + 32 + 31 >= HOST_BITS_PER_WIDE_INT
14029 && size_of_uleb128 (i) > 6)
14030 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
14031 return int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT - clz - 32);
14038 op = DW_OP_const1s;
14039 else if (i >= -0x8000)
14040 op = DW_OP_const2s;
14041 else if (HOST_BITS_PER_WIDE_INT == 32 || i >= -0x80000000)
14043 if (size_of_int_loc_descriptor (i) < 5)
14045 dw_loc_descr_ref ret = int_loc_descriptor (-i);
14046 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
14049 op = DW_OP_const4s;
14053 if (size_of_int_loc_descriptor (i)
14054 < (unsigned long) 1 + size_of_sleb128 (i))
14056 dw_loc_descr_ref ret = int_loc_descriptor (-i);
14057 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
14064 return new_loc_descr (op, i, 0);
14067 /* Likewise, for unsigned constants. */
14069 static dw_loc_descr_ref
14070 uint_loc_descriptor (unsigned HOST_WIDE_INT i)
14072 const unsigned HOST_WIDE_INT max_int = INTTYPE_MAXIMUM (HOST_WIDE_INT);
14073 const unsigned HOST_WIDE_INT max_uint
14074 = INTTYPE_MAXIMUM (unsigned HOST_WIDE_INT);
14076 /* If possible, use the clever signed constants handling. */
14078 return int_loc_descriptor ((HOST_WIDE_INT) i);
14080 /* Here, we are left with positive numbers that cannot be represented as
14081 HOST_WIDE_INT, i.e.:
14082 max (HOST_WIDE_INT) < i <= max (unsigned HOST_WIDE_INT)
14084 Using DW_OP_const4/8/./u operation to encode them consumes a lot of bytes
14085 whereas may be better to output a negative integer: thanks to integer
14086 wrapping, we know that:
14087 x = x - 2 ** DWARF2_ADDR_SIZE
14088 = x - 2 * (max (HOST_WIDE_INT) + 1)
14089 So numbers close to max (unsigned HOST_WIDE_INT) could be represented as
14090 small negative integers. Let's try that in cases it will clearly improve
14091 the encoding: there is no gain turning DW_OP_const4u into
14093 if (DWARF2_ADDR_SIZE * 8 == HOST_BITS_PER_WIDE_INT
14094 && ((DWARF2_ADDR_SIZE == 4 && i > max_uint - 0x8000)
14095 || (DWARF2_ADDR_SIZE == 8 && i > max_uint - 0x80000000)))
14097 const unsigned HOST_WIDE_INT first_shift = i - max_int - 1;
14099 /* Now, -1 < first_shift <= max (HOST_WIDE_INT)
14100 i.e. 0 <= first_shift <= max (HOST_WIDE_INT). */
14101 const HOST_WIDE_INT second_shift
14102 = (HOST_WIDE_INT) first_shift - (HOST_WIDE_INT) max_int - 1;
14104 /* So we finally have:
14105 -max (HOST_WIDE_INT) - 1 <= second_shift <= -1.
14106 i.e. min (HOST_WIDE_INT) <= second_shift < 0. */
14107 return int_loc_descriptor (second_shift);
14110 /* Last chance: fallback to a simple constant operation. */
14111 return new_loc_descr
14112 ((HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff)
14118 /* Generate and return a location description that computes the unsigned
14119 comparison of the two stack top entries (a OP b where b is the top-most
14120 entry and a is the second one). The KIND of comparison can be LT_EXPR,
14121 LE_EXPR, GT_EXPR or GE_EXPR. */
14123 static dw_loc_descr_ref
14124 uint_comparison_loc_list (enum tree_code kind)
14126 enum dwarf_location_atom op, flip_op;
14127 dw_loc_descr_ref ret, bra_node, jmp_node, tmp;
14144 gcc_unreachable ();
14147 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
14148 jmp_node = new_loc_descr (DW_OP_skip, 0, 0);
14150 /* Until DWARFv4, operations all work on signed integers. It is nevertheless
14151 possible to perform unsigned comparisons: we just have to distinguish
14154 1. when a and b have the same sign (as signed integers); then we should
14155 return: a OP(signed) b;
14157 2. when a is a negative signed integer while b is a positive one, then a
14158 is a greater unsigned integer than b; likewise when a and b's roles
14161 So first, compare the sign of the two operands. */
14162 ret = new_loc_descr (DW_OP_over, 0, 0);
14163 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0));
14164 add_loc_descr (&ret, new_loc_descr (DW_OP_xor, 0, 0));
14165 /* If they have different signs (i.e. they have different sign bits), then
14166 the stack top value has now the sign bit set and thus it's smaller than
14168 add_loc_descr (&ret, new_loc_descr (DW_OP_lit0, 0, 0));
14169 add_loc_descr (&ret, new_loc_descr (DW_OP_lt, 0, 0));
14170 add_loc_descr (&ret, bra_node);
14172 /* We are in case 1. At this point, we know both operands have the same
14173 sign, to it's safe to use the built-in signed comparison. */
14174 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
14175 add_loc_descr (&ret, jmp_node);
14177 /* We are in case 2. Here, we know both operands do not have the same sign,
14178 so we have to flip the signed comparison. */
14179 flip_op = (kind == LT_EXPR || kind == LE_EXPR) ? DW_OP_gt : DW_OP_lt;
14180 tmp = new_loc_descr (flip_op, 0, 0);
14181 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14182 bra_node->dw_loc_oprnd1.v.val_loc = tmp;
14183 add_loc_descr (&ret, tmp);
14185 /* This dummy operation is necessary to make the two branches join. */
14186 tmp = new_loc_descr (DW_OP_nop, 0, 0);
14187 jmp_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
14188 jmp_node->dw_loc_oprnd1.v.val_loc = tmp;
14189 add_loc_descr (&ret, tmp);
14194 /* Likewise, but takes the location description lists (might be destructive on
14195 them). Return NULL if either is NULL or if concatenation fails. */
14197 static dw_loc_list_ref
14198 loc_list_from_uint_comparison (dw_loc_list_ref left, dw_loc_list_ref right,
14199 enum tree_code kind)
14201 if (left == NULL || right == NULL)
14204 add_loc_list (&left, right);
14208 add_loc_descr_to_each (left, uint_comparison_loc_list (kind));
14212 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
14213 without actually allocating it. */
14215 static unsigned long
14216 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i, int shift)
14218 return size_of_int_loc_descriptor (i >> shift)
14219 + size_of_int_loc_descriptor (shift)
14223 /* Return size_of_locs (int_loc_descriptor (i)) without
14224 actually allocating it. */
14226 static unsigned long
14227 size_of_int_loc_descriptor (HOST_WIDE_INT i)
14236 else if (i <= 0xff)
14238 else if (i <= 0xffff)
14242 if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 5
14243 && clz + 5 + 255 >= HOST_BITS_PER_WIDE_INT)
14244 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
14246 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
14247 && clz + 8 + 31 >= HOST_BITS_PER_WIDE_INT)
14248 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
14250 else if (DWARF2_ADDR_SIZE == 4 && i > 0x7fffffff
14251 && size_of_int_loc_descriptor ((HOST_WIDE_INT) (int32_t) i)
14253 return size_of_int_loc_descriptor ((HOST_WIDE_INT) (int32_t) i);
14254 else if (HOST_BITS_PER_WIDE_INT == 32 || i <= 0xffffffff)
14256 s = size_of_uleb128 ((unsigned HOST_WIDE_INT) i);
14257 if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 8
14258 && clz + 8 + 255 >= HOST_BITS_PER_WIDE_INT)
14259 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
14261 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 16
14262 && clz + 16 + (s > 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT)
14263 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
14265 else if (clz + ctz >= HOST_BITS_PER_WIDE_INT - 32
14266 && clz + 32 + 31 >= HOST_BITS_PER_WIDE_INT
14268 return size_of_int_shift_loc_descriptor (i, HOST_BITS_PER_WIDE_INT
14277 else if (i >= -0x8000)
14279 else if (HOST_BITS_PER_WIDE_INT == 32 || i >= -0x80000000)
14281 if (-(unsigned HOST_WIDE_INT) i != (unsigned HOST_WIDE_INT) i)
14283 s = size_of_int_loc_descriptor (-i) + 1;
14291 unsigned long r = 1 + size_of_sleb128 (i);
14292 if (-(unsigned HOST_WIDE_INT) i != (unsigned HOST_WIDE_INT) i)
14294 s = size_of_int_loc_descriptor (-i) + 1;
14303 /* Return loc description representing "address" of integer value.
14304 This can appear only as toplevel expression. */
14306 static dw_loc_descr_ref
14307 address_of_int_loc_descriptor (int size, HOST_WIDE_INT i)
14310 dw_loc_descr_ref loc_result = NULL;
14312 if (!(dwarf_version >= 4 || !dwarf_strict))
14315 litsize = size_of_int_loc_descriptor (i);
14316 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
14317 is more compact. For DW_OP_stack_value we need:
14318 litsize + 1 (DW_OP_stack_value)
14319 and for DW_OP_implicit_value:
14320 1 (DW_OP_implicit_value) + 1 (length) + size. */
14321 if ((int) DWARF2_ADDR_SIZE >= size && litsize + 1 <= 1 + 1 + size)
14323 loc_result = int_loc_descriptor (i);
14324 add_loc_descr (&loc_result,
14325 new_loc_descr (DW_OP_stack_value, 0, 0));
14329 loc_result = new_loc_descr (DW_OP_implicit_value,
14331 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
14332 loc_result->dw_loc_oprnd2.v.val_int = i;
14336 /* Return a location descriptor that designates a base+offset location. */
14338 static dw_loc_descr_ref
14339 based_loc_descr (rtx reg, poly_int64 offset,
14340 enum var_init_status initialized)
14342 unsigned int regno;
14343 dw_loc_descr_ref result;
14344 dw_fde_ref fde = cfun->fde;
14346 /* We only use "frame base" when we're sure we're talking about the
14347 post-prologue local stack frame. We do this by *not* running
14348 register elimination until this point, and recognizing the special
14349 argument pointer and soft frame pointer rtx's. */
14350 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
14352 rtx elim = (ira_use_lra_p
14353 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX)
14354 : eliminate_regs (reg, VOIDmode, NULL_RTX));
14358 /* Allow hard frame pointer here even if frame pointer
14359 isn't used since hard frame pointer is encoded with
14360 DW_OP_fbreg which uses the DW_AT_frame_base attribute,
14361 not hard frame pointer directly. */
14362 elim = strip_offset_and_add (elim, &offset);
14363 gcc_assert (elim == hard_frame_pointer_rtx
14364 || elim == stack_pointer_rtx);
14366 /* If drap register is used to align stack, use frame
14367 pointer + offset to access stack variables. If stack
14368 is aligned without drap, use stack pointer + offset to
14369 access stack variables. */
14370 if (crtl->stack_realign_tried
14371 && reg == frame_pointer_rtx)
14374 = DWARF_FRAME_REGNUM ((fde && fde->drap_reg != INVALID_REGNUM)
14375 ? HARD_FRAME_POINTER_REGNUM
14377 return new_reg_loc_descr (base_reg, offset);
14380 gcc_assert (frame_pointer_fb_offset_valid);
14381 offset += frame_pointer_fb_offset;
14382 HOST_WIDE_INT const_offset;
14383 if (offset.is_constant (&const_offset))
14384 return new_loc_descr (DW_OP_fbreg, const_offset, 0);
14387 dw_loc_descr_ref ret = new_loc_descr (DW_OP_fbreg, 0, 0);
14388 loc_descr_plus_const (&ret, offset);
14394 regno = REGNO (reg);
14395 #ifdef LEAF_REG_REMAP
14396 if (crtl->uses_only_leaf_regs)
14398 int leaf_reg = LEAF_REG_REMAP (regno);
14399 if (leaf_reg != -1)
14400 regno = (unsigned) leaf_reg;
14403 regno = DWARF_FRAME_REGNUM (regno);
14405 HOST_WIDE_INT const_offset;
14406 if (!optimize && fde
14407 && (fde->drap_reg == regno || fde->vdrap_reg == regno)
14408 && offset.is_constant (&const_offset))
14410 /* Use cfa+offset to represent the location of arguments passed
14411 on the stack when drap is used to align stack.
14412 Only do this when not optimizing, for optimized code var-tracking
14413 is supposed to track where the arguments live and the register
14414 used as vdrap or drap in some spot might be used for something
14415 else in other part of the routine. */
14416 return new_loc_descr (DW_OP_fbreg, const_offset, 0);
14419 result = new_reg_loc_descr (regno, offset);
14421 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
14422 add_loc_descr (&result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
14427 /* Return true if this RTL expression describes a base+offset calculation. */
14430 is_based_loc (const_rtx rtl)
14432 return (GET_CODE (rtl) == PLUS
14433 && ((REG_P (XEXP (rtl, 0))
14434 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
14435 && CONST_INT_P (XEXP (rtl, 1)))));
14438 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
14441 static dw_loc_descr_ref
14442 tls_mem_loc_descriptor (rtx mem)
14445 dw_loc_descr_ref loc_result;
14447 if (MEM_EXPR (mem) == NULL_TREE || !MEM_OFFSET_KNOWN_P (mem))
14450 base = get_base_address (MEM_EXPR (mem));
14453 || !DECL_THREAD_LOCAL_P (base))
14456 loc_result = loc_descriptor_from_tree (MEM_EXPR (mem), 1, NULL);
14457 if (loc_result == NULL)
14460 if (maybe_ne (MEM_OFFSET (mem), 0))
14461 loc_descr_plus_const (&loc_result, MEM_OFFSET (mem));
14466 /* Output debug info about reason why we failed to expand expression as dwarf
14470 expansion_failed (tree expr, rtx rtl, char const *reason)
14472 if (dump_file && (dump_flags & TDF_DETAILS))
14474 fprintf (dump_file, "Failed to expand as dwarf: ");
14476 print_generic_expr (dump_file, expr, dump_flags);
14479 fprintf (dump_file, "\n");
14480 print_rtl (dump_file, rtl);
14482 fprintf (dump_file, "\nReason: %s\n", reason);
14486 /* Helper function for const_ok_for_output. */
14489 const_ok_for_output_1 (rtx rtl)
14491 if (targetm.const_not_ok_for_debug_p (rtl))
14493 if (GET_CODE (rtl) != UNSPEC)
14495 expansion_failed (NULL_TREE, rtl,
14496 "Expression rejected for debug by the backend.\n");
14500 /* If delegitimize_address couldn't do anything with the UNSPEC, and
14501 the target hook doesn't explicitly allow it in debug info, assume
14502 we can't express it in the debug info. */
14503 /* Don't complain about TLS UNSPECs, those are just too hard to
14504 delegitimize. Note this could be a non-decl SYMBOL_REF such as
14505 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
14506 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
14508 && (XVECLEN (rtl, 0) == 0
14509 || GET_CODE (XVECEXP (rtl, 0, 0)) != SYMBOL_REF
14510 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl, 0, 0)) == TLS_MODEL_NONE))
14511 inform (current_function_decl
14512 ? DECL_SOURCE_LOCATION (current_function_decl)
14513 : UNKNOWN_LOCATION,
14514 #if NUM_UNSPEC_VALUES > 0
14515 "non-delegitimized UNSPEC %s (%d) found in variable location",
14516 ((XINT (rtl, 1) >= 0 && XINT (rtl, 1) < NUM_UNSPEC_VALUES)
14517 ? unspec_strings[XINT (rtl, 1)] : "unknown"),
14519 "non-delegitimized UNSPEC %d found in variable location",
14522 expansion_failed (NULL_TREE, rtl,
14523 "UNSPEC hasn't been delegitimized.\n");
14527 if (CONST_POLY_INT_P (rtl))
14530 /* FIXME: Refer to PR60655. It is possible for simplification
14531 of rtl expressions in var tracking to produce such expressions.
14532 We should really identify / validate expressions
14533 enclosed in CONST that can be handled by assemblers on various
14534 targets and only handle legitimate cases here. */
14535 switch (GET_CODE (rtl))
14544 /* Make sure SYMBOL_REFs/UNSPECs are at most in one of the
14546 subrtx_var_iterator::array_type array;
14547 bool first = false;
14548 FOR_EACH_SUBRTX_VAR (iter, array, XEXP (rtl, 0), ALL)
14549 if (SYMBOL_REF_P (*iter)
14551 || GET_CODE (*iter) == UNSPEC)
14558 FOR_EACH_SUBRTX_VAR (iter, array, XEXP (rtl, 1), ALL)
14559 if (SYMBOL_REF_P (*iter)
14561 || GET_CODE (*iter) == UNSPEC)
14567 /* Disallow negation of SYMBOL_REFs or UNSPECs when they
14568 appear in the second operand of MINUS. */
14569 subrtx_var_iterator::array_type array;
14570 FOR_EACH_SUBRTX_VAR (iter, array, XEXP (rtl, 1), ALL)
14571 if (SYMBOL_REF_P (*iter)
14573 || GET_CODE (*iter) == UNSPEC)
14581 if (CONSTANT_POOL_ADDRESS_P (rtl))
14584 get_pool_constant_mark (rtl, &marked);
14585 /* If all references to this pool constant were optimized away,
14586 it was not output and thus we can't represent it. */
14589 expansion_failed (NULL_TREE, rtl,
14590 "Constant was removed from constant pool.\n");
14595 if (SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
14598 /* Avoid references to external symbols in debug info, on several targets
14599 the linker might even refuse to link when linking a shared library,
14600 and in many other cases the relocations for .debug_info/.debug_loc are
14601 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
14602 to be defined within the same shared library or executable are fine. */
14603 if (SYMBOL_REF_EXTERNAL_P (rtl))
14605 tree decl = SYMBOL_REF_DECL (rtl);
14607 if (decl == NULL || !targetm.binds_local_p (decl))
14609 expansion_failed (NULL_TREE, rtl,
14610 "Symbol not defined in current TU.\n");
14618 /* Return true if constant RTL can be emitted in DW_OP_addr or
14619 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
14620 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
14623 const_ok_for_output (rtx rtl)
14625 if (GET_CODE (rtl) == SYMBOL_REF)
14626 return const_ok_for_output_1 (rtl);
14628 if (GET_CODE (rtl) == CONST)
14630 subrtx_var_iterator::array_type array;
14631 FOR_EACH_SUBRTX_VAR (iter, array, XEXP (rtl, 0), ALL)
14632 if (!const_ok_for_output_1 (*iter))
14640 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
14641 if possible, NULL otherwise. */
14644 base_type_for_mode (machine_mode mode, bool unsignedp)
14646 dw_die_ref type_die;
14647 tree type = lang_hooks.types.type_for_mode (mode, unsignedp);
14651 switch (TREE_CODE (type))
14659 type_die = lookup_type_die (type);
14661 type_die = modified_type_die (type, TYPE_UNQUALIFIED, false,
14663 if (type_die == NULL || type_die->die_tag != DW_TAG_base_type)
14668 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
14669 type matching MODE, or, if MODE is narrower than or as wide as
14670 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
14673 static dw_loc_descr_ref
14674 convert_descriptor_to_mode (scalar_int_mode mode, dw_loc_descr_ref op)
14676 machine_mode outer_mode = mode;
14677 dw_die_ref type_die;
14678 dw_loc_descr_ref cvt;
14680 if (GET_MODE_SIZE (mode) <= DWARF2_ADDR_SIZE)
14682 add_loc_descr (&op, new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0));
14685 type_die = base_type_for_mode (outer_mode, 1);
14686 if (type_die == NULL)
14688 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
14689 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14690 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14691 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14692 add_loc_descr (&op, cvt);
14696 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
14698 static dw_loc_descr_ref
14699 compare_loc_descriptor (enum dwarf_location_atom op, dw_loc_descr_ref op0,
14700 dw_loc_descr_ref op1)
14702 dw_loc_descr_ref ret = op0;
14703 add_loc_descr (&ret, op1);
14704 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
14705 if (STORE_FLAG_VALUE != 1)
14707 add_loc_descr (&ret, int_loc_descriptor (STORE_FLAG_VALUE));
14708 add_loc_descr (&ret, new_loc_descr (DW_OP_mul, 0, 0));
14713 /* Subroutine of scompare_loc_descriptor for the case in which we're
14714 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
14715 and in which OP_MODE is bigger than DWARF2_ADDR_SIZE. */
14717 static dw_loc_descr_ref
14718 scompare_loc_descriptor_wide (enum dwarf_location_atom op,
14719 scalar_int_mode op_mode,
14720 dw_loc_descr_ref op0, dw_loc_descr_ref op1)
14722 dw_die_ref type_die = base_type_for_mode (op_mode, 0);
14723 dw_loc_descr_ref cvt;
14725 if (type_die == NULL)
14727 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
14728 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14729 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14730 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14731 add_loc_descr (&op0, cvt);
14732 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
14733 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14734 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14735 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14736 add_loc_descr (&op1, cvt);
14737 return compare_loc_descriptor (op, op0, op1);
14740 /* Subroutine of scompare_loc_descriptor for the case in which we're
14741 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
14742 and in which OP_MODE is smaller than DWARF2_ADDR_SIZE. */
14744 static dw_loc_descr_ref
14745 scompare_loc_descriptor_narrow (enum dwarf_location_atom op, rtx rtl,
14746 scalar_int_mode op_mode,
14747 dw_loc_descr_ref op0, dw_loc_descr_ref op1)
14749 int shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (op_mode)) * BITS_PER_UNIT;
14750 /* For eq/ne, if the operands are known to be zero-extended,
14751 there is no need to do the fancy shifting up. */
14752 if (op == DW_OP_eq || op == DW_OP_ne)
14754 dw_loc_descr_ref last0, last1;
14755 for (last0 = op0; last0->dw_loc_next != NULL; last0 = last0->dw_loc_next)
14757 for (last1 = op1; last1->dw_loc_next != NULL; last1 = last1->dw_loc_next)
14759 /* deref_size zero extends, and for constants we can check
14760 whether they are zero extended or not. */
14761 if (((last0->dw_loc_opc == DW_OP_deref_size
14762 && last0->dw_loc_oprnd1.v.val_int <= GET_MODE_SIZE (op_mode))
14763 || (CONST_INT_P (XEXP (rtl, 0))
14764 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 0))
14765 == (INTVAL (XEXP (rtl, 0)) & GET_MODE_MASK (op_mode))))
14766 && ((last1->dw_loc_opc == DW_OP_deref_size
14767 && last1->dw_loc_oprnd1.v.val_int <= GET_MODE_SIZE (op_mode))
14768 || (CONST_INT_P (XEXP (rtl, 1))
14769 && (unsigned HOST_WIDE_INT) INTVAL (XEXP (rtl, 1))
14770 == (INTVAL (XEXP (rtl, 1)) & GET_MODE_MASK (op_mode)))))
14771 return compare_loc_descriptor (op, op0, op1);
14773 /* EQ/NE comparison against constant in narrower type than
14774 DWARF2_ADDR_SIZE can be performed either as
14775 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
14778 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
14779 DW_OP_{eq,ne}. Pick whatever is shorter. */
14780 if (CONST_INT_P (XEXP (rtl, 1))
14781 && GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_WIDE_INT
14782 && (size_of_int_loc_descriptor (shift) + 1
14783 + size_of_int_loc_descriptor (UINTVAL (XEXP (rtl, 1)) << shift)
14784 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode)) + 1
14785 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl, 1))
14786 & GET_MODE_MASK (op_mode))))
14788 add_loc_descr (&op0, int_loc_descriptor (GET_MODE_MASK (op_mode)));
14789 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
14790 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1))
14791 & GET_MODE_MASK (op_mode));
14792 return compare_loc_descriptor (op, op0, op1);
14795 add_loc_descr (&op0, int_loc_descriptor (shift));
14796 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
14797 if (CONST_INT_P (XEXP (rtl, 1)))
14798 op1 = int_loc_descriptor (UINTVAL (XEXP (rtl, 1)) << shift);
14801 add_loc_descr (&op1, int_loc_descriptor (shift));
14802 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
14804 return compare_loc_descriptor (op, op0, op1);
14807 /* Return location descriptor for unsigned comparison OP RTL. */
14809 static dw_loc_descr_ref
14810 scompare_loc_descriptor (enum dwarf_location_atom op, rtx rtl,
14811 machine_mode mem_mode)
14813 machine_mode op_mode = GET_MODE (XEXP (rtl, 0));
14814 dw_loc_descr_ref op0, op1;
14816 if (op_mode == VOIDmode)
14817 op_mode = GET_MODE (XEXP (rtl, 1));
14818 if (op_mode == VOIDmode)
14821 scalar_int_mode int_op_mode;
14823 && dwarf_version < 5
14824 && (!is_a <scalar_int_mode> (op_mode, &int_op_mode)
14825 || GET_MODE_SIZE (int_op_mode) > DWARF2_ADDR_SIZE))
14828 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode,
14829 VAR_INIT_STATUS_INITIALIZED);
14830 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode,
14831 VAR_INIT_STATUS_INITIALIZED);
14833 if (op0 == NULL || op1 == NULL)
14836 if (is_a <scalar_int_mode> (op_mode, &int_op_mode))
14838 if (GET_MODE_SIZE (int_op_mode) < DWARF2_ADDR_SIZE)
14839 return scompare_loc_descriptor_narrow (op, rtl, int_op_mode, op0, op1);
14841 if (GET_MODE_SIZE (int_op_mode) > DWARF2_ADDR_SIZE)
14842 return scompare_loc_descriptor_wide (op, int_op_mode, op0, op1);
14844 return compare_loc_descriptor (op, op0, op1);
14847 /* Return location descriptor for unsigned comparison OP RTL. */
14849 static dw_loc_descr_ref
14850 ucompare_loc_descriptor (enum dwarf_location_atom op, rtx rtl,
14851 machine_mode mem_mode)
14853 dw_loc_descr_ref op0, op1;
14855 machine_mode test_op_mode = GET_MODE (XEXP (rtl, 0));
14856 if (test_op_mode == VOIDmode)
14857 test_op_mode = GET_MODE (XEXP (rtl, 1));
14859 scalar_int_mode op_mode;
14860 if (!is_a <scalar_int_mode> (test_op_mode, &op_mode))
14864 && dwarf_version < 5
14865 && GET_MODE_SIZE (op_mode) > DWARF2_ADDR_SIZE)
14868 op0 = mem_loc_descriptor (XEXP (rtl, 0), op_mode, mem_mode,
14869 VAR_INIT_STATUS_INITIALIZED);
14870 op1 = mem_loc_descriptor (XEXP (rtl, 1), op_mode, mem_mode,
14871 VAR_INIT_STATUS_INITIALIZED);
14873 if (op0 == NULL || op1 == NULL)
14876 if (GET_MODE_SIZE (op_mode) < DWARF2_ADDR_SIZE)
14878 HOST_WIDE_INT mask = GET_MODE_MASK (op_mode);
14879 dw_loc_descr_ref last0, last1;
14880 for (last0 = op0; last0->dw_loc_next != NULL; last0 = last0->dw_loc_next)
14882 for (last1 = op1; last1->dw_loc_next != NULL; last1 = last1->dw_loc_next)
14884 if (CONST_INT_P (XEXP (rtl, 0)))
14885 op0 = int_loc_descriptor (INTVAL (XEXP (rtl, 0)) & mask);
14886 /* deref_size zero extends, so no need to mask it again. */
14887 else if (last0->dw_loc_opc != DW_OP_deref_size
14888 || last0->dw_loc_oprnd1.v.val_int > GET_MODE_SIZE (op_mode))
14890 add_loc_descr (&op0, int_loc_descriptor (mask));
14891 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
14893 if (CONST_INT_P (XEXP (rtl, 1)))
14894 op1 = int_loc_descriptor (INTVAL (XEXP (rtl, 1)) & mask);
14895 /* deref_size zero extends, so no need to mask it again. */
14896 else if (last1->dw_loc_opc != DW_OP_deref_size
14897 || last1->dw_loc_oprnd1.v.val_int > GET_MODE_SIZE (op_mode))
14899 add_loc_descr (&op1, int_loc_descriptor (mask));
14900 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
14903 else if (GET_MODE_SIZE (op_mode) == DWARF2_ADDR_SIZE)
14905 HOST_WIDE_INT bias = 1;
14906 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
14907 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
14908 if (CONST_INT_P (XEXP (rtl, 1)))
14909 op1 = int_loc_descriptor ((unsigned HOST_WIDE_INT) bias
14910 + INTVAL (XEXP (rtl, 1)));
14912 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst,
14915 return compare_loc_descriptor (op, op0, op1);
14918 /* Return location descriptor for {U,S}{MIN,MAX}. */
14920 static dw_loc_descr_ref
14921 minmax_loc_descriptor (rtx rtl, machine_mode mode,
14922 machine_mode mem_mode)
14924 enum dwarf_location_atom op;
14925 dw_loc_descr_ref op0, op1, ret;
14926 dw_loc_descr_ref bra_node, drop_node;
14928 scalar_int_mode int_mode;
14930 && dwarf_version < 5
14931 && (!is_a <scalar_int_mode> (mode, &int_mode)
14932 || GET_MODE_SIZE (int_mode) > DWARF2_ADDR_SIZE))
14935 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
14936 VAR_INIT_STATUS_INITIALIZED);
14937 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
14938 VAR_INIT_STATUS_INITIALIZED);
14940 if (op0 == NULL || op1 == NULL)
14943 add_loc_descr (&op0, new_loc_descr (DW_OP_dup, 0, 0));
14944 add_loc_descr (&op1, new_loc_descr (DW_OP_swap, 0, 0));
14945 add_loc_descr (&op1, new_loc_descr (DW_OP_over, 0, 0));
14946 if (GET_CODE (rtl) == UMIN || GET_CODE (rtl) == UMAX)
14948 /* Checked by the caller. */
14949 int_mode = as_a <scalar_int_mode> (mode);
14950 if (GET_MODE_SIZE (int_mode) < DWARF2_ADDR_SIZE)
14952 HOST_WIDE_INT mask = GET_MODE_MASK (int_mode);
14953 add_loc_descr (&op0, int_loc_descriptor (mask));
14954 add_loc_descr (&op0, new_loc_descr (DW_OP_and, 0, 0));
14955 add_loc_descr (&op1, int_loc_descriptor (mask));
14956 add_loc_descr (&op1, new_loc_descr (DW_OP_and, 0, 0));
14958 else if (GET_MODE_SIZE (int_mode) == DWARF2_ADDR_SIZE)
14960 HOST_WIDE_INT bias = 1;
14961 bias <<= (DWARF2_ADDR_SIZE * BITS_PER_UNIT - 1);
14962 add_loc_descr (&op0, new_loc_descr (DW_OP_plus_uconst, bias, 0));
14963 add_loc_descr (&op1, new_loc_descr (DW_OP_plus_uconst, bias, 0));
14966 else if (is_a <scalar_int_mode> (mode, &int_mode)
14967 && GET_MODE_SIZE (int_mode) < DWARF2_ADDR_SIZE)
14969 int shift = (DWARF2_ADDR_SIZE - GET_MODE_SIZE (int_mode)) * BITS_PER_UNIT;
14970 add_loc_descr (&op0, int_loc_descriptor (shift));
14971 add_loc_descr (&op0, new_loc_descr (DW_OP_shl, 0, 0));
14972 add_loc_descr (&op1, int_loc_descriptor (shift));
14973 add_loc_descr (&op1, new_loc_descr (DW_OP_shl, 0, 0));
14975 else if (is_a <scalar_int_mode> (mode, &int_mode)
14976 && GET_MODE_SIZE (int_mode) > DWARF2_ADDR_SIZE)
14978 dw_die_ref type_die = base_type_for_mode (int_mode, 0);
14979 dw_loc_descr_ref cvt;
14980 if (type_die == NULL)
14982 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
14983 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14984 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14985 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14986 add_loc_descr (&op0, cvt);
14987 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
14988 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
14989 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
14990 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
14991 add_loc_descr (&op1, cvt);
14994 if (GET_CODE (rtl) == SMIN || GET_CODE (rtl) == UMIN)
14999 add_loc_descr (&ret, op1);
15000 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
15001 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
15002 add_loc_descr (&ret, bra_node);
15003 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
15004 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
15005 add_loc_descr (&ret, drop_node);
15006 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
15007 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
15008 if ((GET_CODE (rtl) == SMIN || GET_CODE (rtl) == SMAX)
15009 && is_a <scalar_int_mode> (mode, &int_mode)
15010 && GET_MODE_SIZE (int_mode) > DWARF2_ADDR_SIZE)
15011 ret = convert_descriptor_to_mode (int_mode, ret);
15015 /* Helper function for mem_loc_descriptor. Perform OP binary op,
15016 but after converting arguments to type_die, afterwards
15017 convert back to unsigned. */
15019 static dw_loc_descr_ref
15020 typed_binop (enum dwarf_location_atom op, rtx rtl, dw_die_ref type_die,
15021 scalar_int_mode mode, machine_mode mem_mode)
15023 dw_loc_descr_ref cvt, op0, op1;
15025 if (type_die == NULL)
15027 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
15028 VAR_INIT_STATUS_INITIALIZED);
15029 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
15030 VAR_INIT_STATUS_INITIALIZED);
15031 if (op0 == NULL || op1 == NULL)
15033 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
15034 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
15035 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
15036 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
15037 add_loc_descr (&op0, cvt);
15038 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
15039 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
15040 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
15041 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
15042 add_loc_descr (&op1, cvt);
15043 add_loc_descr (&op0, op1);
15044 add_loc_descr (&op0, new_loc_descr (op, 0, 0));
15045 return convert_descriptor_to_mode (mode, op0);
15048 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
15049 const0 is DW_OP_lit0 or corresponding typed constant,
15050 const1 is DW_OP_lit1 or corresponding typed constant
15051 and constMSB is constant with just the MSB bit set
15053 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
15054 L1: const0 DW_OP_swap
15055 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
15056 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15061 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
15062 L1: const0 DW_OP_swap
15063 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
15064 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15069 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
15070 L1: const1 DW_OP_swap
15071 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
15072 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15076 static dw_loc_descr_ref
15077 clz_loc_descriptor (rtx rtl, scalar_int_mode mode,
15078 machine_mode mem_mode)
15080 dw_loc_descr_ref op0, ret, tmp;
15081 HOST_WIDE_INT valv;
15082 dw_loc_descr_ref l1jump, l1label;
15083 dw_loc_descr_ref l2jump, l2label;
15084 dw_loc_descr_ref l3jump, l3label;
15085 dw_loc_descr_ref l4jump, l4label;
15088 if (GET_MODE (XEXP (rtl, 0)) != mode)
15091 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
15092 VAR_INIT_STATUS_INITIALIZED);
15096 if (GET_CODE (rtl) == CLZ)
15098 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode, valv))
15099 valv = GET_MODE_BITSIZE (mode);
15101 else if (GET_CODE (rtl) == FFS)
15103 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode, valv))
15104 valv = GET_MODE_BITSIZE (mode);
15105 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
15106 l1jump = new_loc_descr (DW_OP_bra, 0, 0);
15107 add_loc_descr (&ret, l1jump);
15108 add_loc_descr (&ret, new_loc_descr (DW_OP_drop, 0, 0));
15109 tmp = mem_loc_descriptor (GEN_INT (valv), mode, mem_mode,
15110 VAR_INIT_STATUS_INITIALIZED);
15113 add_loc_descr (&ret, tmp);
15114 l4jump = new_loc_descr (DW_OP_skip, 0, 0);
15115 add_loc_descr (&ret, l4jump);
15116 l1label = mem_loc_descriptor (GET_CODE (rtl) == FFS
15117 ? const1_rtx : const0_rtx,
15119 VAR_INIT_STATUS_INITIALIZED);
15120 if (l1label == NULL)
15122 add_loc_descr (&ret, l1label);
15123 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
15124 l2label = new_loc_descr (DW_OP_dup, 0, 0);
15125 add_loc_descr (&ret, l2label);
15126 if (GET_CODE (rtl) != CLZ)
15128 else if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
15129 msb = GEN_INT (HOST_WIDE_INT_1U
15130 << (GET_MODE_BITSIZE (mode) - 1));
15132 msb = immed_wide_int_const
15133 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode) - 1,
15134 GET_MODE_PRECISION (mode)), mode);
15135 if (GET_CODE (msb) == CONST_INT && INTVAL (msb) < 0)
15136 tmp = new_loc_descr (HOST_BITS_PER_WIDE_INT == 32
15137 ? DW_OP_const4u : HOST_BITS_PER_WIDE_INT == 64
15138 ? DW_OP_const8u : DW_OP_constu, INTVAL (msb), 0);
15140 tmp = mem_loc_descriptor (msb, mode, mem_mode,
15141 VAR_INIT_STATUS_INITIALIZED);
15144 add_loc_descr (&ret, tmp);
15145 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
15146 l3jump = new_loc_descr (DW_OP_bra, 0, 0);
15147 add_loc_descr (&ret, l3jump);
15148 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
15149 VAR_INIT_STATUS_INITIALIZED);
15152 add_loc_descr (&ret, tmp);
15153 add_loc_descr (&ret, new_loc_descr (GET_CODE (rtl) == CLZ
15154 ? DW_OP_shl : DW_OP_shr, 0, 0));
15155 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
15156 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, 1, 0));
15157 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
15158 l2jump = new_loc_descr (DW_OP_skip, 0, 0);
15159 add_loc_descr (&ret, l2jump);
15160 l3label = new_loc_descr (DW_OP_drop, 0, 0);
15161 add_loc_descr (&ret, l3label);
15162 l4label = new_loc_descr (DW_OP_nop, 0, 0);
15163 add_loc_descr (&ret, l4label);
15164 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
15165 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
15166 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
15167 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
15168 l3jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
15169 l3jump->dw_loc_oprnd1.v.val_loc = l3label;
15170 l4jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
15171 l4jump->dw_loc_oprnd1.v.val_loc = l4label;
15175 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
15176 const1 is DW_OP_lit1 or corresponding typed constant):
15178 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15179 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15183 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15184 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15187 static dw_loc_descr_ref
15188 popcount_loc_descriptor (rtx rtl, scalar_int_mode mode,
15189 machine_mode mem_mode)
15191 dw_loc_descr_ref op0, ret, tmp;
15192 dw_loc_descr_ref l1jump, l1label;
15193 dw_loc_descr_ref l2jump, l2label;
15195 if (GET_MODE (XEXP (rtl, 0)) != mode)
15198 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
15199 VAR_INIT_STATUS_INITIALIZED);
15203 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
15204 VAR_INIT_STATUS_INITIALIZED);
15207 add_loc_descr (&ret, tmp);
15208 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
15209 l1label = new_loc_descr (DW_OP_dup, 0, 0);
15210 add_loc_descr (&ret, l1label);
15211 l2jump = new_loc_descr (DW_OP_bra, 0, 0);
15212 add_loc_descr (&ret, l2jump);
15213 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
15214 add_loc_descr (&ret, new_loc_descr (DW_OP_rot, 0, 0));
15215 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
15216 VAR_INIT_STATUS_INITIALIZED);
15219 add_loc_descr (&ret, tmp);
15220 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
15221 add_loc_descr (&ret, new_loc_descr (GET_CODE (rtl) == POPCOUNT
15222 ? DW_OP_plus : DW_OP_xor, 0, 0));
15223 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
15224 tmp = mem_loc_descriptor (const1_rtx, mode, mem_mode,
15225 VAR_INIT_STATUS_INITIALIZED);
15226 add_loc_descr (&ret, tmp);
15227 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
15228 l1jump = new_loc_descr (DW_OP_skip, 0, 0);
15229 add_loc_descr (&ret, l1jump);
15230 l2label = new_loc_descr (DW_OP_drop, 0, 0);
15231 add_loc_descr (&ret, l2label);
15232 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
15233 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
15234 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
15235 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
15239 /* BSWAP (constS is initial shift count, either 56 or 24):
15241 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
15242 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
15243 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
15244 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
15245 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
15247 static dw_loc_descr_ref
15248 bswap_loc_descriptor (rtx rtl, scalar_int_mode mode,
15249 machine_mode mem_mode)
15251 dw_loc_descr_ref op0, ret, tmp;
15252 dw_loc_descr_ref l1jump, l1label;
15253 dw_loc_descr_ref l2jump, l2label;
15255 if (BITS_PER_UNIT != 8
15256 || (GET_MODE_BITSIZE (mode) != 32
15257 && GET_MODE_BITSIZE (mode) != 64))
15260 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
15261 VAR_INIT_STATUS_INITIALIZED);
15266 tmp = mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode) - 8),
15268 VAR_INIT_STATUS_INITIALIZED);
15271 add_loc_descr (&ret, tmp);
15272 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
15273 VAR_INIT_STATUS_INITIALIZED);
15276 add_loc_descr (&ret, tmp);
15277 l1label = new_loc_descr (DW_OP_pick, 2, 0);
15278 add_loc_descr (&ret, l1label);
15279 tmp = mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode) - 8),
15281 VAR_INIT_STATUS_INITIALIZED);
15282 add_loc_descr (&ret, tmp);
15283 add_loc_descr (&ret, new_loc_descr (DW_OP_pick, 3, 0));
15284 add_loc_descr (&ret, new_loc_descr (DW_OP_minus, 0, 0));
15285 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
15286 tmp = mem_loc_descriptor (GEN_INT (255), mode, mem_mode,
15287 VAR_INIT_STATUS_INITIALIZED);
15290 add_loc_descr (&ret, tmp);
15291 add_loc_descr (&ret, new_loc_descr (DW_OP_and, 0, 0));
15292 add_loc_descr (&ret, new_loc_descr (DW_OP_pick, 2, 0));
15293 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
15294 add_loc_descr (&ret, new_loc_descr (DW_OP_or, 0, 0));
15295 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
15296 add_loc_descr (&ret, new_loc_descr (DW_OP_dup, 0, 0));
15297 tmp = mem_loc_descriptor (const0_rtx, mode, mem_mode,
15298 VAR_INIT_STATUS_INITIALIZED);
15299 add_loc_descr (&ret, tmp);
15300 add_loc_descr (&ret, new_loc_descr (DW_OP_eq, 0, 0));
15301 l2jump = new_loc_descr (DW_OP_bra, 0, 0);
15302 add_loc_descr (&ret, l2jump);
15303 tmp = mem_loc_descriptor (GEN_INT (8), mode, mem_mode,
15304 VAR_INIT_STATUS_INITIALIZED);
15305 add_loc_descr (&ret, tmp);
15306 add_loc_descr (&ret, new_loc_descr (DW_OP_minus, 0, 0));
15307 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
15308 l1jump = new_loc_descr (DW_OP_skip, 0, 0);
15309 add_loc_descr (&ret, l1jump);
15310 l2label = new_loc_descr (DW_OP_drop, 0, 0);
15311 add_loc_descr (&ret, l2label);
15312 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
15313 add_loc_descr (&ret, new_loc_descr (DW_OP_drop, 0, 0));
15314 l1jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
15315 l1jump->dw_loc_oprnd1.v.val_loc = l1label;
15316 l2jump->dw_loc_oprnd1.val_class = dw_val_class_loc;
15317 l2jump->dw_loc_oprnd1.v.val_loc = l2label;
15321 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
15322 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15323 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
15324 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
15326 ROTATERT is similar:
15327 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
15328 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15329 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
15331 static dw_loc_descr_ref
15332 rotate_loc_descriptor (rtx rtl, scalar_int_mode mode,
15333 machine_mode mem_mode)
15335 rtx rtlop1 = XEXP (rtl, 1);
15336 dw_loc_descr_ref op0, op1, ret, mask[2] = { NULL, NULL };
15339 if (is_narrower_int_mode (GET_MODE (rtlop1), mode))
15340 rtlop1 = gen_rtx_ZERO_EXTEND (mode, rtlop1);
15341 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
15342 VAR_INIT_STATUS_INITIALIZED);
15343 op1 = mem_loc_descriptor (rtlop1, mode, mem_mode,
15344 VAR_INIT_STATUS_INITIALIZED);
15345 if (op0 == NULL || op1 == NULL)
15347 if (GET_MODE_SIZE (mode) < DWARF2_ADDR_SIZE)
15348 for (i = 0; i < 2; i++)
15350 if (GET_MODE_BITSIZE (mode) < HOST_BITS_PER_WIDE_INT)
15351 mask[i] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode)),
15353 VAR_INIT_STATUS_INITIALIZED);
15354 else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT)
15355 mask[i] = new_loc_descr (HOST_BITS_PER_WIDE_INT == 32
15357 : HOST_BITS_PER_WIDE_INT == 64
15358 ? DW_OP_const8u : DW_OP_constu,
15359 GET_MODE_MASK (mode), 0);
15362 if (mask[i] == NULL)
15364 add_loc_descr (&mask[i], new_loc_descr (DW_OP_and, 0, 0));
15367 add_loc_descr (&ret, op1);
15368 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0));
15369 add_loc_descr (&ret, new_loc_descr (DW_OP_over, 0, 0));
15370 if (GET_CODE (rtl) == ROTATERT)
15372 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
15373 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst,
15374 GET_MODE_BITSIZE (mode), 0));
15376 add_loc_descr (&ret, new_loc_descr (DW_OP_shl, 0, 0));
15377 if (mask[0] != NULL)
15378 add_loc_descr (&ret, mask[0]);
15379 add_loc_descr (&ret, new_loc_descr (DW_OP_rot, 0, 0));
15380 if (mask[1] != NULL)
15382 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
15383 add_loc_descr (&ret, mask[1]);
15384 add_loc_descr (&ret, new_loc_descr (DW_OP_swap, 0, 0));
15386 if (GET_CODE (rtl) == ROTATE)
15388 add_loc_descr (&ret, new_loc_descr (DW_OP_neg, 0, 0));
15389 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst,
15390 GET_MODE_BITSIZE (mode), 0));
15392 add_loc_descr (&ret, new_loc_descr (DW_OP_shr, 0, 0));
15393 add_loc_descr (&ret, new_loc_descr (DW_OP_or, 0, 0));
15397 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
15398 for DEBUG_PARAMETER_REF RTL. */
15400 static dw_loc_descr_ref
15401 parameter_ref_descriptor (rtx rtl)
15403 dw_loc_descr_ref ret;
15408 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl)) == PARM_DECL);
15409 /* With LTO during LTRANS we get the late DIE that refers to the early
15410 DIE, thus we add another indirection here. This seems to confuse
15411 gdb enough to make gcc.dg/guality/pr68860-1.c FAIL with LTO. */
15412 ref = lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl));
15413 ret = new_loc_descr (DW_OP_GNU_parameter_ref, 0, 0);
15416 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
15417 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
15418 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
15422 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
15423 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_PARAMETER_REF_DECL (rtl);
15428 /* The following routine converts the RTL for a variable or parameter
15429 (resident in memory) into an equivalent Dwarf representation of a
15430 mechanism for getting the address of that same variable onto the top of a
15431 hypothetical "address evaluation" stack.
15433 When creating memory location descriptors, we are effectively transforming
15434 the RTL for a memory-resident object into its Dwarf postfix expression
15435 equivalent. This routine recursively descends an RTL tree, turning
15436 it into Dwarf postfix code as it goes.
15438 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
15440 MEM_MODE is the mode of the memory reference, needed to handle some
15441 autoincrement addressing modes.
15443 Return 0 if we can't represent the location. */
15446 mem_loc_descriptor (rtx rtl, machine_mode mode,
15447 machine_mode mem_mode,
15448 enum var_init_status initialized)
15450 dw_loc_descr_ref mem_loc_result = NULL;
15451 enum dwarf_location_atom op;
15452 dw_loc_descr_ref op0, op1;
15453 rtx inner = NULL_RTX;
15456 if (mode == VOIDmode)
15457 mode = GET_MODE (rtl);
15459 /* Note that for a dynamically sized array, the location we will generate a
15460 description of here will be the lowest numbered location which is
15461 actually within the array. That's *not* necessarily the same as the
15462 zeroth element of the array. */
15464 rtl = targetm.delegitimize_address (rtl);
15466 if (mode != GET_MODE (rtl) && GET_MODE (rtl) != VOIDmode)
15469 scalar_int_mode int_mode = BImode, inner_mode, op1_mode;
15470 switch (GET_CODE (rtl))
15475 return mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode, initialized);
15478 /* The case of a subreg may arise when we have a local (register)
15479 variable or a formal (register) parameter which doesn't quite fill
15480 up an entire register. For now, just assume that it is
15481 legitimate to make the Dwarf info refer to the whole register which
15482 contains the given subreg. */
15483 if (!subreg_lowpart_p (rtl))
15485 inner = SUBREG_REG (rtl);
15488 if (inner == NULL_RTX)
15489 inner = XEXP (rtl, 0);
15490 if (is_a <scalar_int_mode> (mode, &int_mode)
15491 && is_a <scalar_int_mode> (GET_MODE (inner), &inner_mode)
15492 && (GET_MODE_SIZE (int_mode) <= DWARF2_ADDR_SIZE
15493 #ifdef POINTERS_EXTEND_UNSIGNED
15494 || (int_mode == Pmode && mem_mode != VOIDmode)
15497 && GET_MODE_SIZE (inner_mode) <= DWARF2_ADDR_SIZE)
15499 mem_loc_result = mem_loc_descriptor (inner,
15501 mem_mode, initialized);
15504 if (dwarf_strict && dwarf_version < 5)
15506 if (is_a <scalar_int_mode> (mode, &int_mode)
15507 && is_a <scalar_int_mode> (GET_MODE (inner), &inner_mode)
15508 ? GET_MODE_SIZE (int_mode) <= GET_MODE_SIZE (inner_mode)
15509 : known_eq (GET_MODE_SIZE (mode), GET_MODE_SIZE (GET_MODE (inner))))
15511 dw_die_ref type_die;
15512 dw_loc_descr_ref cvt;
15514 mem_loc_result = mem_loc_descriptor (inner,
15516 mem_mode, initialized);
15517 if (mem_loc_result == NULL)
15519 type_die = base_type_for_mode (mode, SCALAR_INT_MODE_P (mode));
15520 if (type_die == NULL)
15522 mem_loc_result = NULL;
15525 if (maybe_ne (GET_MODE_SIZE (mode), GET_MODE_SIZE (GET_MODE (inner))))
15526 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
15528 cvt = new_loc_descr (dwarf_OP (DW_OP_reinterpret), 0, 0);
15529 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
15530 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
15531 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
15532 add_loc_descr (&mem_loc_result, cvt);
15533 if (is_a <scalar_int_mode> (mode, &int_mode)
15534 && GET_MODE_SIZE (int_mode) <= DWARF2_ADDR_SIZE)
15536 /* Convert it to untyped afterwards. */
15537 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
15538 add_loc_descr (&mem_loc_result, cvt);
15544 if (!is_a <scalar_int_mode> (mode, &int_mode)
15545 || (GET_MODE_SIZE (int_mode) > DWARF2_ADDR_SIZE
15546 && rtl != arg_pointer_rtx
15547 && rtl != frame_pointer_rtx
15548 #ifdef POINTERS_EXTEND_UNSIGNED
15549 && (int_mode != Pmode || mem_mode == VOIDmode)
15553 dw_die_ref type_die;
15554 unsigned int dbx_regnum;
15556 if (dwarf_strict && dwarf_version < 5)
15558 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
15560 type_die = base_type_for_mode (mode, SCALAR_INT_MODE_P (mode));
15561 if (type_die == NULL)
15564 dbx_regnum = dbx_reg_number (rtl);
15565 if (dbx_regnum == IGNORED_DWARF_REGNUM)
15567 mem_loc_result = new_loc_descr (dwarf_OP (DW_OP_regval_type),
15569 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
15570 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.die = type_die;
15571 mem_loc_result->dw_loc_oprnd2.v.val_die_ref.external = 0;
15574 /* Whenever a register number forms a part of the description of the
15575 method for calculating the (dynamic) address of a memory resident
15576 object, DWARF rules require the register number be referred to as
15577 a "base register". This distinction is not based in any way upon
15578 what category of register the hardware believes the given register
15579 belongs to. This is strictly DWARF terminology we're dealing with
15580 here. Note that in cases where the location of a memory-resident
15581 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
15582 OP_CONST (0)) the actual DWARF location descriptor that we generate
15583 may just be OP_BASEREG (basereg). This may look deceptively like
15584 the object in question was allocated to a register (rather than in
15585 memory) so DWARF consumers need to be aware of the subtle
15586 distinction between OP_REG and OP_BASEREG. */
15587 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
15588 mem_loc_result = based_loc_descr (rtl, 0, VAR_INIT_STATUS_INITIALIZED);
15589 else if (stack_realign_drap
15591 && crtl->args.internal_arg_pointer == rtl
15592 && REGNO (crtl->drap_reg) < FIRST_PSEUDO_REGISTER)
15594 /* If RTL is internal_arg_pointer, which has been optimized
15595 out, use DRAP instead. */
15596 mem_loc_result = based_loc_descr (crtl->drap_reg, 0,
15597 VAR_INIT_STATUS_INITIALIZED);
15603 if (!is_a <scalar_int_mode> (mode, &int_mode)
15604 || !is_a <scalar_int_mode> (GET_MODE (XEXP (rtl, 0)), &inner_mode))
15606 op0 = mem_loc_descriptor (XEXP (rtl, 0), inner_mode,
15607 mem_mode, VAR_INIT_STATUS_INITIALIZED);
15610 else if (GET_CODE (rtl) == ZERO_EXTEND
15611 && GET_MODE_SIZE (int_mode) <= DWARF2_ADDR_SIZE
15612 && GET_MODE_BITSIZE (inner_mode) < HOST_BITS_PER_WIDE_INT
15613 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
15614 to expand zero extend as two shifts instead of
15616 && GET_MODE_SIZE (inner_mode) <= 4)
15618 mem_loc_result = op0;
15619 add_loc_descr (&mem_loc_result,
15620 int_loc_descriptor (GET_MODE_MASK (inner_mode)));
15621 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_and, 0, 0));
15623 else if (GET_MODE_SIZE (int_mode) <= DWARF2_ADDR_SIZE)
15625 int shift = DWARF2_ADDR_SIZE - GET_MODE_SIZE (inner_mode);
15626 shift *= BITS_PER_UNIT;
15627 if (GET_CODE (rtl) == SIGN_EXTEND)
15631 mem_loc_result = op0;
15632 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
15633 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
15634 add_loc_descr (&mem_loc_result, int_loc_descriptor (shift));
15635 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
15637 else if (!dwarf_strict || dwarf_version >= 5)
15639 dw_die_ref type_die1, type_die2;
15640 dw_loc_descr_ref cvt;
15642 type_die1 = base_type_for_mode (inner_mode,
15643 GET_CODE (rtl) == ZERO_EXTEND);
15644 if (type_die1 == NULL)
15646 type_die2 = base_type_for_mode (int_mode, 1);
15647 if (type_die2 == NULL)
15649 mem_loc_result = op0;
15650 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
15651 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
15652 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die1;
15653 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
15654 add_loc_descr (&mem_loc_result, cvt);
15655 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
15656 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
15657 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die2;
15658 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
15659 add_loc_descr (&mem_loc_result, cvt);
15665 rtx new_rtl = avoid_constant_pool_reference (rtl);
15666 if (new_rtl != rtl)
15668 mem_loc_result = mem_loc_descriptor (new_rtl, mode, mem_mode,
15670 if (mem_loc_result != NULL)
15671 return mem_loc_result;
15674 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0),
15675 get_address_mode (rtl), mode,
15676 VAR_INIT_STATUS_INITIALIZED);
15677 if (mem_loc_result == NULL)
15678 mem_loc_result = tls_mem_loc_descriptor (rtl);
15679 if (mem_loc_result != NULL)
15681 if (!is_a <scalar_int_mode> (mode, &int_mode)
15682 || GET_MODE_SIZE (int_mode) > DWARF2_ADDR_SIZE)
15684 dw_die_ref type_die;
15685 dw_loc_descr_ref deref;
15686 HOST_WIDE_INT size;
15688 if (dwarf_strict && dwarf_version < 5)
15690 if (!GET_MODE_SIZE (mode).is_constant (&size))
15693 = base_type_for_mode (mode, SCALAR_INT_MODE_P (mode));
15694 if (type_die == NULL)
15696 deref = new_loc_descr (dwarf_OP (DW_OP_deref_type), size, 0);
15697 deref->dw_loc_oprnd2.val_class = dw_val_class_die_ref;
15698 deref->dw_loc_oprnd2.v.val_die_ref.die = type_die;
15699 deref->dw_loc_oprnd2.v.val_die_ref.external = 0;
15700 add_loc_descr (&mem_loc_result, deref);
15702 else if (GET_MODE_SIZE (int_mode) == DWARF2_ADDR_SIZE)
15703 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
15705 add_loc_descr (&mem_loc_result,
15706 new_loc_descr (DW_OP_deref_size,
15707 GET_MODE_SIZE (int_mode), 0));
15712 return mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode, initialized);
15715 /* Some ports can transform a symbol ref into a label ref, because
15716 the symbol ref is too far away and has to be dumped into a constant
15721 if (!is_a <scalar_int_mode> (mode, &int_mode)
15722 || (GET_MODE_SIZE (int_mode) > DWARF2_ADDR_SIZE
15723 #ifdef POINTERS_EXTEND_UNSIGNED
15724 && (int_mode != Pmode || mem_mode == VOIDmode)
15729 if (GET_CODE (rtl) == UNSPEC)
15731 /* If delegitimize_address couldn't do anything with the UNSPEC, we
15732 can't express it in the debug info. This can happen e.g. with some
15733 TLS UNSPECs. Allow UNSPECs formerly from CONST that the backend
15735 bool not_ok = false;
15736 subrtx_var_iterator::array_type array;
15737 FOR_EACH_SUBRTX_VAR (iter, array, rtl, ALL)
15738 if (*iter != rtl && !CONSTANT_P (*iter))
15747 FOR_EACH_SUBRTX_VAR (iter, array, rtl, ALL)
15748 if (!const_ok_for_output_1 (*iter))
15757 rtl = gen_rtx_CONST (GET_MODE (rtl), rtl);
15761 if (GET_CODE (rtl) == SYMBOL_REF
15762 && SYMBOL_REF_TLS_MODEL (rtl) != TLS_MODEL_NONE)
15764 dw_loc_descr_ref temp;
15766 /* If this is not defined, we have no way to emit the data. */
15767 if (!targetm.have_tls || !targetm.asm_out.output_dwarf_dtprel)
15770 temp = new_addr_loc_descr (rtl, dtprel_true);
15772 /* We check for DWARF 5 here because gdb did not implement
15773 DW_OP_form_tls_address until after 7.12. */
15774 mem_loc_result = new_loc_descr ((dwarf_version >= 5
15775 ? DW_OP_form_tls_address
15776 : DW_OP_GNU_push_tls_address),
15778 add_loc_descr (&mem_loc_result, temp);
15783 if (!const_ok_for_output (rtl))
15785 if (GET_CODE (rtl) == CONST)
15786 switch (GET_CODE (XEXP (rtl, 0)))
15790 goto try_const_unop;
15793 goto try_const_unop;
15796 arg = XEXP (XEXP (rtl, 0), 0);
15797 if (!CONSTANT_P (arg))
15798 arg = gen_rtx_CONST (int_mode, arg);
15799 op0 = mem_loc_descriptor (arg, int_mode, mem_mode,
15803 mem_loc_result = op0;
15804 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
15808 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), int_mode,
15809 mem_mode, initialized);
15816 mem_loc_result = new_addr_loc_descr (rtl, dtprel_false);
15817 vec_safe_push (used_rtx_array, rtl);
15823 case DEBUG_IMPLICIT_PTR:
15824 expansion_failed (NULL_TREE, rtl,
15825 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
15829 if (dwarf_strict && dwarf_version < 5)
15831 if (REG_P (ENTRY_VALUE_EXP (rtl)))
15833 if (!is_a <scalar_int_mode> (mode, &int_mode)
15834 || GET_MODE_SIZE (int_mode) > DWARF2_ADDR_SIZE)
15835 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode,
15836 VOIDmode, VAR_INIT_STATUS_INITIALIZED);
15839 unsigned int dbx_regnum = dbx_reg_number (ENTRY_VALUE_EXP (rtl));
15840 if (dbx_regnum == IGNORED_DWARF_REGNUM)
15842 op0 = one_reg_loc_descriptor (dbx_regnum,
15843 VAR_INIT_STATUS_INITIALIZED);
15846 else if (MEM_P (ENTRY_VALUE_EXP (rtl))
15847 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl), 0)))
15849 op0 = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), mode,
15850 VOIDmode, VAR_INIT_STATUS_INITIALIZED);
15851 if (op0 && op0->dw_loc_opc == DW_OP_fbreg)
15855 gcc_unreachable ();
15858 mem_loc_result = new_loc_descr (dwarf_OP (DW_OP_entry_value), 0, 0);
15859 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_loc;
15860 mem_loc_result->dw_loc_oprnd1.v.val_loc = op0;
15863 case DEBUG_PARAMETER_REF:
15864 mem_loc_result = parameter_ref_descriptor (rtl);
15868 /* Extract the PLUS expression nested inside and fall into
15869 PLUS code below. */
15870 rtl = XEXP (rtl, 1);
15875 /* Turn these into a PLUS expression and fall into the PLUS code
15877 rtl = gen_rtx_PLUS (mode, XEXP (rtl, 0),
15878 gen_int_mode (GET_CODE (rtl) == PRE_INC
15879 ? GET_MODE_UNIT_SIZE (mem_mode)
15880 : -GET_MODE_UNIT_SIZE (mem_mode),
15887 if (is_based_loc (rtl)
15888 && is_a <scalar_int_mode> (mode, &int_mode)
15889 && (GET_MODE_SIZE (int_mode) <= DWARF2_ADDR_SIZE
15890 || XEXP (rtl, 0) == arg_pointer_rtx
15891 || XEXP (rtl, 0) == frame_pointer_rtx))
15892 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
15893 INTVAL (XEXP (rtl, 1)),
15894 VAR_INIT_STATUS_INITIALIZED);
15897 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
15898 VAR_INIT_STATUS_INITIALIZED);
15899 if (mem_loc_result == 0)
15902 if (CONST_INT_P (XEXP (rtl, 1))
15903 && (GET_MODE_SIZE (as_a <scalar_int_mode> (mode))
15904 <= DWARF2_ADDR_SIZE))
15905 loc_descr_plus_const (&mem_loc_result, INTVAL (XEXP (rtl, 1)));
15908 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
15909 VAR_INIT_STATUS_INITIALIZED);
15912 add_loc_descr (&mem_loc_result, op1);
15913 add_loc_descr (&mem_loc_result,
15914 new_loc_descr (DW_OP_plus, 0, 0));
15919 /* If a pseudo-reg is optimized away, it is possible for it to
15920 be replaced with a MEM containing a multiply or shift. */
15930 if ((!dwarf_strict || dwarf_version >= 5)
15931 && is_a <scalar_int_mode> (mode, &int_mode)
15932 && GET_MODE_SIZE (int_mode) > DWARF2_ADDR_SIZE)
15934 mem_loc_result = typed_binop (DW_OP_div, rtl,
15935 base_type_for_mode (mode, 0),
15936 int_mode, mem_mode);
15959 if (!is_a <scalar_int_mode> (mode, &int_mode))
15961 op0 = mem_loc_descriptor (XEXP (rtl, 0), int_mode, mem_mode,
15962 VAR_INIT_STATUS_INITIALIZED);
15964 rtx rtlop1 = XEXP (rtl, 1);
15965 if (is_a <scalar_int_mode> (GET_MODE (rtlop1), &op1_mode)
15966 && GET_MODE_BITSIZE (op1_mode) < GET_MODE_BITSIZE (int_mode))
15967 rtlop1 = gen_rtx_ZERO_EXTEND (int_mode, rtlop1);
15968 op1 = mem_loc_descriptor (rtlop1, int_mode, mem_mode,
15969 VAR_INIT_STATUS_INITIALIZED);
15972 if (op0 == 0 || op1 == 0)
15975 mem_loc_result = op0;
15976 add_loc_descr (&mem_loc_result, op1);
15977 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
15993 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
15994 VAR_INIT_STATUS_INITIALIZED);
15995 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
15996 VAR_INIT_STATUS_INITIALIZED);
15998 if (op0 == 0 || op1 == 0)
16001 mem_loc_result = op0;
16002 add_loc_descr (&mem_loc_result, op1);
16003 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
16007 if ((!dwarf_strict || dwarf_version >= 5)
16008 && is_a <scalar_int_mode> (mode, &int_mode)
16009 && GET_MODE_SIZE (int_mode) > DWARF2_ADDR_SIZE)
16011 mem_loc_result = typed_binop (DW_OP_mod, rtl,
16012 base_type_for_mode (mode, 0),
16013 int_mode, mem_mode);
16017 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
16018 VAR_INIT_STATUS_INITIALIZED);
16019 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
16020 VAR_INIT_STATUS_INITIALIZED);
16022 if (op0 == 0 || op1 == 0)
16025 mem_loc_result = op0;
16026 add_loc_descr (&mem_loc_result, op1);
16027 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
16028 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_over, 0, 0));
16029 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_div, 0, 0));
16030 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
16031 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_minus, 0, 0));
16035 if ((!dwarf_strict || dwarf_version >= 5)
16036 && is_a <scalar_int_mode> (mode, &int_mode))
16038 if (GET_MODE_SIZE (int_mode) > DWARF2_ADDR_SIZE)
16043 mem_loc_result = typed_binop (DW_OP_div, rtl,
16044 base_type_for_mode (int_mode, 1),
16045 int_mode, mem_mode);
16062 op0 = mem_loc_descriptor (XEXP (rtl, 0), mode, mem_mode,
16063 VAR_INIT_STATUS_INITIALIZED);
16068 mem_loc_result = op0;
16069 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
16073 if (!is_a <scalar_int_mode> (mode, &int_mode)
16074 || GET_MODE_SIZE (int_mode) <= DWARF2_ADDR_SIZE
16075 #ifdef POINTERS_EXTEND_UNSIGNED
16076 || (int_mode == Pmode
16077 && mem_mode != VOIDmode
16078 && trunc_int_for_mode (INTVAL (rtl), ptr_mode) == INTVAL (rtl))
16082 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
16085 if ((!dwarf_strict || dwarf_version >= 5)
16086 && (GET_MODE_BITSIZE (int_mode) == HOST_BITS_PER_WIDE_INT
16087 || GET_MODE_BITSIZE (int_mode) == HOST_BITS_PER_DOUBLE_INT))
16089 dw_die_ref type_die = base_type_for_mode (int_mode, 1);
16090 scalar_int_mode amode;
16091 if (type_die == NULL)
16093 if (INTVAL (rtl) >= 0
16094 && (int_mode_for_size (DWARF2_ADDR_SIZE * BITS_PER_UNIT, 0)
16096 && trunc_int_for_mode (INTVAL (rtl), amode) == INTVAL (rtl)
16097 /* const DW_OP_convert <XXX> vs.
16098 DW_OP_const_type <XXX, 1, const>. */
16099 && size_of_int_loc_descriptor (INTVAL (rtl)) + 1 + 1
16100 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (int_mode))
16102 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
16103 op0 = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
16104 op0->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
16105 op0->dw_loc_oprnd1.v.val_die_ref.die = type_die;
16106 op0->dw_loc_oprnd1.v.val_die_ref.external = 0;
16107 add_loc_descr (&mem_loc_result, op0);
16108 return mem_loc_result;
16110 mem_loc_result = new_loc_descr (dwarf_OP (DW_OP_const_type), 0,
16112 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
16113 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
16114 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
16115 if (GET_MODE_BITSIZE (int_mode) == HOST_BITS_PER_WIDE_INT)
16116 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_const;
16119 mem_loc_result->dw_loc_oprnd2.val_class
16120 = dw_val_class_const_double;
16121 mem_loc_result->dw_loc_oprnd2.v.val_double
16122 = double_int::from_shwi (INTVAL (rtl));
16128 if (!dwarf_strict || dwarf_version >= 5)
16130 dw_die_ref type_die;
16132 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
16133 CONST_DOUBLE rtx could represent either a large integer
16134 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
16135 the value is always a floating point constant.
16137 When it is an integer, a CONST_DOUBLE is used whenever
16138 the constant requires 2 HWIs to be adequately represented.
16139 We output CONST_DOUBLEs as blocks. */
16140 if (mode == VOIDmode
16141 || (GET_MODE (rtl) == VOIDmode
16142 && maybe_ne (GET_MODE_BITSIZE (mode),
16143 HOST_BITS_PER_DOUBLE_INT)))
16145 type_die = base_type_for_mode (mode, SCALAR_INT_MODE_P (mode));
16146 if (type_die == NULL)
16148 mem_loc_result = new_loc_descr (dwarf_OP (DW_OP_const_type), 0, 0);
16149 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
16150 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
16151 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
16152 #if TARGET_SUPPORTS_WIDE_INT == 0
16153 if (!SCALAR_FLOAT_MODE_P (mode))
16155 mem_loc_result->dw_loc_oprnd2.val_class
16156 = dw_val_class_const_double;
16157 mem_loc_result->dw_loc_oprnd2.v.val_double
16158 = rtx_to_double_int (rtl);
16163 scalar_float_mode float_mode = as_a <scalar_float_mode> (mode);
16164 unsigned int length = GET_MODE_SIZE (float_mode);
16165 unsigned char *array = ggc_vec_alloc<unsigned char> (length);
16167 insert_float (rtl, array);
16168 mem_loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
16169 mem_loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
16170 mem_loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
16171 mem_loc_result->dw_loc_oprnd2.v.val_vec.array = array;
16176 case CONST_WIDE_INT:
16177 if (!dwarf_strict || dwarf_version >= 5)
16179 dw_die_ref type_die;
16181 type_die = base_type_for_mode (mode, SCALAR_INT_MODE_P (mode));
16182 if (type_die == NULL)
16184 mem_loc_result = new_loc_descr (dwarf_OP (DW_OP_const_type), 0, 0);
16185 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
16186 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.die = type_die;
16187 mem_loc_result->dw_loc_oprnd1.v.val_die_ref.external = 0;
16188 mem_loc_result->dw_loc_oprnd2.val_class
16189 = dw_val_class_wide_int;
16190 mem_loc_result->dw_loc_oprnd2.v.val_wide = ggc_alloc<wide_int> ();
16191 *mem_loc_result->dw_loc_oprnd2.v.val_wide = rtx_mode_t (rtl, mode);
16195 case CONST_POLY_INT:
16196 mem_loc_result = int_loc_descriptor (rtx_to_poly_int64 (rtl));
16200 mem_loc_result = scompare_loc_descriptor (DW_OP_eq, rtl, mem_mode);
16204 mem_loc_result = scompare_loc_descriptor (DW_OP_ge, rtl, mem_mode);
16208 mem_loc_result = scompare_loc_descriptor (DW_OP_gt, rtl, mem_mode);
16212 mem_loc_result = scompare_loc_descriptor (DW_OP_le, rtl, mem_mode);
16216 mem_loc_result = scompare_loc_descriptor (DW_OP_lt, rtl, mem_mode);
16220 mem_loc_result = scompare_loc_descriptor (DW_OP_ne, rtl, mem_mode);
16224 mem_loc_result = ucompare_loc_descriptor (DW_OP_ge, rtl, mem_mode);
16228 mem_loc_result = ucompare_loc_descriptor (DW_OP_gt, rtl, mem_mode);
16232 mem_loc_result = ucompare_loc_descriptor (DW_OP_le, rtl, mem_mode);
16236 mem_loc_result = ucompare_loc_descriptor (DW_OP_lt, rtl, mem_mode);
16241 if (!SCALAR_INT_MODE_P (mode))
16246 mem_loc_result = minmax_loc_descriptor (rtl, mode, mem_mode);
16251 if (CONST_INT_P (XEXP (rtl, 1))
16252 && CONST_INT_P (XEXP (rtl, 2))
16253 && is_a <scalar_int_mode> (mode, &int_mode)
16254 && is_a <scalar_int_mode> (GET_MODE (XEXP (rtl, 0)), &inner_mode)
16255 && GET_MODE_SIZE (int_mode) <= DWARF2_ADDR_SIZE
16256 && GET_MODE_SIZE (inner_mode) <= DWARF2_ADDR_SIZE
16257 && ((unsigned) INTVAL (XEXP (rtl, 1))
16258 + (unsigned) INTVAL (XEXP (rtl, 2))
16259 <= GET_MODE_BITSIZE (int_mode)))
16262 op0 = mem_loc_descriptor (XEXP (rtl, 0), inner_mode,
16263 mem_mode, VAR_INIT_STATUS_INITIALIZED);
16266 if (GET_CODE (rtl) == SIGN_EXTRACT)
16270 mem_loc_result = op0;
16271 size = INTVAL (XEXP (rtl, 1));
16272 shift = INTVAL (XEXP (rtl, 2));
16273 if (BITS_BIG_ENDIAN)
16274 shift = GET_MODE_BITSIZE (inner_mode) - shift - size;
16275 if (shift + size != (int) DWARF2_ADDR_SIZE)
16277 add_loc_descr (&mem_loc_result,
16278 int_loc_descriptor (DWARF2_ADDR_SIZE
16280 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_shl, 0, 0));
16282 if (size != (int) DWARF2_ADDR_SIZE)
16284 add_loc_descr (&mem_loc_result,
16285 int_loc_descriptor (DWARF2_ADDR_SIZE - size));
16286 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
16293 dw_loc_descr_ref op2, bra_node, drop_node;
16294 op0 = mem_loc_descriptor (XEXP (rtl, 0),
16295 GET_MODE (XEXP (rtl, 0)) == VOIDmode
16296 ? word_mode : GET_MODE (XEXP (rtl, 0)),
16297 mem_mode, VAR_INIT_STATUS_INITIALIZED);
16298 op1 = mem_loc_descriptor (XEXP (rtl, 1), mode, mem_mode,
16299 VAR_INIT_STATUS_INITIALIZED);
16300 op2 = mem_loc_descriptor (XEXP (rtl, 2), mode, mem_mode,
16301 VAR_INIT_STATUS_INITIALIZED);
16302 if (op0 == NULL || op1 == NULL || op2 == NULL)
16305 mem_loc_result = op1;
16306 add_loc_descr (&mem_loc_result, op2);
16307 add_loc_descr (&mem_loc_result, op0);
16308 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
16309 add_loc_descr (&mem_loc_result, bra_node);
16310 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_swap, 0, 0));
16311 drop_node = new_loc_descr (DW_OP_drop, 0, 0);
16312 add_loc_descr (&mem_loc_result, drop_node);
16313 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
16314 bra_node->dw_loc_oprnd1.v.val_loc = drop_node;
16319 case FLOAT_TRUNCATE:
16321 case UNSIGNED_FLOAT:
16324 if (!dwarf_strict || dwarf_version >= 5)
16326 dw_die_ref type_die;
16327 dw_loc_descr_ref cvt;
16329 op0 = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (XEXP (rtl, 0)),
16330 mem_mode, VAR_INIT_STATUS_INITIALIZED);
16333 if (is_a <scalar_int_mode> (GET_MODE (XEXP (rtl, 0)), &int_mode)
16334 && (GET_CODE (rtl) == FLOAT
16335 || GET_MODE_SIZE (int_mode) <= DWARF2_ADDR_SIZE))
16337 type_die = base_type_for_mode (int_mode,
16338 GET_CODE (rtl) == UNSIGNED_FLOAT);
16339 if (type_die == NULL)
16341 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
16342 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
16343 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
16344 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
16345 add_loc_descr (&op0, cvt);
16347 type_die = base_type_for_mode (mode, GET_CODE (rtl) == UNSIGNED_FIX);
16348 if (type_die == NULL)
16350 cvt = new_loc_descr (dwarf_OP (DW_OP_convert), 0, 0);
16351 cvt->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
16352 cvt->dw_loc_oprnd1.v.val_die_ref.die = type_die;
16353 cvt->dw_loc_oprnd1.v.val_die_ref.external = 0;
16354 add_loc_descr (&op0, cvt);
16355 if (is_a <scalar_int_mode> (mode, &int_mode)
16356 && (GET_CODE (rtl) == FIX
16357 || GET_MODE_SIZE (int_mode) < DWARF2_ADDR_SIZE))
16359 op0 = convert_descriptor_to_mode (int_mode, op0);
16363 mem_loc_result = op0;
16370 if (is_a <scalar_int_mode> (mode, &int_mode))
16371 mem_loc_result = clz_loc_descriptor (rtl, int_mode, mem_mode);
16376 if (is_a <scalar_int_mode> (mode, &int_mode))
16377 mem_loc_result = popcount_loc_descriptor (rtl, int_mode, mem_mode);
16381 if (is_a <scalar_int_mode> (mode, &int_mode))
16382 mem_loc_result = bswap_loc_descriptor (rtl, int_mode, mem_mode);
16387 if (is_a <scalar_int_mode> (mode, &int_mode))
16388 mem_loc_result = rotate_loc_descriptor (rtl, int_mode, mem_mode);
16392 /* In theory, we could implement the above. */
16393 /* DWARF cannot represent the unsigned compare operations
16418 case FRACT_CONVERT:
16419 case UNSIGNED_FRACT_CONVERT:
16421 case UNSIGNED_SAT_FRACT:
16427 case VEC_DUPLICATE:
16431 case STRICT_LOW_PART:
16439 resolve_one_addr (&rtl);
16442 /* RTL sequences inside PARALLEL record a series of DWARF operations for
16443 the expression. An UNSPEC rtx represents a raw DWARF operation,
16444 new_loc_descr is called for it to build the operation directly.
16445 Otherwise mem_loc_descriptor is called recursively. */
16449 dw_loc_descr_ref exp_result = NULL;
16451 for (; index < XVECLEN (rtl, 0); index++)
16453 rtx elem = XVECEXP (rtl, 0, index);
16454 if (GET_CODE (elem) == UNSPEC)
16456 /* Each DWARF operation UNSPEC contain two operands, if
16457 one operand is not used for the operation, const0_rtx is
16459 gcc_assert (XVECLEN (elem, 0) == 2);
16461 HOST_WIDE_INT dw_op = XINT (elem, 1);
16462 HOST_WIDE_INT oprnd1 = INTVAL (XVECEXP (elem, 0, 0));
16463 HOST_WIDE_INT oprnd2 = INTVAL (XVECEXP (elem, 0, 1));
16465 = new_loc_descr ((enum dwarf_location_atom) dw_op, oprnd1,
16470 = mem_loc_descriptor (elem, mode, mem_mode,
16471 VAR_INIT_STATUS_INITIALIZED);
16473 if (!mem_loc_result)
16474 mem_loc_result = exp_result;
16476 add_loc_descr (&mem_loc_result, exp_result);
16485 print_rtl (stderr, rtl);
16486 gcc_unreachable ();
16491 if (mem_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
16492 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
16494 return mem_loc_result;
16497 /* Return a descriptor that describes the concatenation of two locations.
16498 This is typically a complex variable. */
16500 static dw_loc_descr_ref
16501 concat_loc_descriptor (rtx x0, rtx x1, enum var_init_status initialized)
16503 /* At present we only track constant-sized pieces. */
16504 unsigned int size0, size1;
16505 if (!GET_MODE_SIZE (GET_MODE (x0)).is_constant (&size0)
16506 || !GET_MODE_SIZE (GET_MODE (x1)).is_constant (&size1))
16509 dw_loc_descr_ref cc_loc_result = NULL;
16510 dw_loc_descr_ref x0_ref
16511 = loc_descriptor (x0, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
16512 dw_loc_descr_ref x1_ref
16513 = loc_descriptor (x1, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
16515 if (x0_ref == 0 || x1_ref == 0)
16518 cc_loc_result = x0_ref;
16519 add_loc_descr_op_piece (&cc_loc_result, size0);
16521 add_loc_descr (&cc_loc_result, x1_ref);
16522 add_loc_descr_op_piece (&cc_loc_result, size1);
16524 if (initialized == VAR_INIT_STATUS_UNINITIALIZED)
16525 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
16527 return cc_loc_result;
16530 /* Return a descriptor that describes the concatenation of N
16533 static dw_loc_descr_ref
16534 concatn_loc_descriptor (rtx concatn, enum var_init_status initialized)
16537 dw_loc_descr_ref cc_loc_result = NULL;
16538 unsigned int n = XVECLEN (concatn, 0);
16541 for (i = 0; i < n; ++i)
16543 dw_loc_descr_ref ref;
16544 rtx x = XVECEXP (concatn, 0, i);
16546 /* At present we only track constant-sized pieces. */
16547 if (!GET_MODE_SIZE (GET_MODE (x)).is_constant (&size))
16550 ref = loc_descriptor (x, VOIDmode, VAR_INIT_STATUS_INITIALIZED);
16554 add_loc_descr (&cc_loc_result, ref);
16555 add_loc_descr_op_piece (&cc_loc_result, size);
16558 if (cc_loc_result && initialized == VAR_INIT_STATUS_UNINITIALIZED)
16559 add_loc_descr (&cc_loc_result, new_loc_descr (DW_OP_GNU_uninit, 0, 0));
16561 return cc_loc_result;
16564 /* Helper function for loc_descriptor. Return DW_OP_implicit_pointer
16565 for DEBUG_IMPLICIT_PTR RTL. */
16567 static dw_loc_descr_ref
16568 implicit_ptr_descriptor (rtx rtl, HOST_WIDE_INT offset)
16570 dw_loc_descr_ref ret;
16573 if (dwarf_strict && dwarf_version < 5)
16575 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == VAR_DECL
16576 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == PARM_DECL
16577 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl)) == RESULT_DECL);
16578 ref = lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl));
16579 ret = new_loc_descr (dwarf_OP (DW_OP_implicit_pointer), 0, offset);
16580 ret->dw_loc_oprnd2.val_class = dw_val_class_const;
16583 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
16584 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
16585 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
16589 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
16590 ret->dw_loc_oprnd1.v.val_decl_ref = DEBUG_IMPLICIT_PTR_DECL (rtl);
16595 /* Output a proper Dwarf location descriptor for a variable or parameter
16596 which is either allocated in a register or in a memory location. For a
16597 register, we just generate an OP_REG and the register number. For a
16598 memory location we provide a Dwarf postfix expression describing how to
16599 generate the (dynamic) address of the object onto the address stack.
16601 MODE is mode of the decl if this loc_descriptor is going to be used in
16602 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
16603 allowed, VOIDmode otherwise.
16605 If we don't know how to describe it, return 0. */
16607 static dw_loc_descr_ref
16608 loc_descriptor (rtx rtl, machine_mode mode,
16609 enum var_init_status initialized)
16611 dw_loc_descr_ref loc_result = NULL;
16612 scalar_int_mode int_mode;
16614 switch (GET_CODE (rtl))
16617 /* The case of a subreg may arise when we have a local (register)
16618 variable or a formal (register) parameter which doesn't quite fill
16619 up an entire register. For now, just assume that it is
16620 legitimate to make the Dwarf info refer to the whole register which
16621 contains the given subreg. */
16622 if (REG_P (SUBREG_REG (rtl)) && subreg_lowpart_p (rtl))
16623 loc_result = loc_descriptor (SUBREG_REG (rtl),
16624 GET_MODE (SUBREG_REG (rtl)), initialized);
16630 loc_result = reg_loc_descriptor (rtl, initialized);
16634 loc_result = mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl),
16635 GET_MODE (rtl), initialized);
16636 if (loc_result == NULL)
16637 loc_result = tls_mem_loc_descriptor (rtl);
16638 if (loc_result == NULL)
16640 rtx new_rtl = avoid_constant_pool_reference (rtl);
16641 if (new_rtl != rtl)
16642 loc_result = loc_descriptor (new_rtl, mode, initialized);
16647 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1),
16652 loc_result = concatn_loc_descriptor (rtl, initialized);
16657 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl)) != PARALLEL)
16659 rtx loc = PAT_VAR_LOCATION_LOC (rtl);
16660 if (GET_CODE (loc) == EXPR_LIST)
16661 loc = XEXP (loc, 0);
16662 loc_result = loc_descriptor (loc, mode, initialized);
16666 rtl = XEXP (rtl, 1);
16671 rtvec par_elems = XVEC (rtl, 0);
16672 int num_elem = GET_NUM_ELEM (par_elems);
16676 /* Create the first one, so we have something to add to. */
16677 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0),
16678 VOIDmode, initialized);
16679 if (loc_result == NULL)
16681 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
16682 /* At present we only track constant-sized pieces. */
16683 if (!GET_MODE_SIZE (mode).is_constant (&size))
16685 add_loc_descr_op_piece (&loc_result, size);
16686 for (i = 1; i < num_elem; i++)
16688 dw_loc_descr_ref temp;
16690 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0),
16691 VOIDmode, initialized);
16694 add_loc_descr (&loc_result, temp);
16695 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
16696 /* At present we only track constant-sized pieces. */
16697 if (!GET_MODE_SIZE (mode).is_constant (&size))
16699 add_loc_descr_op_piece (&loc_result, size);
16705 if (mode != VOIDmode && mode != BLKmode)
16707 int_mode = as_a <scalar_int_mode> (mode);
16708 loc_result = address_of_int_loc_descriptor (GET_MODE_SIZE (int_mode),
16714 if (mode == VOIDmode)
16715 mode = GET_MODE (rtl);
16717 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
16719 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
16721 /* Note that a CONST_DOUBLE rtx could represent either an integer
16722 or a floating-point constant. A CONST_DOUBLE is used whenever
16723 the constant requires more than one word in order to be
16724 adequately represented. We output CONST_DOUBLEs as blocks. */
16725 scalar_mode smode = as_a <scalar_mode> (mode);
16726 loc_result = new_loc_descr (DW_OP_implicit_value,
16727 GET_MODE_SIZE (smode), 0);
16728 #if TARGET_SUPPORTS_WIDE_INT == 0
16729 if (!SCALAR_FLOAT_MODE_P (smode))
16731 loc_result->dw_loc_oprnd2.val_class = dw_val_class_const_double;
16732 loc_result->dw_loc_oprnd2.v.val_double
16733 = rtx_to_double_int (rtl);
16738 unsigned int length = GET_MODE_SIZE (smode);
16739 unsigned char *array = ggc_vec_alloc<unsigned char> (length);
16741 insert_float (rtl, array);
16742 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
16743 loc_result->dw_loc_oprnd2.v.val_vec.length = length / 4;
16744 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = 4;
16745 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
16750 case CONST_WIDE_INT:
16751 if (mode == VOIDmode)
16752 mode = GET_MODE (rtl);
16754 if (mode != VOIDmode && (dwarf_version >= 4 || !dwarf_strict))
16756 int_mode = as_a <scalar_int_mode> (mode);
16757 loc_result = new_loc_descr (DW_OP_implicit_value,
16758 GET_MODE_SIZE (int_mode), 0);
16759 loc_result->dw_loc_oprnd2.val_class = dw_val_class_wide_int;
16760 loc_result->dw_loc_oprnd2.v.val_wide = ggc_alloc<wide_int> ();
16761 *loc_result->dw_loc_oprnd2.v.val_wide = rtx_mode_t (rtl, int_mode);
16766 if (mode == VOIDmode)
16767 mode = GET_MODE (rtl);
16769 if (mode != VOIDmode
16770 /* The combination of a length and byte elt_size doesn't extend
16771 naturally to boolean vectors, where several elements are packed
16772 into the same byte. */
16773 && GET_MODE_CLASS (mode) != MODE_VECTOR_BOOL
16774 && (dwarf_version >= 4 || !dwarf_strict))
16776 unsigned int length;
16777 if (!CONST_VECTOR_NUNITS (rtl).is_constant (&length))
16780 unsigned int elt_size = GET_MODE_UNIT_SIZE (GET_MODE (rtl));
16781 unsigned char *array
16782 = ggc_vec_alloc<unsigned char> (length * elt_size);
16785 machine_mode imode = GET_MODE_INNER (mode);
16787 gcc_assert (mode == GET_MODE (rtl) || VOIDmode == GET_MODE (rtl));
16788 switch (GET_MODE_CLASS (mode))
16790 case MODE_VECTOR_INT:
16791 for (i = 0, p = array; i < length; i++, p += elt_size)
16793 rtx elt = CONST_VECTOR_ELT (rtl, i);
16794 insert_wide_int (rtx_mode_t (elt, imode), p, elt_size);
16798 case MODE_VECTOR_FLOAT:
16799 for (i = 0, p = array; i < length; i++, p += elt_size)
16801 rtx elt = CONST_VECTOR_ELT (rtl, i);
16802 insert_float (elt, p);
16807 gcc_unreachable ();
16810 loc_result = new_loc_descr (DW_OP_implicit_value,
16811 length * elt_size, 0);
16812 loc_result->dw_loc_oprnd2.val_class = dw_val_class_vec;
16813 loc_result->dw_loc_oprnd2.v.val_vec.length = length;
16814 loc_result->dw_loc_oprnd2.v.val_vec.elt_size = elt_size;
16815 loc_result->dw_loc_oprnd2.v.val_vec.array = array;
16820 if (mode == VOIDmode
16821 || CONST_SCALAR_INT_P (XEXP (rtl, 0))
16822 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl, 0))
16823 || GET_CODE (XEXP (rtl, 0)) == CONST_VECTOR)
16825 loc_result = loc_descriptor (XEXP (rtl, 0), mode, initialized);
16830 if (!const_ok_for_output (rtl))
16834 if (is_a <scalar_int_mode> (mode, &int_mode)
16835 && GET_MODE_SIZE (int_mode) == DWARF2_ADDR_SIZE
16836 && (dwarf_version >= 4 || !dwarf_strict))
16838 loc_result = new_addr_loc_descr (rtl, dtprel_false);
16839 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
16840 vec_safe_push (used_rtx_array, rtl);
16844 case DEBUG_IMPLICIT_PTR:
16845 loc_result = implicit_ptr_descriptor (rtl, 0);
16849 if (GET_CODE (XEXP (rtl, 0)) == DEBUG_IMPLICIT_PTR
16850 && CONST_INT_P (XEXP (rtl, 1)))
16853 = implicit_ptr_descriptor (XEXP (rtl, 0), INTVAL (XEXP (rtl, 1)));
16859 if ((is_a <scalar_int_mode> (mode, &int_mode)
16860 && GET_MODE (rtl) == int_mode
16861 && GET_MODE_SIZE (int_mode) <= DWARF2_ADDR_SIZE
16862 && dwarf_version >= 4)
16863 || (!dwarf_strict && mode != VOIDmode && mode != BLKmode))
16865 /* Value expression. */
16866 loc_result = mem_loc_descriptor (rtl, mode, VOIDmode, initialized);
16868 add_loc_descr (&loc_result,
16869 new_loc_descr (DW_OP_stack_value, 0, 0));
16877 /* We need to figure out what section we should use as the base for the
16878 address ranges where a given location is valid.
16879 1. If this particular DECL has a section associated with it, use that.
16880 2. If this function has a section associated with it, use that.
16881 3. Otherwise, use the text section.
16882 XXX: If you split a variable across multiple sections, we won't notice. */
16884 static const char *
16885 secname_for_decl (const_tree decl)
16887 const char *secname;
16889 if (VAR_OR_FUNCTION_DECL_P (decl)
16890 && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl) || TREE_STATIC (decl))
16891 && DECL_SECTION_NAME (decl))
16892 secname = DECL_SECTION_NAME (decl);
16893 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
16895 if (in_cold_section_p)
16897 section *sec = current_function_section ();
16898 if (sec->common.flags & SECTION_NAMED)
16899 return sec->named.name;
16901 secname = DECL_SECTION_NAME (current_function_decl);
16903 else if (cfun && in_cold_section_p)
16904 secname = crtl->subsections.cold_section_label;
16906 secname = text_section_label;
16911 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
16914 decl_by_reference_p (tree decl)
16916 return ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL
16918 && DECL_BY_REFERENCE (decl));
16921 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
16924 static dw_loc_descr_ref
16925 dw_loc_list_1 (tree loc, rtx varloc, int want_address,
16926 enum var_init_status initialized)
16928 int have_address = 0;
16929 dw_loc_descr_ref descr;
16932 if (want_address != 2)
16934 gcc_assert (GET_CODE (varloc) == VAR_LOCATION);
16936 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
16938 varloc = PAT_VAR_LOCATION_LOC (varloc);
16939 if (GET_CODE (varloc) == EXPR_LIST)
16940 varloc = XEXP (varloc, 0);
16941 mode = GET_MODE (varloc);
16942 if (MEM_P (varloc))
16944 rtx addr = XEXP (varloc, 0);
16945 descr = mem_loc_descriptor (addr, get_address_mode (varloc),
16946 mode, initialized);
16951 rtx x = avoid_constant_pool_reference (varloc);
16953 descr = mem_loc_descriptor (x, mode, VOIDmode,
16958 descr = mem_loc_descriptor (varloc, mode, VOIDmode, initialized);
16965 if (GET_CODE (varloc) == VAR_LOCATION)
16966 mode = DECL_MODE (PAT_VAR_LOCATION_DECL (varloc));
16968 mode = DECL_MODE (loc);
16969 descr = loc_descriptor (varloc, mode, initialized);
16976 if (want_address == 2 && !have_address
16977 && (dwarf_version >= 4 || !dwarf_strict))
16979 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
16981 expansion_failed (loc, NULL_RTX,
16982 "DWARF address size mismatch");
16985 add_loc_descr (&descr, new_loc_descr (DW_OP_stack_value, 0, 0));
16988 /* Show if we can't fill the request for an address. */
16989 if (want_address && !have_address)
16991 expansion_failed (loc, NULL_RTX,
16992 "Want address and only have value");
16996 /* If we've got an address and don't want one, dereference. */
16997 if (!want_address && have_address)
16999 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
17000 enum dwarf_location_atom op;
17002 if (size > DWARF2_ADDR_SIZE || size == -1)
17004 expansion_failed (loc, NULL_RTX,
17005 "DWARF address size mismatch");
17008 else if (size == DWARF2_ADDR_SIZE)
17011 op = DW_OP_deref_size;
17013 add_loc_descr (&descr, new_loc_descr (op, size, 0));
17019 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
17020 if it is not possible. */
17022 static dw_loc_descr_ref
17023 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize, HOST_WIDE_INT offset)
17025 if ((bitsize % BITS_PER_UNIT) == 0 && offset == 0)
17026 return new_loc_descr (DW_OP_piece, bitsize / BITS_PER_UNIT, 0);
17027 else if (dwarf_version >= 3 || !dwarf_strict)
17028 return new_loc_descr (DW_OP_bit_piece, bitsize, offset);
17033 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
17034 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
17036 static dw_loc_descr_ref
17037 dw_sra_loc_expr (tree decl, rtx loc)
17040 unsigned HOST_WIDE_INT padsize = 0;
17041 dw_loc_descr_ref descr, *descr_tail;
17042 unsigned HOST_WIDE_INT decl_size;
17044 enum var_init_status initialized;
17046 if (DECL_SIZE (decl) == NULL
17047 || !tree_fits_uhwi_p (DECL_SIZE (decl)))
17050 decl_size = tree_to_uhwi (DECL_SIZE (decl));
17052 descr_tail = &descr;
17054 for (p = loc; p; p = XEXP (p, 1))
17056 unsigned HOST_WIDE_INT bitsize = decl_piece_bitsize (p);
17057 rtx loc_note = *decl_piece_varloc_ptr (p);
17058 dw_loc_descr_ref cur_descr;
17059 dw_loc_descr_ref *tail, last = NULL;
17060 unsigned HOST_WIDE_INT opsize = 0;
17062 if (loc_note == NULL_RTX
17063 || NOTE_VAR_LOCATION_LOC (loc_note) == NULL_RTX)
17065 padsize += bitsize;
17068 initialized = NOTE_VAR_LOCATION_STATUS (loc_note);
17069 varloc = NOTE_VAR_LOCATION (loc_note);
17070 cur_descr = dw_loc_list_1 (decl, varloc, 2, initialized);
17071 if (cur_descr == NULL)
17073 padsize += bitsize;
17077 /* Check that cur_descr either doesn't use
17078 DW_OP_*piece operations, or their sum is equal
17079 to bitsize. Otherwise we can't embed it. */
17080 for (tail = &cur_descr; *tail != NULL;
17081 tail = &(*tail)->dw_loc_next)
17082 if ((*tail)->dw_loc_opc == DW_OP_piece)
17084 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned
17088 else if ((*tail)->dw_loc_opc == DW_OP_bit_piece)
17090 opsize += (*tail)->dw_loc_oprnd1.v.val_unsigned;
17094 if (last != NULL && opsize != bitsize)
17096 padsize += bitsize;
17097 /* Discard the current piece of the descriptor and release any
17098 addr_table entries it uses. */
17099 remove_loc_list_addr_table_entries (cur_descr);
17103 /* If there is a hole, add DW_OP_*piece after empty DWARF
17104 expression, which means that those bits are optimized out. */
17107 if (padsize > decl_size)
17109 remove_loc_list_addr_table_entries (cur_descr);
17110 goto discard_descr;
17112 decl_size -= padsize;
17113 *descr_tail = new_loc_descr_op_bit_piece (padsize, 0);
17114 if (*descr_tail == NULL)
17116 remove_loc_list_addr_table_entries (cur_descr);
17117 goto discard_descr;
17119 descr_tail = &(*descr_tail)->dw_loc_next;
17122 *descr_tail = cur_descr;
17124 if (bitsize > decl_size)
17125 goto discard_descr;
17126 decl_size -= bitsize;
17129 HOST_WIDE_INT offset = 0;
17130 if (GET_CODE (varloc) == VAR_LOCATION
17131 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc)) != PARALLEL)
17133 varloc = PAT_VAR_LOCATION_LOC (varloc);
17134 if (GET_CODE (varloc) == EXPR_LIST)
17135 varloc = XEXP (varloc, 0);
17139 if (GET_CODE (varloc) == CONST
17140 || GET_CODE (varloc) == SIGN_EXTEND
17141 || GET_CODE (varloc) == ZERO_EXTEND)
17142 varloc = XEXP (varloc, 0);
17143 else if (GET_CODE (varloc) == SUBREG)
17144 varloc = SUBREG_REG (varloc);
17149 /* DW_OP_bit_size offset should be zero for register
17150 or implicit location descriptions and empty location
17151 descriptions, but for memory addresses needs big endian
17153 if (MEM_P (varloc))
17155 unsigned HOST_WIDE_INT memsize;
17156 if (!poly_uint64 (MEM_SIZE (varloc)).is_constant (&memsize))
17157 goto discard_descr;
17158 memsize *= BITS_PER_UNIT;
17159 if (memsize != bitsize)
17161 if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
17162 && (memsize > BITS_PER_WORD || bitsize > BITS_PER_WORD))
17163 goto discard_descr;
17164 if (memsize < bitsize)
17165 goto discard_descr;
17166 if (BITS_BIG_ENDIAN)
17167 offset = memsize - bitsize;
17171 *descr_tail = new_loc_descr_op_bit_piece (bitsize, offset);
17172 if (*descr_tail == NULL)
17173 goto discard_descr;
17174 descr_tail = &(*descr_tail)->dw_loc_next;
17178 /* If there were any non-empty expressions, add padding till the end of
17180 if (descr != NULL && decl_size != 0)
17182 *descr_tail = new_loc_descr_op_bit_piece (decl_size, 0);
17183 if (*descr_tail == NULL)
17184 goto discard_descr;
17189 /* Discard the descriptor and release any addr_table entries it uses. */
17190 remove_loc_list_addr_table_entries (descr);
17194 /* Return the dwarf representation of the location list LOC_LIST of
17195 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
17198 static dw_loc_list_ref
17199 dw_loc_list (var_loc_list *loc_list, tree decl, int want_address)
17201 const char *endname, *secname;
17202 var_loc_view endview;
17204 enum var_init_status initialized;
17205 struct var_loc_node *node;
17206 dw_loc_descr_ref descr;
17207 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
17208 dw_loc_list_ref list = NULL;
17209 dw_loc_list_ref *listp = &list;
17211 /* Now that we know what section we are using for a base,
17212 actually construct the list of locations.
17213 The first location information is what is passed to the
17214 function that creates the location list, and the remaining
17215 locations just get added on to that list.
17216 Note that we only know the start address for a location
17217 (IE location changes), so to build the range, we use
17218 the range [current location start, next location start].
17219 This means we have to special case the last node, and generate
17220 a range of [last location start, end of function label]. */
17222 if (cfun && crtl->has_bb_partition)
17224 bool save_in_cold_section_p = in_cold_section_p;
17225 in_cold_section_p = first_function_block_is_cold;
17226 if (loc_list->last_before_switch == NULL)
17227 in_cold_section_p = !in_cold_section_p;
17228 secname = secname_for_decl (decl);
17229 in_cold_section_p = save_in_cold_section_p;
17232 secname = secname_for_decl (decl);
17234 for (node = loc_list->first; node; node = node->next)
17236 bool range_across_switch = false;
17237 if (GET_CODE (node->loc) == EXPR_LIST
17238 || NOTE_VAR_LOCATION_LOC (node->loc) != NULL_RTX)
17240 if (GET_CODE (node->loc) == EXPR_LIST)
17243 /* This requires DW_OP_{,bit_}piece, which is not usable
17244 inside DWARF expressions. */
17245 if (want_address == 2)
17246 descr = dw_sra_loc_expr (decl, node->loc);
17250 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
17251 varloc = NOTE_VAR_LOCATION (node->loc);
17252 descr = dw_loc_list_1 (decl, varloc, want_address, initialized);
17256 /* If section switch happens in between node->label
17257 and node->next->label (or end of function) and
17258 we can't emit it as a single entry list,
17259 emit two ranges, first one ending at the end
17260 of first partition and second one starting at the
17261 beginning of second partition. */
17262 if (node == loc_list->last_before_switch
17263 && (node != loc_list->first || loc_list->first->next
17264 /* If we are to emit a view number, we will emit
17265 a loclist rather than a single location
17266 expression for the entire function (see
17267 loc_list_has_views), so we have to split the
17268 range that straddles across partitions. */
17269 || !ZERO_VIEW_P (node->view))
17270 && current_function_decl)
17272 endname = cfun->fde->dw_fde_end;
17274 range_across_switch = true;
17276 /* The variable has a location between NODE->LABEL and
17277 NODE->NEXT->LABEL. */
17278 else if (node->next)
17279 endname = node->next->label, endview = node->next->view;
17280 /* If the variable has a location at the last label
17281 it keeps its location until the end of function. */
17282 else if (!current_function_decl)
17283 endname = text_end_label, endview = 0;
17286 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
17287 current_function_funcdef_no);
17288 endname = ggc_strdup (label_id);
17292 *listp = new_loc_list (descr, node->label, node->view,
17293 endname, endview, secname);
17294 if (TREE_CODE (decl) == PARM_DECL
17295 && node == loc_list->first
17296 && NOTE_P (node->loc)
17297 && strcmp (node->label, endname) == 0)
17298 (*listp)->force = true;
17299 listp = &(*listp)->dw_loc_next;
17304 && crtl->has_bb_partition
17305 && node == loc_list->last_before_switch)
17307 bool save_in_cold_section_p = in_cold_section_p;
17308 in_cold_section_p = !first_function_block_is_cold;
17309 secname = secname_for_decl (decl);
17310 in_cold_section_p = save_in_cold_section_p;
17313 if (range_across_switch)
17315 if (GET_CODE (node->loc) == EXPR_LIST)
17316 descr = dw_sra_loc_expr (decl, node->loc);
17319 initialized = NOTE_VAR_LOCATION_STATUS (node->loc);
17320 varloc = NOTE_VAR_LOCATION (node->loc);
17321 descr = dw_loc_list_1 (decl, varloc, want_address,
17324 gcc_assert (descr);
17325 /* The variable has a location between NODE->LABEL and
17326 NODE->NEXT->LABEL. */
17328 endname = node->next->label, endview = node->next->view;
17330 endname = cfun->fde->dw_fde_second_end, endview = 0;
17331 *listp = new_loc_list (descr, cfun->fde->dw_fde_second_begin, 0,
17332 endname, endview, secname);
17333 listp = &(*listp)->dw_loc_next;
17337 /* Try to avoid the overhead of a location list emitting a location
17338 expression instead, but only if we didn't have more than one
17339 location entry in the first place. If some entries were not
17340 representable, we don't want to pretend a single entry that was
17341 applies to the entire scope in which the variable is
17343 if (list && loc_list->first->next)
17346 maybe_gen_llsym (list);
17351 /* Return if the loc_list has only single element and thus can be represented
17352 as location description. */
17355 single_element_loc_list_p (dw_loc_list_ref list)
17357 gcc_assert (!list->dw_loc_next || list->ll_symbol);
17358 return !list->ll_symbol;
17361 /* Duplicate a single element of location list. */
17363 static inline dw_loc_descr_ref
17364 copy_loc_descr (dw_loc_descr_ref ref)
17366 dw_loc_descr_ref copy = ggc_alloc<dw_loc_descr_node> ();
17367 memcpy (copy, ref, sizeof (dw_loc_descr_node));
17371 /* To each location in list LIST append loc descr REF. */
17374 add_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref)
17376 dw_loc_descr_ref copy;
17377 add_loc_descr (&list->expr, ref);
17378 list = list->dw_loc_next;
17381 copy = copy_loc_descr (ref);
17382 add_loc_descr (&list->expr, copy);
17383 while (copy->dw_loc_next)
17384 copy = copy->dw_loc_next = copy_loc_descr (copy->dw_loc_next);
17385 list = list->dw_loc_next;
17389 /* To each location in list LIST prepend loc descr REF. */
17392 prepend_loc_descr_to_each (dw_loc_list_ref list, dw_loc_descr_ref ref)
17394 dw_loc_descr_ref copy;
17395 dw_loc_descr_ref ref_end = list->expr;
17396 add_loc_descr (&ref, list->expr);
17398 list = list->dw_loc_next;
17401 dw_loc_descr_ref end = list->expr;
17402 list->expr = copy = copy_loc_descr (ref);
17403 while (copy->dw_loc_next != ref_end)
17404 copy = copy->dw_loc_next = copy_loc_descr (copy->dw_loc_next);
17405 copy->dw_loc_next = end;
17406 list = list->dw_loc_next;
17410 /* Given two lists RET and LIST
17411 produce location list that is result of adding expression in LIST
17412 to expression in RET on each position in program.
17413 Might be destructive on both RET and LIST.
17415 TODO: We handle only simple cases of RET or LIST having at most one
17416 element. General case would involve sorting the lists in program order
17417 and merging them that will need some additional work.
17418 Adding that will improve quality of debug info especially for SRA-ed
17422 add_loc_list (dw_loc_list_ref *ret, dw_loc_list_ref list)
17431 if (!list->dw_loc_next)
17433 add_loc_descr_to_each (*ret, list->expr);
17436 if (!(*ret)->dw_loc_next)
17438 prepend_loc_descr_to_each (list, (*ret)->expr);
17442 expansion_failed (NULL_TREE, NULL_RTX,
17443 "Don't know how to merge two non-trivial"
17444 " location lists.\n");
17449 /* LOC is constant expression. Try a luck, look it up in constant
17450 pool and return its loc_descr of its address. */
17452 static dw_loc_descr_ref
17453 cst_pool_loc_descr (tree loc)
17455 /* Get an RTL for this, if something has been emitted. */
17456 rtx rtl = lookup_constant_def (loc);
17458 if (!rtl || !MEM_P (rtl))
17463 gcc_assert (GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF);
17465 /* TODO: We might get more coverage if we was actually delaying expansion
17466 of all expressions till end of compilation when constant pools are fully
17468 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl, 0))))
17470 expansion_failed (loc, NULL_RTX,
17471 "CST value in contant pool but not marked.");
17474 return mem_loc_descriptor (XEXP (rtl, 0), get_address_mode (rtl),
17475 GET_MODE (rtl), VAR_INIT_STATUS_INITIALIZED);
17478 /* Return dw_loc_list representing address of addr_expr LOC
17479 by looking for inner INDIRECT_REF expression and turning
17480 it into simple arithmetics.
17482 See loc_list_from_tree for the meaning of CONTEXT. */
17484 static dw_loc_list_ref
17485 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc, bool toplev,
17486 loc_descr_context *context)
17489 poly_int64 bitsize, bitpos, bytepos;
17491 int unsignedp, reversep, volatilep = 0;
17492 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
17494 obj = get_inner_reference (TREE_OPERAND (loc, 0),
17495 &bitsize, &bitpos, &offset, &mode,
17496 &unsignedp, &reversep, &volatilep);
17498 if (!multiple_p (bitpos, BITS_PER_UNIT, &bytepos))
17500 expansion_failed (loc, NULL_RTX, "bitfield access");
17503 if (!INDIRECT_REF_P (obj))
17505 expansion_failed (obj,
17506 NULL_RTX, "no indirect ref in inner refrence");
17509 if (!offset && known_eq (bitpos, 0))
17510 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), toplev ? 2 : 1,
17513 && int_size_in_bytes (TREE_TYPE (loc)) <= DWARF2_ADDR_SIZE
17514 && (dwarf_version >= 4 || !dwarf_strict))
17516 list_ret = loc_list_from_tree (TREE_OPERAND (obj, 0), 0, context);
17521 /* Variable offset. */
17522 list_ret1 = loc_list_from_tree (offset, 0, context);
17523 if (list_ret1 == 0)
17525 add_loc_list (&list_ret, list_ret1);
17528 add_loc_descr_to_each (list_ret,
17529 new_loc_descr (DW_OP_plus, 0, 0));
17531 HOST_WIDE_INT value;
17532 if (bytepos.is_constant (&value) && value > 0)
17533 add_loc_descr_to_each (list_ret,
17534 new_loc_descr (DW_OP_plus_uconst, value, 0));
17535 else if (maybe_ne (bytepos, 0))
17536 loc_list_plus_const (list_ret, bytepos);
17537 add_loc_descr_to_each (list_ret,
17538 new_loc_descr (DW_OP_stack_value, 0, 0));
17543 /* Set LOC to the next operation that is not a DW_OP_nop operation. In the case
17544 all operations from LOC are nops, move to the last one. Insert in NOPS all
17545 operations that are skipped. */
17548 loc_descr_to_next_no_nop (dw_loc_descr_ref &loc,
17549 hash_set<dw_loc_descr_ref> &nops)
17551 while (loc->dw_loc_next != NULL && loc->dw_loc_opc == DW_OP_nop)
17554 loc = loc->dw_loc_next;
17558 /* Helper for loc_descr_without_nops: free the location description operation
17562 free_loc_descr (const dw_loc_descr_ref &loc, void *data ATTRIBUTE_UNUSED)
17568 /* Remove all DW_OP_nop operations from LOC except, if it exists, the one that
17572 loc_descr_without_nops (dw_loc_descr_ref &loc)
17574 if (loc->dw_loc_opc == DW_OP_nop && loc->dw_loc_next == NULL)
17577 /* Set of all DW_OP_nop operations we remove. */
17578 hash_set<dw_loc_descr_ref> nops;
17580 /* First, strip all prefix NOP operations in order to keep the head of the
17581 operations list. */
17582 loc_descr_to_next_no_nop (loc, nops);
17584 for (dw_loc_descr_ref cur = loc; cur != NULL;)
17586 /* For control flow operations: strip "prefix" nops in destination
17588 if (cur->dw_loc_oprnd1.val_class == dw_val_class_loc)
17589 loc_descr_to_next_no_nop (cur->dw_loc_oprnd1.v.val_loc, nops);
17590 if (cur->dw_loc_oprnd2.val_class == dw_val_class_loc)
17591 loc_descr_to_next_no_nop (cur->dw_loc_oprnd2.v.val_loc, nops);
17593 /* Do the same for the operations that follow, then move to the next
17595 if (cur->dw_loc_next != NULL)
17596 loc_descr_to_next_no_nop (cur->dw_loc_next, nops);
17597 cur = cur->dw_loc_next;
17600 nops.traverse<void *, free_loc_descr> (NULL);
17604 struct dwarf_procedure_info;
17606 /* Helper structure for location descriptions generation. */
17607 struct loc_descr_context
17609 /* The type that is implicitly referenced by DW_OP_push_object_address, or
17610 NULL_TREE if DW_OP_push_object_address in invalid for this location
17611 description. This is used when processing PLACEHOLDER_EXPR nodes. */
17613 /* The ..._DECL node that should be translated as a
17614 DW_OP_push_object_address operation. */
17616 /* Information about the DWARF procedure we are currently generating. NULL if
17617 we are not generating a DWARF procedure. */
17618 struct dwarf_procedure_info *dpi;
17619 /* True if integral PLACEHOLDER_EXPR stands for the first argument passed
17620 by consumer. Used for DW_TAG_generic_subrange attributes. */
17621 bool placeholder_arg;
17622 /* True if PLACEHOLDER_EXPR has been seen. */
17623 bool placeholder_seen;
17626 /* DWARF procedures generation
17628 DWARF expressions (aka. location descriptions) are used to encode variable
17629 things such as sizes or offsets. Such computations can have redundant parts
17630 that can be factorized in order to reduce the size of the output debug
17631 information. This is the whole point of DWARF procedures.
17633 Thanks to stor-layout.c, size and offset expressions in GENERIC trees are
17634 already factorized into functions ("size functions") in order to handle very
17635 big and complex types. Such functions are quite simple: they have integral
17636 arguments, they return an integral result and their body contains only a
17637 return statement with arithmetic expressions. This is the only kind of
17638 function we are interested in translating into DWARF procedures, here.
17640 DWARF expressions and DWARF procedure are executed using a stack, so we have
17641 to define some calling convention for them to interact. Let's say that:
17643 - Before calling a DWARF procedure, DWARF expressions must push on the stack
17644 all arguments in reverse order (right-to-left) so that when the DWARF
17645 procedure execution starts, the first argument is the top of the stack.
17647 - Then, when returning, the DWARF procedure must have consumed all arguments
17648 on the stack, must have pushed the result and touched nothing else.
17650 - Each integral argument and the result are integral types can be hold in a
17653 - We call "frame offset" the number of stack slots that are "under DWARF
17654 procedure control": it includes the arguments slots, the temporaries and
17655 the result slot. Thus, it is equal to the number of arguments when the
17656 procedure execution starts and must be equal to one (the result) when it
17659 /* Helper structure used when generating operations for a DWARF procedure. */
17660 struct dwarf_procedure_info
17662 /* The FUNCTION_DECL node corresponding to the DWARF procedure that is
17663 currently translated. */
17665 /* The number of arguments FNDECL takes. */
17666 unsigned args_count;
17669 /* Return a pointer to a newly created DIE node for a DWARF procedure. Add
17670 LOCATION as its DW_AT_location attribute. If FNDECL is not NULL_TREE,
17671 equate it to this DIE. */
17674 new_dwarf_proc_die (dw_loc_descr_ref location, tree fndecl,
17675 dw_die_ref parent_die)
17677 dw_die_ref dwarf_proc_die;
17679 if ((dwarf_version < 3 && dwarf_strict)
17680 || location == NULL)
17683 dwarf_proc_die = new_die (DW_TAG_dwarf_procedure, parent_die, fndecl);
17685 equate_decl_number_to_die (fndecl, dwarf_proc_die);
17686 add_AT_loc (dwarf_proc_die, DW_AT_location, location);
17687 return dwarf_proc_die;
17690 /* Return whether TYPE is a supported type as a DWARF procedure argument
17691 type or return type (we handle only scalar types and pointer types that
17692 aren't wider than the DWARF expression evaluation stack. */
17695 is_handled_procedure_type (tree type)
17697 return ((INTEGRAL_TYPE_P (type)
17698 || TREE_CODE (type) == OFFSET_TYPE
17699 || TREE_CODE (type) == POINTER_TYPE)
17700 && int_size_in_bytes (type) <= DWARF2_ADDR_SIZE);
17703 /* Helper for resolve_args_picking: do the same but stop when coming across
17704 visited nodes. For each node we visit, register in FRAME_OFFSETS the frame
17705 offset *before* evaluating the corresponding operation. */
17708 resolve_args_picking_1 (dw_loc_descr_ref loc, unsigned initial_frame_offset,
17709 struct dwarf_procedure_info *dpi,
17710 hash_map<dw_loc_descr_ref, unsigned> &frame_offsets)
17712 /* The "frame_offset" identifier is already used to name a macro... */
17713 unsigned frame_offset_ = initial_frame_offset;
17714 dw_loc_descr_ref l;
17716 for (l = loc; l != NULL;)
17719 unsigned &l_frame_offset = frame_offsets.get_or_insert (l, &existed);
17721 /* If we already met this node, there is nothing to compute anymore. */
17724 /* Make sure that the stack size is consistent wherever the execution
17725 flow comes from. */
17726 gcc_assert ((unsigned) l_frame_offset == frame_offset_);
17729 l_frame_offset = frame_offset_;
17731 /* If needed, relocate the picking offset with respect to the frame
17733 if (l->frame_offset_rel)
17735 unsigned HOST_WIDE_INT off;
17736 switch (l->dw_loc_opc)
17739 off = l->dw_loc_oprnd1.v.val_unsigned;
17748 gcc_unreachable ();
17750 /* frame_offset_ is the size of the current stack frame, including
17751 incoming arguments. Besides, the arguments are pushed
17752 right-to-left. Thus, in order to access the Nth argument from
17753 this operation node, the picking has to skip temporaries *plus*
17754 one stack slot per argument (0 for the first one, 1 for the second
17757 The targetted argument number (N) is already set as the operand,
17758 and the number of temporaries can be computed with:
17759 frame_offsets_ - dpi->args_count */
17760 off += frame_offset_ - dpi->args_count;
17762 /* DW_OP_pick handles only offsets from 0 to 255 (inclusive)... */
17768 l->dw_loc_opc = DW_OP_dup;
17769 l->dw_loc_oprnd1.v.val_unsigned = 0;
17773 l->dw_loc_opc = DW_OP_over;
17774 l->dw_loc_oprnd1.v.val_unsigned = 0;
17778 l->dw_loc_opc = DW_OP_pick;
17779 l->dw_loc_oprnd1.v.val_unsigned = off;
17783 /* Update frame_offset according to the effect the current operation has
17785 switch (l->dw_loc_opc)
17793 case DW_OP_plus_uconst:
17829 case DW_OP_deref_size:
17831 case DW_OP_bit_piece:
17832 case DW_OP_implicit_value:
17833 case DW_OP_stack_value:
17837 case DW_OP_const1u:
17838 case DW_OP_const1s:
17839 case DW_OP_const2u:
17840 case DW_OP_const2s:
17841 case DW_OP_const4u:
17842 case DW_OP_const4s:
17843 case DW_OP_const8u:
17844 case DW_OP_const8s:
17915 case DW_OP_push_object_address:
17916 case DW_OP_call_frame_cfa:
17917 case DW_OP_GNU_variable_value:
17918 case DW_OP_GNU_addr_index:
17919 case DW_OP_GNU_const_index:
17944 case DW_OP_xderef_size:
17950 case DW_OP_call_ref:
17952 dw_die_ref dwarf_proc = l->dw_loc_oprnd1.v.val_die_ref.die;
17953 int *stack_usage = dwarf_proc_stack_usage_map->get (dwarf_proc);
17955 if (stack_usage == NULL)
17957 frame_offset_ += *stack_usage;
17961 case DW_OP_implicit_pointer:
17962 case DW_OP_entry_value:
17963 case DW_OP_const_type:
17964 case DW_OP_regval_type:
17965 case DW_OP_deref_type:
17966 case DW_OP_convert:
17967 case DW_OP_reinterpret:
17968 case DW_OP_form_tls_address:
17969 case DW_OP_GNU_push_tls_address:
17970 case DW_OP_GNU_uninit:
17971 case DW_OP_GNU_encoded_addr:
17972 case DW_OP_GNU_implicit_pointer:
17973 case DW_OP_GNU_entry_value:
17974 case DW_OP_GNU_const_type:
17975 case DW_OP_GNU_regval_type:
17976 case DW_OP_GNU_deref_type:
17977 case DW_OP_GNU_convert:
17978 case DW_OP_GNU_reinterpret:
17979 case DW_OP_GNU_parameter_ref:
17980 /* loc_list_from_tree will probably not output these operations for
17981 size functions, so assume they will not appear here. */
17982 /* Fall through... */
17985 gcc_unreachable ();
17988 /* Now, follow the control flow (except subroutine calls). */
17989 switch (l->dw_loc_opc)
17992 if (!resolve_args_picking_1 (l->dw_loc_next, frame_offset_, dpi,
17995 /* Fall through. */
17998 l = l->dw_loc_oprnd1.v.val_loc;
18001 case DW_OP_stack_value:
18005 l = l->dw_loc_next;
18013 /* Make a DFS over operations reachable through LOC (i.e. follow branch
18014 operations) in order to resolve the operand of DW_OP_pick operations that
18015 target DWARF procedure arguments (DPI). INITIAL_FRAME_OFFSET is the frame
18016 offset *before* LOC is executed. Return if all relocations were
18020 resolve_args_picking (dw_loc_descr_ref loc, unsigned initial_frame_offset,
18021 struct dwarf_procedure_info *dpi)
18023 /* Associate to all visited operations the frame offset *before* evaluating
18025 hash_map<dw_loc_descr_ref, unsigned> frame_offsets;
18027 return resolve_args_picking_1 (loc, initial_frame_offset, dpi,
18031 /* Try to generate a DWARF procedure that computes the same result as FNDECL.
18032 Return NULL if it is not possible. */
18035 function_to_dwarf_procedure (tree fndecl)
18037 struct loc_descr_context ctx;
18038 struct dwarf_procedure_info dpi;
18039 dw_die_ref dwarf_proc_die;
18040 tree tree_body = DECL_SAVED_TREE (fndecl);
18041 dw_loc_descr_ref loc_body, epilogue;
18046 /* Do not generate multiple DWARF procedures for the same function
18048 dwarf_proc_die = lookup_decl_die (fndecl);
18049 if (dwarf_proc_die != NULL)
18050 return dwarf_proc_die;
18052 /* DWARF procedures are available starting with the DWARFv3 standard. */
18053 if (dwarf_version < 3 && dwarf_strict)
18056 /* We handle only functions for which we still have a body, that return a
18057 supported type and that takes arguments with supported types. Note that
18058 there is no point translating functions that return nothing. */
18059 if (tree_body == NULL_TREE
18060 || DECL_RESULT (fndecl) == NULL_TREE
18061 || !is_handled_procedure_type (TREE_TYPE (DECL_RESULT (fndecl))))
18064 for (cursor = DECL_ARGUMENTS (fndecl);
18065 cursor != NULL_TREE;
18066 cursor = TREE_CHAIN (cursor))
18067 if (!is_handled_procedure_type (TREE_TYPE (cursor)))
18070 /* Match only "expr" in: RETURN_EXPR (MODIFY_EXPR (RESULT_DECL, expr)). */
18071 if (TREE_CODE (tree_body) != RETURN_EXPR)
18073 tree_body = TREE_OPERAND (tree_body, 0);
18074 if (TREE_CODE (tree_body) != MODIFY_EXPR
18075 || TREE_OPERAND (tree_body, 0) != DECL_RESULT (fndecl))
18077 tree_body = TREE_OPERAND (tree_body, 1);
18079 /* Try to translate the body expression itself. Note that this will probably
18080 cause an infinite recursion if its call graph has a cycle. This is very
18081 unlikely for size functions, however, so don't bother with such things at
18083 ctx.context_type = NULL_TREE;
18084 ctx.base_decl = NULL_TREE;
18086 ctx.placeholder_arg = false;
18087 ctx.placeholder_seen = false;
18088 dpi.fndecl = fndecl;
18089 dpi.args_count = list_length (DECL_ARGUMENTS (fndecl));
18090 loc_body = loc_descriptor_from_tree (tree_body, 0, &ctx);
18094 /* After evaluating all operands in "loc_body", we should still have on the
18095 stack all arguments plus the desired function result (top of the stack).
18096 Generate code in order to keep only the result in our stack frame. */
18098 for (i = 0; i < dpi.args_count; ++i)
18100 dw_loc_descr_ref op_couple = new_loc_descr (DW_OP_swap, 0, 0);
18101 op_couple->dw_loc_next = new_loc_descr (DW_OP_drop, 0, 0);
18102 op_couple->dw_loc_next->dw_loc_next = epilogue;
18103 epilogue = op_couple;
18105 add_loc_descr (&loc_body, epilogue);
18106 if (!resolve_args_picking (loc_body, dpi.args_count, &dpi))
18109 /* Trailing nops from loc_descriptor_from_tree (if any) cannot be removed
18110 because they are considered useful. Now there is an epilogue, they are
18111 not anymore, so give it another try. */
18112 loc_descr_without_nops (loc_body);
18114 /* fndecl may be used both as a regular DW_TAG_subprogram DIE and as
18115 a DW_TAG_dwarf_procedure, so we may have a conflict, here. It's unlikely,
18116 though, given that size functions do not come from source, so they should
18117 not have a dedicated DW_TAG_subprogram DIE. */
18119 = new_dwarf_proc_die (loc_body, fndecl,
18120 get_context_die (DECL_CONTEXT (fndecl)));
18122 /* The called DWARF procedure consumes one stack slot per argument and
18123 returns one stack slot. */
18124 dwarf_proc_stack_usage_map->put (dwarf_proc_die, 1 - dpi.args_count);
18126 return dwarf_proc_die;
18130 /* Generate Dwarf location list representing LOC.
18131 If WANT_ADDRESS is false, expression computing LOC will be computed
18132 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
18133 if WANT_ADDRESS is 2, expression computing address useable in location
18134 will be returned (i.e. DW_OP_reg can be used
18135 to refer to register values).
18137 CONTEXT provides information to customize the location descriptions
18138 generation. Its context_type field specifies what type is implicitly
18139 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
18140 will not be generated.
18142 Its DPI field determines whether we are generating a DWARF expression for a
18143 DWARF procedure, so PARM_DECL references are processed specifically.
18145 If CONTEXT is NULL, the behavior is the same as if context_type, base_decl
18146 and dpi fields were null. */
18148 static dw_loc_list_ref
18149 loc_list_from_tree_1 (tree loc, int want_address,
18150 struct loc_descr_context *context)
18152 dw_loc_descr_ref ret = NULL, ret1 = NULL;
18153 dw_loc_list_ref list_ret = NULL, list_ret1 = NULL;
18154 int have_address = 0;
18155 enum dwarf_location_atom op;
18157 /* ??? Most of the time we do not take proper care for sign/zero
18158 extending the values properly. Hopefully this won't be a real
18161 if (context != NULL
18162 && context->base_decl == loc
18163 && want_address == 0)
18165 if (dwarf_version >= 3 || !dwarf_strict)
18166 return new_loc_list (new_loc_descr (DW_OP_push_object_address, 0, 0),
18167 NULL, 0, NULL, 0, NULL);
18172 switch (TREE_CODE (loc))
18175 expansion_failed (loc, NULL_RTX, "ERROR_MARK");
18178 case PLACEHOLDER_EXPR:
18179 /* This case involves extracting fields from an object to determine the
18180 position of other fields. It is supposed to appear only as the first
18181 operand of COMPONENT_REF nodes and to reference precisely the type
18182 that the context allows. */
18183 if (context != NULL
18184 && TREE_TYPE (loc) == context->context_type
18185 && want_address >= 1)
18187 if (dwarf_version >= 3 || !dwarf_strict)
18189 ret = new_loc_descr (DW_OP_push_object_address, 0, 0);
18196 /* For DW_TAG_generic_subrange attributes, PLACEHOLDER_EXPR stands for
18197 the single argument passed by consumer. */
18198 else if (context != NULL
18199 && context->placeholder_arg
18200 && INTEGRAL_TYPE_P (TREE_TYPE (loc))
18201 && want_address == 0)
18203 ret = new_loc_descr (DW_OP_pick, 0, 0);
18204 ret->frame_offset_rel = 1;
18205 context->placeholder_seen = true;
18209 expansion_failed (loc, NULL_RTX,
18210 "PLACEHOLDER_EXPR for an unexpected type");
18215 const int nargs = call_expr_nargs (loc);
18216 tree callee = get_callee_fndecl (loc);
18218 dw_die_ref dwarf_proc;
18220 if (callee == NULL_TREE)
18221 goto call_expansion_failed;
18223 /* We handle only functions that return an integer. */
18224 if (!is_handled_procedure_type (TREE_TYPE (TREE_TYPE (callee))))
18225 goto call_expansion_failed;
18227 dwarf_proc = function_to_dwarf_procedure (callee);
18228 if (dwarf_proc == NULL)
18229 goto call_expansion_failed;
18231 /* Evaluate arguments right-to-left so that the first argument will
18232 be the top-most one on the stack. */
18233 for (i = nargs - 1; i >= 0; --i)
18235 dw_loc_descr_ref loc_descr
18236 = loc_descriptor_from_tree (CALL_EXPR_ARG (loc, i), 0,
18239 if (loc_descr == NULL)
18240 goto call_expansion_failed;
18242 add_loc_descr (&ret, loc_descr);
18245 ret1 = new_loc_descr (DW_OP_call4, 0, 0);
18246 ret1->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
18247 ret1->dw_loc_oprnd1.v.val_die_ref.die = dwarf_proc;
18248 ret1->dw_loc_oprnd1.v.val_die_ref.external = 0;
18249 add_loc_descr (&ret, ret1);
18252 call_expansion_failed:
18253 expansion_failed (loc, NULL_RTX, "CALL_EXPR");
18254 /* There are no opcodes for these operations. */
18258 case PREINCREMENT_EXPR:
18259 case PREDECREMENT_EXPR:
18260 case POSTINCREMENT_EXPR:
18261 case POSTDECREMENT_EXPR:
18262 expansion_failed (loc, NULL_RTX, "PRE/POST INDCREMENT/DECREMENT");
18263 /* There are no opcodes for these operations. */
18267 /* If we already want an address, see if there is INDIRECT_REF inside
18268 e.g. for &this->field. */
18271 list_ret = loc_list_for_address_of_addr_expr_of_indirect_ref
18272 (loc, want_address == 2, context);
18275 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc, 0))
18276 && (ret = cst_pool_loc_descr (loc)))
18279 /* Otherwise, process the argument and look for the address. */
18280 if (!list_ret && !ret)
18281 list_ret = loc_list_from_tree_1 (TREE_OPERAND (loc, 0), 1, context);
18285 expansion_failed (loc, NULL_RTX, "need address of ADDR_EXPR");
18291 if (DECL_THREAD_LOCAL_P (loc))
18294 enum dwarf_location_atom tls_op;
18295 enum dtprel_bool dtprel = dtprel_false;
18297 if (targetm.have_tls)
18299 /* If this is not defined, we have no way to emit the
18301 if (!targetm.asm_out.output_dwarf_dtprel)
18304 /* The way DW_OP_GNU_push_tls_address is specified, we
18305 can only look up addresses of objects in the current
18306 module. We used DW_OP_addr as first op, but that's
18307 wrong, because DW_OP_addr is relocated by the debug
18308 info consumer, while DW_OP_GNU_push_tls_address
18309 operand shouldn't be. */
18310 if (DECL_EXTERNAL (loc) && !targetm.binds_local_p (loc))
18312 dtprel = dtprel_true;
18313 /* We check for DWARF 5 here because gdb did not implement
18314 DW_OP_form_tls_address until after 7.12. */
18315 tls_op = (dwarf_version >= 5 ? DW_OP_form_tls_address
18316 : DW_OP_GNU_push_tls_address);
18320 if (!targetm.emutls.debug_form_tls_address
18321 || !(dwarf_version >= 3 || !dwarf_strict))
18323 /* We stuffed the control variable into the DECL_VALUE_EXPR
18324 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
18325 no longer appear in gimple code. We used the control
18326 variable in specific so that we could pick it up here. */
18327 loc = DECL_VALUE_EXPR (loc);
18328 tls_op = DW_OP_form_tls_address;
18331 rtl = rtl_for_decl_location (loc);
18332 if (rtl == NULL_RTX)
18337 rtl = XEXP (rtl, 0);
18338 if (! CONSTANT_P (rtl))
18341 ret = new_addr_loc_descr (rtl, dtprel);
18342 ret1 = new_loc_descr (tls_op, 0, 0);
18343 add_loc_descr (&ret, ret1);
18351 if (context != NULL && context->dpi != NULL
18352 && DECL_CONTEXT (loc) == context->dpi->fndecl)
18354 /* We are generating code for a DWARF procedure and we want to access
18355 one of its arguments: find the appropriate argument offset and let
18356 the resolve_args_picking pass compute the offset that complies
18357 with the stack frame size. */
18361 for (cursor = DECL_ARGUMENTS (context->dpi->fndecl);
18362 cursor != NULL_TREE && cursor != loc;
18363 cursor = TREE_CHAIN (cursor), ++i)
18365 /* If we are translating a DWARF procedure, all referenced parameters
18366 must belong to the current function. */
18367 gcc_assert (cursor != NULL_TREE);
18369 ret = new_loc_descr (DW_OP_pick, i, 0);
18370 ret->frame_offset_rel = 1;
18376 if (DECL_HAS_VALUE_EXPR_P (loc))
18377 return loc_list_from_tree_1 (DECL_VALUE_EXPR (loc),
18378 want_address, context);
18381 case FUNCTION_DECL:
18384 var_loc_list *loc_list = lookup_decl_loc (loc);
18386 if (loc_list && loc_list->first)
18388 list_ret = dw_loc_list (loc_list, loc, want_address);
18389 have_address = want_address != 0;
18392 rtl = rtl_for_decl_location (loc);
18393 if (rtl == NULL_RTX)
18395 if (TREE_CODE (loc) != FUNCTION_DECL
18397 && current_function_decl
18398 && want_address != 1
18399 && ! DECL_IGNORED_P (loc)
18400 && (INTEGRAL_TYPE_P (TREE_TYPE (loc))
18401 || POINTER_TYPE_P (TREE_TYPE (loc)))
18402 && DECL_CONTEXT (loc) == current_function_decl
18403 && (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (loc)))
18404 <= DWARF2_ADDR_SIZE))
18406 dw_die_ref ref = lookup_decl_die (loc);
18407 ret = new_loc_descr (DW_OP_GNU_variable_value, 0, 0);
18410 ret->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
18411 ret->dw_loc_oprnd1.v.val_die_ref.die = ref;
18412 ret->dw_loc_oprnd1.v.val_die_ref.external = 0;
18416 ret->dw_loc_oprnd1.val_class = dw_val_class_decl_ref;
18417 ret->dw_loc_oprnd1.v.val_decl_ref = loc;
18421 expansion_failed (loc, NULL_RTX, "DECL has no RTL");
18424 else if (CONST_INT_P (rtl))
18426 HOST_WIDE_INT val = INTVAL (rtl);
18427 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
18428 val &= GET_MODE_MASK (DECL_MODE (loc));
18429 ret = int_loc_descriptor (val);
18431 else if (GET_CODE (rtl) == CONST_STRING)
18433 expansion_failed (loc, NULL_RTX, "CONST_STRING");
18436 else if (CONSTANT_P (rtl) && const_ok_for_output (rtl))
18437 ret = new_addr_loc_descr (rtl, dtprel_false);
18440 machine_mode mode, mem_mode;
18442 /* Certain constructs can only be represented at top-level. */
18443 if (want_address == 2)
18445 ret = loc_descriptor (rtl, VOIDmode,
18446 VAR_INIT_STATUS_INITIALIZED);
18451 mode = GET_MODE (rtl);
18452 mem_mode = VOIDmode;
18456 mode = get_address_mode (rtl);
18457 rtl = XEXP (rtl, 0);
18460 ret = mem_loc_descriptor (rtl, mode, mem_mode,
18461 VAR_INIT_STATUS_INITIALIZED);
18464 expansion_failed (loc, rtl,
18465 "failed to produce loc descriptor for rtl");
18471 if (!integer_zerop (TREE_OPERAND (loc, 1)))
18478 list_ret = loc_list_from_tree_1 (TREE_OPERAND (loc, 0), 0, context);
18482 case TARGET_MEM_REF:
18484 case DEBUG_EXPR_DECL:
18487 case COMPOUND_EXPR:
18488 return loc_list_from_tree_1 (TREE_OPERAND (loc, 1), want_address,
18492 case VIEW_CONVERT_EXPR:
18495 case NON_LVALUE_EXPR:
18496 return loc_list_from_tree_1 (TREE_OPERAND (loc, 0), want_address,
18499 case COMPONENT_REF:
18500 case BIT_FIELD_REF:
18502 case ARRAY_RANGE_REF:
18503 case REALPART_EXPR:
18504 case IMAGPART_EXPR:
18507 poly_int64 bitsize, bitpos, bytepos;
18509 int unsignedp, reversep, volatilep = 0;
18511 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
18512 &unsignedp, &reversep, &volatilep);
18514 gcc_assert (obj != loc);
18516 list_ret = loc_list_from_tree_1 (obj,
18518 && known_eq (bitpos, 0)
18519 && !offset ? 2 : 1,
18521 /* TODO: We can extract value of the small expression via shifting even
18522 for nonzero bitpos. */
18525 if (!multiple_p (bitpos, BITS_PER_UNIT, &bytepos)
18526 || !multiple_p (bitsize, BITS_PER_UNIT))
18528 expansion_failed (loc, NULL_RTX,
18529 "bitfield access");
18533 if (offset != NULL_TREE)
18535 /* Variable offset. */
18536 list_ret1 = loc_list_from_tree_1 (offset, 0, context);
18537 if (list_ret1 == 0)
18539 add_loc_list (&list_ret, list_ret1);
18542 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus, 0, 0));
18545 HOST_WIDE_INT value;
18546 if (bytepos.is_constant (&value) && value > 0)
18547 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_plus_uconst,
18549 else if (maybe_ne (bytepos, 0))
18550 loc_list_plus_const (list_ret, bytepos);
18557 if ((want_address || !tree_fits_shwi_p (loc))
18558 && (ret = cst_pool_loc_descr (loc)))
18560 else if (want_address == 2
18561 && tree_fits_shwi_p (loc)
18562 && (ret = address_of_int_loc_descriptor
18563 (int_size_in_bytes (TREE_TYPE (loc)),
18564 tree_to_shwi (loc))))
18566 else if (tree_fits_shwi_p (loc))
18567 ret = int_loc_descriptor (tree_to_shwi (loc));
18568 else if (tree_fits_uhwi_p (loc))
18569 ret = uint_loc_descriptor (tree_to_uhwi (loc));
18572 expansion_failed (loc, NULL_RTX,
18573 "Integer operand is not host integer");
18582 expansion_failed (loc, NULL_RTX,
18583 "constant address with a runtime component");
18587 if (!poly_int_tree_p (loc, &value))
18589 expansion_failed (loc, NULL_RTX, "constant too big");
18592 ret = int_loc_descriptor (value);
18600 if ((ret = cst_pool_loc_descr (loc)))
18602 else if (TREE_CODE (loc) == CONSTRUCTOR)
18604 tree type = TREE_TYPE (loc);
18605 unsigned HOST_WIDE_INT size = int_size_in_bytes (type);
18606 unsigned HOST_WIDE_INT offset = 0;
18607 unsigned HOST_WIDE_INT cnt;
18608 constructor_elt *ce;
18610 if (TREE_CODE (type) == RECORD_TYPE)
18612 /* This is very limited, but it's enough to output
18613 pointers to member functions, as long as the
18614 referenced function is defined in the current
18615 translation unit. */
18616 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (loc), cnt, ce)
18618 tree val = ce->value;
18620 tree field = ce->index;
18625 if (!field || DECL_BIT_FIELD (field))
18627 expansion_failed (loc, NULL_RTX,
18628 "bitfield in record type constructor");
18629 size = offset = (unsigned HOST_WIDE_INT)-1;
18634 HOST_WIDE_INT fieldsize = tree_to_shwi (DECL_SIZE_UNIT (field));
18635 unsigned HOST_WIDE_INT pos = int_byte_position (field);
18636 gcc_assert (pos + fieldsize <= size);
18639 expansion_failed (loc, NULL_RTX,
18640 "out-of-order fields in record constructor");
18641 size = offset = (unsigned HOST_WIDE_INT)-1;
18647 ret1 = new_loc_descr (DW_OP_piece, pos - offset, 0);
18648 add_loc_descr (&ret, ret1);
18651 if (val && fieldsize != 0)
18653 ret1 = loc_descriptor_from_tree (val, want_address, context);
18656 expansion_failed (loc, NULL_RTX,
18657 "unsupported expression in field");
18658 size = offset = (unsigned HOST_WIDE_INT)-1;
18662 add_loc_descr (&ret, ret1);
18666 ret1 = new_loc_descr (DW_OP_piece, fieldsize, 0);
18667 add_loc_descr (&ret, ret1);
18668 offset = pos + fieldsize;
18672 if (offset != size)
18674 ret1 = new_loc_descr (DW_OP_piece, size - offset, 0);
18675 add_loc_descr (&ret, ret1);
18679 have_address = !!want_address;
18682 expansion_failed (loc, NULL_RTX,
18683 "constructor of non-record type");
18686 /* We can construct small constants here using int_loc_descriptor. */
18687 expansion_failed (loc, NULL_RTX,
18688 "constructor or constant not in constant pool");
18691 case TRUTH_AND_EXPR:
18692 case TRUTH_ANDIF_EXPR:
18697 case TRUTH_XOR_EXPR:
18702 case TRUTH_OR_EXPR:
18703 case TRUTH_ORIF_EXPR:
18708 case FLOOR_DIV_EXPR:
18709 case CEIL_DIV_EXPR:
18710 case ROUND_DIV_EXPR:
18711 case TRUNC_DIV_EXPR:
18712 case EXACT_DIV_EXPR:
18713 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
18722 case FLOOR_MOD_EXPR:
18723 case CEIL_MOD_EXPR:
18724 case ROUND_MOD_EXPR:
18725 case TRUNC_MOD_EXPR:
18726 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
18731 list_ret = loc_list_from_tree_1 (TREE_OPERAND (loc, 0), 0, context);
18732 list_ret1 = loc_list_from_tree_1 (TREE_OPERAND (loc, 1), 0, context);
18733 if (list_ret == 0 || list_ret1 == 0)
18736 add_loc_list (&list_ret, list_ret1);
18739 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
18740 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_over, 0, 0));
18741 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_div, 0, 0));
18742 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_mul, 0, 0));
18743 add_loc_descr_to_each (list_ret, new_loc_descr (DW_OP_minus, 0, 0));
18755 op = (TYPE_UNSIGNED (TREE_TYPE (loc)) ? DW_OP_shr : DW_OP_shra);
18758 case POINTER_PLUS_EXPR:
18761 if (tree_fits_shwi_p (TREE_OPERAND (loc, 1)))
18763 /* Big unsigned numbers can fit in HOST_WIDE_INT but it may be
18764 smarter to encode their opposite. The DW_OP_plus_uconst operation
18765 takes 1 + X bytes, X being the size of the ULEB128 addend. On the
18766 other hand, a "<push literal>; DW_OP_minus" pattern takes 1 + Y
18767 bytes, Y being the size of the operation that pushes the opposite
18768 of the addend. So let's choose the smallest representation. */
18769 const tree tree_addend = TREE_OPERAND (loc, 1);
18770 offset_int wi_addend;
18771 HOST_WIDE_INT shwi_addend;
18772 dw_loc_descr_ref loc_naddend;
18774 list_ret = loc_list_from_tree_1 (TREE_OPERAND (loc, 0), 0, context);
18778 /* Try to get the literal to push. It is the opposite of the addend,
18779 so as we rely on wrapping during DWARF evaluation, first decode
18780 the literal as a "DWARF-sized" signed number. */
18781 wi_addend = wi::to_offset (tree_addend);
18782 wi_addend = wi::sext (wi_addend, DWARF2_ADDR_SIZE * 8);
18783 shwi_addend = wi_addend.to_shwi ();
18784 loc_naddend = (shwi_addend != INTTYPE_MINIMUM (HOST_WIDE_INT))
18785 ? int_loc_descriptor (-shwi_addend)
18788 if (loc_naddend != NULL
18789 && ((unsigned) size_of_uleb128 (shwi_addend)
18790 > size_of_loc_descr (loc_naddend)))
18792 add_loc_descr_to_each (list_ret, loc_naddend);
18793 add_loc_descr_to_each (list_ret,
18794 new_loc_descr (DW_OP_minus, 0, 0));
18798 for (dw_loc_descr_ref loc_cur = loc_naddend; loc_cur != NULL; )
18800 loc_naddend = loc_cur;
18801 loc_cur = loc_cur->dw_loc_next;
18802 ggc_free (loc_naddend);
18804 loc_list_plus_const (list_ret, wi_addend.to_shwi ());
18814 goto do_comp_binop;
18818 goto do_comp_binop;
18822 goto do_comp_binop;
18826 goto do_comp_binop;
18829 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
18831 list_ret = loc_list_from_tree (TREE_OPERAND (loc, 0), 0, context);
18832 list_ret1 = loc_list_from_tree (TREE_OPERAND (loc, 1), 0, context);
18833 list_ret = loc_list_from_uint_comparison (list_ret, list_ret1,
18849 list_ret = loc_list_from_tree_1 (TREE_OPERAND (loc, 0), 0, context);
18850 list_ret1 = loc_list_from_tree_1 (TREE_OPERAND (loc, 1), 0, context);
18851 if (list_ret == 0 || list_ret1 == 0)
18854 add_loc_list (&list_ret, list_ret1);
18857 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
18860 case TRUTH_NOT_EXPR:
18874 list_ret = loc_list_from_tree_1 (TREE_OPERAND (loc, 0), 0, context);
18878 add_loc_descr_to_each (list_ret, new_loc_descr (op, 0, 0));
18884 const enum tree_code code =
18885 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
18887 loc = build3 (COND_EXPR, TREE_TYPE (loc),
18888 build2 (code, integer_type_node,
18889 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
18890 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
18897 dw_loc_descr_ref lhs
18898 = loc_descriptor_from_tree (TREE_OPERAND (loc, 1), 0, context);
18899 dw_loc_list_ref rhs
18900 = loc_list_from_tree_1 (TREE_OPERAND (loc, 2), 0, context);
18901 dw_loc_descr_ref bra_node, jump_node, tmp;
18903 list_ret = loc_list_from_tree_1 (TREE_OPERAND (loc, 0), 0, context);
18904 if (list_ret == 0 || lhs == 0 || rhs == 0)
18907 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
18908 add_loc_descr_to_each (list_ret, bra_node);
18910 add_loc_list (&list_ret, rhs);
18911 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
18912 add_loc_descr_to_each (list_ret, jump_node);
18914 add_loc_descr_to_each (list_ret, lhs);
18915 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
18916 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
18918 /* ??? Need a node to point the skip at. Use a nop. */
18919 tmp = new_loc_descr (DW_OP_nop, 0, 0);
18920 add_loc_descr_to_each (list_ret, tmp);
18921 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
18922 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
18926 case FIX_TRUNC_EXPR:
18930 /* Leave front-end specific codes as simply unknown. This comes
18931 up, for instance, with the C STMT_EXPR. */
18932 if ((unsigned int) TREE_CODE (loc)
18933 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
18935 expansion_failed (loc, NULL_RTX,
18936 "language specific tree node");
18940 /* Otherwise this is a generic code; we should just lists all of
18941 these explicitly. We forgot one. */
18943 gcc_unreachable ();
18945 /* In a release build, we want to degrade gracefully: better to
18946 generate incomplete debugging information than to crash. */
18950 if (!ret && !list_ret)
18953 if (want_address == 2 && !have_address
18954 && (dwarf_version >= 4 || !dwarf_strict))
18956 if (int_size_in_bytes (TREE_TYPE (loc)) > DWARF2_ADDR_SIZE)
18958 expansion_failed (loc, NULL_RTX,
18959 "DWARF address size mismatch");
18963 add_loc_descr (&ret, new_loc_descr (DW_OP_stack_value, 0, 0));
18965 add_loc_descr_to_each (list_ret,
18966 new_loc_descr (DW_OP_stack_value, 0, 0));
18969 /* Show if we can't fill the request for an address. */
18970 if (want_address && !have_address)
18972 expansion_failed (loc, NULL_RTX,
18973 "Want address and only have value");
18977 gcc_assert (!ret || !list_ret);
18979 /* If we've got an address and don't want one, dereference. */
18980 if (!want_address && have_address)
18982 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
18984 if (size > DWARF2_ADDR_SIZE || size == -1)
18986 expansion_failed (loc, NULL_RTX,
18987 "DWARF address size mismatch");
18990 else if (size == DWARF2_ADDR_SIZE)
18993 op = DW_OP_deref_size;
18996 add_loc_descr (&ret, new_loc_descr (op, size, 0));
18998 add_loc_descr_to_each (list_ret, new_loc_descr (op, size, 0));
19001 list_ret = new_loc_list (ret, NULL, 0, NULL, 0, NULL);
19006 /* Likewise, but strip useless DW_OP_nop operations in the resulting
19009 static dw_loc_list_ref
19010 loc_list_from_tree (tree loc, int want_address,
19011 struct loc_descr_context *context)
19013 dw_loc_list_ref result = loc_list_from_tree_1 (loc, want_address, context);
19015 for (dw_loc_list_ref loc_cur = result;
19016 loc_cur != NULL; loc_cur = loc_cur->dw_loc_next)
19017 loc_descr_without_nops (loc_cur->expr);
19021 /* Same as above but return only single location expression. */
19022 static dw_loc_descr_ref
19023 loc_descriptor_from_tree (tree loc, int want_address,
19024 struct loc_descr_context *context)
19026 dw_loc_list_ref ret = loc_list_from_tree (loc, want_address, context);
19029 if (ret->dw_loc_next)
19031 expansion_failed (loc, NULL_RTX,
19032 "Location list where only loc descriptor needed");
19038 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
19039 pointer to the declared type for the relevant field variable, or return
19040 `integer_type_node' if the given node turns out to be an
19041 ERROR_MARK node. */
19044 field_type (const_tree decl)
19048 if (TREE_CODE (decl) == ERROR_MARK)
19049 return integer_type_node;
19051 type = DECL_BIT_FIELD_TYPE (decl);
19052 if (type == NULL_TREE)
19053 type = TREE_TYPE (decl);
19058 /* Given a pointer to a tree node, return the alignment in bits for
19059 it, or else return BITS_PER_WORD if the node actually turns out to
19060 be an ERROR_MARK node. */
19062 static inline unsigned
19063 simple_type_align_in_bits (const_tree type)
19065 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
19068 static inline unsigned
19069 simple_decl_align_in_bits (const_tree decl)
19071 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
19074 /* Return the result of rounding T up to ALIGN. */
19076 static inline offset_int
19077 round_up_to_align (const offset_int &t, unsigned int align)
19079 return wi::udiv_trunc (t + align - 1, align) * align;
19082 /* Compute the size of TYPE in bytes. If possible, return NULL and store the
19083 size as an integer constant in CST_SIZE. Otherwise, if possible, return a
19084 DWARF expression that computes the size. Return NULL and set CST_SIZE to -1
19085 if we fail to return the size in one of these two forms. */
19087 static dw_loc_descr_ref
19088 type_byte_size (const_tree type, HOST_WIDE_INT *cst_size)
19091 struct loc_descr_context ctx;
19093 /* Return a constant integer in priority, if possible. */
19094 *cst_size = int_size_in_bytes (type);
19095 if (*cst_size != -1)
19098 ctx.context_type = const_cast<tree> (type);
19099 ctx.base_decl = NULL_TREE;
19101 ctx.placeholder_arg = false;
19102 ctx.placeholder_seen = false;
19104 type = TYPE_MAIN_VARIANT (type);
19105 tree_size = TYPE_SIZE_UNIT (type);
19106 return ((tree_size != NULL_TREE)
19107 ? loc_descriptor_from_tree (tree_size, 0, &ctx)
19111 /* Helper structure for RECORD_TYPE processing. */
19114 /* Root RECORD_TYPE. It is needed to generate data member location
19115 descriptions in variable-length records (VLR), but also to cope with
19116 variants, which are composed of nested structures multiplexed with
19117 QUAL_UNION_TYPE nodes. Each time such a structure is passed to a
19118 function processing a FIELD_DECL, it is required to be non null. */
19121 /* When generating a variant part in a RECORD_TYPE (i.e. a nested
19122 QUAL_UNION_TYPE), this holds an expression that computes the offset for
19123 this variant part as part of the root record (in storage units). For
19124 regular records, it must be NULL_TREE. */
19125 tree variant_part_offset;
19128 /* Given a pointer to a FIELD_DECL, compute the byte offset of the lowest
19129 addressed byte of the "containing object" for the given FIELD_DECL. If
19130 possible, return a native constant through CST_OFFSET (in which case NULL is
19131 returned); otherwise return a DWARF expression that computes the offset.
19133 Set *CST_OFFSET to 0 and return NULL if we are unable to determine what
19134 that offset is, either because the argument turns out to be a pointer to an
19135 ERROR_MARK node, or because the offset expression is too complex for us.
19137 CTX is required: see the comment for VLR_CONTEXT. */
19139 static dw_loc_descr_ref
19140 field_byte_offset (const_tree decl, struct vlr_context *ctx,
19141 HOST_WIDE_INT *cst_offset)
19144 dw_loc_list_ref loc_result;
19148 if (TREE_CODE (decl) == ERROR_MARK)
19151 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
19153 /* We cannot handle variable bit offsets at the moment, so abort if it's the
19155 if (TREE_CODE (DECL_FIELD_BIT_OFFSET (decl)) != INTEGER_CST)
19158 /* We used to handle only constant offsets in all cases. Now, we handle
19159 properly dynamic byte offsets only when PCC bitfield type doesn't
19161 if (PCC_BITFIELD_TYPE_MATTERS
19162 && TREE_CODE (DECL_FIELD_OFFSET (decl)) == INTEGER_CST)
19164 offset_int object_offset_in_bits;
19165 offset_int object_offset_in_bytes;
19166 offset_int bitpos_int;
19168 tree field_size_tree;
19169 offset_int deepest_bitpos;
19170 offset_int field_size_in_bits;
19171 unsigned int type_align_in_bits;
19172 unsigned int decl_align_in_bits;
19173 offset_int type_size_in_bits;
19175 bitpos_int = wi::to_offset (bit_position (decl));
19176 type = field_type (decl);
19177 type_size_in_bits = offset_int_type_size_in_bits (type);
19178 type_align_in_bits = simple_type_align_in_bits (type);
19180 field_size_tree = DECL_SIZE (decl);
19182 /* The size could be unspecified if there was an error, or for
19183 a flexible array member. */
19184 if (!field_size_tree)
19185 field_size_tree = bitsize_zero_node;
19187 /* If the size of the field is not constant, use the type size. */
19188 if (TREE_CODE (field_size_tree) == INTEGER_CST)
19189 field_size_in_bits = wi::to_offset (field_size_tree);
19191 field_size_in_bits = type_size_in_bits;
19193 decl_align_in_bits = simple_decl_align_in_bits (decl);
19195 /* The GCC front-end doesn't make any attempt to keep track of the
19196 starting bit offset (relative to the start of the containing
19197 structure type) of the hypothetical "containing object" for a
19198 bit-field. Thus, when computing the byte offset value for the
19199 start of the "containing object" of a bit-field, we must deduce
19200 this information on our own. This can be rather tricky to do in
19201 some cases. For example, handling the following structure type
19202 definition when compiling for an i386/i486 target (which only
19203 aligns long long's to 32-bit boundaries) can be very tricky:
19205 struct S { int field1; long long field2:31; };
19207 Fortunately, there is a simple rule-of-thumb which can be used
19208 in such cases. When compiling for an i386/i486, GCC will
19209 allocate 8 bytes for the structure shown above. It decides to
19210 do this based upon one simple rule for bit-field allocation.
19211 GCC allocates each "containing object" for each bit-field at
19212 the first (i.e. lowest addressed) legitimate alignment boundary
19213 (based upon the required minimum alignment for the declared
19214 type of the field) which it can possibly use, subject to the
19215 condition that there is still enough available space remaining
19216 in the containing object (when allocated at the selected point)
19217 to fully accommodate all of the bits of the bit-field itself.
19219 This simple rule makes it obvious why GCC allocates 8 bytes for
19220 each object of the structure type shown above. When looking
19221 for a place to allocate the "containing object" for `field2',
19222 the compiler simply tries to allocate a 64-bit "containing
19223 object" at each successive 32-bit boundary (starting at zero)
19224 until it finds a place to allocate that 64- bit field such that
19225 at least 31 contiguous (and previously unallocated) bits remain
19226 within that selected 64 bit field. (As it turns out, for the
19227 example above, the compiler finds it is OK to allocate the
19228 "containing object" 64-bit field at bit-offset zero within the
19231 Here we attempt to work backwards from the limited set of facts
19232 we're given, and we try to deduce from those facts, where GCC
19233 must have believed that the containing object started (within
19234 the structure type). The value we deduce is then used (by the
19235 callers of this routine) to generate DW_AT_location and
19236 DW_AT_bit_offset attributes for fields (both bit-fields and, in
19237 the case of DW_AT_location, regular fields as well). */
19239 /* Figure out the bit-distance from the start of the structure to
19240 the "deepest" bit of the bit-field. */
19241 deepest_bitpos = bitpos_int + field_size_in_bits;
19243 /* This is the tricky part. Use some fancy footwork to deduce
19244 where the lowest addressed bit of the containing object must
19246 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
19248 /* Round up to type_align by default. This works best for
19250 object_offset_in_bits
19251 = round_up_to_align (object_offset_in_bits, type_align_in_bits);
19253 if (wi::gtu_p (object_offset_in_bits, bitpos_int))
19255 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
19257 /* Round up to decl_align instead. */
19258 object_offset_in_bits
19259 = round_up_to_align (object_offset_in_bits, decl_align_in_bits);
19262 object_offset_in_bytes
19263 = wi::lrshift (object_offset_in_bits, LOG2_BITS_PER_UNIT);
19264 if (ctx->variant_part_offset == NULL_TREE)
19266 *cst_offset = object_offset_in_bytes.to_shwi ();
19269 tree_result = wide_int_to_tree (sizetype, object_offset_in_bytes);
19272 tree_result = byte_position (decl);
19274 if (ctx->variant_part_offset != NULL_TREE)
19275 tree_result = fold_build2 (PLUS_EXPR, TREE_TYPE (tree_result),
19276 ctx->variant_part_offset, tree_result);
19278 /* If the byte offset is a constant, it's simplier to handle a native
19279 constant rather than a DWARF expression. */
19280 if (TREE_CODE (tree_result) == INTEGER_CST)
19282 *cst_offset = wi::to_offset (tree_result).to_shwi ();
19285 struct loc_descr_context loc_ctx = {
19286 ctx->struct_type, /* context_type */
19287 NULL_TREE, /* base_decl */
19289 false, /* placeholder_arg */
19290 false /* placeholder_seen */
19292 loc_result = loc_list_from_tree (tree_result, 0, &loc_ctx);
19294 /* We want a DWARF expression: abort if we only have a location list with
19295 multiple elements. */
19296 if (!loc_result || !single_element_loc_list_p (loc_result))
19299 return loc_result->expr;
19302 /* The following routines define various Dwarf attributes and any data
19303 associated with them. */
19305 /* Add a location description attribute value to a DIE.
19307 This emits location attributes suitable for whole variables and
19308 whole parameters. Note that the location attributes for struct fields are
19309 generated by the routine `data_member_location_attribute' below. */
19312 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
19313 dw_loc_list_ref descr)
19315 bool check_no_locviews = true;
19318 if (single_element_loc_list_p (descr))
19319 add_AT_loc (die, attr_kind, descr->expr);
19322 add_AT_loc_list (die, attr_kind, descr);
19323 gcc_assert (descr->ll_symbol);
19324 if (attr_kind == DW_AT_location && descr->vl_symbol
19325 && dwarf2out_locviews_in_attribute ())
19327 add_AT_view_list (die, DW_AT_GNU_locviews);
19328 check_no_locviews = false;
19332 if (check_no_locviews)
19333 gcc_assert (!get_AT (die, DW_AT_GNU_locviews));
19336 /* Add DW_AT_accessibility attribute to DIE if needed. */
19339 add_accessibility_attribute (dw_die_ref die, tree decl)
19341 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19342 children, otherwise the default is DW_ACCESS_public. In DWARF2
19343 the default has always been DW_ACCESS_public. */
19344 if (TREE_PROTECTED (decl))
19345 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
19346 else if (TREE_PRIVATE (decl))
19348 if (dwarf_version == 2
19349 || die->die_parent == NULL
19350 || die->die_parent->die_tag != DW_TAG_class_type)
19351 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
19353 else if (dwarf_version > 2
19355 && die->die_parent->die_tag == DW_TAG_class_type)
19356 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
19359 /* Attach the specialized form of location attribute used for data members of
19360 struct and union types. In the special case of a FIELD_DECL node which
19361 represents a bit-field, the "offset" part of this special location
19362 descriptor must indicate the distance in bytes from the lowest-addressed
19363 byte of the containing struct or union type to the lowest-addressed byte of
19364 the "containing object" for the bit-field. (See the `field_byte_offset'
19367 For any given bit-field, the "containing object" is a hypothetical object
19368 (of some integral or enum type) within which the given bit-field lives. The
19369 type of this hypothetical "containing object" is always the same as the
19370 declared type of the individual bit-field itself (for GCC anyway... the
19371 DWARF spec doesn't actually mandate this). Note that it is the size (in
19372 bytes) of the hypothetical "containing object" which will be given in the
19373 DW_AT_byte_size attribute for this bit-field. (See the
19374 `byte_size_attribute' function below.) It is also used when calculating the
19375 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
19378 CTX is required: see the comment for VLR_CONTEXT. */
19381 add_data_member_location_attribute (dw_die_ref die,
19383 struct vlr_context *ctx)
19385 HOST_WIDE_INT offset;
19386 dw_loc_descr_ref loc_descr = 0;
19388 if (TREE_CODE (decl) == TREE_BINFO)
19390 /* We're working on the TAG_inheritance for a base class. */
19391 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
19393 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
19394 aren't at a fixed offset from all (sub)objects of the same
19395 type. We need to extract the appropriate offset from our
19396 vtable. The following dwarf expression means
19398 BaseAddr = ObAddr + *((*ObAddr) - Offset)
19400 This is specific to the V3 ABI, of course. */
19402 dw_loc_descr_ref tmp;
19404 /* Make a copy of the object address. */
19405 tmp = new_loc_descr (DW_OP_dup, 0, 0);
19406 add_loc_descr (&loc_descr, tmp);
19408 /* Extract the vtable address. */
19409 tmp = new_loc_descr (DW_OP_deref, 0, 0);
19410 add_loc_descr (&loc_descr, tmp);
19412 /* Calculate the address of the offset. */
19413 offset = tree_to_shwi (BINFO_VPTR_FIELD (decl));
19414 gcc_assert (offset < 0);
19416 tmp = int_loc_descriptor (-offset);
19417 add_loc_descr (&loc_descr, tmp);
19418 tmp = new_loc_descr (DW_OP_minus, 0, 0);
19419 add_loc_descr (&loc_descr, tmp);
19421 /* Extract the offset. */
19422 tmp = new_loc_descr (DW_OP_deref, 0, 0);
19423 add_loc_descr (&loc_descr, tmp);
19425 /* Add it to the object address. */
19426 tmp = new_loc_descr (DW_OP_plus, 0, 0);
19427 add_loc_descr (&loc_descr, tmp);
19430 offset = tree_to_shwi (BINFO_OFFSET (decl));
19434 loc_descr = field_byte_offset (decl, ctx, &offset);
19436 /* If loc_descr is available then we know the field offset is dynamic.
19437 However, GDB does not handle dynamic field offsets very well at the
19439 if (loc_descr != NULL && gnat_encodings != DWARF_GNAT_ENCODINGS_MINIMAL)
19445 /* Data member location evalutation starts with the base address on the
19446 stack. Compute the field offset and add it to this base address. */
19447 else if (loc_descr != NULL)
19448 add_loc_descr (&loc_descr, new_loc_descr (DW_OP_plus, 0, 0));
19453 /* While DW_AT_data_bit_offset has been added already in DWARF4,
19454 e.g. GDB only added support to it in November 2016. For DWARF5
19455 we need newer debug info consumers anyway. We might change this
19456 to dwarf_version >= 4 once most consumers catched up. */
19457 if (dwarf_version >= 5
19458 && TREE_CODE (decl) == FIELD_DECL
19459 && DECL_BIT_FIELD_TYPE (decl)
19460 && (ctx->variant_part_offset == NULL_TREE
19461 || TREE_CODE (ctx->variant_part_offset) == INTEGER_CST))
19463 tree off = bit_position (decl);
19464 if (ctx->variant_part_offset)
19465 off = bit_from_pos (ctx->variant_part_offset, off);
19466 if (tree_fits_uhwi_p (off) && get_AT (die, DW_AT_bit_size))
19468 remove_AT (die, DW_AT_byte_size);
19469 remove_AT (die, DW_AT_bit_offset);
19470 add_AT_unsigned (die, DW_AT_data_bit_offset, tree_to_uhwi (off));
19474 if (dwarf_version > 2)
19476 /* Don't need to output a location expression, just the constant. */
19478 add_AT_int (die, DW_AT_data_member_location, offset);
19480 add_AT_unsigned (die, DW_AT_data_member_location, offset);
19485 enum dwarf_location_atom op;
19487 /* The DWARF2 standard says that we should assume that the structure
19488 address is already on the stack, so we can specify a structure
19489 field address by using DW_OP_plus_uconst. */
19490 op = DW_OP_plus_uconst;
19491 loc_descr = new_loc_descr (op, offset, 0);
19495 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
19498 /* Writes integer values to dw_vec_const array. */
19501 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
19505 *dest++ = val & 0xff;
19511 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
19513 static HOST_WIDE_INT
19514 extract_int (const unsigned char *src, unsigned int size)
19516 HOST_WIDE_INT val = 0;
19522 val |= *--src & 0xff;
19528 /* Writes wide_int values to dw_vec_const array. */
19531 insert_wide_int (const wide_int &val, unsigned char *dest, int elt_size)
19535 if (elt_size <= HOST_BITS_PER_WIDE_INT/BITS_PER_UNIT)
19537 insert_int ((HOST_WIDE_INT) val.elt (0), elt_size, dest);
19541 /* We'd have to extend this code to support odd sizes. */
19542 gcc_assert (elt_size % (HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT) == 0);
19544 int n = elt_size / (HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT);
19546 if (WORDS_BIG_ENDIAN)
19547 for (i = n - 1; i >= 0; i--)
19549 insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest);
19550 dest += sizeof (HOST_WIDE_INT);
19553 for (i = 0; i < n; i++)
19555 insert_int ((HOST_WIDE_INT) val.elt (i), sizeof (HOST_WIDE_INT), dest);
19556 dest += sizeof (HOST_WIDE_INT);
19560 /* Writes floating point values to dw_vec_const array. */
19563 insert_float (const_rtx rtl, unsigned char *array)
19567 scalar_float_mode mode = as_a <scalar_float_mode> (GET_MODE (rtl));
19569 real_to_target (val, CONST_DOUBLE_REAL_VALUE (rtl), mode);
19571 /* real_to_target puts 32-bit pieces in each long. Pack them. */
19572 for (i = 0; i < GET_MODE_SIZE (mode) / 4; i++)
19574 insert_int (val[i], 4, array);
19579 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
19580 does not have a "location" either in memory or in a register. These
19581 things can arise in GNU C when a constant is passed as an actual parameter
19582 to an inlined function. They can also arise in C++ where declared
19583 constants do not necessarily get memory "homes". */
19586 add_const_value_attribute (dw_die_ref die, rtx rtl)
19588 switch (GET_CODE (rtl))
19592 HOST_WIDE_INT val = INTVAL (rtl);
19595 add_AT_int (die, DW_AT_const_value, val);
19597 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
19601 case CONST_WIDE_INT:
19603 wide_int w1 = rtx_mode_t (rtl, MAX_MODE_INT);
19604 unsigned int prec = MIN (wi::min_precision (w1, UNSIGNED),
19605 (unsigned int)CONST_WIDE_INT_NUNITS (rtl) * HOST_BITS_PER_WIDE_INT);
19606 wide_int w = wi::zext (w1, prec);
19607 add_AT_wide (die, DW_AT_const_value, w);
19612 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
19613 floating-point constant. A CONST_DOUBLE is used whenever the
19614 constant requires more than one word in order to be adequately
19616 if (TARGET_SUPPORTS_WIDE_INT == 0
19617 && !SCALAR_FLOAT_MODE_P (GET_MODE (rtl)))
19618 add_AT_double (die, DW_AT_const_value,
19619 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
19622 scalar_float_mode mode = as_a <scalar_float_mode> (GET_MODE (rtl));
19623 unsigned int length = GET_MODE_SIZE (mode);
19624 unsigned char *array = ggc_vec_alloc<unsigned char> (length);
19626 insert_float (rtl, array);
19627 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
19633 unsigned int length;
19634 if (!CONST_VECTOR_NUNITS (rtl).is_constant (&length))
19637 machine_mode mode = GET_MODE (rtl);
19638 /* The combination of a length and byte elt_size doesn't extend
19639 naturally to boolean vectors, where several elements are packed
19640 into the same byte. */
19641 if (GET_MODE_CLASS (mode) == MODE_VECTOR_BOOL)
19644 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
19645 unsigned char *array
19646 = ggc_vec_alloc<unsigned char> (length * elt_size);
19649 machine_mode imode = GET_MODE_INNER (mode);
19651 switch (GET_MODE_CLASS (mode))
19653 case MODE_VECTOR_INT:
19654 for (i = 0, p = array; i < length; i++, p += elt_size)
19656 rtx elt = CONST_VECTOR_ELT (rtl, i);
19657 insert_wide_int (rtx_mode_t (elt, imode), p, elt_size);
19661 case MODE_VECTOR_FLOAT:
19662 for (i = 0, p = array; i < length; i++, p += elt_size)
19664 rtx elt = CONST_VECTOR_ELT (rtl, i);
19665 insert_float (elt, p);
19670 gcc_unreachable ();
19673 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
19678 if (dwarf_version >= 4 || !dwarf_strict)
19680 dw_loc_descr_ref loc_result;
19681 resolve_one_addr (&rtl);
19683 loc_result = new_addr_loc_descr (rtl, dtprel_false);
19684 add_loc_descr (&loc_result, new_loc_descr (DW_OP_stack_value, 0, 0));
19685 add_AT_loc (die, DW_AT_location, loc_result);
19686 vec_safe_push (used_rtx_array, rtl);
19692 if (CONSTANT_P (XEXP (rtl, 0)))
19693 return add_const_value_attribute (die, XEXP (rtl, 0));
19696 if (!const_ok_for_output (rtl))
19700 if (dwarf_version >= 4 || !dwarf_strict)
19705 /* In cases where an inlined instance of an inline function is passed
19706 the address of an `auto' variable (which is local to the caller) we
19707 can get a situation where the DECL_RTL of the artificial local
19708 variable (for the inlining) which acts as a stand-in for the
19709 corresponding formal parameter (of the inline function) will look
19710 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
19711 exactly a compile-time constant expression, but it isn't the address
19712 of the (artificial) local variable either. Rather, it represents the
19713 *value* which the artificial local variable always has during its
19714 lifetime. We currently have no way to represent such quasi-constant
19715 values in Dwarf, so for now we just punt and generate nothing. */
19723 case CONST_POLY_INT:
19727 if (GET_CODE (XEXP (rtl, 0)) == CONST_STRING
19728 && MEM_READONLY_P (rtl)
19729 && GET_MODE (rtl) == BLKmode)
19731 add_AT_string (die, DW_AT_const_value, XSTR (XEXP (rtl, 0), 0));
19737 /* No other kinds of rtx should be possible here. */
19738 gcc_unreachable ();
19743 /* Determine whether the evaluation of EXPR references any variables
19744 or functions which aren't otherwise used (and therefore may not be
19747 reference_to_unused (tree * tp, int * walk_subtrees,
19748 void * data ATTRIBUTE_UNUSED)
19750 if (! EXPR_P (*tp) && ! CONSTANT_CLASS_P (*tp))
19751 *walk_subtrees = 0;
19753 if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
19754 && ! TREE_ASM_WRITTEN (*tp))
19756 /* ??? The C++ FE emits debug information for using decls, so
19757 putting gcc_unreachable here falls over. See PR31899. For now
19758 be conservative. */
19759 else if (!symtab->global_info_ready && VAR_OR_FUNCTION_DECL_P (*tp))
19761 else if (VAR_P (*tp))
19763 varpool_node *node = varpool_node::get (*tp);
19764 if (!node || !node->definition)
19767 else if (TREE_CODE (*tp) == FUNCTION_DECL
19768 && (!DECL_EXTERNAL (*tp) || DECL_DECLARED_INLINE_P (*tp)))
19770 /* The call graph machinery must have finished analyzing,
19771 optimizing and gimplifying the CU by now.
19772 So if *TP has no call graph node associated
19773 to it, it means *TP will not be emitted. */
19774 if (!cgraph_node::get (*tp))
19777 else if (TREE_CODE (*tp) == STRING_CST && !TREE_ASM_WRITTEN (*tp))
19783 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
19784 for use in a later add_const_value_attribute call. */
19787 rtl_for_decl_init (tree init, tree type)
19789 rtx rtl = NULL_RTX;
19793 /* If a variable is initialized with a string constant without embedded
19794 zeros, build CONST_STRING. */
19795 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
19797 tree enttype = TREE_TYPE (type);
19798 tree domain = TYPE_DOMAIN (type);
19799 scalar_int_mode mode;
19801 if (is_int_mode (TYPE_MODE (enttype), &mode)
19802 && GET_MODE_SIZE (mode) == 1
19804 && TYPE_MAX_VALUE (domain)
19805 && TREE_CODE (TYPE_MAX_VALUE (domain)) == INTEGER_CST
19806 && integer_zerop (TYPE_MIN_VALUE (domain))
19807 && compare_tree_int (TYPE_MAX_VALUE (domain),
19808 TREE_STRING_LENGTH (init) - 1) == 0
19809 && ((size_t) TREE_STRING_LENGTH (init)
19810 == strlen (TREE_STRING_POINTER (init)) + 1))
19812 rtl = gen_rtx_CONST_STRING (VOIDmode,
19813 ggc_strdup (TREE_STRING_POINTER (init)));
19814 rtl = gen_rtx_MEM (BLKmode, rtl);
19815 MEM_READONLY_P (rtl) = 1;
19818 /* Other aggregates, and complex values, could be represented using
19820 else if (AGGREGATE_TYPE_P (type)
19821 || (TREE_CODE (init) == VIEW_CONVERT_EXPR
19822 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init, 0))))
19823 || TREE_CODE (type) == COMPLEX_TYPE)
19825 /* Vectors only work if their mode is supported by the target.
19826 FIXME: generic vectors ought to work too. */
19827 else if (TREE_CODE (type) == VECTOR_TYPE
19828 && !VECTOR_MODE_P (TYPE_MODE (type)))
19830 /* If the initializer is something that we know will expand into an
19831 immediate RTL constant, expand it now. We must be careful not to
19832 reference variables which won't be output. */
19833 else if (initializer_constant_valid_p (init, type)
19834 && ! walk_tree (&init, reference_to_unused, NULL, NULL))
19836 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
19838 if (TREE_CODE (type) == VECTOR_TYPE)
19839 switch (TREE_CODE (init))
19844 if (TREE_CONSTANT (init))
19846 vec<constructor_elt, va_gc> *elts = CONSTRUCTOR_ELTS (init);
19847 bool constant_p = true;
19849 unsigned HOST_WIDE_INT ix;
19851 /* Even when ctor is constant, it might contain non-*_CST
19852 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
19853 belong into VECTOR_CST nodes. */
19854 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
19855 if (!CONSTANT_CLASS_P (value))
19857 constant_p = false;
19863 init = build_vector_from_ctor (type, elts);
19873 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
19875 /* If expand_expr returns a MEM, it wasn't immediate. */
19876 gcc_assert (!rtl || !MEM_P (rtl));
19882 /* Generate RTL for the variable DECL to represent its location. */
19885 rtl_for_decl_location (tree decl)
19889 /* Here we have to decide where we are going to say the parameter "lives"
19890 (as far as the debugger is concerned). We only have a couple of
19891 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
19893 DECL_RTL normally indicates where the parameter lives during most of the
19894 activation of the function. If optimization is enabled however, this
19895 could be either NULL or else a pseudo-reg. Both of those cases indicate
19896 that the parameter doesn't really live anywhere (as far as the code
19897 generation parts of GCC are concerned) during most of the function's
19898 activation. That will happen (for example) if the parameter is never
19899 referenced within the function.
19901 We could just generate a location descriptor here for all non-NULL
19902 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
19903 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
19904 where DECL_RTL is NULL or is a pseudo-reg.
19906 Note however that we can only get away with using DECL_INCOMING_RTL as
19907 a backup substitute for DECL_RTL in certain limited cases. In cases
19908 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
19909 we can be sure that the parameter was passed using the same type as it is
19910 declared to have within the function, and that its DECL_INCOMING_RTL
19911 points us to a place where a value of that type is passed.
19913 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
19914 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
19915 because in these cases DECL_INCOMING_RTL points us to a value of some
19916 type which is *different* from the type of the parameter itself. Thus,
19917 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
19918 such cases, the debugger would end up (for example) trying to fetch a
19919 `float' from a place which actually contains the first part of a
19920 `double'. That would lead to really incorrect and confusing
19921 output at debug-time.
19923 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
19924 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
19925 are a couple of exceptions however. On little-endian machines we can
19926 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
19927 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
19928 an integral type that is smaller than TREE_TYPE (decl). These cases arise
19929 when (on a little-endian machine) a non-prototyped function has a
19930 parameter declared to be of type `short' or `char'. In such cases,
19931 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
19932 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
19933 passed `int' value. If the debugger then uses that address to fetch
19934 a `short' or a `char' (on a little-endian machine) the result will be
19935 the correct data, so we allow for such exceptional cases below.
19937 Note that our goal here is to describe the place where the given formal
19938 parameter lives during most of the function's activation (i.e. between the
19939 end of the prologue and the start of the epilogue). We'll do that as best
19940 as we can. Note however that if the given formal parameter is modified
19941 sometime during the execution of the function, then a stack backtrace (at
19942 debug-time) will show the function as having been called with the *new*
19943 value rather than the value which was originally passed in. This happens
19944 rarely enough that it is not a major problem, but it *is* a problem, and
19945 I'd like to fix it.
19947 A future version of dwarf2out.c may generate two additional attributes for
19948 any given DW_TAG_formal_parameter DIE which will describe the "passed
19949 type" and the "passed location" for the given formal parameter in addition
19950 to the attributes we now generate to indicate the "declared type" and the
19951 "active location" for each parameter. This additional set of attributes
19952 could be used by debuggers for stack backtraces. Separately, note that
19953 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
19954 This happens (for example) for inlined-instances of inline function formal
19955 parameters which are never referenced. This really shouldn't be
19956 happening. All PARM_DECL nodes should get valid non-NULL
19957 DECL_INCOMING_RTL values. FIXME. */
19959 /* Use DECL_RTL as the "location" unless we find something better. */
19960 rtl = DECL_RTL_IF_SET (decl);
19962 /* When generating abstract instances, ignore everything except
19963 constants, symbols living in memory, and symbols living in
19964 fixed registers. */
19965 if (! reload_completed)
19968 && (CONSTANT_P (rtl)
19970 && CONSTANT_P (XEXP (rtl, 0)))
19973 && TREE_STATIC (decl))))
19975 rtl = targetm.delegitimize_address (rtl);
19980 else if (TREE_CODE (decl) == PARM_DECL)
19982 if (rtl == NULL_RTX
19983 || is_pseudo_reg (rtl)
19985 && is_pseudo_reg (XEXP (rtl, 0))
19986 && DECL_INCOMING_RTL (decl)
19987 && MEM_P (DECL_INCOMING_RTL (decl))
19988 && GET_MODE (rtl) == GET_MODE (DECL_INCOMING_RTL (decl))))
19990 tree declared_type = TREE_TYPE (decl);
19991 tree passed_type = DECL_ARG_TYPE (decl);
19992 machine_mode dmode = TYPE_MODE (declared_type);
19993 machine_mode pmode = TYPE_MODE (passed_type);
19995 /* This decl represents a formal parameter which was optimized out.
19996 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
19997 all cases where (rtl == NULL_RTX) just below. */
19998 if (dmode == pmode)
19999 rtl = DECL_INCOMING_RTL (decl);
20000 else if ((rtl == NULL_RTX || is_pseudo_reg (rtl))
20001 && SCALAR_INT_MODE_P (dmode)
20002 && known_le (GET_MODE_SIZE (dmode), GET_MODE_SIZE (pmode))
20003 && DECL_INCOMING_RTL (decl))
20005 rtx inc = DECL_INCOMING_RTL (decl);
20008 else if (MEM_P (inc))
20010 if (BYTES_BIG_ENDIAN)
20011 rtl = adjust_address_nv (inc, dmode,
20012 GET_MODE_SIZE (pmode)
20013 - GET_MODE_SIZE (dmode));
20020 /* If the parm was passed in registers, but lives on the stack, then
20021 make a big endian correction if the mode of the type of the
20022 parameter is not the same as the mode of the rtl. */
20023 /* ??? This is the same series of checks that are made in dbxout.c before
20024 we reach the big endian correction code there. It isn't clear if all
20025 of these checks are necessary here, but keeping them all is the safe
20027 else if (MEM_P (rtl)
20028 && XEXP (rtl, 0) != const0_rtx
20029 && ! CONSTANT_P (XEXP (rtl, 0))
20030 /* Not passed in memory. */
20031 && !MEM_P (DECL_INCOMING_RTL (decl))
20032 /* Not passed by invisible reference. */
20033 && (!REG_P (XEXP (rtl, 0))
20034 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
20035 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
20036 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
20037 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
20040 /* Big endian correction check. */
20041 && BYTES_BIG_ENDIAN
20042 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
20043 && known_lt (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))),
20046 machine_mode addr_mode = get_address_mode (rtl);
20047 poly_int64 offset = (UNITS_PER_WORD
20048 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
20050 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
20051 plus_constant (addr_mode, XEXP (rtl, 0), offset));
20054 else if (VAR_P (decl)
20057 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl)))
20059 machine_mode addr_mode = get_address_mode (rtl);
20060 poly_int64 offset = byte_lowpart_offset (TYPE_MODE (TREE_TYPE (decl)),
20063 /* If a variable is declared "register" yet is smaller than
20064 a register, then if we store the variable to memory, it
20065 looks like we're storing a register-sized value, when in
20066 fact we are not. We need to adjust the offset of the
20067 storage location to reflect the actual value's bytes,
20068 else gdb will not be able to display it. */
20069 if (maybe_ne (offset, 0))
20070 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
20071 plus_constant (addr_mode, XEXP (rtl, 0), offset));
20074 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
20075 and will have been substituted directly into all expressions that use it.
20076 C does not have such a concept, but C++ and other languages do. */
20077 if (!rtl && VAR_P (decl) && DECL_INITIAL (decl))
20078 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
20081 rtl = targetm.delegitimize_address (rtl);
20083 /* If we don't look past the constant pool, we risk emitting a
20084 reference to a constant pool entry that isn't referenced from
20085 code, and thus is not emitted. */
20087 rtl = avoid_constant_pool_reference (rtl);
20089 /* Try harder to get a rtl. If this symbol ends up not being emitted
20090 in the current CU, resolve_addr will remove the expression referencing
20092 if (rtl == NULL_RTX
20093 && !(early_dwarf && (flag_generate_lto || flag_generate_offload))
20095 && !DECL_EXTERNAL (decl)
20096 && TREE_STATIC (decl)
20097 && DECL_NAME (decl)
20098 && !DECL_HARD_REGISTER (decl)
20099 && DECL_MODE (decl) != VOIDmode)
20101 rtl = make_decl_rtl_for_debug (decl);
20103 || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF
20104 || SYMBOL_REF_DECL (XEXP (rtl, 0)) != decl)
20111 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
20112 returned. If so, the decl for the COMMON block is returned, and the
20113 value is the offset into the common block for the symbol. */
20116 fortran_common (tree decl, HOST_WIDE_INT *value)
20118 tree val_expr, cvar;
20120 poly_int64 bitsize, bitpos;
20122 HOST_WIDE_INT cbitpos;
20123 int unsignedp, reversep, volatilep = 0;
20125 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
20126 it does not have a value (the offset into the common area), or if it
20127 is thread local (as opposed to global) then it isn't common, and shouldn't
20128 be handled as such. */
20130 || !TREE_STATIC (decl)
20131 || !DECL_HAS_VALUE_EXPR_P (decl)
20135 val_expr = DECL_VALUE_EXPR (decl);
20136 if (TREE_CODE (val_expr) != COMPONENT_REF)
20139 cvar = get_inner_reference (val_expr, &bitsize, &bitpos, &offset, &mode,
20140 &unsignedp, &reversep, &volatilep);
20142 if (cvar == NULL_TREE
20144 || DECL_ARTIFICIAL (cvar)
20145 || !TREE_PUBLIC (cvar)
20146 /* We don't expect to have to cope with variable offsets,
20147 since at present all static data must have a constant size. */
20148 || !bitpos.is_constant (&cbitpos))
20152 if (offset != NULL)
20154 if (!tree_fits_shwi_p (offset))
20156 *value = tree_to_shwi (offset);
20159 *value += cbitpos / BITS_PER_UNIT;
20164 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
20165 data attribute for a variable or a parameter. We generate the
20166 DW_AT_const_value attribute only in those cases where the given variable
20167 or parameter does not have a true "location" either in memory or in a
20168 register. This can happen (for example) when a constant is passed as an
20169 actual argument in a call to an inline function. (It's possible that
20170 these things can crop up in other ways also.) Note that one type of
20171 constant value which can be passed into an inlined function is a constant
20172 pointer. This can happen for example if an actual argument in an inlined
20173 function call evaluates to a compile-time constant address.
20175 CACHE_P is true if it is worth caching the location list for DECL,
20176 so that future calls can reuse it rather than regenerate it from scratch.
20177 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
20178 since we will need to refer to them each time the function is inlined. */
20181 add_location_or_const_value_attribute (dw_die_ref die, tree decl, bool cache_p)
20184 dw_loc_list_ref list;
20185 var_loc_list *loc_list;
20186 cached_dw_loc_list *cache;
20191 if (TREE_CODE (decl) == ERROR_MARK)
20194 if (get_AT (die, DW_AT_location)
20195 || get_AT (die, DW_AT_const_value))
20198 gcc_assert (VAR_P (decl) || TREE_CODE (decl) == PARM_DECL
20199 || TREE_CODE (decl) == RESULT_DECL);
20201 /* Try to get some constant RTL for this decl, and use that as the value of
20204 rtl = rtl_for_decl_location (decl);
20205 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
20206 && add_const_value_attribute (die, rtl))
20209 /* See if we have single element location list that is equivalent to
20210 a constant value. That way we are better to use add_const_value_attribute
20211 rather than expanding constant value equivalent. */
20212 loc_list = lookup_decl_loc (decl);
20215 && loc_list->first->next == NULL
20216 && NOTE_P (loc_list->first->loc)
20217 && NOTE_VAR_LOCATION (loc_list->first->loc)
20218 && NOTE_VAR_LOCATION_LOC (loc_list->first->loc))
20220 struct var_loc_node *node;
20222 node = loc_list->first;
20223 rtl = NOTE_VAR_LOCATION_LOC (node->loc);
20224 if (GET_CODE (rtl) == EXPR_LIST)
20225 rtl = XEXP (rtl, 0);
20226 if ((CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING)
20227 && add_const_value_attribute (die, rtl))
20230 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
20231 list several times. See if we've already cached the contents. */
20233 if (loc_list == NULL || cached_dw_loc_list_table == NULL)
20237 cache = cached_dw_loc_list_table->find_with_hash (decl, DECL_UID (decl));
20239 list = cache->loc_list;
20243 list = loc_list_from_tree (decl, decl_by_reference_p (decl) ? 0 : 2,
20245 /* It is usually worth caching this result if the decl is from
20246 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
20247 if (cache_p && list && list->dw_loc_next)
20249 cached_dw_loc_list **slot
20250 = cached_dw_loc_list_table->find_slot_with_hash (decl,
20253 cache = ggc_cleared_alloc<cached_dw_loc_list> ();
20254 cache->decl_id = DECL_UID (decl);
20255 cache->loc_list = list;
20261 add_AT_location_description (die, DW_AT_location, list);
20264 /* None of that worked, so it must not really have a location;
20265 try adding a constant value attribute from the DECL_INITIAL. */
20266 return tree_add_const_value_attribute_for_decl (die, decl);
20269 /* Attach a DW_AT_const_value attribute to DIE. The value of the
20270 attribute is the const value T. */
20273 tree_add_const_value_attribute (dw_die_ref die, tree t)
20276 tree type = TREE_TYPE (t);
20279 if (!t || !TREE_TYPE (t) || TREE_TYPE (t) == error_mark_node)
20283 gcc_assert (!DECL_P (init));
20285 if (TREE_CODE (init) == INTEGER_CST)
20287 if (tree_fits_uhwi_p (init))
20289 add_AT_unsigned (die, DW_AT_const_value, tree_to_uhwi (init));
20292 if (tree_fits_shwi_p (init))
20294 add_AT_int (die, DW_AT_const_value, tree_to_shwi (init));
20300 rtl = rtl_for_decl_init (init, type);
20302 return add_const_value_attribute (die, rtl);
20304 /* If the host and target are sane, try harder. */
20305 if (CHAR_BIT == 8 && BITS_PER_UNIT == 8
20306 && initializer_constant_valid_p (init, type))
20308 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (init));
20309 if (size > 0 && (int) size == size)
20311 unsigned char *array = ggc_cleared_vec_alloc<unsigned char> (size);
20313 if (native_encode_initializer (init, array, size) == size)
20315 add_AT_vec (die, DW_AT_const_value, size, 1, array);
20324 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
20325 attribute is the const value of T, where T is an integral constant
20326 variable with static storage duration
20327 (so it can't be a PARM_DECL or a RESULT_DECL). */
20330 tree_add_const_value_attribute_for_decl (dw_die_ref var_die, tree decl)
20334 || (!VAR_P (decl) && TREE_CODE (decl) != CONST_DECL)
20335 || (VAR_P (decl) && !TREE_STATIC (decl)))
20338 if (TREE_READONLY (decl)
20339 && ! TREE_THIS_VOLATILE (decl)
20340 && DECL_INITIAL (decl))
20345 /* Don't add DW_AT_const_value if abstract origin already has one. */
20346 if (get_AT (var_die, DW_AT_const_value))
20349 return tree_add_const_value_attribute (var_die, DECL_INITIAL (decl));
20352 /* Convert the CFI instructions for the current function into a
20353 location list. This is used for DW_AT_frame_base when we targeting
20354 a dwarf2 consumer that does not support the dwarf3
20355 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
20358 static dw_loc_list_ref
20359 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset)
20363 dw_loc_list_ref list, *list_tail;
20365 dw_cfa_location last_cfa, next_cfa;
20366 const char *start_label, *last_label, *section;
20367 dw_cfa_location remember;
20370 gcc_assert (fde != NULL);
20372 section = secname_for_decl (current_function_decl);
20376 memset (&next_cfa, 0, sizeof (next_cfa));
20377 next_cfa.reg = INVALID_REGNUM;
20378 remember = next_cfa;
20380 start_label = fde->dw_fde_begin;
20382 /* ??? Bald assumption that the CIE opcode list does not contain
20383 advance opcodes. */
20384 FOR_EACH_VEC_ELT (*cie_cfi_vec, ix, cfi)
20385 lookup_cfa_1 (cfi, &next_cfa, &remember);
20387 last_cfa = next_cfa;
20388 last_label = start_label;
20390 if (fde->dw_fde_second_begin && fde->dw_fde_switch_cfi_index == 0)
20392 /* If the first partition contained no CFI adjustments, the
20393 CIE opcodes apply to the whole first partition. */
20394 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
20395 fde->dw_fde_begin, 0, fde->dw_fde_end, 0, section);
20396 list_tail =&(*list_tail)->dw_loc_next;
20397 start_label = last_label = fde->dw_fde_second_begin;
20400 FOR_EACH_VEC_SAFE_ELT (fde->dw_fde_cfi, ix, cfi)
20402 switch (cfi->dw_cfi_opc)
20404 case DW_CFA_set_loc:
20405 case DW_CFA_advance_loc1:
20406 case DW_CFA_advance_loc2:
20407 case DW_CFA_advance_loc4:
20408 if (!cfa_equal_p (&last_cfa, &next_cfa))
20410 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
20411 start_label, 0, last_label, 0, section);
20413 list_tail = &(*list_tail)->dw_loc_next;
20414 last_cfa = next_cfa;
20415 start_label = last_label;
20417 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
20420 case DW_CFA_advance_loc:
20421 /* The encoding is complex enough that we should never emit this. */
20422 gcc_unreachable ();
20425 lookup_cfa_1 (cfi, &next_cfa, &remember);
20428 if (ix + 1 == fde->dw_fde_switch_cfi_index)
20430 if (!cfa_equal_p (&last_cfa, &next_cfa))
20432 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
20433 start_label, 0, last_label, 0, section);
20435 list_tail = &(*list_tail)->dw_loc_next;
20436 last_cfa = next_cfa;
20437 start_label = last_label;
20439 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
20440 start_label, 0, fde->dw_fde_end, 0, section);
20441 list_tail = &(*list_tail)->dw_loc_next;
20442 start_label = last_label = fde->dw_fde_second_begin;
20446 if (!cfa_equal_p (&last_cfa, &next_cfa))
20448 *list_tail = new_loc_list (build_cfa_loc (&last_cfa, offset),
20449 start_label, 0, last_label, 0, section);
20450 list_tail = &(*list_tail)->dw_loc_next;
20451 start_label = last_label;
20454 *list_tail = new_loc_list (build_cfa_loc (&next_cfa, offset),
20456 fde->dw_fde_second_begin
20457 ? fde->dw_fde_second_end : fde->dw_fde_end, 0,
20460 maybe_gen_llsym (list);
20465 /* Compute a displacement from the "steady-state frame pointer" to the
20466 frame base (often the same as the CFA), and store it in
20467 frame_pointer_fb_offset. OFFSET is added to the displacement
20468 before the latter is negated. */
20471 compute_frame_pointer_to_fb_displacement (poly_int64 offset)
20475 #ifdef FRAME_POINTER_CFA_OFFSET
20476 reg = frame_pointer_rtx;
20477 offset += FRAME_POINTER_CFA_OFFSET (current_function_decl);
20479 reg = arg_pointer_rtx;
20480 offset += ARG_POINTER_CFA_OFFSET (current_function_decl);
20483 elim = (ira_use_lra_p
20484 ? lra_eliminate_regs (reg, VOIDmode, NULL_RTX)
20485 : eliminate_regs (reg, VOIDmode, NULL_RTX));
20486 elim = strip_offset_and_add (elim, &offset);
20488 frame_pointer_fb_offset = -offset;
20490 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
20491 in which to eliminate. This is because it's stack pointer isn't
20492 directly accessible as a register within the ISA. To work around
20493 this, assume that while we cannot provide a proper value for
20494 frame_pointer_fb_offset, we won't need one either. We can use
20495 hard frame pointer in debug info even if frame pointer isn't used
20496 since hard frame pointer in debug info is encoded with DW_OP_fbreg
20497 which uses the DW_AT_frame_base attribute, not hard frame pointer
20499 frame_pointer_fb_offset_valid
20500 = (elim == hard_frame_pointer_rtx || elim == stack_pointer_rtx);
20503 /* Generate a DW_AT_name attribute given some string value to be included as
20504 the value of the attribute. */
20507 add_name_attribute (dw_die_ref die, const char *name_string)
20509 if (name_string != NULL && *name_string != 0)
20511 if (demangle_name_func)
20512 name_string = (*demangle_name_func) (name_string);
20514 add_AT_string (die, DW_AT_name, name_string);
20518 /* Generate a DW_AT_description attribute given some string value to be included
20519 as the value of the attribute. */
20522 add_desc_attribute (dw_die_ref die, const char *name_string)
20524 if (!flag_describe_dies || (dwarf_version < 3 && dwarf_strict))
20527 if (name_string == NULL || *name_string == 0)
20530 if (demangle_name_func)
20531 name_string = (*demangle_name_func) (name_string);
20533 add_AT_string (die, DW_AT_description, name_string);
20536 /* Generate a DW_AT_description attribute given some decl to be included
20537 as the value of the attribute. */
20540 add_desc_attribute (dw_die_ref die, tree decl)
20544 if (!flag_describe_dies || (dwarf_version < 3 && dwarf_strict))
20547 if (decl == NULL_TREE || !DECL_P (decl))
20549 decl_name = DECL_NAME (decl);
20551 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
20553 const char *name = dwarf2_name (decl, 0);
20554 add_desc_attribute (die, name ? name : IDENTIFIER_POINTER (decl_name));
20558 char *desc = print_generic_expr_to_str (decl);
20559 add_desc_attribute (die, desc);
20564 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
20565 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
20566 of TYPE accordingly.
20568 ??? This is a temporary measure until after we're able to generate
20569 regular DWARF for the complex Ada type system. */
20572 add_gnat_descriptive_type_attribute (dw_die_ref die, tree type,
20573 dw_die_ref context_die)
20576 dw_die_ref dtype_die;
20578 if (!lang_hooks.types.descriptive_type)
20581 dtype = lang_hooks.types.descriptive_type (type);
20585 dtype_die = lookup_type_die (dtype);
20588 gen_type_die (dtype, context_die);
20589 dtype_die = lookup_type_die (dtype);
20590 gcc_assert (dtype_die);
20593 add_AT_die_ref (die, DW_AT_GNAT_descriptive_type, dtype_die);
20596 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
20598 static const char *
20599 comp_dir_string (void)
20602 char *wd_plus_sep = NULL;
20603 static const char *cached_wd = NULL;
20605 if (cached_wd != NULL)
20608 wd = get_src_pwd ();
20612 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR)
20614 size_t wdlen = strlen (wd);
20615 wd_plus_sep = XNEWVEC (char, wdlen + 2);
20616 strcpy (wd_plus_sep, wd);
20617 wd_plus_sep [wdlen] = DIR_SEPARATOR;
20618 wd_plus_sep [wdlen + 1] = 0;
20622 cached_wd = remap_debug_filename (wd);
20624 /* remap_debug_filename can just pass through wd or return a new gc string.
20625 These two types can't be both stored in a GTY(())-tagged string, but since
20626 the cached value lives forever just copy it if needed. */
20627 if (cached_wd != wd)
20629 cached_wd = xstrdup (cached_wd);
20630 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR && wd_plus_sep != NULL)
20631 free (wd_plus_sep);
20637 /* Generate a DW_AT_comp_dir attribute for DIE. */
20640 add_comp_dir_attribute (dw_die_ref die)
20642 const char * wd = comp_dir_string ();
20644 add_AT_string (die, DW_AT_comp_dir, wd);
20647 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
20648 pointer computation, ...), output a representation for that bound according
20649 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
20650 loc_list_from_tree for the meaning of CONTEXT. */
20653 add_scalar_info (dw_die_ref die, enum dwarf_attribute attr, tree value,
20654 int forms, struct loc_descr_context *context)
20656 dw_die_ref context_die, decl_die = NULL;
20657 dw_loc_list_ref list;
20658 bool strip_conversions = true;
20659 bool placeholder_seen = false;
20661 while (strip_conversions)
20662 switch (TREE_CODE (value))
20669 case VIEW_CONVERT_EXPR:
20670 value = TREE_OPERAND (value, 0);
20674 strip_conversions = false;
20678 /* If possible and permitted, output the attribute as a constant. */
20679 if ((forms & dw_scalar_form_constant) != 0
20680 && TREE_CODE (value) == INTEGER_CST)
20682 unsigned int prec = simple_type_size_in_bits (TREE_TYPE (value));
20684 /* If HOST_WIDE_INT is big enough then represent the bound as
20685 a constant value. We need to choose a form based on
20686 whether the type is signed or unsigned. We cannot just
20687 call add_AT_unsigned if the value itself is positive
20688 (add_AT_unsigned might add the unsigned value encoded as
20689 DW_FORM_data[1248]). Some DWARF consumers will lookup the
20690 bounds type and then sign extend any unsigned values found
20691 for signed types. This is needed only for
20692 DW_AT_{lower,upper}_bound, since for most other attributes,
20693 consumers will treat DW_FORM_data[1248] as unsigned values,
20694 regardless of the underlying type. */
20695 if (prec <= HOST_BITS_PER_WIDE_INT
20696 || tree_fits_uhwi_p (value))
20698 if (TYPE_UNSIGNED (TREE_TYPE (value)))
20699 add_AT_unsigned (die, attr, TREE_INT_CST_LOW (value));
20701 add_AT_int (die, attr, TREE_INT_CST_LOW (value));
20704 /* Otherwise represent the bound as an unsigned value with
20705 the precision of its type. The precision and signedness
20706 of the type will be necessary to re-interpret it
20708 add_AT_wide (die, attr, wi::to_wide (value));
20712 /* Otherwise, if it's possible and permitted too, output a reference to
20714 if ((forms & dw_scalar_form_reference) != 0)
20716 tree decl = NULL_TREE;
20718 /* Some type attributes reference an outer type. For instance, the upper
20719 bound of an array may reference an embedding record (this happens in
20721 if (TREE_CODE (value) == COMPONENT_REF
20722 && TREE_CODE (TREE_OPERAND (value, 0)) == PLACEHOLDER_EXPR
20723 && TREE_CODE (TREE_OPERAND (value, 1)) == FIELD_DECL)
20724 decl = TREE_OPERAND (value, 1);
20726 else if (VAR_P (value)
20727 || TREE_CODE (value) == PARM_DECL
20728 || TREE_CODE (value) == RESULT_DECL)
20731 if (decl != NULL_TREE)
20733 decl_die = lookup_decl_die (decl);
20735 /* ??? Can this happen, or should the variable have been bound
20736 first? Probably it can, since I imagine that we try to create
20737 the types of parameters in the order in which they exist in
20738 the list, and won't have created a forward reference to a
20739 later parameter. */
20740 if (decl_die != NULL)
20742 if (get_AT (decl_die, DW_AT_location)
20743 || get_AT (decl_die, DW_AT_data_member_location)
20744 || get_AT (decl_die, DW_AT_const_value))
20746 add_AT_die_ref (die, attr, decl_die);
20753 /* Last chance: try to create a stack operation procedure to evaluate the
20754 value. Do nothing if even that is not possible or permitted. */
20755 if ((forms & dw_scalar_form_exprloc) == 0)
20758 list = loc_list_from_tree (value, 2, context);
20759 if (context && context->placeholder_arg)
20761 placeholder_seen = context->placeholder_seen;
20762 context->placeholder_seen = false;
20764 if (list == NULL || single_element_loc_list_p (list))
20766 /* If this attribute is not a reference nor constant, it is
20767 a DWARF expression rather than location description. For that
20768 loc_list_from_tree (value, 0, &context) is needed. */
20769 dw_loc_list_ref list2 = loc_list_from_tree (value, 0, context);
20770 if (list2 && single_element_loc_list_p (list2))
20772 if (placeholder_seen)
20774 struct dwarf_procedure_info dpi;
20775 dpi.fndecl = NULL_TREE;
20776 dpi.args_count = 1;
20777 if (!resolve_args_picking (list2->expr, 1, &dpi))
20780 add_AT_loc (die, attr, list2->expr);
20785 /* If that failed to give a single element location list, fall back to
20786 outputting this as a reference... still if permitted. */
20788 || (forms & dw_scalar_form_reference) == 0
20789 || placeholder_seen)
20794 if (current_function_decl == 0)
20795 context_die = comp_unit_die ();
20797 context_die = lookup_decl_die (current_function_decl);
20799 decl_die = new_die (DW_TAG_variable, context_die, value);
20800 add_AT_flag (decl_die, DW_AT_artificial, 1);
20801 add_type_attribute (decl_die, TREE_TYPE (value), TYPE_QUAL_CONST, false,
20805 add_AT_location_description (decl_die, DW_AT_location, list);
20806 add_AT_die_ref (die, attr, decl_die);
20809 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
20813 lower_bound_default (void)
20815 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language))
20821 case DW_LANG_C_plus_plus:
20822 case DW_LANG_C_plus_plus_11:
20823 case DW_LANG_C_plus_plus_14:
20825 case DW_LANG_ObjC_plus_plus:
20827 case DW_LANG_Fortran77:
20828 case DW_LANG_Fortran90:
20829 case DW_LANG_Fortran95:
20830 case DW_LANG_Fortran03:
20831 case DW_LANG_Fortran08:
20835 case DW_LANG_Python:
20836 return dwarf_version >= 4 ? 0 : -1;
20837 case DW_LANG_Ada95:
20838 case DW_LANG_Ada83:
20839 case DW_LANG_Cobol74:
20840 case DW_LANG_Cobol85:
20841 case DW_LANG_Modula2:
20843 return dwarf_version >= 4 ? 1 : -1;
20849 /* Given a tree node describing an array bound (either lower or upper) output
20850 a representation for that bound. */
20853 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr,
20854 tree bound, struct loc_descr_context *context)
20859 switch (TREE_CODE (bound))
20861 /* Strip all conversions. */
20863 case VIEW_CONVERT_EXPR:
20864 bound = TREE_OPERAND (bound, 0);
20867 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
20868 are even omitted when they are the default. */
20870 /* If the value for this bound is the default one, we can even omit the
20872 if (bound_attr == DW_AT_lower_bound
20873 && tree_fits_shwi_p (bound)
20874 && (dflt = lower_bound_default ()) != -1
20875 && tree_to_shwi (bound) == dflt)
20881 /* Because of the complex interaction there can be with other GNAT
20882 encodings, GDB isn't ready yet to handle proper DWARF description
20883 for self-referencial subrange bounds: let GNAT encodings do the
20884 magic in such a case. */
20886 && gnat_encodings != DWARF_GNAT_ENCODINGS_MINIMAL
20887 && contains_placeholder_p (bound))
20890 add_scalar_info (subrange_die, bound_attr, bound,
20891 dw_scalar_form_constant
20892 | dw_scalar_form_exprloc
20893 | dw_scalar_form_reference,
20899 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
20900 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
20901 Note that the block of subscript information for an array type also
20902 includes information about the element type of the given array type.
20904 This function reuses previously set type and bound information if
20908 add_subscript_info (dw_die_ref type_die, tree type, bool collapse_p)
20910 unsigned dimension_number;
20912 dw_die_ref child = type_die->die_child;
20914 for (dimension_number = 0;
20915 TREE_CODE (type) == ARRAY_TYPE && (dimension_number == 0 || collapse_p);
20916 type = TREE_TYPE (type), dimension_number++)
20918 tree domain = TYPE_DOMAIN (type);
20920 if (TYPE_STRING_FLAG (type) && is_fortran () && dimension_number > 0)
20923 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
20924 and (in GNU C only) variable bounds. Handle all three forms
20927 /* Find and reuse a previously generated DW_TAG_subrange_type if
20930 For multi-dimensional arrays, as we iterate through the
20931 various dimensions in the enclosing for loop above, we also
20932 iterate through the DIE children and pick at each
20933 DW_TAG_subrange_type previously generated (if available).
20934 Each child DW_TAG_subrange_type DIE describes the range of
20935 the current dimension. At this point we should have as many
20936 DW_TAG_subrange_type's as we have dimensions in the
20938 dw_die_ref subrange_die = NULL;
20942 child = child->die_sib;
20943 if (child->die_tag == DW_TAG_subrange_type)
20944 subrange_die = child;
20945 if (child == type_die->die_child)
20947 /* If we wrapped around, stop looking next time. */
20951 if (child->die_tag == DW_TAG_subrange_type)
20955 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
20959 /* We have an array type with specified bounds. */
20960 lower = TYPE_MIN_VALUE (domain);
20961 upper = TYPE_MAX_VALUE (domain);
20963 /* Define the index type. */
20964 if (TREE_TYPE (domain)
20965 && !get_AT (subrange_die, DW_AT_type))
20967 /* ??? This is probably an Ada unnamed subrange type. Ignore the
20968 TREE_TYPE field. We can't emit debug info for this
20969 because it is an unnamed integral type. */
20970 if (TREE_CODE (domain) == INTEGER_TYPE
20971 && TYPE_NAME (domain) == NULL_TREE
20972 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
20973 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
20976 add_type_attribute (subrange_die, TREE_TYPE (domain),
20977 TYPE_UNQUALIFIED, false, type_die);
20980 /* ??? If upper is NULL, the array has unspecified length,
20981 but it does have a lower bound. This happens with Fortran
20983 Since the debugger is definitely going to need to know N
20984 to produce useful results, go ahead and output the lower
20985 bound solo, and hope the debugger can cope. */
20987 if (!get_AT (subrange_die, DW_AT_lower_bound))
20988 add_bound_info (subrange_die, DW_AT_lower_bound, lower, NULL);
20989 if (!get_AT (subrange_die, DW_AT_upper_bound)
20990 && !get_AT (subrange_die, DW_AT_count))
20993 add_bound_info (subrange_die, DW_AT_upper_bound, upper, NULL);
20994 else if ((is_c () || is_cxx ()) && COMPLETE_TYPE_P (type))
20995 /* Zero-length array. */
20996 add_bound_info (subrange_die, DW_AT_count,
20997 build_int_cst (TREE_TYPE (lower), 0), NULL);
21001 /* Otherwise we have an array type with an unspecified length. The
21002 DWARF-2 spec does not say how to handle this; let's just leave out the
21007 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
21010 add_byte_size_attribute (dw_die_ref die, tree tree_node)
21012 dw_die_ref decl_die;
21013 HOST_WIDE_INT size;
21014 dw_loc_descr_ref size_expr = NULL;
21016 switch (TREE_CODE (tree_node))
21021 case ENUMERAL_TYPE:
21024 case QUAL_UNION_TYPE:
21025 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node)) == VAR_DECL
21026 && (decl_die = lookup_decl_die (TYPE_SIZE_UNIT (tree_node))))
21028 add_AT_die_ref (die, DW_AT_byte_size, decl_die);
21031 size_expr = type_byte_size (tree_node, &size);
21034 /* For a data member of a struct or union, the DW_AT_byte_size is
21035 generally given as the number of bytes normally allocated for an
21036 object of the *declared* type of the member itself. This is true
21037 even for bit-fields. */
21038 size = int_size_in_bytes (field_type (tree_node));
21041 gcc_unreachable ();
21044 /* Support for dynamically-sized objects was introduced by DWARFv3.
21045 At the moment, GDB does not handle variable byte sizes very well,
21047 if ((dwarf_version >= 3 || !dwarf_strict)
21048 && gnat_encodings == DWARF_GNAT_ENCODINGS_MINIMAL
21049 && size_expr != NULL)
21050 add_AT_loc (die, DW_AT_byte_size, size_expr);
21052 /* Note that `size' might be -1 when we get to this point. If it is, that
21053 indicates that the byte size of the entity in question is variable and
21054 that we could not generate a DWARF expression that computes it. */
21056 add_AT_unsigned (die, DW_AT_byte_size, size);
21059 /* Add a DW_AT_alignment attribute to DIE with TREE_NODE's non-default
21063 add_alignment_attribute (dw_die_ref die, tree tree_node)
21065 if (dwarf_version < 5 && dwarf_strict)
21070 if (DECL_P (tree_node))
21072 if (!DECL_USER_ALIGN (tree_node))
21075 align = DECL_ALIGN_UNIT (tree_node);
21077 else if (TYPE_P (tree_node))
21079 if (!TYPE_USER_ALIGN (tree_node))
21082 align = TYPE_ALIGN_UNIT (tree_node);
21085 gcc_unreachable ();
21087 add_AT_unsigned (die, DW_AT_alignment, align);
21090 /* For a FIELD_DECL node which represents a bit-field, output an attribute
21091 which specifies the distance in bits from the highest order bit of the
21092 "containing object" for the bit-field to the highest order bit of the
21095 For any given bit-field, the "containing object" is a hypothetical object
21096 (of some integral or enum type) within which the given bit-field lives. The
21097 type of this hypothetical "containing object" is always the same as the
21098 declared type of the individual bit-field itself. The determination of the
21099 exact location of the "containing object" for a bit-field is rather
21100 complicated. It's handled by the `field_byte_offset' function (above).
21102 Note that it is the size (in bytes) of the hypothetical "containing object"
21103 which will be given in the DW_AT_byte_size attribute for this bit-field.
21104 (See `byte_size_attribute' above). */
21107 add_bit_offset_attribute (dw_die_ref die, tree decl)
21109 HOST_WIDE_INT object_offset_in_bytes;
21110 tree original_type = DECL_BIT_FIELD_TYPE (decl);
21111 HOST_WIDE_INT bitpos_int;
21112 HOST_WIDE_INT highest_order_object_bit_offset;
21113 HOST_WIDE_INT highest_order_field_bit_offset;
21114 HOST_WIDE_INT bit_offset;
21116 /* The containing object is within the DECL_CONTEXT. */
21117 struct vlr_context ctx = { DECL_CONTEXT (decl), NULL_TREE };
21119 field_byte_offset (decl, &ctx, &object_offset_in_bytes);
21121 /* Must be a field and a bit field. */
21122 gcc_assert (original_type && TREE_CODE (decl) == FIELD_DECL);
21124 /* We can't yet handle bit-fields whose offsets are variable, so if we
21125 encounter such things, just return without generating any attribute
21126 whatsoever. Likewise for variable or too large size. */
21127 if (! tree_fits_shwi_p (bit_position (decl))
21128 || ! tree_fits_uhwi_p (DECL_SIZE (decl)))
21131 bitpos_int = int_bit_position (decl);
21133 /* Note that the bit offset is always the distance (in bits) from the
21134 highest-order bit of the "containing object" to the highest-order bit of
21135 the bit-field itself. Since the "high-order end" of any object or field
21136 is different on big-endian and little-endian machines, the computation
21137 below must take account of these differences. */
21138 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
21139 highest_order_field_bit_offset = bitpos_int;
21141 if (! BYTES_BIG_ENDIAN)
21143 highest_order_field_bit_offset += tree_to_shwi (DECL_SIZE (decl));
21144 highest_order_object_bit_offset +=
21145 simple_type_size_in_bits (original_type);
21149 = (! BYTES_BIG_ENDIAN
21150 ? highest_order_object_bit_offset - highest_order_field_bit_offset
21151 : highest_order_field_bit_offset - highest_order_object_bit_offset);
21153 if (bit_offset < 0)
21154 add_AT_int (die, DW_AT_bit_offset, bit_offset);
21156 add_AT_unsigned (die, DW_AT_bit_offset, (unsigned HOST_WIDE_INT) bit_offset);
21159 /* For a FIELD_DECL node which represents a bit field, output an attribute
21160 which specifies the length in bits of the given field. */
21163 add_bit_size_attribute (dw_die_ref die, tree decl)
21165 /* Must be a field and a bit field. */
21166 gcc_assert (TREE_CODE (decl) == FIELD_DECL
21167 && DECL_BIT_FIELD_TYPE (decl));
21169 if (tree_fits_uhwi_p (DECL_SIZE (decl)))
21170 add_AT_unsigned (die, DW_AT_bit_size, tree_to_uhwi (DECL_SIZE (decl)));
21173 /* If the compiled language is ANSI C, then add a 'prototyped'
21174 attribute, if arg types are given for the parameters of a function. */
21177 add_prototyped_attribute (dw_die_ref die, tree func_type)
21179 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language))
21186 if (prototype_p (func_type))
21187 add_AT_flag (die, DW_AT_prototyped, 1);
21194 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
21195 by looking in the type declaration, the object declaration equate table or
21196 the block mapping. */
21199 add_abstract_origin_attribute (dw_die_ref die, tree origin)
21201 dw_die_ref origin_die = NULL;
21203 /* For late LTO debug output we want to refer directly to the abstract
21204 DIE in the early debug rather to the possibly existing concrete
21205 instance and avoid creating that just for this purpose. */
21206 sym_off_pair *desc;
21208 && external_die_map
21209 && (desc = external_die_map->get (origin)))
21211 add_AT_external_die_ref (die, DW_AT_abstract_origin,
21212 desc->sym, desc->off);
21216 if (DECL_P (origin))
21217 origin_die = lookup_decl_die (origin);
21218 else if (TYPE_P (origin))
21219 origin_die = lookup_type_die (origin);
21220 else if (TREE_CODE (origin) == BLOCK)
21221 origin_die = lookup_block_die (origin);
21223 /* XXX: Functions that are never lowered don't always have correct block
21224 trees (in the case of java, they simply have no block tree, in some other
21225 languages). For these functions, there is nothing we can really do to
21226 output correct debug info for inlined functions in all cases. Rather
21227 than die, we'll just produce deficient debug info now, in that we will
21228 have variables without a proper abstract origin. In the future, when all
21229 functions are lowered, we should re-add a gcc_assert (origin_die)
21233 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
21236 /* We do not currently support the pure_virtual attribute. */
21239 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
21241 if (DECL_VINDEX (func_decl))
21243 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
21245 if (tree_fits_shwi_p (DECL_VINDEX (func_decl)))
21246 add_AT_loc (die, DW_AT_vtable_elem_location,
21247 new_loc_descr (DW_OP_constu,
21248 tree_to_shwi (DECL_VINDEX (func_decl)),
21251 /* GNU extension: Record what type this method came from originally. */
21252 if (debug_info_level > DINFO_LEVEL_TERSE
21253 && DECL_CONTEXT (func_decl))
21254 add_AT_die_ref (die, DW_AT_containing_type,
21255 lookup_type_die (DECL_CONTEXT (func_decl)));
21259 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
21260 given decl. This used to be a vendor extension until after DWARF 4
21261 standardized it. */
21264 add_linkage_attr (dw_die_ref die, tree decl)
21266 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
21268 /* Mimic what assemble_name_raw does with a leading '*'. */
21269 if (name[0] == '*')
21272 if (dwarf_version >= 4)
21273 add_AT_string (die, DW_AT_linkage_name, name);
21275 add_AT_string (die, DW_AT_MIPS_linkage_name, name);
21278 /* Add source coordinate attributes for the given decl. */
21281 add_src_coords_attributes (dw_die_ref die, tree decl)
21283 expanded_location s;
21285 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl)) == UNKNOWN_LOCATION)
21287 s = expand_location (DECL_SOURCE_LOCATION (decl));
21288 add_AT_file (die, DW_AT_decl_file, lookup_filename (s.file));
21289 add_AT_unsigned (die, DW_AT_decl_line, s.line);
21290 if (debug_column_info && s.column)
21291 add_AT_unsigned (die, DW_AT_decl_column, s.column);
21294 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
21297 add_linkage_name_raw (dw_die_ref die, tree decl)
21299 /* Defer until we have an assembler name set. */
21300 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
21302 limbo_die_node *asm_name;
21304 asm_name = ggc_cleared_alloc<limbo_die_node> ();
21305 asm_name->die = die;
21306 asm_name->created_for = decl;
21307 asm_name->next = deferred_asm_name;
21308 deferred_asm_name = asm_name;
21310 else if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
21311 add_linkage_attr (die, decl);
21314 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl if desired. */
21317 add_linkage_name (dw_die_ref die, tree decl)
21319 if (debug_info_level > DINFO_LEVEL_NONE
21320 && VAR_OR_FUNCTION_DECL_P (decl)
21321 && TREE_PUBLIC (decl)
21322 && !(VAR_P (decl) && DECL_REGISTER (decl))
21323 && die->die_tag != DW_TAG_member)
21324 add_linkage_name_raw (die, decl);
21327 /* Add a DW_AT_name attribute and source coordinate attribute for the
21328 given decl, but only if it actually has a name. */
21331 add_name_and_src_coords_attributes (dw_die_ref die, tree decl,
21332 bool no_linkage_name)
21336 decl_name = DECL_NAME (decl);
21337 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
21339 const char *name = dwarf2_name (decl, 0);
21341 add_name_attribute (die, name);
21343 add_desc_attribute (die, decl);
21345 if (! DECL_ARTIFICIAL (decl))
21346 add_src_coords_attributes (die, decl);
21348 if (!no_linkage_name)
21349 add_linkage_name (die, decl);
21352 add_desc_attribute (die, decl);
21354 #ifdef VMS_DEBUGGING_INFO
21355 /* Get the function's name, as described by its RTL. This may be different
21356 from the DECL_NAME name used in the source file. */
21357 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
21359 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
21360 XEXP (DECL_RTL (decl), 0), false);
21361 vec_safe_push (used_rtx_array, XEXP (DECL_RTL (decl), 0));
21363 #endif /* VMS_DEBUGGING_INFO */
21366 /* Add VALUE as a DW_AT_discr_value attribute to DIE. */
21369 add_discr_value (dw_die_ref die, dw_discr_value *value)
21373 attr.dw_attr = DW_AT_discr_value;
21374 attr.dw_attr_val.val_class = dw_val_class_discr_value;
21375 attr.dw_attr_val.val_entry = NULL;
21376 attr.dw_attr_val.v.val_discr_value.pos = value->pos;
21378 attr.dw_attr_val.v.val_discr_value.v.uval = value->v.uval;
21380 attr.dw_attr_val.v.val_discr_value.v.sval = value->v.sval;
21381 add_dwarf_attr (die, &attr);
21384 /* Add DISCR_LIST as a DW_AT_discr_list to DIE. */
21387 add_discr_list (dw_die_ref die, dw_discr_list_ref discr_list)
21391 attr.dw_attr = DW_AT_discr_list;
21392 attr.dw_attr_val.val_class = dw_val_class_discr_list;
21393 attr.dw_attr_val.val_entry = NULL;
21394 attr.dw_attr_val.v.val_discr_list = discr_list;
21395 add_dwarf_attr (die, &attr);
21398 static inline dw_discr_list_ref
21399 AT_discr_list (dw_attr_node *attr)
21401 return attr->dw_attr_val.v.val_discr_list;
21404 #ifdef VMS_DEBUGGING_INFO
21405 /* Output the debug main pointer die for VMS */
21408 dwarf2out_vms_debug_main_pointer (void)
21410 char label[MAX_ARTIFICIAL_LABEL_BYTES];
21413 /* Allocate the VMS debug main subprogram die. */
21414 die = new_die_raw (DW_TAG_subprogram);
21415 add_name_attribute (die, VMS_DEBUG_MAIN_POINTER);
21416 ASM_GENERATE_INTERNAL_LABEL (label, PROLOGUE_END_LABEL,
21417 current_function_funcdef_no);
21418 add_AT_lbl_id (die, DW_AT_entry_pc, label);
21420 /* Make it the first child of comp_unit_die (). */
21421 die->die_parent = comp_unit_die ();
21422 if (comp_unit_die ()->die_child)
21424 die->die_sib = comp_unit_die ()->die_child->die_sib;
21425 comp_unit_die ()->die_child->die_sib = die;
21429 die->die_sib = die;
21430 comp_unit_die ()->die_child = die;
21433 #endif /* VMS_DEBUGGING_INFO */
21435 /* walk_tree helper function for uses_local_type, below. */
21438 uses_local_type_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
21441 *walk_subtrees = 0;
21444 tree name = TYPE_NAME (*tp);
21445 if (name && DECL_P (name) && decl_function_context (name))
21451 /* If TYPE involves a function-local type (including a local typedef to a
21452 non-local type), returns that type; otherwise returns NULL_TREE. */
21455 uses_local_type (tree type)
21457 tree used = walk_tree_without_duplicates (&type, uses_local_type_r, NULL);
21461 /* Return the DIE for the scope that immediately contains this type.
21462 Non-named types that do not involve a function-local type get global
21463 scope. Named types nested in namespaces or other types get their
21464 containing scope. All other types (i.e. function-local named types) get
21465 the current active scope. */
21468 scope_die_for (tree t, dw_die_ref context_die)
21470 dw_die_ref scope_die = NULL;
21471 tree containing_scope;
21473 /* Non-types always go in the current scope. */
21474 gcc_assert (TYPE_P (t));
21476 /* Use the scope of the typedef, rather than the scope of the type
21478 if (TYPE_NAME (t) && DECL_P (TYPE_NAME (t)))
21479 containing_scope = DECL_CONTEXT (TYPE_NAME (t));
21481 containing_scope = TYPE_CONTEXT (t);
21483 /* Use the containing namespace if there is one. */
21484 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
21486 if (context_die == lookup_decl_die (containing_scope))
21488 else if (debug_info_level > DINFO_LEVEL_TERSE)
21489 context_die = get_context_die (containing_scope);
21491 containing_scope = NULL_TREE;
21494 /* Ignore function type "scopes" from the C frontend. They mean that
21495 a tagged type is local to a parmlist of a function declarator, but
21496 that isn't useful to DWARF. */
21497 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
21498 containing_scope = NULL_TREE;
21500 if (SCOPE_FILE_SCOPE_P (containing_scope))
21502 /* If T uses a local type keep it local as well, to avoid references
21503 to function-local DIEs from outside the function. */
21504 if (current_function_decl && uses_local_type (t))
21505 scope_die = context_die;
21507 scope_die = comp_unit_die ();
21509 else if (TYPE_P (containing_scope))
21511 /* For types, we can just look up the appropriate DIE. */
21512 if (debug_info_level > DINFO_LEVEL_TERSE)
21513 scope_die = get_context_die (containing_scope);
21516 scope_die = lookup_type_die_strip_naming_typedef (containing_scope);
21517 if (scope_die == NULL)
21518 scope_die = comp_unit_die ();
21522 scope_die = context_die;
21527 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
21530 local_scope_p (dw_die_ref context_die)
21532 for (; context_die; context_die = context_die->die_parent)
21533 if (context_die->die_tag == DW_TAG_inlined_subroutine
21534 || context_die->die_tag == DW_TAG_subprogram)
21540 /* Returns nonzero if CONTEXT_DIE is a class. */
21543 class_scope_p (dw_die_ref context_die)
21545 return (context_die
21546 && (context_die->die_tag == DW_TAG_structure_type
21547 || context_die->die_tag == DW_TAG_class_type
21548 || context_die->die_tag == DW_TAG_interface_type
21549 || context_die->die_tag == DW_TAG_union_type));
21552 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
21553 whether or not to treat a DIE in this context as a declaration. */
21556 class_or_namespace_scope_p (dw_die_ref context_die)
21558 return (class_scope_p (context_die)
21559 || (context_die && context_die->die_tag == DW_TAG_namespace));
21562 /* Many forms of DIEs require a "type description" attribute. This
21563 routine locates the proper "type descriptor" die for the type given
21564 by 'type' plus any additional qualifiers given by 'cv_quals', and
21565 adds a DW_AT_type attribute below the given die. */
21568 add_type_attribute (dw_die_ref object_die, tree type, int cv_quals,
21569 bool reverse, dw_die_ref context_die)
21571 enum tree_code code = TREE_CODE (type);
21572 dw_die_ref type_die = NULL;
21574 if (debug_info_level <= DINFO_LEVEL_TERSE)
21577 /* ??? If this type is an unnamed subrange type of an integral, floating-point
21578 or fixed-point type, use the inner type. This is because we have no
21579 support for unnamed types in base_type_die. This can happen if this is
21580 an Ada subrange type. Correct solution is emit a subrange type die. */
21581 if ((code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE)
21582 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
21583 type = TREE_TYPE (type), code = TREE_CODE (type);
21585 if (code == ERROR_MARK
21586 /* Handle a special case. For functions whose return type is void, we
21587 generate *no* type attribute. (Note that no object may have type
21588 `void', so this only applies to function return types). */
21589 || code == VOID_TYPE)
21592 type_die = modified_type_die (type,
21593 cv_quals | TYPE_QUALS (type),
21597 if (type_die != NULL)
21598 add_AT_die_ref (object_die, DW_AT_type, type_die);
21601 /* Given an object die, add the calling convention attribute for the
21602 function call type. */
21604 add_calling_convention_attribute (dw_die_ref subr_die, tree decl)
21606 enum dwarf_calling_convention value = DW_CC_normal;
21608 value = ((enum dwarf_calling_convention)
21609 targetm.dwarf_calling_convention (TREE_TYPE (decl)));
21612 && id_equal (DECL_ASSEMBLER_NAME (decl), "MAIN__"))
21614 /* DWARF 2 doesn't provide a way to identify a program's source-level
21615 entry point. DW_AT_calling_convention attributes are only meant
21616 to describe functions' calling conventions. However, lacking a
21617 better way to signal the Fortran main program, we used this for
21618 a long time, following existing custom. Now, DWARF 4 has
21619 DW_AT_main_subprogram, which we add below, but some tools still
21620 rely on the old way, which we thus keep. */
21621 value = DW_CC_program;
21623 if (dwarf_version >= 4 || !dwarf_strict)
21624 add_AT_flag (subr_die, DW_AT_main_subprogram, 1);
21627 /* Only add the attribute if the backend requests it, and
21628 is not DW_CC_normal. */
21629 if (value && (value != DW_CC_normal))
21630 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
21633 /* Given a tree pointer to a struct, class, union, or enum type node, return
21634 a pointer to the (string) tag name for the given type, or zero if the type
21635 was declared without a tag. */
21637 static const char *
21638 type_tag (const_tree type)
21640 const char *name = 0;
21642 if (TYPE_NAME (type) != 0)
21646 /* Find the IDENTIFIER_NODE for the type name. */
21647 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
21648 && !TYPE_NAMELESS (type))
21649 t = TYPE_NAME (type);
21651 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
21652 a TYPE_DECL node, regardless of whether or not a `typedef' was
21654 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
21655 && ! DECL_IGNORED_P (TYPE_NAME (type)))
21657 /* We want to be extra verbose. Don't call dwarf_name if
21658 DECL_NAME isn't set. The default hook for decl_printable_name
21659 doesn't like that, and in this context it's correct to return
21660 0, instead of "<anonymous>" or the like. */
21661 if (DECL_NAME (TYPE_NAME (type))
21662 && !DECL_NAMELESS (TYPE_NAME (type)))
21663 name = lang_hooks.dwarf_name (TYPE_NAME (type), 2);
21666 /* Now get the name as a string, or invent one. */
21667 if (!name && t != 0)
21668 name = IDENTIFIER_POINTER (t);
21671 return (name == 0 || *name == '\0') ? 0 : name;
21674 /* Return the type associated with a data member, make a special check
21675 for bit field types. */
21678 member_declared_type (const_tree member)
21680 return (DECL_BIT_FIELD_TYPE (member)
21681 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
21684 /* Get the decl's label, as described by its RTL. This may be different
21685 from the DECL_NAME name used in the source file. */
21688 static const char *
21689 decl_start_label (tree decl)
21692 const char *fnname;
21694 x = DECL_RTL (decl);
21695 gcc_assert (MEM_P (x));
21698 gcc_assert (GET_CODE (x) == SYMBOL_REF);
21700 fnname = XSTR (x, 0);
21705 /* For variable-length arrays that have been previously generated, but
21706 may be incomplete due to missing subscript info, fill the subscript
21707 info. Return TRUE if this is one of those cases. */
21709 fill_variable_array_bounds (tree type)
21711 if (TREE_ASM_WRITTEN (type)
21712 && TREE_CODE (type) == ARRAY_TYPE
21713 && variably_modified_type_p (type, NULL))
21715 dw_die_ref array_die = lookup_type_die (type);
21718 add_subscript_info (array_die, type, !is_ada ());
21724 /* These routines generate the internal representation of the DIE's for
21725 the compilation unit. Debugging information is collected by walking
21726 the declaration trees passed in from dwarf2out_decl(). */
21729 gen_array_type_die (tree type, dw_die_ref context_die)
21731 dw_die_ref array_die;
21733 /* GNU compilers represent multidimensional array types as sequences of one
21734 dimensional array types whose element types are themselves array types.
21735 We sometimes squish that down to a single array_type DIE with multiple
21736 subscripts in the Dwarf debugging info. The draft Dwarf specification
21737 say that we are allowed to do this kind of compression in C, because
21738 there is no difference between an array of arrays and a multidimensional
21739 array. We don't do this for Ada to remain as close as possible to the
21740 actual representation, which is especially important against the language
21741 flexibilty wrt arrays of variable size. */
21743 bool collapse_nested_arrays = !is_ada ();
21745 if (fill_variable_array_bounds (type))
21748 dw_die_ref scope_die = scope_die_for (type, context_die);
21751 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
21752 DW_TAG_string_type doesn't have DW_AT_type attribute). */
21753 if (TREE_CODE (type) == ARRAY_TYPE
21754 && TYPE_STRING_FLAG (type)
21756 && TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (char_type_node))
21758 HOST_WIDE_INT size;
21760 array_die = new_die (DW_TAG_string_type, scope_die, type);
21761 add_name_attribute (array_die, type_tag (type));
21762 equate_type_number_to_die (type, array_die);
21763 size = int_size_in_bytes (type);
21765 add_AT_unsigned (array_die, DW_AT_byte_size, size);
21766 /* ??? We can't annotate types late, but for LTO we may not
21767 generate a location early either (gfortran.dg/save_6.f90). */
21768 else if (! (early_dwarf && (flag_generate_lto || flag_generate_offload))
21769 && TYPE_DOMAIN (type) != NULL_TREE
21770 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != NULL_TREE)
21772 tree szdecl = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
21773 tree rszdecl = szdecl;
21775 size = int_size_in_bytes (TREE_TYPE (szdecl));
21776 if (!DECL_P (szdecl))
21778 if (TREE_CODE (szdecl) == INDIRECT_REF
21779 && DECL_P (TREE_OPERAND (szdecl, 0)))
21781 rszdecl = TREE_OPERAND (szdecl, 0);
21782 if (int_size_in_bytes (TREE_TYPE (rszdecl))
21783 != DWARF2_ADDR_SIZE)
21791 dw_loc_list_ref loc
21792 = loc_list_from_tree (rszdecl, szdecl == rszdecl ? 2 : 0,
21796 add_AT_location_description (array_die, DW_AT_string_length,
21798 if (size != DWARF2_ADDR_SIZE)
21799 add_AT_unsigned (array_die, dwarf_version >= 5
21800 ? DW_AT_string_length_byte_size
21801 : DW_AT_byte_size, size);
21808 array_die = new_die (DW_TAG_array_type, scope_die, type);
21809 add_name_attribute (array_die, type_tag (type));
21810 equate_type_number_to_die (type, array_die);
21812 if (TREE_CODE (type) == VECTOR_TYPE)
21813 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
21815 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
21817 && TREE_CODE (type) == ARRAY_TYPE
21818 && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE
21819 && !TYPE_STRING_FLAG (TREE_TYPE (type)))
21820 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
21823 /* We default the array ordering. Debuggers will probably do the right
21824 things even if DW_AT_ordering is not present. It's not even an issue
21825 until we start to get into multidimensional arrays anyway. If a debugger
21826 is ever caught doing the Wrong Thing for multi-dimensional arrays,
21827 then we'll have to put the DW_AT_ordering attribute back in. (But if
21828 and when we find out that we need to put these in, we will only do so
21829 for multidimensional arrays. */
21830 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
21833 if (TREE_CODE (type) == VECTOR_TYPE)
21835 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
21836 dw_die_ref subrange_die = new_die (DW_TAG_subrange_type, array_die, NULL);
21837 add_bound_info (subrange_die, DW_AT_lower_bound, size_zero_node, NULL);
21838 add_bound_info (subrange_die, DW_AT_upper_bound,
21839 size_int (TYPE_VECTOR_SUBPARTS (type) - 1), NULL);
21842 add_subscript_info (array_die, type, collapse_nested_arrays);
21844 /* Add representation of the type of the elements of this array type and
21845 emit the corresponding DIE if we haven't done it already. */
21846 element_type = TREE_TYPE (type);
21847 if (collapse_nested_arrays)
21848 while (TREE_CODE (element_type) == ARRAY_TYPE)
21850 if (TYPE_STRING_FLAG (element_type) && is_fortran ())
21852 element_type = TREE_TYPE (element_type);
21855 add_type_attribute (array_die, element_type, TYPE_UNQUALIFIED,
21856 TREE_CODE (type) == ARRAY_TYPE
21857 && TYPE_REVERSE_STORAGE_ORDER (type),
21860 add_gnat_descriptive_type_attribute (array_die, type, context_die);
21861 if (TYPE_ARTIFICIAL (type))
21862 add_AT_flag (array_die, DW_AT_artificial, 1);
21864 if (get_AT (array_die, DW_AT_name))
21865 add_pubtype (type, array_die);
21867 add_alignment_attribute (array_die, type);
21870 /* This routine generates DIE for array with hidden descriptor, details
21871 are filled into *info by a langhook. */
21874 gen_descr_array_type_die (tree type, struct array_descr_info *info,
21875 dw_die_ref context_die)
21877 const dw_die_ref scope_die = scope_die_for (type, context_die);
21878 const dw_die_ref array_die = new_die (DW_TAG_array_type, scope_die, type);
21879 struct loc_descr_context context = { type, info->base_decl, NULL,
21881 enum dwarf_tag subrange_tag = DW_TAG_subrange_type;
21884 add_name_attribute (array_die, type_tag (type));
21885 equate_type_number_to_die (type, array_die);
21887 if (info->ndimensions > 1)
21888 switch (info->ordering)
21890 case array_descr_ordering_row_major:
21891 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
21893 case array_descr_ordering_column_major:
21894 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_col_major);
21900 if (dwarf_version >= 3 || !dwarf_strict)
21902 if (info->data_location)
21903 add_scalar_info (array_die, DW_AT_data_location, info->data_location,
21904 dw_scalar_form_exprloc, &context);
21905 if (info->associated)
21906 add_scalar_info (array_die, DW_AT_associated, info->associated,
21907 dw_scalar_form_constant
21908 | dw_scalar_form_exprloc
21909 | dw_scalar_form_reference, &context);
21910 if (info->allocated)
21911 add_scalar_info (array_die, DW_AT_allocated, info->allocated,
21912 dw_scalar_form_constant
21913 | dw_scalar_form_exprloc
21914 | dw_scalar_form_reference, &context);
21917 const enum dwarf_attribute attr
21918 = (info->stride_in_bits) ? DW_AT_bit_stride : DW_AT_byte_stride;
21920 = (info->stride_in_bits)
21921 ? dw_scalar_form_constant
21922 : (dw_scalar_form_constant
21923 | dw_scalar_form_exprloc
21924 | dw_scalar_form_reference);
21926 add_scalar_info (array_die, attr, info->stride, forms, &context);
21929 if (dwarf_version >= 5)
21933 add_scalar_info (array_die, DW_AT_rank, info->rank,
21934 dw_scalar_form_constant
21935 | dw_scalar_form_exprloc, &context);
21936 subrange_tag = DW_TAG_generic_subrange;
21937 context.placeholder_arg = true;
21941 add_gnat_descriptive_type_attribute (array_die, type, context_die);
21943 for (dim = 0; dim < info->ndimensions; dim++)
21945 dw_die_ref subrange_die = new_die (subrange_tag, array_die, NULL);
21947 if (info->dimen[dim].bounds_type)
21948 add_type_attribute (subrange_die,
21949 info->dimen[dim].bounds_type, TYPE_UNQUALIFIED,
21950 false, context_die);
21951 if (info->dimen[dim].lower_bound)
21952 add_bound_info (subrange_die, DW_AT_lower_bound,
21953 info->dimen[dim].lower_bound, &context);
21954 if (info->dimen[dim].upper_bound)
21955 add_bound_info (subrange_die, DW_AT_upper_bound,
21956 info->dimen[dim].upper_bound, &context);
21957 if ((dwarf_version >= 3 || !dwarf_strict) && info->dimen[dim].stride)
21958 add_scalar_info (subrange_die, DW_AT_byte_stride,
21959 info->dimen[dim].stride,
21960 dw_scalar_form_constant
21961 | dw_scalar_form_exprloc
21962 | dw_scalar_form_reference,
21966 gen_type_die (info->element_type, context_die);
21967 add_type_attribute (array_die, info->element_type, TYPE_UNQUALIFIED,
21968 TREE_CODE (type) == ARRAY_TYPE
21969 && TYPE_REVERSE_STORAGE_ORDER (type),
21972 if (get_AT (array_die, DW_AT_name))
21973 add_pubtype (type, array_die);
21975 add_alignment_attribute (array_die, type);
21980 gen_entry_point_die (tree decl, dw_die_ref context_die)
21982 tree origin = decl_ultimate_origin (decl);
21983 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
21985 if (origin != NULL)
21986 add_abstract_origin_attribute (decl_die, origin);
21989 add_name_and_src_coords_attributes (decl_die, decl);
21990 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
21991 TYPE_UNQUALIFIED, false, context_die);
21994 if (DECL_ABSTRACT_P (decl))
21995 equate_decl_number_to_die (decl, decl_die);
21997 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
22001 /* Walk through the list of incomplete types again, trying once more to
22002 emit full debugging info for them. */
22005 retry_incomplete_types (void)
22010 for (i = vec_safe_length (incomplete_types) - 1; i >= 0; i--)
22011 if (should_emit_struct_debug ((*incomplete_types)[i], DINFO_USAGE_DIR_USE))
22012 gen_type_die ((*incomplete_types)[i], comp_unit_die ());
22013 vec_safe_truncate (incomplete_types, 0);
22016 /* Determine what tag to use for a record type. */
22018 static enum dwarf_tag
22019 record_type_tag (tree type)
22021 if (! lang_hooks.types.classify_record)
22022 return DW_TAG_structure_type;
22024 switch (lang_hooks.types.classify_record (type))
22026 case RECORD_IS_STRUCT:
22027 return DW_TAG_structure_type;
22029 case RECORD_IS_CLASS:
22030 return DW_TAG_class_type;
22032 case RECORD_IS_INTERFACE:
22033 if (dwarf_version >= 3 || !dwarf_strict)
22034 return DW_TAG_interface_type;
22035 return DW_TAG_structure_type;
22038 gcc_unreachable ();
22042 /* Generate a DIE to represent an enumeration type. Note that these DIEs
22043 include all of the information about the enumeration values also. Each
22044 enumerated type name/value is listed as a child of the enumerated type
22048 gen_enumeration_type_die (tree type, dw_die_ref context_die)
22050 dw_die_ref type_die = lookup_type_die (type);
22051 dw_die_ref orig_type_die = type_die;
22053 if (type_die == NULL)
22055 type_die = new_die (DW_TAG_enumeration_type,
22056 scope_die_for (type, context_die), type);
22057 equate_type_number_to_die (type, type_die);
22058 add_name_attribute (type_die, type_tag (type));
22059 if ((dwarf_version >= 4 || !dwarf_strict)
22060 && ENUM_IS_SCOPED (type))
22061 add_AT_flag (type_die, DW_AT_enum_class, 1);
22062 if (ENUM_IS_OPAQUE (type) && TYPE_SIZE (type))
22063 add_AT_flag (type_die, DW_AT_declaration, 1);
22065 add_AT_unsigned (type_die, DW_AT_encoding,
22066 TYPE_UNSIGNED (type)
22070 else if (! TYPE_SIZE (type) || ENUM_IS_OPAQUE (type))
22073 remove_AT (type_die, DW_AT_declaration);
22075 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
22076 given enum type is incomplete, do not generate the DW_AT_byte_size
22077 attribute or the DW_AT_element_list attribute. */
22078 if (TYPE_SIZE (type))
22082 if (!ENUM_IS_OPAQUE (type))
22083 TREE_ASM_WRITTEN (type) = 1;
22084 if (!orig_type_die || !get_AT (type_die, DW_AT_byte_size))
22085 add_byte_size_attribute (type_die, type);
22086 if (!orig_type_die || !get_AT (type_die, DW_AT_alignment))
22087 add_alignment_attribute (type_die, type);
22088 if ((dwarf_version >= 3 || !dwarf_strict)
22089 && (!orig_type_die || !get_AT (type_die, DW_AT_type)))
22091 tree underlying = lang_hooks.types.enum_underlying_base_type (type);
22092 add_type_attribute (type_die, underlying, TYPE_UNQUALIFIED, false,
22095 if (TYPE_STUB_DECL (type) != NULL_TREE)
22097 if (!orig_type_die || !get_AT (type_die, DW_AT_decl_file))
22098 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
22099 if (!orig_type_die || !get_AT (type_die, DW_AT_accessibility))
22100 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
22103 /* If the first reference to this type was as the return type of an
22104 inline function, then it may not have a parent. Fix this now. */
22105 if (type_die->die_parent == NULL)
22106 add_child_die (scope_die_for (type, context_die), type_die);
22108 for (link = TYPE_VALUES (type);
22109 link != NULL; link = TREE_CHAIN (link))
22111 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
22112 tree value = TREE_VALUE (link);
22114 gcc_assert (!ENUM_IS_OPAQUE (type));
22115 add_name_attribute (enum_die,
22116 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
22118 if (TREE_CODE (value) == CONST_DECL)
22119 value = DECL_INITIAL (value);
22121 if (simple_type_size_in_bits (TREE_TYPE (value))
22122 <= HOST_BITS_PER_WIDE_INT || tree_fits_shwi_p (value))
22124 /* For constant forms created by add_AT_unsigned DWARF
22125 consumers (GDB, elfutils, etc.) always zero extend
22126 the value. Only when the actual value is negative
22127 do we need to use add_AT_int to generate a constant
22128 form that can represent negative values. */
22129 HOST_WIDE_INT val = TREE_INT_CST_LOW (value);
22130 if (TYPE_UNSIGNED (TREE_TYPE (value)) || val >= 0)
22131 add_AT_unsigned (enum_die, DW_AT_const_value,
22132 (unsigned HOST_WIDE_INT) val);
22134 add_AT_int (enum_die, DW_AT_const_value, val);
22137 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
22138 that here. TODO: This should be re-worked to use correct
22139 signed/unsigned double tags for all cases. */
22140 add_AT_wide (enum_die, DW_AT_const_value, wi::to_wide (value));
22143 add_gnat_descriptive_type_attribute (type_die, type, context_die);
22144 if (TYPE_ARTIFICIAL (type)
22145 && (!orig_type_die || !get_AT (type_die, DW_AT_artificial)))
22146 add_AT_flag (type_die, DW_AT_artificial, 1);
22149 add_AT_flag (type_die, DW_AT_declaration, 1);
22151 add_pubtype (type, type_die);
22156 /* Generate a DIE to represent either a real live formal parameter decl or to
22157 represent just the type of some formal parameter position in some function
22160 Note that this routine is a bit unusual because its argument may be a
22161 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
22162 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
22163 node. If it's the former then this function is being called to output a
22164 DIE to represent a formal parameter object (or some inlining thereof). If
22165 it's the latter, then this function is only being called to output a
22166 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
22167 argument type of some subprogram type.
22168 If EMIT_NAME_P is true, name and source coordinate attributes
22172 gen_formal_parameter_die (tree node, tree origin, bool emit_name_p,
22173 dw_die_ref context_die)
22175 tree node_or_origin = node ? node : origin;
22176 tree ultimate_origin;
22177 dw_die_ref parm_die = NULL;
22179 if (DECL_P (node_or_origin))
22181 parm_die = lookup_decl_die (node);
22183 /* If the contexts differ, we may not be talking about the same
22185 ??? When in LTO the DIE parent is the "abstract" copy and the
22186 context_die is the specification "copy". */
22188 && parm_die->die_parent != context_die
22189 && (parm_die->die_parent->die_tag != DW_TAG_GNU_formal_parameter_pack
22190 || parm_die->die_parent->die_parent != context_die)
22193 gcc_assert (!DECL_ABSTRACT_P (node));
22194 /* This can happen when creating a concrete instance, in
22195 which case we need to create a new DIE that will get
22196 annotated with DW_AT_abstract_origin. */
22200 if (parm_die && parm_die->die_parent == NULL)
22202 /* Check that parm_die already has the right attributes that
22203 we would have added below. If any attributes are
22204 missing, fall through to add them. */
22205 if (! DECL_ABSTRACT_P (node_or_origin)
22206 && !get_AT (parm_die, DW_AT_location)
22207 && !get_AT (parm_die, DW_AT_const_value))
22208 /* We are missing location info, and are about to add it. */
22212 add_child_die (context_die, parm_die);
22218 /* If we have a previously generated DIE, use it, unless this is an
22219 concrete instance (origin != NULL), in which case we need a new
22220 DIE with a corresponding DW_AT_abstract_origin. */
22222 if (parm_die && origin == NULL)
22223 reusing_die = true;
22226 parm_die = new_die (DW_TAG_formal_parameter, context_die, node);
22227 reusing_die = false;
22230 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
22232 case tcc_declaration:
22233 ultimate_origin = decl_ultimate_origin (node_or_origin);
22234 if (node || ultimate_origin)
22235 origin = ultimate_origin;
22240 if (origin != NULL)
22241 add_abstract_origin_attribute (parm_die, origin);
22242 else if (emit_name_p)
22243 add_name_and_src_coords_attributes (parm_die, node);
22245 || (! DECL_ABSTRACT_P (node_or_origin)
22246 && variably_modified_type_p (TREE_TYPE (node_or_origin),
22247 decl_function_context
22248 (node_or_origin))))
22250 tree type = TREE_TYPE (node_or_origin);
22251 if (decl_by_reference_p (node_or_origin))
22252 add_type_attribute (parm_die, TREE_TYPE (type),
22254 false, context_die);
22256 add_type_attribute (parm_die, type,
22257 decl_quals (node_or_origin),
22258 false, context_die);
22260 if (origin == NULL && DECL_ARTIFICIAL (node))
22261 add_AT_flag (parm_die, DW_AT_artificial, 1);
22263 if (node && node != origin)
22264 equate_decl_number_to_die (node, parm_die);
22265 if (! DECL_ABSTRACT_P (node_or_origin))
22266 add_location_or_const_value_attribute (parm_die, node_or_origin,
22272 /* We were called with some kind of a ..._TYPE node. */
22273 add_type_attribute (parm_die, node_or_origin, TYPE_UNQUALIFIED, false,
22278 gcc_unreachable ();
22284 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
22285 children DW_TAG_formal_parameter DIEs representing the arguments of the
22288 PARM_PACK must be a function parameter pack.
22289 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
22290 must point to the subsequent arguments of the function PACK_ARG belongs to.
22291 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
22292 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
22293 following the last one for which a DIE was generated. */
22296 gen_formal_parameter_pack_die (tree parm_pack,
22298 dw_die_ref subr_die,
22302 dw_die_ref parm_pack_die;
22304 gcc_assert (parm_pack
22305 && lang_hooks.function_parameter_pack_p (parm_pack)
22308 parm_pack_die = new_die (DW_TAG_GNU_formal_parameter_pack, subr_die, parm_pack);
22309 add_src_coords_attributes (parm_pack_die, parm_pack);
22311 for (arg = pack_arg; arg; arg = DECL_CHAIN (arg))
22313 if (! lang_hooks.decls.function_parm_expanded_from_pack_p (arg,
22316 gen_formal_parameter_die (arg, NULL,
22317 false /* Don't emit name attribute. */,
22322 return parm_pack_die;
22325 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
22326 at the end of an (ANSI prototyped) formal parameters list. */
22329 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
22331 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
22334 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
22335 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
22336 parameters as specified in some function type specification (except for
22337 those which appear as part of a function *definition*). */
22340 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
22343 tree formal_type = NULL;
22344 tree first_parm_type;
22347 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
22349 arg = DECL_ARGUMENTS (function_or_method_type);
22350 function_or_method_type = TREE_TYPE (function_or_method_type);
22355 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
22357 /* Make our first pass over the list of formal parameter types and output a
22358 DW_TAG_formal_parameter DIE for each one. */
22359 for (link = first_parm_type; link; )
22361 dw_die_ref parm_die;
22363 formal_type = TREE_VALUE (link);
22364 if (formal_type == void_type_node)
22367 /* Output a (nameless) DIE to represent the formal parameter itself. */
22368 parm_die = gen_formal_parameter_die (formal_type, NULL,
22369 true /* Emit name attribute. */,
22371 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
22372 && link == first_parm_type)
22374 add_AT_flag (parm_die, DW_AT_artificial, 1);
22375 if (dwarf_version >= 3 || !dwarf_strict)
22376 add_AT_die_ref (context_die, DW_AT_object_pointer, parm_die);
22378 else if (arg && DECL_ARTIFICIAL (arg))
22379 add_AT_flag (parm_die, DW_AT_artificial, 1);
22381 link = TREE_CHAIN (link);
22383 arg = DECL_CHAIN (arg);
22386 /* If this function type has an ellipsis, add a
22387 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
22388 if (formal_type != void_type_node)
22389 gen_unspecified_parameters_die (function_or_method_type, context_die);
22391 /* Make our second (and final) pass over the list of formal parameter types
22392 and output DIEs to represent those types (as necessary). */
22393 for (link = TYPE_ARG_TYPES (function_or_method_type);
22394 link && TREE_VALUE (link);
22395 link = TREE_CHAIN (link))
22396 gen_type_die (TREE_VALUE (link), context_die);
22399 /* We want to generate the DIE for TYPE so that we can generate the
22400 die for MEMBER, which has been defined; we will need to refer back
22401 to the member declaration nested within TYPE. If we're trying to
22402 generate minimal debug info for TYPE, processing TYPE won't do the
22403 trick; we need to attach the member declaration by hand. */
22406 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
22408 gen_type_die (type, context_die);
22410 /* If we're trying to avoid duplicate debug info, we may not have
22411 emitted the member decl for this function. Emit it now. */
22412 if (TYPE_STUB_DECL (type)
22413 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
22414 && ! lookup_decl_die (member))
22416 dw_die_ref type_die;
22417 gcc_assert (!decl_ultimate_origin (member));
22419 type_die = lookup_type_die_strip_naming_typedef (type);
22420 if (TREE_CODE (member) == FUNCTION_DECL)
22421 gen_subprogram_die (member, type_die);
22422 else if (TREE_CODE (member) == FIELD_DECL)
22424 /* Ignore the nameless fields that are used to skip bits but handle
22425 C++ anonymous unions and structs. */
22426 if (DECL_NAME (member) != NULL_TREE
22427 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
22428 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
22430 struct vlr_context vlr_ctx = {
22431 DECL_CONTEXT (member), /* struct_type */
22432 NULL_TREE /* variant_part_offset */
22434 gen_type_die (member_declared_type (member), type_die);
22435 gen_field_die (member, &vlr_ctx, type_die);
22439 gen_variable_die (member, NULL_TREE, type_die);
22443 /* Forward declare these functions, because they are mutually recursive
22444 with their set_block_* pairing functions. */
22445 static void set_decl_origin_self (tree);
22447 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
22448 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
22449 that it points to the node itself, thus indicating that the node is its
22450 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
22451 the given node is NULL, recursively descend the decl/block tree which
22452 it is the root of, and for each other ..._DECL or BLOCK node contained
22453 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
22454 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
22455 values to point to themselves. */
22458 set_block_origin_self (tree stmt)
22460 if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
22462 BLOCK_ABSTRACT_ORIGIN (stmt) = stmt;
22467 for (local_decl = BLOCK_VARS (stmt);
22468 local_decl != NULL_TREE;
22469 local_decl = DECL_CHAIN (local_decl))
22470 /* Do not recurse on nested functions since the inlining status
22471 of parent and child can be different as per the DWARF spec. */
22472 if (TREE_CODE (local_decl) != FUNCTION_DECL
22473 && !DECL_EXTERNAL (local_decl))
22474 set_decl_origin_self (local_decl);
22480 for (subblock = BLOCK_SUBBLOCKS (stmt);
22481 subblock != NULL_TREE;
22482 subblock = BLOCK_CHAIN (subblock))
22483 set_block_origin_self (subblock); /* Recurse. */
22488 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
22489 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
22490 node to so that it points to the node itself, thus indicating that the
22491 node represents its own (abstract) origin. Additionally, if the
22492 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
22493 the decl/block tree of which the given node is the root of, and for
22494 each other ..._DECL or BLOCK node contained therein whose
22495 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
22496 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
22497 point to themselves. */
22500 set_decl_origin_self (tree decl)
22502 if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
22504 DECL_ABSTRACT_ORIGIN (decl) = decl;
22505 if (TREE_CODE (decl) == FUNCTION_DECL)
22509 for (arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg))
22510 DECL_ABSTRACT_ORIGIN (arg) = arg;
22511 if (DECL_INITIAL (decl) != NULL_TREE
22512 && DECL_INITIAL (decl) != error_mark_node)
22513 set_block_origin_self (DECL_INITIAL (decl));
22518 /* Mark the early DIE for DECL as the abstract instance. */
22521 dwarf2out_abstract_function (tree decl)
22523 dw_die_ref old_die;
22525 /* Make sure we have the actual abstract inline, not a clone. */
22526 decl = DECL_ORIGIN (decl);
22528 if (DECL_IGNORED_P (decl))
22531 /* In LTO we're all set. We already created abstract instances
22532 early and we want to avoid creating a concrete instance of that
22533 if we don't output it. */
22537 old_die = lookup_decl_die (decl);
22538 gcc_assert (old_die != NULL);
22539 if (get_AT (old_die, DW_AT_inline))
22540 /* We've already generated the abstract instance. */
22543 /* Go ahead and put DW_AT_inline on the DIE. */
22544 if (DECL_DECLARED_INLINE_P (decl))
22546 if (cgraph_function_possibly_inlined_p (decl))
22547 add_AT_unsigned (old_die, DW_AT_inline, DW_INL_declared_inlined);
22549 add_AT_unsigned (old_die, DW_AT_inline, DW_INL_declared_not_inlined);
22553 if (cgraph_function_possibly_inlined_p (decl))
22554 add_AT_unsigned (old_die, DW_AT_inline, DW_INL_inlined);
22556 add_AT_unsigned (old_die, DW_AT_inline, DW_INL_not_inlined);
22559 if (DECL_DECLARED_INLINE_P (decl)
22560 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl)))
22561 add_AT_flag (old_die, DW_AT_artificial, 1);
22563 set_decl_origin_self (decl);
22566 /* Helper function of premark_used_types() which gets called through
22569 Marks the DIE of a given type in *SLOT as perennial, so it never gets
22570 marked as unused by prune_unused_types. */
22573 premark_used_types_helper (tree const &type, void *)
22577 die = lookup_type_die (type);
22579 die->die_perennial_p = 1;
22583 /* Helper function of premark_types_used_by_global_vars which gets called
22584 through htab_traverse.
22586 Marks the DIE of a given type in *SLOT as perennial, so it never gets
22587 marked as unused by prune_unused_types. The DIE of the type is marked
22588 only if the global variable using the type will actually be emitted. */
22591 premark_types_used_by_global_vars_helper (types_used_by_vars_entry **slot,
22594 struct types_used_by_vars_entry *entry;
22597 entry = (struct types_used_by_vars_entry *) *slot;
22598 gcc_assert (entry->type != NULL
22599 && entry->var_decl != NULL);
22600 die = lookup_type_die (entry->type);
22603 /* Ask cgraph if the global variable really is to be emitted.
22604 If yes, then we'll keep the DIE of ENTRY->TYPE. */
22605 varpool_node *node = varpool_node::get (entry->var_decl);
22606 if (node && node->definition)
22608 die->die_perennial_p = 1;
22609 /* Keep the parent DIEs as well. */
22610 while ((die = die->die_parent) && die->die_perennial_p == 0)
22611 die->die_perennial_p = 1;
22617 /* Mark all members of used_types_hash as perennial. */
22620 premark_used_types (struct function *fun)
22622 if (fun && fun->used_types_hash)
22623 fun->used_types_hash->traverse<void *, premark_used_types_helper> (NULL);
22626 /* Mark all members of types_used_by_vars_entry as perennial. */
22629 premark_types_used_by_global_vars (void)
22631 if (types_used_by_vars_hash)
22632 types_used_by_vars_hash
22633 ->traverse<void *, premark_types_used_by_global_vars_helper> (NULL);
22636 /* Mark all variables used by the symtab as perennial. */
22639 premark_used_variables (void)
22641 /* Mark DIEs in the symtab as used. */
22643 FOR_EACH_VARIABLE (var)
22645 dw_die_ref die = lookup_decl_die (var->decl);
22647 die->die_perennial_p = 1;
22651 /* Generate a DW_TAG_call_site DIE in function DECL under SUBR_DIE
22652 for CA_LOC call arg loc node. */
22655 gen_call_site_die (tree decl, dw_die_ref subr_die,
22656 struct call_arg_loc_node *ca_loc)
22658 dw_die_ref stmt_die = NULL, die;
22659 tree block = ca_loc->block;
22662 && block != DECL_INITIAL (decl)
22663 && TREE_CODE (block) == BLOCK)
22665 stmt_die = lookup_block_die (block);
22668 block = BLOCK_SUPERCONTEXT (block);
22670 if (stmt_die == NULL)
22671 stmt_die = subr_die;
22672 die = new_die (dwarf_TAG (DW_TAG_call_site), stmt_die, NULL_TREE);
22673 add_AT_lbl_id (die, dwarf_AT (DW_AT_call_return_pc), ca_loc->label);
22674 if (ca_loc->tail_call_p)
22675 add_AT_flag (die, dwarf_AT (DW_AT_call_tail_call), 1);
22676 if (ca_loc->symbol_ref)
22678 dw_die_ref tdie = lookup_decl_die (SYMBOL_REF_DECL (ca_loc->symbol_ref));
22680 add_AT_die_ref (die, dwarf_AT (DW_AT_call_origin), tdie);
22682 add_AT_addr (die, dwarf_AT (DW_AT_call_origin), ca_loc->symbol_ref,
22688 /* Generate a DIE to represent a declared function (either file-scope or
22692 gen_subprogram_die (tree decl, dw_die_ref context_die)
22694 tree origin = decl_ultimate_origin (decl);
22695 dw_die_ref subr_die;
22696 dw_die_ref old_die = lookup_decl_die (decl);
22698 /* This function gets called multiple times for different stages of
22699 the debug process. For example, for func() in this code:
22703 void func() { ... }
22706 ...we get called 4 times. Twice in early debug and twice in
22712 1. Once while generating func() within the namespace. This is
22713 the declaration. The declaration bit below is set, as the
22714 context is the namespace.
22716 A new DIE will be generated with DW_AT_declaration set.
22718 2. Once for func() itself. This is the specification. The
22719 declaration bit below is clear as the context is the CU.
22721 We will use the cached DIE from (1) to create a new DIE with
22722 DW_AT_specification pointing to the declaration in (1).
22724 Late debug via rest_of_handle_final()
22725 -------------------------------------
22727 3. Once generating func() within the namespace. This is also the
22728 declaration, as in (1), but this time we will early exit below
22729 as we have a cached DIE and a declaration needs no additional
22730 annotations (no locations), as the source declaration line
22733 4. Once for func() itself. As in (2), this is the specification,
22734 but this time we will re-use the cached DIE, and just annotate
22735 it with the location information that should now be available.
22737 For something without namespaces, but with abstract instances, we
22738 are also called a multiple times:
22743 Base (); // constructor declaration (1)
22746 Base::Base () { } // constructor specification (2)
22751 1. Once for the Base() constructor by virtue of it being a
22752 member of the Base class. This is done via
22753 rest_of_type_compilation.
22755 This is a declaration, so a new DIE will be created with
22758 2. Once for the Base() constructor definition, but this time
22759 while generating the abstract instance of the base
22760 constructor (__base_ctor) which is being generated via early
22761 debug of reachable functions.
22763 Even though we have a cached version of the declaration (1),
22764 we will create a DW_AT_specification of the declaration DIE
22767 3. Once for the __base_ctor itself, but this time, we generate
22768 an DW_AT_abstract_origin version of the DW_AT_specification in
22771 Late debug via rest_of_handle_final
22772 -----------------------------------
22774 4. One final time for the __base_ctor (which will have a cached
22775 DIE with DW_AT_abstract_origin created in (3). This time,
22776 we will just annotate the location information now
22779 int declaration = (current_function_decl != decl
22780 || class_or_namespace_scope_p (context_die));
22782 /* A declaration that has been previously dumped needs no
22783 additional information. */
22784 if (old_die && declaration)
22787 /* Now that the C++ front end lazily declares artificial member fns, we
22788 might need to retrofit the declaration into its class. */
22789 if (!declaration && !origin && !old_die
22790 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
22791 && !class_or_namespace_scope_p (context_die)
22792 && debug_info_level > DINFO_LEVEL_TERSE)
22793 old_die = force_decl_die (decl);
22795 /* A concrete instance, tag a new DIE with DW_AT_abstract_origin. */
22796 if (origin != NULL)
22798 gcc_assert (!declaration || local_scope_p (context_die));
22800 /* Fixup die_parent for the abstract instance of a nested
22801 inline function. */
22802 if (old_die && old_die->die_parent == NULL)
22803 add_child_die (context_die, old_die);
22805 if (old_die && get_AT_ref (old_die, DW_AT_abstract_origin))
22807 /* If we have a DW_AT_abstract_origin we have a working
22809 subr_die = old_die;
22813 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
22814 add_abstract_origin_attribute (subr_die, origin);
22815 /* This is where the actual code for a cloned function is.
22816 Let's emit linkage name attribute for it. This helps
22817 debuggers to e.g, set breakpoints into
22818 constructors/destructors when the user asks "break
22820 add_linkage_name (subr_die, decl);
22823 /* A cached copy, possibly from early dwarf generation. Reuse as
22824 much as possible. */
22827 if (!get_AT_flag (old_die, DW_AT_declaration)
22828 /* We can have a normal definition following an inline one in the
22829 case of redefinition of GNU C extern inlines.
22830 It seems reasonable to use AT_specification in this case. */
22831 && !get_AT (old_die, DW_AT_inline))
22833 /* Detect and ignore this case, where we are trying to output
22834 something we have already output. */
22835 if (get_AT (old_die, DW_AT_low_pc)
22836 || get_AT (old_die, DW_AT_ranges))
22839 /* If we have no location information, this must be a
22840 partially generated DIE from early dwarf generation.
22841 Fall through and generate it. */
22844 /* If the definition comes from the same place as the declaration,
22845 maybe use the old DIE. We always want the DIE for this function
22846 that has the *_pc attributes to be under comp_unit_die so the
22847 debugger can find it. We also need to do this for abstract
22848 instances of inlines, since the spec requires the out-of-line copy
22849 to have the same parent. For local class methods, this doesn't
22850 apply; we just use the old DIE. */
22851 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
22852 struct dwarf_file_data * file_index = lookup_filename (s.file);
22853 if (((is_unit_die (old_die->die_parent)
22854 /* This condition fixes the inconsistency/ICE with the
22855 following Fortran test (or some derivative thereof) while
22856 building libgfortran:
22860 logical function funky (FLAG)
22865 || (old_die->die_parent
22866 && old_die->die_parent->die_tag == DW_TAG_module)
22867 || local_scope_p (old_die->die_parent)
22868 || context_die == NULL)
22869 && (DECL_ARTIFICIAL (decl)
22870 || (get_AT_file (old_die, DW_AT_decl_file) == file_index
22871 && (get_AT_unsigned (old_die, DW_AT_decl_line)
22872 == (unsigned) s.line)
22873 && (!debug_column_info
22875 || (get_AT_unsigned (old_die, DW_AT_decl_column)
22876 == (unsigned) s.column)))))
22877 /* With LTO if there's an abstract instance for
22878 the old DIE, this is a concrete instance and
22879 thus re-use the DIE. */
22880 || get_AT (old_die, DW_AT_abstract_origin))
22882 subr_die = old_die;
22884 /* Clear out the declaration attribute, but leave the
22885 parameters so they can be augmented with location
22886 information later. Unless this was a declaration, in
22887 which case, wipe out the nameless parameters and recreate
22888 them further down. */
22889 if (remove_AT (subr_die, DW_AT_declaration))
22892 remove_AT (subr_die, DW_AT_object_pointer);
22893 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
22896 /* Make a specification pointing to the previously built
22900 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
22901 add_AT_specification (subr_die, old_die);
22902 add_pubname (decl, subr_die);
22903 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
22904 add_AT_file (subr_die, DW_AT_decl_file, file_index);
22905 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
22906 add_AT_unsigned (subr_die, DW_AT_decl_line, s.line);
22907 if (debug_column_info
22909 && (get_AT_unsigned (old_die, DW_AT_decl_column)
22910 != (unsigned) s.column))
22911 add_AT_unsigned (subr_die, DW_AT_decl_column, s.column);
22913 /* If the prototype had an 'auto' or 'decltype(auto)' in
22914 the return type, emit the real type on the definition die. */
22915 if (is_cxx () && debug_info_level > DINFO_LEVEL_TERSE)
22917 dw_die_ref die = get_AT_ref (old_die, DW_AT_type);
22919 && (die->die_tag == DW_TAG_reference_type
22920 || die->die_tag == DW_TAG_rvalue_reference_type
22921 || die->die_tag == DW_TAG_pointer_type
22922 || die->die_tag == DW_TAG_const_type
22923 || die->die_tag == DW_TAG_volatile_type
22924 || die->die_tag == DW_TAG_restrict_type
22925 || die->die_tag == DW_TAG_array_type
22926 || die->die_tag == DW_TAG_ptr_to_member_type
22927 || die->die_tag == DW_TAG_subroutine_type))
22928 die = get_AT_ref (die, DW_AT_type);
22929 if (die == auto_die || die == decltype_auto_die)
22930 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
22931 TYPE_UNQUALIFIED, false, context_die);
22934 /* When we process the method declaration, we haven't seen
22935 the out-of-class defaulted definition yet, so we have to
22937 if ((dwarf_version >= 5 || ! dwarf_strict)
22938 && !get_AT (subr_die, DW_AT_defaulted))
22941 = lang_hooks.decls.decl_dwarf_attribute (decl,
22943 if (defaulted != -1)
22945 /* Other values must have been handled before. */
22946 gcc_assert (defaulted == DW_DEFAULTED_out_of_class);
22947 add_AT_unsigned (subr_die, DW_AT_defaulted, defaulted);
22952 /* Create a fresh DIE for anything else. */
22955 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
22957 if (TREE_PUBLIC (decl))
22958 add_AT_flag (subr_die, DW_AT_external, 1);
22960 add_name_and_src_coords_attributes (subr_die, decl);
22961 add_pubname (decl, subr_die);
22962 if (debug_info_level > DINFO_LEVEL_TERSE)
22964 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
22965 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
22966 TYPE_UNQUALIFIED, false, context_die);
22969 add_pure_or_virtual_attribute (subr_die, decl);
22970 if (DECL_ARTIFICIAL (decl))
22971 add_AT_flag (subr_die, DW_AT_artificial, 1);
22973 if (TREE_THIS_VOLATILE (decl) && (dwarf_version >= 5 || !dwarf_strict))
22974 add_AT_flag (subr_die, DW_AT_noreturn, 1);
22976 add_alignment_attribute (subr_die, decl);
22978 add_accessibility_attribute (subr_die, decl);
22981 /* Unless we have an existing non-declaration DIE, equate the new
22983 if (!old_die || is_declaration_die (old_die))
22984 equate_decl_number_to_die (decl, subr_die);
22988 if (!old_die || !get_AT (old_die, DW_AT_inline))
22990 add_AT_flag (subr_die, DW_AT_declaration, 1);
22992 /* If this is an explicit function declaration then generate
22993 a DW_AT_explicit attribute. */
22994 if ((dwarf_version >= 3 || !dwarf_strict)
22995 && lang_hooks.decls.decl_dwarf_attribute (decl,
22996 DW_AT_explicit) == 1)
22997 add_AT_flag (subr_die, DW_AT_explicit, 1);
22999 /* If this is a C++11 deleted special function member then generate
23000 a DW_AT_deleted attribute. */
23001 if ((dwarf_version >= 5 || !dwarf_strict)
23002 && lang_hooks.decls.decl_dwarf_attribute (decl,
23003 DW_AT_deleted) == 1)
23004 add_AT_flag (subr_die, DW_AT_deleted, 1);
23006 /* If this is a C++11 defaulted special function member then
23007 generate a DW_AT_defaulted attribute. */
23008 if (dwarf_version >= 5 || !dwarf_strict)
23011 = lang_hooks.decls.decl_dwarf_attribute (decl,
23013 if (defaulted != -1)
23014 add_AT_unsigned (subr_die, DW_AT_defaulted, defaulted);
23017 /* If this is a C++11 non-static member function with & ref-qualifier
23018 then generate a DW_AT_reference attribute. */
23019 if ((dwarf_version >= 5 || !dwarf_strict)
23020 && lang_hooks.decls.decl_dwarf_attribute (decl,
23021 DW_AT_reference) == 1)
23022 add_AT_flag (subr_die, DW_AT_reference, 1);
23024 /* If this is a C++11 non-static member function with &&
23025 ref-qualifier then generate a DW_AT_reference attribute. */
23026 if ((dwarf_version >= 5 || !dwarf_strict)
23027 && lang_hooks.decls.decl_dwarf_attribute (decl,
23028 DW_AT_rvalue_reference)
23030 add_AT_flag (subr_die, DW_AT_rvalue_reference, 1);
23033 /* For non DECL_EXTERNALs, if range information is available, fill
23034 the DIE with it. */
23035 else if (!DECL_EXTERNAL (decl) && !early_dwarf)
23037 HOST_WIDE_INT cfa_fb_offset;
23039 struct function *fun = DECL_STRUCT_FUNCTION (decl);
23041 if (!crtl->has_bb_partition)
23043 dw_fde_ref fde = fun->fde;
23044 if (fde->dw_fde_begin)
23046 /* We have already generated the labels. */
23047 add_AT_low_high_pc (subr_die, fde->dw_fde_begin,
23048 fde->dw_fde_end, false);
23052 /* Create start/end labels and add the range. */
23053 char label_id_low[MAX_ARTIFICIAL_LABEL_BYTES];
23054 char label_id_high[MAX_ARTIFICIAL_LABEL_BYTES];
23055 ASM_GENERATE_INTERNAL_LABEL (label_id_low, FUNC_BEGIN_LABEL,
23056 current_function_funcdef_no);
23057 ASM_GENERATE_INTERNAL_LABEL (label_id_high, FUNC_END_LABEL,
23058 current_function_funcdef_no);
23059 add_AT_low_high_pc (subr_die, label_id_low, label_id_high,
23063 #if VMS_DEBUGGING_INFO
23064 /* HP OpenVMS Industry Standard 64: DWARF Extensions
23065 Section 2.3 Prologue and Epilogue Attributes:
23066 When a breakpoint is set on entry to a function, it is generally
23067 desirable for execution to be suspended, not on the very first
23068 instruction of the function, but rather at a point after the
23069 function's frame has been set up, after any language defined local
23070 declaration processing has been completed, and before execution of
23071 the first statement of the function begins. Debuggers generally
23072 cannot properly determine where this point is. Similarly for a
23073 breakpoint set on exit from a function. The prologue and epilogue
23074 attributes allow a compiler to communicate the location(s) to use. */
23077 if (fde->dw_fde_vms_end_prologue)
23078 add_AT_vms_delta (subr_die, DW_AT_HP_prologue,
23079 fde->dw_fde_begin, fde->dw_fde_vms_end_prologue);
23081 if (fde->dw_fde_vms_begin_epilogue)
23082 add_AT_vms_delta (subr_die, DW_AT_HP_epilogue,
23083 fde->dw_fde_begin, fde->dw_fde_vms_begin_epilogue);
23090 /* Generate pubnames entries for the split function code ranges. */
23091 dw_fde_ref fde = fun->fde;
23093 if (fde->dw_fde_second_begin)
23095 if (dwarf_version >= 3 || !dwarf_strict)
23097 /* We should use ranges for non-contiguous code section
23098 addresses. Use the actual code range for the initial
23099 section, since the HOT/COLD labels might precede an
23100 alignment offset. */
23101 bool range_list_added = false;
23102 add_ranges_by_labels (subr_die, fde->dw_fde_begin,
23103 fde->dw_fde_end, &range_list_added,
23105 add_ranges_by_labels (subr_die, fde->dw_fde_second_begin,
23106 fde->dw_fde_second_end,
23107 &range_list_added, false);
23108 if (range_list_added)
23113 /* There is no real support in DW2 for this .. so we make
23114 a work-around. First, emit the pub name for the segment
23115 containing the function label. Then make and emit a
23116 simplified subprogram DIE for the second segment with the
23117 name pre-fixed by __hot/cold_sect_of_. We use the same
23118 linkage name for the second die so that gdb will find both
23119 sections when given "b foo". */
23120 const char *name = NULL;
23121 tree decl_name = DECL_NAME (decl);
23122 dw_die_ref seg_die;
23124 /* Do the 'primary' section. */
23125 add_AT_low_high_pc (subr_die, fde->dw_fde_begin,
23126 fde->dw_fde_end, false);
23128 /* Build a minimal DIE for the secondary section. */
23129 seg_die = new_die (DW_TAG_subprogram,
23130 subr_die->die_parent, decl);
23132 if (TREE_PUBLIC (decl))
23133 add_AT_flag (seg_die, DW_AT_external, 1);
23135 if (decl_name != NULL
23136 && IDENTIFIER_POINTER (decl_name) != NULL)
23138 name = dwarf2_name (decl, 1);
23139 if (! DECL_ARTIFICIAL (decl))
23140 add_src_coords_attributes (seg_die, decl);
23142 add_linkage_name (seg_die, decl);
23144 gcc_assert (name != NULL);
23145 add_pure_or_virtual_attribute (seg_die, decl);
23146 if (DECL_ARTIFICIAL (decl))
23147 add_AT_flag (seg_die, DW_AT_artificial, 1);
23149 name = concat ("__second_sect_of_", name, NULL);
23150 add_AT_low_high_pc (seg_die, fde->dw_fde_second_begin,
23151 fde->dw_fde_second_end, false);
23152 add_name_attribute (seg_die, name);
23153 if (want_pubnames ())
23154 add_pubname_string (name, seg_die);
23158 add_AT_low_high_pc (subr_die, fde->dw_fde_begin, fde->dw_fde_end,
23162 cfa_fb_offset = CFA_FRAME_BASE_OFFSET (decl);
23164 /* We define the "frame base" as the function's CFA. This is more
23165 convenient for several reasons: (1) It's stable across the prologue
23166 and epilogue, which makes it better than just a frame pointer,
23167 (2) With dwarf3, there exists a one-byte encoding that allows us
23168 to reference the .debug_frame data by proxy, but failing that,
23169 (3) We can at least reuse the code inspection and interpretation
23170 code that determines the CFA position at various points in the
23172 if (dwarf_version >= 3 && targetm.debug_unwind_info () == UI_DWARF2)
23174 dw_loc_descr_ref op = new_loc_descr (DW_OP_call_frame_cfa, 0, 0);
23175 add_AT_loc (subr_die, DW_AT_frame_base, op);
23179 dw_loc_list_ref list = convert_cfa_to_fb_loc_list (cfa_fb_offset);
23180 if (list->dw_loc_next)
23181 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
23183 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
23186 /* Compute a displacement from the "steady-state frame pointer" to
23187 the CFA. The former is what all stack slots and argument slots
23188 will reference in the rtl; the latter is what we've told the
23189 debugger about. We'll need to adjust all frame_base references
23190 by this displacement. */
23191 compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
23193 if (fun->static_chain_decl)
23195 /* DWARF requires here a location expression that computes the
23196 address of the enclosing subprogram's frame base. The machinery
23197 in tree-nested.c is supposed to store this specific address in the
23198 last field of the FRAME record. */
23199 const tree frame_type
23200 = TREE_TYPE (TREE_TYPE (fun->static_chain_decl));
23201 const tree fb_decl = tree_last (TYPE_FIELDS (frame_type));
23204 = build1 (INDIRECT_REF, frame_type, fun->static_chain_decl);
23205 fb_expr = build3 (COMPONENT_REF, TREE_TYPE (fb_decl),
23206 fb_expr, fb_decl, NULL_TREE);
23208 add_AT_location_description (subr_die, DW_AT_static_link,
23209 loc_list_from_tree (fb_expr, 0, NULL));
23212 resolve_variable_values ();
23215 /* Generate child dies for template paramaters. */
23216 if (early_dwarf && debug_info_level > DINFO_LEVEL_TERSE)
23217 gen_generic_params_dies (decl);
23219 /* Now output descriptions of the arguments for this function. This gets
23220 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
23221 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
23222 `...' at the end of the formal parameter list. In order to find out if
23223 there was a trailing ellipsis or not, we must instead look at the type
23224 associated with the FUNCTION_DECL. This will be a node of type
23225 FUNCTION_TYPE. If the chain of type nodes hanging off of this
23226 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
23227 an ellipsis at the end. */
23229 /* In the case where we are describing a mere function declaration, all we
23230 need to do here (and all we *can* do here) is to describe the *types* of
23231 its formal parameters. */
23232 if (debug_info_level <= DINFO_LEVEL_TERSE)
23234 else if (declaration)
23235 gen_formal_types_die (decl, subr_die);
23238 /* Generate DIEs to represent all known formal parameters. */
23239 tree parm = DECL_ARGUMENTS (decl);
23240 tree generic_decl = early_dwarf
23241 ? lang_hooks.decls.get_generic_function_decl (decl) : NULL;
23242 tree generic_decl_parm = generic_decl
23243 ? DECL_ARGUMENTS (generic_decl)
23246 /* Now we want to walk the list of parameters of the function and
23247 emit their relevant DIEs.
23249 We consider the case of DECL being an instance of a generic function
23250 as well as it being a normal function.
23252 If DECL is an instance of a generic function we walk the
23253 parameters of the generic function declaration _and_ the parameters of
23254 DECL itself. This is useful because we want to emit specific DIEs for
23255 function parameter packs and those are declared as part of the
23256 generic function declaration. In that particular case,
23257 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
23258 That DIE has children DIEs representing the set of arguments
23259 of the pack. Note that the set of pack arguments can be empty.
23260 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
23263 Otherwise, we just consider the parameters of DECL. */
23264 while (generic_decl_parm || parm)
23266 if (generic_decl_parm
23267 && lang_hooks.function_parameter_pack_p (generic_decl_parm))
23268 gen_formal_parameter_pack_die (generic_decl_parm,
23273 dw_die_ref parm_die = gen_decl_die (parm, NULL, NULL, subr_die);
23276 && parm == DECL_ARGUMENTS (decl)
23277 && TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE
23279 && (dwarf_version >= 3 || !dwarf_strict))
23280 add_AT_die_ref (subr_die, DW_AT_object_pointer, parm_die);
23282 parm = DECL_CHAIN (parm);
23285 if (generic_decl_parm)
23286 generic_decl_parm = DECL_CHAIN (generic_decl_parm);
23289 /* Decide whether we need an unspecified_parameters DIE at the end.
23290 There are 2 more cases to do this for: 1) the ansi ... declaration -
23291 this is detectable when the end of the arg list is not a
23292 void_type_node 2) an unprototyped function declaration (not a
23293 definition). This just means that we have no info about the
23294 parameters at all. */
23297 if (prototype_p (TREE_TYPE (decl)))
23299 /* This is the prototyped case, check for.... */
23300 if (stdarg_p (TREE_TYPE (decl)))
23301 gen_unspecified_parameters_die (decl, subr_die);
23303 else if (DECL_INITIAL (decl) == NULL_TREE)
23304 gen_unspecified_parameters_die (decl, subr_die);
23308 if (subr_die != old_die)
23309 /* Add the calling convention attribute if requested. */
23310 add_calling_convention_attribute (subr_die, decl);
23312 /* Output Dwarf info for all of the stuff within the body of the function
23313 (if it has one - it may be just a declaration).
23315 OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
23316 a function. This BLOCK actually represents the outermost binding contour
23317 for the function, i.e. the contour in which the function's formal
23318 parameters and labels get declared. Curiously, it appears that the front
23319 end doesn't actually put the PARM_DECL nodes for the current function onto
23320 the BLOCK_VARS list for this outer scope, but are strung off of the
23321 DECL_ARGUMENTS list for the function instead.
23323 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
23324 the LABEL_DECL nodes for the function however, and we output DWARF info
23325 for those in decls_for_scope. Just within the `outer_scope' there will be
23326 a BLOCK node representing the function's outermost pair of curly braces,
23327 and any blocks used for the base and member initializers of a C++
23328 constructor function. */
23329 tree outer_scope = DECL_INITIAL (decl);
23330 if (! declaration && outer_scope && TREE_CODE (outer_scope) != ERROR_MARK)
23332 int call_site_note_count = 0;
23333 int tail_call_site_note_count = 0;
23335 /* Emit a DW_TAG_variable DIE for a named return value. */
23336 if (DECL_NAME (DECL_RESULT (decl)))
23337 gen_decl_die (DECL_RESULT (decl), NULL, NULL, subr_die);
23339 /* The first time through decls_for_scope we will generate the
23340 DIEs for the locals. The second time, we fill in the
23342 decls_for_scope (outer_scope, subr_die);
23344 if (call_arg_locations && (!dwarf_strict || dwarf_version >= 5))
23346 struct call_arg_loc_node *ca_loc;
23347 for (ca_loc = call_arg_locations; ca_loc; ca_loc = ca_loc->next)
23349 dw_die_ref die = NULL;
23350 rtx tloc = NULL_RTX, tlocc = NULL_RTX;
23352 tree arg_decl = NULL_TREE;
23354 for (arg = (ca_loc->call_arg_loc_note != NULL_RTX
23355 ? XEXP (ca_loc->call_arg_loc_note, 0)
23357 arg; arg = next_arg)
23359 dw_loc_descr_ref reg, val;
23360 machine_mode mode = GET_MODE (XEXP (XEXP (arg, 0), 1));
23361 dw_die_ref cdie, tdie = NULL;
23363 next_arg = XEXP (arg, 1);
23364 if (REG_P (XEXP (XEXP (arg, 0), 0))
23366 && MEM_P (XEXP (XEXP (next_arg, 0), 0))
23367 && REG_P (XEXP (XEXP (XEXP (next_arg, 0), 0), 0))
23368 && REGNO (XEXP (XEXP (arg, 0), 0))
23369 == REGNO (XEXP (XEXP (XEXP (next_arg, 0), 0), 0)))
23370 next_arg = XEXP (next_arg, 1);
23371 if (mode == VOIDmode)
23373 mode = GET_MODE (XEXP (XEXP (arg, 0), 0));
23374 if (mode == VOIDmode)
23375 mode = GET_MODE (XEXP (arg, 0));
23377 if (mode == VOIDmode || mode == BLKmode)
23379 /* Get dynamic information about call target only if we
23380 have no static information: we cannot generate both
23381 DW_AT_call_origin and DW_AT_call_target
23383 if (ca_loc->symbol_ref == NULL_RTX)
23385 if (XEXP (XEXP (arg, 0), 0) == pc_rtx)
23387 tloc = XEXP (XEXP (arg, 0), 1);
23390 else if (GET_CODE (XEXP (XEXP (arg, 0), 0)) == CLOBBER
23391 && XEXP (XEXP (XEXP (arg, 0), 0), 0) == pc_rtx)
23393 tlocc = XEXP (XEXP (arg, 0), 1);
23398 if (REG_P (XEXP (XEXP (arg, 0), 0)))
23399 reg = reg_loc_descriptor (XEXP (XEXP (arg, 0), 0),
23400 VAR_INIT_STATUS_INITIALIZED);
23401 else if (MEM_P (XEXP (XEXP (arg, 0), 0)))
23403 rtx mem = XEXP (XEXP (arg, 0), 0);
23404 reg = mem_loc_descriptor (XEXP (mem, 0),
23405 get_address_mode (mem),
23407 VAR_INIT_STATUS_INITIALIZED);
23409 else if (GET_CODE (XEXP (XEXP (arg, 0), 0))
23410 == DEBUG_PARAMETER_REF)
23413 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg, 0), 0));
23414 tdie = lookup_decl_die (tdecl);
23422 && GET_CODE (XEXP (XEXP (arg, 0), 0))
23423 != DEBUG_PARAMETER_REF)
23425 val = mem_loc_descriptor (XEXP (XEXP (arg, 0), 1), mode,
23427 VAR_INIT_STATUS_INITIALIZED);
23431 die = gen_call_site_die (decl, subr_die, ca_loc);
23432 cdie = new_die (dwarf_TAG (DW_TAG_call_site_parameter), die,
23434 add_desc_attribute (cdie, arg_decl);
23436 add_AT_loc (cdie, DW_AT_location, reg);
23437 else if (tdie != NULL)
23438 add_AT_die_ref (cdie, dwarf_AT (DW_AT_call_parameter),
23440 add_AT_loc (cdie, dwarf_AT (DW_AT_call_value), val);
23441 if (next_arg != XEXP (arg, 1))
23443 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 1));
23444 if (mode == VOIDmode)
23445 mode = GET_MODE (XEXP (XEXP (XEXP (arg, 1), 0), 0));
23446 val = mem_loc_descriptor (XEXP (XEXP (XEXP (arg, 1),
23449 VAR_INIT_STATUS_INITIALIZED);
23451 add_AT_loc (cdie, dwarf_AT (DW_AT_call_data_value),
23456 && (ca_loc->symbol_ref || tloc))
23457 die = gen_call_site_die (decl, subr_die, ca_loc);
23458 if (die != NULL && (tloc != NULL_RTX || tlocc != NULL_RTX))
23460 dw_loc_descr_ref tval = NULL;
23462 if (tloc != NULL_RTX)
23463 tval = mem_loc_descriptor (tloc,
23464 GET_MODE (tloc) == VOIDmode
23465 ? Pmode : GET_MODE (tloc),
23467 VAR_INIT_STATUS_INITIALIZED);
23469 add_AT_loc (die, dwarf_AT (DW_AT_call_target), tval);
23470 else if (tlocc != NULL_RTX)
23472 tval = mem_loc_descriptor (tlocc,
23473 GET_MODE (tlocc) == VOIDmode
23474 ? Pmode : GET_MODE (tlocc),
23476 VAR_INIT_STATUS_INITIALIZED);
23479 dwarf_AT (DW_AT_call_target_clobbered),
23485 call_site_note_count++;
23486 if (ca_loc->tail_call_p)
23487 tail_call_site_note_count++;
23491 call_arg_locations = NULL;
23492 call_arg_loc_last = NULL;
23493 if (tail_call_site_count >= 0
23494 && tail_call_site_count == tail_call_site_note_count
23495 && (!dwarf_strict || dwarf_version >= 5))
23497 if (call_site_count >= 0
23498 && call_site_count == call_site_note_count)
23499 add_AT_flag (subr_die, dwarf_AT (DW_AT_call_all_calls), 1);
23501 add_AT_flag (subr_die, dwarf_AT (DW_AT_call_all_tail_calls), 1);
23503 call_site_count = -1;
23504 tail_call_site_count = -1;
23507 /* Mark used types after we have created DIEs for the functions scopes. */
23508 premark_used_types (DECL_STRUCT_FUNCTION (decl));
23511 /* Returns a hash value for X (which really is a die_struct). */
23514 block_die_hasher::hash (die_struct *d)
23516 return (hashval_t) d->decl_id ^ htab_hash_pointer (d->die_parent);
23519 /* Return nonzero if decl_id and die_parent of die_struct X is the same
23520 as decl_id and die_parent of die_struct Y. */
23523 block_die_hasher::equal (die_struct *x, die_struct *y)
23525 return x->decl_id == y->decl_id && x->die_parent == y->die_parent;
23528 /* Hold information about markers for inlined entry points. */
23529 struct GTY ((for_user)) inline_entry_data
23531 /* The block that's the inlined_function_outer_scope for an inlined
23535 /* The label at the inlined entry point. */
23536 const char *label_pfx;
23537 unsigned int label_num;
23539 /* The view number to be used as the inlined entry point. */
23543 struct inline_entry_data_hasher : ggc_ptr_hash <inline_entry_data>
23545 typedef tree compare_type;
23546 static inline hashval_t hash (const inline_entry_data *);
23547 static inline bool equal (const inline_entry_data *, const_tree);
23550 /* Hash table routines for inline_entry_data. */
23553 inline_entry_data_hasher::hash (const inline_entry_data *data)
23555 return htab_hash_pointer (data->block);
23559 inline_entry_data_hasher::equal (const inline_entry_data *data,
23562 return data->block == block;
23565 /* Inlined entry points pending DIE creation in this compilation unit. */
23567 static GTY(()) hash_table<inline_entry_data_hasher> *inline_entry_data_table;
23570 /* Return TRUE if DECL, which may have been previously generated as
23571 OLD_DIE, is a candidate for a DW_AT_specification. DECLARATION is
23572 true if decl (or its origin) is either an extern declaration or a
23573 class/namespace scoped declaration.
23575 The declare_in_namespace support causes us to get two DIEs for one
23576 variable, both of which are declarations. We want to avoid
23577 considering one to be a specification, so we must test for
23578 DECLARATION and DW_AT_declaration. */
23580 decl_will_get_specification_p (dw_die_ref old_die, tree decl, bool declaration)
23582 return (old_die && TREE_STATIC (decl) && !declaration
23583 && get_AT_flag (old_die, DW_AT_declaration) == 1);
23586 /* Return true if DECL is a local static. */
23589 local_function_static (tree decl)
23591 gcc_assert (VAR_P (decl));
23592 return TREE_STATIC (decl)
23593 && DECL_CONTEXT (decl)
23594 && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL;
23597 /* Return true iff DECL overrides (presumably completes) the type of
23598 OLD_DIE within CONTEXT_DIE. */
23601 override_type_for_decl_p (tree decl, dw_die_ref old_die,
23602 dw_die_ref context_die)
23604 tree type = TREE_TYPE (decl);
23607 if (decl_by_reference_p (decl))
23609 type = TREE_TYPE (type);
23610 cv_quals = TYPE_UNQUALIFIED;
23613 cv_quals = decl_quals (decl);
23615 dw_die_ref type_die = modified_type_die (type,
23616 cv_quals | TYPE_QUALS (type),
23620 dw_die_ref old_type_die = get_AT_ref (old_die, DW_AT_type);
23622 return type_die != old_type_die;
23625 /* Generate a DIE to represent a declared data object.
23626 Either DECL or ORIGIN must be non-null. */
23629 gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
23631 HOST_WIDE_INT off = 0;
23633 tree decl_or_origin = decl ? decl : origin;
23634 tree ultimate_origin;
23635 dw_die_ref var_die;
23636 dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
23637 bool declaration = (DECL_EXTERNAL (decl_or_origin)
23638 || class_or_namespace_scope_p (context_die));
23639 bool specialization_p = false;
23640 bool no_linkage_name = false;
23642 /* While C++ inline static data members have definitions inside of the
23643 class, force the first DIE to be a declaration, then let gen_member_die
23644 reparent it to the class context and call gen_variable_die again
23645 to create the outside of the class DIE for the definition. */
23649 && DECL_CONTEXT (decl)
23650 && TYPE_P (DECL_CONTEXT (decl))
23651 && lang_hooks.decls.decl_dwarf_attribute (decl, DW_AT_inline) != -1)
23653 declaration = true;
23654 if (dwarf_version < 5)
23655 no_linkage_name = true;
23658 ultimate_origin = decl_ultimate_origin (decl_or_origin);
23659 if (decl || ultimate_origin)
23660 origin = ultimate_origin;
23661 com_decl = fortran_common (decl_or_origin, &off);
23663 /* Symbol in common gets emitted as a child of the common block, in the form
23664 of a data member. */
23667 dw_die_ref com_die;
23668 dw_loc_list_ref loc = NULL;
23669 die_node com_die_arg;
23671 var_die = lookup_decl_die (decl_or_origin);
23674 if (! early_dwarf && get_AT (var_die, DW_AT_location) == NULL)
23676 loc = loc_list_from_tree (com_decl, off ? 1 : 2, NULL);
23681 /* Optimize the common case. */
23682 if (single_element_loc_list_p (loc)
23683 && loc->expr->dw_loc_opc == DW_OP_addr
23684 && loc->expr->dw_loc_next == NULL
23685 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr)
23688 rtx x = loc->expr->dw_loc_oprnd1.v.val_addr;
23689 loc->expr->dw_loc_oprnd1.v.val_addr
23690 = plus_constant (GET_MODE (x), x , off);
23693 loc_list_plus_const (loc, off);
23695 add_AT_location_description (var_die, DW_AT_location, loc);
23696 remove_AT (var_die, DW_AT_declaration);
23702 if (common_block_die_table == NULL)
23703 common_block_die_table = hash_table<block_die_hasher>::create_ggc (10);
23705 com_die_arg.decl_id = DECL_UID (com_decl);
23706 com_die_arg.die_parent = context_die;
23707 com_die = common_block_die_table->find (&com_die_arg);
23709 loc = loc_list_from_tree (com_decl, 2, NULL);
23710 if (com_die == NULL)
23713 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl));
23716 com_die = new_die (DW_TAG_common_block, context_die, decl);
23717 add_name_and_src_coords_attributes (com_die, com_decl);
23720 add_AT_location_description (com_die, DW_AT_location, loc);
23721 /* Avoid sharing the same loc descriptor between
23722 DW_TAG_common_block and DW_TAG_variable. */
23723 loc = loc_list_from_tree (com_decl, 2, NULL);
23725 else if (DECL_EXTERNAL (decl_or_origin))
23726 add_AT_flag (com_die, DW_AT_declaration, 1);
23727 if (want_pubnames ())
23728 add_pubname_string (cnam, com_die); /* ??? needed? */
23729 com_die->decl_id = DECL_UID (com_decl);
23730 slot = common_block_die_table->find_slot (com_die, INSERT);
23733 else if (get_AT (com_die, DW_AT_location) == NULL && loc)
23735 add_AT_location_description (com_die, DW_AT_location, loc);
23736 loc = loc_list_from_tree (com_decl, 2, NULL);
23737 remove_AT (com_die, DW_AT_declaration);
23739 var_die = new_die (DW_TAG_variable, com_die, decl);
23740 add_name_and_src_coords_attributes (var_die, decl_or_origin);
23741 add_type_attribute (var_die, TREE_TYPE (decl_or_origin),
23742 decl_quals (decl_or_origin), false,
23744 add_alignment_attribute (var_die, decl);
23745 add_AT_flag (var_die, DW_AT_external, 1);
23750 /* Optimize the common case. */
23751 if (single_element_loc_list_p (loc)
23752 && loc->expr->dw_loc_opc == DW_OP_addr
23753 && loc->expr->dw_loc_next == NULL
23754 && GET_CODE (loc->expr->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF)
23756 rtx x = loc->expr->dw_loc_oprnd1.v.val_addr;
23757 loc->expr->dw_loc_oprnd1.v.val_addr
23758 = plus_constant (GET_MODE (x), x, off);
23761 loc_list_plus_const (loc, off);
23763 add_AT_location_description (var_die, DW_AT_location, loc);
23765 else if (DECL_EXTERNAL (decl_or_origin))
23766 add_AT_flag (var_die, DW_AT_declaration, 1);
23768 equate_decl_number_to_die (decl, var_die);
23776 /* A declaration that has been previously dumped, needs no
23777 further annotations, since it doesn't need location on
23778 the second pass. */
23781 else if (decl_will_get_specification_p (old_die, decl, declaration)
23782 && !get_AT (old_die, DW_AT_specification))
23784 /* Fall-thru so we can make a new variable die along with a
23785 DW_AT_specification. */
23787 else if (origin && old_die->die_parent != context_die)
23789 /* If we will be creating an inlined instance, we need a
23790 new DIE that will get annotated with
23791 DW_AT_abstract_origin. */
23792 gcc_assert (!DECL_ABSTRACT_P (decl));
23796 /* If a DIE was dumped early, it still needs location info.
23797 Skip to where we fill the location bits. */
23800 /* ??? In LTRANS we cannot annotate early created variably
23801 modified type DIEs without copying them and adjusting all
23802 references to them. Thus we dumped them again. Also add a
23803 reference to them but beware of -g0 compile and -g link
23804 in which case the reference will be already present. */
23805 tree type = TREE_TYPE (decl_or_origin);
23807 && ! get_AT (var_die, DW_AT_type)
23808 && variably_modified_type_p
23809 (type, decl_function_context (decl_or_origin)))
23811 if (decl_by_reference_p (decl_or_origin))
23812 add_type_attribute (var_die, TREE_TYPE (type),
23813 TYPE_UNQUALIFIED, false, context_die);
23815 add_type_attribute (var_die, type, decl_quals (decl_or_origin),
23816 false, context_die);
23819 goto gen_variable_die_location;
23823 /* For static data members, the declaration in the class is supposed
23824 to have DW_TAG_member tag in DWARF{3,4} and we emit it for compatibility
23825 also in DWARF2; the specification should still be DW_TAG_variable
23826 referencing the DW_TAG_member DIE. */
23827 if (declaration && class_scope_p (context_die) && dwarf_version < 5)
23828 var_die = new_die (DW_TAG_member, context_die, decl);
23830 var_die = new_die (DW_TAG_variable, context_die, decl);
23832 if (origin != NULL)
23833 add_abstract_origin_attribute (var_die, origin);
23835 /* Loop unrolling can create multiple blocks that refer to the same
23836 static variable, so we must test for the DW_AT_declaration flag.
23838 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
23839 copy decls and set the DECL_ABSTRACT_P flag on them instead of
23842 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
23843 else if (decl_will_get_specification_p (old_die, decl, declaration))
23845 /* This is a definition of a C++ class level static. */
23846 add_AT_specification (var_die, old_die);
23847 specialization_p = true;
23848 if (DECL_NAME (decl))
23850 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
23851 struct dwarf_file_data * file_index = lookup_filename (s.file);
23853 if (get_AT_file (old_die, DW_AT_decl_file) != file_index)
23854 add_AT_file (var_die, DW_AT_decl_file, file_index);
23856 if (get_AT_unsigned (old_die, DW_AT_decl_line) != (unsigned) s.line)
23857 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
23859 if (debug_column_info
23861 && (get_AT_unsigned (old_die, DW_AT_decl_column)
23862 != (unsigned) s.column))
23863 add_AT_unsigned (var_die, DW_AT_decl_column, s.column);
23865 if (old_die->die_tag == DW_TAG_member)
23866 add_linkage_name (var_die, decl);
23870 add_name_and_src_coords_attributes (var_die, decl, no_linkage_name);
23872 if ((origin == NULL && !specialization_p)
23874 && !DECL_ABSTRACT_P (decl_or_origin)
23875 && variably_modified_type_p (TREE_TYPE (decl_or_origin),
23876 decl_function_context
23878 || (old_die && specialization_p
23879 && override_type_for_decl_p (decl_or_origin, old_die, context_die)))
23881 tree type = TREE_TYPE (decl_or_origin);
23883 if (decl_by_reference_p (decl_or_origin))
23884 add_type_attribute (var_die, TREE_TYPE (type), TYPE_UNQUALIFIED, false,
23887 add_type_attribute (var_die, type, decl_quals (decl_or_origin), false,
23891 if (origin == NULL && !specialization_p)
23893 if (TREE_PUBLIC (decl))
23894 add_AT_flag (var_die, DW_AT_external, 1);
23896 if (DECL_ARTIFICIAL (decl))
23897 add_AT_flag (var_die, DW_AT_artificial, 1);
23899 add_alignment_attribute (var_die, decl);
23901 add_accessibility_attribute (var_die, decl);
23905 add_AT_flag (var_die, DW_AT_declaration, 1);
23907 if (decl && (DECL_ABSTRACT_P (decl)
23908 || !old_die || is_declaration_die (old_die)))
23909 equate_decl_number_to_die (decl, var_die);
23911 gen_variable_die_location:
23913 && (! DECL_ABSTRACT_P (decl_or_origin)
23914 /* Local static vars are shared between all clones/inlines,
23915 so emit DW_AT_location on the abstract DIE if DECL_RTL is
23917 || (VAR_P (decl_or_origin)
23918 && TREE_STATIC (decl_or_origin)
23919 && DECL_RTL_SET_P (decl_or_origin))))
23922 add_pubname (decl_or_origin, var_die);
23924 add_location_or_const_value_attribute (var_die, decl_or_origin,
23928 tree_add_const_value_attribute_for_decl (var_die, decl_or_origin);
23930 if ((dwarf_version >= 4 || !dwarf_strict)
23931 && lang_hooks.decls.decl_dwarf_attribute (decl_or_origin,
23932 DW_AT_const_expr) == 1
23933 && !get_AT (var_die, DW_AT_const_expr)
23934 && !specialization_p)
23935 add_AT_flag (var_die, DW_AT_const_expr, 1);
23939 int inl = lang_hooks.decls.decl_dwarf_attribute (decl_or_origin,
23942 && !get_AT (var_die, DW_AT_inline)
23943 && !specialization_p)
23944 add_AT_unsigned (var_die, DW_AT_inline, inl);
23948 /* Generate a DIE to represent a named constant. */
23951 gen_const_die (tree decl, dw_die_ref context_die)
23953 dw_die_ref const_die;
23954 tree type = TREE_TYPE (decl);
23956 const_die = lookup_decl_die (decl);
23960 const_die = new_die (DW_TAG_constant, context_die, decl);
23961 equate_decl_number_to_die (decl, const_die);
23962 add_name_and_src_coords_attributes (const_die, decl);
23963 add_type_attribute (const_die, type, TYPE_QUAL_CONST, false, context_die);
23964 if (TREE_PUBLIC (decl))
23965 add_AT_flag (const_die, DW_AT_external, 1);
23966 if (DECL_ARTIFICIAL (decl))
23967 add_AT_flag (const_die, DW_AT_artificial, 1);
23968 tree_add_const_value_attribute_for_decl (const_die, decl);
23971 /* Generate a DIE to represent a label identifier. */
23974 gen_label_die (tree decl, dw_die_ref context_die)
23976 tree origin = decl_ultimate_origin (decl);
23977 dw_die_ref lbl_die = lookup_decl_die (decl);
23979 char label[MAX_ARTIFICIAL_LABEL_BYTES];
23983 lbl_die = new_die (DW_TAG_label, context_die, decl);
23984 equate_decl_number_to_die (decl, lbl_die);
23986 if (origin != NULL)
23987 add_abstract_origin_attribute (lbl_die, origin);
23989 add_name_and_src_coords_attributes (lbl_die, decl);
23992 if (DECL_ABSTRACT_P (decl))
23993 equate_decl_number_to_die (decl, lbl_die);
23994 else if (! early_dwarf)
23996 insn = DECL_RTL_IF_SET (decl);
23998 /* Deleted labels are programmer specified labels which have been
23999 eliminated because of various optimizations. We still emit them
24000 here so that it is possible to put breakpoints on them. */
24004 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL))))
24006 /* When optimization is enabled (via -O) some parts of the compiler
24007 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
24008 represent source-level labels which were explicitly declared by
24009 the user. This really shouldn't be happening though, so catch
24010 it if it ever does happen. */
24011 gcc_assert (!as_a<rtx_insn *> (insn)->deleted ());
24013 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
24014 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
24018 && NOTE_KIND (insn) == NOTE_INSN_DELETED_DEBUG_LABEL
24019 && CODE_LABEL_NUMBER (insn) != -1)
24021 ASM_GENERATE_INTERNAL_LABEL (label, "LDL", CODE_LABEL_NUMBER (insn));
24022 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
24027 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
24028 attributes to the DIE for a block STMT, to describe where the inlined
24029 function was called from. This is similar to add_src_coords_attributes. */
24032 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
24034 /* We can end up with BUILTINS_LOCATION here. */
24035 if (RESERVED_LOCATION_P (BLOCK_SOURCE_LOCATION (stmt)))
24038 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
24040 if (dwarf_version >= 3 || !dwarf_strict)
24042 add_AT_file (die, DW_AT_call_file, lookup_filename (s.file));
24043 add_AT_unsigned (die, DW_AT_call_line, s.line);
24044 if (debug_column_info && s.column)
24045 add_AT_unsigned (die, DW_AT_call_column, s.column);
24050 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
24051 Add low_pc and high_pc attributes to the DIE for a block STMT. */
24054 add_high_low_attributes (tree stmt, dw_die_ref die)
24056 char label[MAX_ARTIFICIAL_LABEL_BYTES];
24058 if (inline_entry_data **iedp
24059 = !inline_entry_data_table ? NULL
24060 : inline_entry_data_table->find_slot_with_hash (stmt,
24061 htab_hash_pointer (stmt),
24064 inline_entry_data *ied = *iedp;
24065 gcc_assert (MAY_HAVE_DEBUG_MARKER_INSNS);
24066 gcc_assert (debug_inline_points);
24067 gcc_assert (inlined_function_outer_scope_p (stmt));
24069 ASM_GENERATE_INTERNAL_LABEL (label, ied->label_pfx, ied->label_num);
24070 add_AT_lbl_id (die, DW_AT_entry_pc, label);
24072 if (debug_variable_location_views && !ZERO_VIEW_P (ied->view)
24075 if (!output_asm_line_debug_info ())
24076 add_AT_unsigned (die, DW_AT_GNU_entry_view, ied->view);
24079 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", ied->view);
24080 /* FIXME: this will resolve to a small number. Could we
24081 possibly emit smaller data? Ideally we'd emit a
24082 uleb128, but that would make the size of DIEs
24083 impossible for the compiler to compute, since it's
24084 the assembler that computes the value of the view
24085 label in this case. Ideally, we'd have a single form
24086 encompassing both the address and the view, and
24087 indirecting them through a table might make things
24088 easier, but even that would be more wasteful,
24089 space-wise, than what we have now. */
24090 add_AT_symview (die, DW_AT_GNU_entry_view, label);
24094 inline_entry_data_table->clear_slot (iedp);
24097 if (BLOCK_FRAGMENT_CHAIN (stmt)
24098 && (dwarf_version >= 3 || !dwarf_strict))
24100 tree chain, superblock = NULL_TREE;
24102 dw_attr_node *attr = NULL;
24104 if (!debug_inline_points && inlined_function_outer_scope_p (stmt))
24106 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
24107 BLOCK_NUMBER (stmt));
24108 add_AT_lbl_id (die, DW_AT_entry_pc, label);
24111 /* Optimize duplicate .debug_ranges lists or even tails of
24112 lists. If this BLOCK has same ranges as its supercontext,
24113 lookup DW_AT_ranges attribute in the supercontext (and
24114 recursively so), verify that the ranges_table contains the
24115 right values and use it instead of adding a new .debug_range. */
24116 for (chain = stmt, pdie = die;
24117 BLOCK_SAME_RANGE (chain);
24118 chain = BLOCK_SUPERCONTEXT (chain))
24120 dw_attr_node *new_attr;
24122 pdie = pdie->die_parent;
24125 if (BLOCK_SUPERCONTEXT (chain) == NULL_TREE)
24127 new_attr = get_AT (pdie, DW_AT_ranges);
24128 if (new_attr == NULL
24129 || new_attr->dw_attr_val.val_class != dw_val_class_range_list)
24132 superblock = BLOCK_SUPERCONTEXT (chain);
24135 && ((*ranges_table)[attr->dw_attr_val.v.val_offset].num
24136 == (int)BLOCK_NUMBER (superblock))
24137 && BLOCK_FRAGMENT_CHAIN (superblock))
24139 unsigned long off = attr->dw_attr_val.v.val_offset;
24140 unsigned long supercnt = 0, thiscnt = 0;
24141 for (chain = BLOCK_FRAGMENT_CHAIN (superblock);
24142 chain; chain = BLOCK_FRAGMENT_CHAIN (chain))
24145 gcc_checking_assert ((*ranges_table)[off + supercnt].num
24146 == (int)BLOCK_NUMBER (chain));
24148 gcc_checking_assert ((*ranges_table)[off + supercnt + 1].num == 0);
24149 for (chain = BLOCK_FRAGMENT_CHAIN (stmt);
24150 chain; chain = BLOCK_FRAGMENT_CHAIN (chain))
24152 gcc_assert (supercnt >= thiscnt);
24153 add_AT_range_list (die, DW_AT_ranges, off + supercnt - thiscnt,
24155 note_rnglist_head (off + supercnt - thiscnt);
24159 unsigned int offset = add_ranges (stmt, true);
24160 add_AT_range_list (die, DW_AT_ranges, offset, false);
24161 note_rnglist_head (offset);
24163 bool prev_in_cold = BLOCK_IN_COLD_SECTION_P (stmt);
24164 chain = BLOCK_FRAGMENT_CHAIN (stmt);
24167 add_ranges (chain, prev_in_cold != BLOCK_IN_COLD_SECTION_P (chain));
24168 prev_in_cold = BLOCK_IN_COLD_SECTION_P (chain);
24169 chain = BLOCK_FRAGMENT_CHAIN (chain);
24176 char label_high[MAX_ARTIFICIAL_LABEL_BYTES];
24177 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
24178 BLOCK_NUMBER (stmt));
24179 ASM_GENERATE_INTERNAL_LABEL (label_high, BLOCK_END_LABEL,
24180 BLOCK_NUMBER (stmt));
24181 add_AT_low_high_pc (die, label, label_high, false);
24185 /* Generate a DIE for a lexical block. */
24188 gen_lexical_block_die (tree stmt, dw_die_ref context_die)
24190 dw_die_ref old_die = lookup_block_die (stmt);
24191 dw_die_ref stmt_die = NULL;
24194 stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
24195 equate_block_to_die (stmt, stmt_die);
24198 if (BLOCK_ABSTRACT_ORIGIN (stmt))
24200 /* If this is an inlined or conrecte instance, create a new lexical
24201 die for anything below to attach DW_AT_abstract_origin to. */
24203 stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
24205 tree origin = block_ultimate_origin (stmt);
24206 if (origin != NULL_TREE && (origin != stmt || old_die))
24207 add_abstract_origin_attribute (stmt_die, origin);
24213 stmt_die = old_die;
24215 /* A non abstract block whose blocks have already been reordered
24216 should have the instruction range for this block. If so, set the
24217 high/low attributes. */
24218 if (!early_dwarf && TREE_ASM_WRITTEN (stmt))
24220 gcc_assert (stmt_die);
24221 add_high_low_attributes (stmt, stmt_die);
24224 decls_for_scope (stmt, stmt_die);
24227 /* Generate a DIE for an inlined subprogram. */
24230 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die)
24232 tree decl = block_ultimate_origin (stmt);
24234 /* Make sure any inlined functions are known to be inlineable. */
24235 gcc_checking_assert (DECL_ABSTRACT_P (decl)
24236 || cgraph_function_possibly_inlined_p (decl));
24238 dw_die_ref subr_die = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
24240 if (call_arg_locations || debug_inline_points)
24241 equate_block_to_die (stmt, subr_die);
24242 add_abstract_origin_attribute (subr_die, decl);
24243 if (TREE_ASM_WRITTEN (stmt))
24244 add_high_low_attributes (stmt, subr_die);
24245 add_call_src_coords_attributes (stmt, subr_die);
24247 /* The inliner creates an extra BLOCK for the parameter setup,
24248 we want to merge that with the actual outermost BLOCK of the
24249 inlined function to avoid duplicate locals in consumers.
24250 Do that by doing the recursion to subblocks on the single subblock
24252 bool unwrap_one = false;
24253 if (BLOCK_SUBBLOCKS (stmt) && !BLOCK_CHAIN (BLOCK_SUBBLOCKS (stmt)))
24255 tree origin = block_ultimate_origin (BLOCK_SUBBLOCKS (stmt));
24257 && TREE_CODE (origin) == BLOCK
24258 && BLOCK_SUPERCONTEXT (origin) == decl)
24261 decls_for_scope (stmt, subr_die, !unwrap_one);
24263 decls_for_scope (BLOCK_SUBBLOCKS (stmt), subr_die);
24266 /* Generate a DIE for a field in a record, or structure. CTX is required: see
24267 the comment for VLR_CONTEXT. */
24270 gen_field_die (tree decl, struct vlr_context *ctx, dw_die_ref context_die)
24272 dw_die_ref decl_die;
24274 if (TREE_TYPE (decl) == error_mark_node)
24277 decl_die = new_die (DW_TAG_member, context_die, decl);
24278 add_name_and_src_coords_attributes (decl_die, decl);
24279 add_type_attribute (decl_die, member_declared_type (decl), decl_quals (decl),
24280 TYPE_REVERSE_STORAGE_ORDER (DECL_FIELD_CONTEXT (decl)),
24283 if (DECL_BIT_FIELD_TYPE (decl))
24285 add_byte_size_attribute (decl_die, decl);
24286 add_bit_size_attribute (decl_die, decl);
24287 add_bit_offset_attribute (decl_die, decl);
24290 add_alignment_attribute (decl_die, decl);
24292 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
24293 add_data_member_location_attribute (decl_die, decl, ctx);
24295 if (DECL_ARTIFICIAL (decl))
24296 add_AT_flag (decl_die, DW_AT_artificial, 1);
24298 add_accessibility_attribute (decl_die, decl);
24300 /* Equate decl number to die, so that we can look up this decl later on. */
24301 equate_decl_number_to_die (decl, decl_die);
24304 /* Generate a DIE for a pointer to a member type. TYPE can be an
24305 OFFSET_TYPE, for a pointer to data member, or a RECORD_TYPE, for a
24306 pointer to member function. */
24309 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
24311 if (lookup_type_die (type))
24314 dw_die_ref ptr_die = new_die (DW_TAG_ptr_to_member_type,
24315 scope_die_for (type, context_die), type);
24317 equate_type_number_to_die (type, ptr_die);
24318 add_AT_die_ref (ptr_die, DW_AT_containing_type,
24319 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
24320 add_type_attribute (ptr_die, TREE_TYPE (type), TYPE_UNQUALIFIED, false,
24322 add_alignment_attribute (ptr_die, type);
24324 if (TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE
24325 && TREE_CODE (TREE_TYPE (type)) != METHOD_TYPE)
24327 dw_loc_descr_ref op = new_loc_descr (DW_OP_plus, 0, 0);
24328 add_AT_loc (ptr_die, DW_AT_use_location, op);
24332 static char *producer_string;
24334 /* Return a heap allocated producer string including command line options
24335 if -grecord-gcc-switches. */
24338 gen_producer_string (void)
24341 auto_vec<const char *> switches;
24342 const char *language_string = lang_hooks.name;
24343 char *producer, *tail;
24345 size_t len = dwarf_record_gcc_switches ? 0 : 3;
24346 size_t plen = strlen (language_string) + 1 + strlen (version_string);
24348 for (j = 1; dwarf_record_gcc_switches && j < save_decoded_options_count; j++)
24349 switch (save_decoded_options[j].opt_index)
24356 case OPT_auxbase_strip:
24365 case OPT_SPECIAL_unknown:
24366 case OPT_SPECIAL_ignore:
24367 case OPT_SPECIAL_warn_removed:
24368 case OPT_SPECIAL_program_name:
24369 case OPT_SPECIAL_input_file:
24370 case OPT_grecord_gcc_switches:
24371 case OPT__output_pch_:
24372 case OPT_fdiagnostics_show_location_:
24373 case OPT_fdiagnostics_show_option:
24374 case OPT_fdiagnostics_show_caret:
24375 case OPT_fdiagnostics_show_labels:
24376 case OPT_fdiagnostics_show_line_numbers:
24377 case OPT_fdiagnostics_color_:
24378 case OPT_fdiagnostics_format_:
24379 case OPT_fverbose_asm:
24381 case OPT__sysroot_:
24383 case OPT_nostdinc__:
24384 case OPT_fpreprocessed:
24385 case OPT_fltrans_output_list_:
24386 case OPT_fresolution_:
24387 case OPT_fdebug_prefix_map_:
24388 case OPT_fmacro_prefix_map_:
24389 case OPT_ffile_prefix_map_:
24390 case OPT_fcompare_debug:
24391 case OPT_fchecking:
24392 case OPT_fchecking_:
24393 /* Ignore these. */
24397 const char *lto_canonical = "-flto";
24398 switches.safe_push (lto_canonical);
24399 len += strlen (lto_canonical) + 1;
24403 if (cl_options[save_decoded_options[j].opt_index].flags
24404 & CL_NO_DWARF_RECORD)
24406 gcc_checking_assert (save_decoded_options[j].canonical_option[0][0]
24408 switch (save_decoded_options[j].canonical_option[0][1])
24415 if (strncmp (save_decoded_options[j].canonical_option[0] + 2,
24422 switches.safe_push (save_decoded_options[j].orig_option_with_args_text);
24423 len += strlen (save_decoded_options[j].orig_option_with_args_text) + 1;
24427 producer = XNEWVEC (char, plen + 1 + len + 1);
24429 sprintf (tail, "%s %s", language_string, version_string);
24432 FOR_EACH_VEC_ELT (switches, j, p)
24436 memcpy (tail + 1, p, len);
24444 /* Given a C and/or C++ language/version string return the "highest".
24445 C++ is assumed to be "higher" than C in this case. Used for merging
24446 LTO translation unit languages. */
24447 static const char *
24448 highest_c_language (const char *lang1, const char *lang2)
24450 if (strcmp ("GNU C++17", lang1) == 0 || strcmp ("GNU C++17", lang2) == 0)
24451 return "GNU C++17";
24452 if (strcmp ("GNU C++14", lang1) == 0 || strcmp ("GNU C++14", lang2) == 0)
24453 return "GNU C++14";
24454 if (strcmp ("GNU C++11", lang1) == 0 || strcmp ("GNU C++11", lang2) == 0)
24455 return "GNU C++11";
24456 if (strcmp ("GNU C++98", lang1) == 0 || strcmp ("GNU C++98", lang2) == 0)
24457 return "GNU C++98";
24459 if (strcmp ("GNU C2X", lang1) == 0 || strcmp ("GNU C2X", lang2) == 0)
24461 if (strcmp ("GNU C17", lang1) == 0 || strcmp ("GNU C17", lang2) == 0)
24463 if (strcmp ("GNU C11", lang1) == 0 || strcmp ("GNU C11", lang2) == 0)
24465 if (strcmp ("GNU C99", lang1) == 0 || strcmp ("GNU C99", lang2) == 0)
24467 if (strcmp ("GNU C89", lang1) == 0 || strcmp ("GNU C89", lang2) == 0)
24470 gcc_unreachable ();
24474 /* Generate the DIE for the compilation unit. */
24477 gen_compile_unit_die (const char *filename)
24480 const char *language_string = lang_hooks.name;
24483 die = new_die (DW_TAG_compile_unit, NULL, NULL);
24487 add_name_attribute (die, filename);
24488 /* Don't add cwd for <built-in>. */
24489 if (filename[0] != '<')
24490 add_comp_dir_attribute (die);
24493 add_AT_string (die, DW_AT_producer, producer_string ? producer_string : "");
24495 /* If our producer is LTO try to figure out a common language to use
24496 from the global list of translation units. */
24497 if (strcmp (language_string, "GNU GIMPLE") == 0)
24501 const char *common_lang = NULL;
24503 FOR_EACH_VEC_SAFE_ELT (all_translation_units, i, t)
24505 if (!TRANSLATION_UNIT_LANGUAGE (t))
24508 common_lang = TRANSLATION_UNIT_LANGUAGE (t);
24509 else if (strcmp (common_lang, TRANSLATION_UNIT_LANGUAGE (t)) == 0)
24511 else if (strncmp (common_lang, "GNU C", 5) == 0
24512 && strncmp (TRANSLATION_UNIT_LANGUAGE (t), "GNU C", 5) == 0)
24513 /* Mixing C and C++ is ok, use C++ in that case. */
24514 common_lang = highest_c_language (common_lang,
24515 TRANSLATION_UNIT_LANGUAGE (t));
24518 /* Fall back to C. */
24519 common_lang = NULL;
24525 language_string = common_lang;
24528 language = DW_LANG_C;
24529 if (strncmp (language_string, "GNU C", 5) == 0
24530 && ISDIGIT (language_string[5]))
24532 language = DW_LANG_C89;
24533 if (dwarf_version >= 3 || !dwarf_strict)
24535 if (strcmp (language_string, "GNU C89") != 0)
24536 language = DW_LANG_C99;
24538 if (dwarf_version >= 5 /* || !dwarf_strict */)
24539 if (strcmp (language_string, "GNU C11") == 0
24540 || strcmp (language_string, "GNU C17") == 0
24541 || strcmp (language_string, "GNU C2X"))
24542 language = DW_LANG_C11;
24545 else if (strncmp (language_string, "GNU C++", 7) == 0)
24547 language = DW_LANG_C_plus_plus;
24548 if (dwarf_version >= 5 /* || !dwarf_strict */)
24550 if (strcmp (language_string, "GNU C++11") == 0)
24551 language = DW_LANG_C_plus_plus_11;
24552 else if (strcmp (language_string, "GNU C++14") == 0)
24553 language = DW_LANG_C_plus_plus_14;
24554 else if (strcmp (language_string, "GNU C++17") == 0)
24556 language = DW_LANG_C_plus_plus_14;
24559 else if (strcmp (language_string, "GNU F77") == 0)
24560 language = DW_LANG_Fortran77;
24561 else if (dwarf_version >= 3 || !dwarf_strict)
24563 if (strcmp (language_string, "GNU Ada") == 0)
24564 language = DW_LANG_Ada95;
24565 else if (strncmp (language_string, "GNU Fortran", 11) == 0)
24567 language = DW_LANG_Fortran95;
24568 if (dwarf_version >= 5 /* || !dwarf_strict */)
24570 if (strcmp (language_string, "GNU Fortran2003") == 0)
24571 language = DW_LANG_Fortran03;
24572 else if (strcmp (language_string, "GNU Fortran2008") == 0)
24573 language = DW_LANG_Fortran08;
24576 else if (strcmp (language_string, "GNU Objective-C") == 0)
24577 language = DW_LANG_ObjC;
24578 else if (strcmp (language_string, "GNU Objective-C++") == 0)
24579 language = DW_LANG_ObjC_plus_plus;
24580 else if (strcmp (language_string, "GNU D") == 0)
24581 language = DW_LANG_D;
24582 else if (dwarf_version >= 5 || !dwarf_strict)
24584 if (strcmp (language_string, "GNU Go") == 0)
24585 language = DW_LANG_Go;
24588 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
24589 else if (strncmp (language_string, "GNU Fortran", 11) == 0)
24590 language = DW_LANG_Fortran90;
24591 /* Likewise for Ada. */
24592 else if (strcmp (language_string, "GNU Ada") == 0)
24593 language = DW_LANG_Ada83;
24595 add_AT_unsigned (die, DW_AT_language, language);
24599 case DW_LANG_Fortran77:
24600 case DW_LANG_Fortran90:
24601 case DW_LANG_Fortran95:
24602 case DW_LANG_Fortran03:
24603 case DW_LANG_Fortran08:
24604 /* Fortran has case insensitive identifiers and the front-end
24605 lowercases everything. */
24606 add_AT_unsigned (die, DW_AT_identifier_case, DW_ID_down_case);
24609 /* The default DW_ID_case_sensitive doesn't need to be specified. */
24615 /* Generate the DIE for a base class. */
24618 gen_inheritance_die (tree binfo, tree access, tree type,
24619 dw_die_ref context_die)
24621 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
24622 struct vlr_context ctx = { type, NULL };
24624 add_type_attribute (die, BINFO_TYPE (binfo), TYPE_UNQUALIFIED, false,
24626 add_data_member_location_attribute (die, binfo, &ctx);
24628 if (BINFO_VIRTUAL_P (binfo))
24629 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
24631 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
24632 children, otherwise the default is DW_ACCESS_public. In DWARF2
24633 the default has always been DW_ACCESS_private. */
24634 if (access == access_public_node)
24636 if (dwarf_version == 2
24637 || context_die->die_tag == DW_TAG_class_type)
24638 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
24640 else if (access == access_protected_node)
24641 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
24642 else if (dwarf_version > 2
24643 && context_die->die_tag != DW_TAG_class_type)
24644 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_private);
24647 /* Return whether DECL is a FIELD_DECL that represents the variant part of a
24651 is_variant_part (tree decl)
24653 return (TREE_CODE (decl) == FIELD_DECL
24654 && TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE);
24657 /* Check that OPERAND is a reference to a field in STRUCT_TYPE. If it is,
24658 return the FIELD_DECL. Return NULL_TREE otherwise. */
24661 analyze_discr_in_predicate (tree operand, tree struct_type)
24663 while (CONVERT_EXPR_P (operand))
24664 operand = TREE_OPERAND (operand, 0);
24666 /* Match field access to members of struct_type only. */
24667 if (TREE_CODE (operand) == COMPONENT_REF
24668 && TREE_CODE (TREE_OPERAND (operand, 0)) == PLACEHOLDER_EXPR
24669 && TREE_TYPE (TREE_OPERAND (operand, 0)) == struct_type
24670 && TREE_CODE (TREE_OPERAND (operand, 1)) == FIELD_DECL)
24671 return TREE_OPERAND (operand, 1);
24676 /* Check that SRC is a constant integer that can be represented as a native
24677 integer constant (either signed or unsigned). If so, store it into DEST and
24678 return true. Return false otherwise. */
24681 get_discr_value (tree src, dw_discr_value *dest)
24683 tree discr_type = TREE_TYPE (src);
24685 if (lang_hooks.types.get_debug_type)
24687 tree debug_type = lang_hooks.types.get_debug_type (discr_type);
24688 if (debug_type != NULL)
24689 discr_type = debug_type;
24692 if (TREE_CODE (src) != INTEGER_CST || !INTEGRAL_TYPE_P (discr_type))
24695 /* Signedness can vary between the original type and the debug type. This
24696 can happen for character types in Ada for instance: the character type
24697 used for code generation can be signed, to be compatible with the C one,
24698 but from a debugger point of view, it must be unsigned. */
24699 bool is_orig_unsigned = TYPE_UNSIGNED (TREE_TYPE (src));
24700 bool is_debug_unsigned = TYPE_UNSIGNED (discr_type);
24702 if (is_orig_unsigned != is_debug_unsigned)
24703 src = fold_convert (discr_type, src);
24705 if (!(is_debug_unsigned ? tree_fits_uhwi_p (src) : tree_fits_shwi_p (src)))
24708 dest->pos = is_debug_unsigned;
24709 if (is_debug_unsigned)
24710 dest->v.uval = tree_to_uhwi (src);
24712 dest->v.sval = tree_to_shwi (src);
24717 /* Try to extract synthetic properties out of VARIANT_PART_DECL, which is a
24718 FIELD_DECL in STRUCT_TYPE that represents a variant part. If unsuccessful,
24719 store NULL_TREE in DISCR_DECL. Otherwise:
24721 - store the discriminant field in STRUCT_TYPE that controls the variant
24722 part to *DISCR_DECL
24724 - put in *DISCR_LISTS_P an array where for each variant, the item
24725 represents the corresponding matching list of discriminant values.
24727 - put in *DISCR_LISTS_LENGTH the number of variants, which is the size of
24730 Note that when the array is allocated (i.e. when the analysis is
24731 successful), it is up to the caller to free the array. */
24734 analyze_variants_discr (tree variant_part_decl,
24737 dw_discr_list_ref **discr_lists_p,
24738 unsigned *discr_lists_length)
24740 tree variant_part_type = TREE_TYPE (variant_part_decl);
24742 dw_discr_list_ref *discr_lists;
24745 /* Compute how many variants there are in this variant part. */
24746 *discr_lists_length = 0;
24747 for (variant = TYPE_FIELDS (variant_part_type);
24748 variant != NULL_TREE;
24749 variant = DECL_CHAIN (variant))
24750 ++*discr_lists_length;
24752 *discr_decl = NULL_TREE;
24754 = (dw_discr_list_ref *) xcalloc (*discr_lists_length,
24755 sizeof (**discr_lists_p));
24756 discr_lists = *discr_lists_p;
24758 /* And then analyze all variants to extract discriminant information for all
24759 of them. This analysis is conservative: as soon as we detect something we
24760 do not support, abort everything and pretend we found nothing. */
24761 for (variant = TYPE_FIELDS (variant_part_type), i = 0;
24762 variant != NULL_TREE;
24763 variant = DECL_CHAIN (variant), ++i)
24765 tree match_expr = DECL_QUALIFIER (variant);
24767 /* Now, try to analyze the predicate and deduce a discriminant for
24769 if (match_expr == boolean_true_node)
24770 /* Typically happens for the default variant: it matches all cases that
24771 previous variants rejected. Don't output any matching value for
24775 /* The following loop tries to iterate over each discriminant
24776 possibility: single values or ranges. */
24777 while (match_expr != NULL_TREE)
24779 tree next_round_match_expr;
24780 tree candidate_discr = NULL_TREE;
24781 dw_discr_list_ref new_node = NULL;
24783 /* Possibilities are matched one after the other by nested
24784 TRUTH_ORIF_EXPR expressions. Process the current possibility and
24785 continue with the rest at next iteration. */
24786 if (TREE_CODE (match_expr) == TRUTH_ORIF_EXPR)
24788 next_round_match_expr = TREE_OPERAND (match_expr, 0);
24789 match_expr = TREE_OPERAND (match_expr, 1);
24792 next_round_match_expr = NULL_TREE;
24794 if (match_expr == boolean_false_node)
24795 /* This sub-expression matches nothing: just wait for the next
24799 else if (TREE_CODE (match_expr) == EQ_EXPR)
24801 /* We are matching: <discr_field> == <integer_cst>
24802 This sub-expression matches a single value. */
24803 tree integer_cst = TREE_OPERAND (match_expr, 1);
24806 = analyze_discr_in_predicate (TREE_OPERAND (match_expr, 0),
24809 new_node = ggc_cleared_alloc<dw_discr_list_node> ();
24810 if (!get_discr_value (integer_cst,
24811 &new_node->dw_discr_lower_bound))
24813 new_node->dw_discr_range = false;
24816 else if (TREE_CODE (match_expr) == TRUTH_ANDIF_EXPR)
24818 /* We are matching:
24819 <discr_field> > <integer_cst>
24820 && <discr_field> < <integer_cst>.
24821 This sub-expression matches the range of values between the
24822 two matched integer constants. Note that comparisons can be
24823 inclusive or exclusive. */
24824 tree candidate_discr_1, candidate_discr_2;
24825 tree lower_cst, upper_cst;
24826 bool lower_cst_included, upper_cst_included;
24827 tree lower_op = TREE_OPERAND (match_expr, 0);
24828 tree upper_op = TREE_OPERAND (match_expr, 1);
24830 /* When the comparison is exclusive, the integer constant is not
24831 the discriminant range bound we are looking for: we will have
24832 to increment or decrement it. */
24833 if (TREE_CODE (lower_op) == GE_EXPR)
24834 lower_cst_included = true;
24835 else if (TREE_CODE (lower_op) == GT_EXPR)
24836 lower_cst_included = false;
24840 if (TREE_CODE (upper_op) == LE_EXPR)
24841 upper_cst_included = true;
24842 else if (TREE_CODE (upper_op) == LT_EXPR)
24843 upper_cst_included = false;
24847 /* Extract the discriminant from the first operand and check it
24848 is consistant with the same analysis in the second
24851 = analyze_discr_in_predicate (TREE_OPERAND (lower_op, 0),
24854 = analyze_discr_in_predicate (TREE_OPERAND (upper_op, 0),
24856 if (candidate_discr_1 == candidate_discr_2)
24857 candidate_discr = candidate_discr_1;
24861 /* Extract bounds from both. */
24862 new_node = ggc_cleared_alloc<dw_discr_list_node> ();
24863 lower_cst = TREE_OPERAND (lower_op, 1);
24864 upper_cst = TREE_OPERAND (upper_op, 1);
24866 if (!lower_cst_included)
24868 = fold_build2 (PLUS_EXPR, TREE_TYPE (lower_cst), lower_cst,
24869 build_int_cst (TREE_TYPE (lower_cst), 1));
24870 if (!upper_cst_included)
24872 = fold_build2 (MINUS_EXPR, TREE_TYPE (upper_cst), upper_cst,
24873 build_int_cst (TREE_TYPE (upper_cst), 1));
24875 if (!get_discr_value (lower_cst,
24876 &new_node->dw_discr_lower_bound)
24877 || !get_discr_value (upper_cst,
24878 &new_node->dw_discr_upper_bound))
24881 new_node->dw_discr_range = true;
24884 else if ((candidate_discr
24885 = analyze_discr_in_predicate (match_expr, struct_type))
24886 && (TREE_TYPE (candidate_discr) == boolean_type_node
24887 || TREE_TYPE (TREE_TYPE (candidate_discr))
24888 == boolean_type_node))
24890 /* We are matching: <discr_field> for a boolean discriminant.
24891 This sub-expression matches boolean_true_node. */
24892 new_node = ggc_cleared_alloc<dw_discr_list_node> ();
24893 if (!get_discr_value (boolean_true_node,
24894 &new_node->dw_discr_lower_bound))
24896 new_node->dw_discr_range = false;
24900 /* Unsupported sub-expression: we cannot determine the set of
24901 matching discriminant values. Abort everything. */
24904 /* If the discriminant info is not consistant with what we saw so
24905 far, consider the analysis failed and abort everything. */
24906 if (candidate_discr == NULL_TREE
24907 || (*discr_decl != NULL_TREE && candidate_discr != *discr_decl))
24910 *discr_decl = candidate_discr;
24912 if (new_node != NULL)
24914 new_node->dw_discr_next = discr_lists[i];
24915 discr_lists[i] = new_node;
24917 match_expr = next_round_match_expr;
24921 /* If we reach this point, we could match everything we were interested
24926 /* Clean all data structure and return no result. */
24927 free (*discr_lists_p);
24928 *discr_lists_p = NULL;
24929 *discr_decl = NULL_TREE;
24932 /* Generate a DIE to represent VARIANT_PART_DECL, a variant part that is part
24933 of STRUCT_TYPE, a record type. This new DIE is emitted as the next child
24936 Variant parts are supposed to be implemented as a FIELD_DECL whose type is a
24937 QUAL_UNION_TYPE: this is the VARIANT_PART_DECL parameter. The members for
24938 this type, which are record types, represent the available variants and each
24939 has a DECL_QUALIFIER attribute. The discriminant and the discriminant
24940 values are inferred from these attributes.
24942 In trees, the offsets for the fields inside these sub-records are relative
24943 to the variant part itself, whereas the corresponding DIEs should have
24944 offset attributes that are relative to the embedding record base address.
24945 This is why the caller must provide a VARIANT_PART_OFFSET expression: it
24946 must be an expression that computes the offset of the variant part to
24947 describe in DWARF. */
24950 gen_variant_part (tree variant_part_decl, struct vlr_context *vlr_ctx,
24951 dw_die_ref context_die)
24953 const tree variant_part_type = TREE_TYPE (variant_part_decl);
24954 tree variant_part_offset = vlr_ctx->variant_part_offset;
24955 struct loc_descr_context ctx = {
24956 vlr_ctx->struct_type, /* context_type */
24957 NULL_TREE, /* base_decl */
24959 false, /* placeholder_arg */
24960 false /* placeholder_seen */
24963 /* The FIELD_DECL node in STRUCT_TYPE that acts as the discriminant, or
24964 NULL_TREE if there is no such field. */
24965 tree discr_decl = NULL_TREE;
24966 dw_discr_list_ref *discr_lists;
24967 unsigned discr_lists_length = 0;
24970 dw_die_ref dwarf_proc_die = NULL;
24971 dw_die_ref variant_part_die
24972 = new_die (DW_TAG_variant_part, context_die, variant_part_type);
24974 equate_decl_number_to_die (variant_part_decl, variant_part_die);
24976 analyze_variants_discr (variant_part_decl, vlr_ctx->struct_type,
24977 &discr_decl, &discr_lists, &discr_lists_length);
24979 if (discr_decl != NULL_TREE)
24981 dw_die_ref discr_die = lookup_decl_die (discr_decl);
24984 add_AT_die_ref (variant_part_die, DW_AT_discr, discr_die);
24986 /* We have no DIE for the discriminant, so just discard all
24987 discrimimant information in the output. */
24988 discr_decl = NULL_TREE;
24991 /* If the offset for this variant part is more complex than a constant,
24992 create a DWARF procedure for it so that we will not have to generate DWARF
24993 expressions for it for each member. */
24994 if (TREE_CODE (variant_part_offset) != INTEGER_CST
24995 && (dwarf_version >= 3 || !dwarf_strict))
24997 const tree dwarf_proc_fndecl
24998 = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL, NULL_TREE,
24999 build_function_type (TREE_TYPE (variant_part_offset),
25001 const tree dwarf_proc_call = build_call_expr (dwarf_proc_fndecl, 0);
25002 const dw_loc_descr_ref dwarf_proc_body
25003 = loc_descriptor_from_tree (variant_part_offset, 0, &ctx);
25005 dwarf_proc_die = new_dwarf_proc_die (dwarf_proc_body,
25006 dwarf_proc_fndecl, context_die);
25007 if (dwarf_proc_die != NULL)
25008 variant_part_offset = dwarf_proc_call;
25011 /* Output DIEs for all variants. */
25013 for (tree variant = TYPE_FIELDS (variant_part_type);
25014 variant != NULL_TREE;
25015 variant = DECL_CHAIN (variant), ++i)
25017 tree variant_type = TREE_TYPE (variant);
25018 dw_die_ref variant_die;
25020 /* All variants (i.e. members of a variant part) are supposed to be
25021 encoded as structures. Sub-variant parts are QUAL_UNION_TYPE fields
25022 under these records. */
25023 gcc_assert (TREE_CODE (variant_type) == RECORD_TYPE);
25025 variant_die = new_die (DW_TAG_variant, variant_part_die, variant_type);
25026 equate_decl_number_to_die (variant, variant_die);
25028 /* Output discriminant values this variant matches, if any. */
25029 if (discr_decl == NULL || discr_lists[i] == NULL)
25030 /* In the case we have discriminant information at all, this is
25031 probably the default variant: as the standard says, don't
25032 output any discriminant value/list attribute. */
25034 else if (discr_lists[i]->dw_discr_next == NULL
25035 && !discr_lists[i]->dw_discr_range)
25036 /* If there is only one accepted value, don't bother outputting a
25038 add_discr_value (variant_die, &discr_lists[i]->dw_discr_lower_bound);
25040 add_discr_list (variant_die, discr_lists[i]);
25042 for (tree member = TYPE_FIELDS (variant_type);
25043 member != NULL_TREE;
25044 member = DECL_CHAIN (member))
25046 struct vlr_context vlr_sub_ctx = {
25047 vlr_ctx->struct_type, /* struct_type */
25048 NULL /* variant_part_offset */
25050 if (is_variant_part (member))
25052 /* All offsets for fields inside variant parts are relative to
25053 the top-level embedding RECORD_TYPE's base address. On the
25054 other hand, offsets in GCC's types are relative to the
25055 nested-most variant part. So we have to sum offsets each time
25058 vlr_sub_ctx.variant_part_offset
25059 = fold_build2 (PLUS_EXPR, TREE_TYPE (variant_part_offset),
25060 variant_part_offset, byte_position (member));
25061 gen_variant_part (member, &vlr_sub_ctx, variant_die);
25065 vlr_sub_ctx.variant_part_offset = variant_part_offset;
25066 gen_decl_die (member, NULL, &vlr_sub_ctx, variant_die);
25071 free (discr_lists);
25074 /* Generate a DIE for a class member. */
25077 gen_member_die (tree type, dw_die_ref context_die)
25080 tree binfo = TYPE_BINFO (type);
25082 gcc_assert (TYPE_MAIN_VARIANT (type) == type);
25084 /* If this is not an incomplete type, output descriptions of each of its
25085 members. Note that as we output the DIEs necessary to represent the
25086 members of this record or union type, we will also be trying to output
25087 DIEs to represent the *types* of those members. However the `type'
25088 function (above) will specifically avoid generating type DIEs for member
25089 types *within* the list of member DIEs for this (containing) type except
25090 for those types (of members) which are explicitly marked as also being
25091 members of this (containing) type themselves. The g++ front- end can
25092 force any given type to be treated as a member of some other (containing)
25093 type by setting the TYPE_CONTEXT of the given (member) type to point to
25094 the TREE node representing the appropriate (containing) type. */
25096 /* First output info about the base classes. */
25097 if (binfo && early_dwarf)
25099 vec<tree, va_gc> *accesses = BINFO_BASE_ACCESSES (binfo);
25103 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
25104 gen_inheritance_die (base,
25105 (accesses ? (*accesses)[i] : access_public_node),
25110 /* Now output info about the members. */
25111 for (member = TYPE_FIELDS (type); member; member = DECL_CHAIN (member))
25113 /* Ignore clones. */
25114 if (DECL_ABSTRACT_ORIGIN (member))
25117 struct vlr_context vlr_ctx = { type, NULL_TREE };
25118 bool static_inline_p
25120 && TREE_STATIC (member)
25121 && (lang_hooks.decls.decl_dwarf_attribute (member, DW_AT_inline)
25124 /* If we thought we were generating minimal debug info for TYPE
25125 and then changed our minds, some of the member declarations
25126 may have already been defined. Don't define them again, but
25127 do put them in the right order. */
25129 if (dw_die_ref child = lookup_decl_die (member))
25131 /* Handle inline static data members, which only have in-class
25133 bool splice = true;
25135 dw_die_ref ref = NULL;
25136 if (child->die_tag == DW_TAG_variable
25137 && child->die_parent == comp_unit_die ())
25139 ref = get_AT_ref (child, DW_AT_specification);
25141 /* For C++17 inline static data members followed by redundant
25142 out of class redeclaration, we might get here with
25143 child being the DIE created for the out of class
25144 redeclaration and with its DW_AT_specification being
25145 the DIE created for in-class definition. We want to
25146 reparent the latter, and don't want to create another
25147 DIE with DW_AT_specification in that case, because
25148 we already have one. */
25151 && ref->die_tag == DW_TAG_variable
25152 && ref->die_parent == comp_unit_die ()
25153 && get_AT (ref, DW_AT_specification) == NULL)
25157 static_inline_p = false;
25162 reparent_child (child, context_die);
25163 if (dwarf_version < 5)
25164 child->die_tag = DW_TAG_member;
25170 splice_child_die (context_die, child);
25173 /* Do not generate standard DWARF for variant parts if we are generating
25174 the corresponding GNAT encodings: DIEs generated for both would
25175 conflict in our mappings. */
25176 else if (is_variant_part (member)
25177 && gnat_encodings == DWARF_GNAT_ENCODINGS_MINIMAL)
25179 vlr_ctx.variant_part_offset = byte_position (member);
25180 gen_variant_part (member, &vlr_ctx, context_die);
25184 vlr_ctx.variant_part_offset = NULL_TREE;
25185 gen_decl_die (member, NULL, &vlr_ctx, context_die);
25188 /* For C++ inline static data members emit immediately a DW_TAG_variable
25189 DIE that will refer to that DW_TAG_member/DW_TAG_variable through
25190 DW_AT_specification. */
25191 if (static_inline_p)
25193 int old_extern = DECL_EXTERNAL (member);
25194 DECL_EXTERNAL (member) = 0;
25195 gen_decl_die (member, NULL, NULL, comp_unit_die ());
25196 DECL_EXTERNAL (member) = old_extern;
25201 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
25202 is set, we pretend that the type was never defined, so we only get the
25203 member DIEs needed by later specification DIEs. */
25206 gen_struct_or_union_type_die (tree type, dw_die_ref context_die,
25207 enum debug_info_usage usage)
25209 if (TREE_ASM_WRITTEN (type))
25211 /* Fill in the bound of variable-length fields in late dwarf if
25212 still incomplete. */
25213 if (!early_dwarf && variably_modified_type_p (type, NULL))
25214 for (tree member = TYPE_FIELDS (type);
25216 member = DECL_CHAIN (member))
25217 fill_variable_array_bounds (TREE_TYPE (member));
25221 dw_die_ref type_die = lookup_type_die (type);
25222 dw_die_ref scope_die = 0;
25224 int complete = (TYPE_SIZE (type)
25225 && (! TYPE_STUB_DECL (type)
25226 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
25227 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
25228 complete = complete && should_emit_struct_debug (type, usage);
25230 if (type_die && ! complete)
25233 if (TYPE_CONTEXT (type) != NULL_TREE
25234 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
25235 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
25238 scope_die = scope_die_for (type, context_die);
25240 /* Generate child dies for template paramaters. */
25241 if (!type_die && debug_info_level > DINFO_LEVEL_TERSE)
25242 schedule_generic_params_dies_gen (type);
25244 if (! type_die || (nested && is_cu_die (scope_die)))
25245 /* First occurrence of type or toplevel definition of nested class. */
25247 dw_die_ref old_die = type_die;
25249 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
25250 ? record_type_tag (type) : DW_TAG_union_type,
25252 equate_type_number_to_die (type, type_die);
25254 add_AT_specification (type_die, old_die);
25256 add_name_attribute (type_die, type_tag (type));
25259 remove_AT (type_die, DW_AT_declaration);
25261 /* If this type has been completed, then give it a byte_size attribute and
25262 then give a list of members. */
25263 if (complete && !ns_decl)
25265 /* Prevent infinite recursion in cases where the type of some member of
25266 this type is expressed in terms of this type itself. */
25267 TREE_ASM_WRITTEN (type) = 1;
25268 add_byte_size_attribute (type_die, type);
25269 add_alignment_attribute (type_die, type);
25270 if (TYPE_STUB_DECL (type) != NULL_TREE)
25272 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
25273 add_accessibility_attribute (type_die, TYPE_STUB_DECL (type));
25276 /* If the first reference to this type was as the return type of an
25277 inline function, then it may not have a parent. Fix this now. */
25278 if (type_die->die_parent == NULL)
25279 add_child_die (scope_die, type_die);
25281 gen_member_die (type, type_die);
25283 add_gnat_descriptive_type_attribute (type_die, type, context_die);
25284 if (TYPE_ARTIFICIAL (type))
25285 add_AT_flag (type_die, DW_AT_artificial, 1);
25287 /* GNU extension: Record what type our vtable lives in. */
25288 if (TYPE_VFIELD (type))
25290 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
25292 gen_type_die (vtype, context_die);
25293 add_AT_die_ref (type_die, DW_AT_containing_type,
25294 lookup_type_die (vtype));
25299 add_AT_flag (type_die, DW_AT_declaration, 1);
25301 /* We don't need to do this for function-local types. */
25302 if (TYPE_STUB_DECL (type)
25303 && ! decl_function_context (TYPE_STUB_DECL (type)))
25304 vec_safe_push (incomplete_types, type);
25307 if (get_AT (type_die, DW_AT_name))
25308 add_pubtype (type, type_die);
25311 /* Generate a DIE for a subroutine _type_. */
25314 gen_subroutine_type_die (tree type, dw_die_ref context_die)
25316 tree return_type = TREE_TYPE (type);
25317 dw_die_ref subr_die
25318 = new_die (DW_TAG_subroutine_type,
25319 scope_die_for (type, context_die), type);
25321 equate_type_number_to_die (type, subr_die);
25322 add_prototyped_attribute (subr_die, type);
25323 add_type_attribute (subr_die, return_type, TYPE_UNQUALIFIED, false,
25325 add_alignment_attribute (subr_die, type);
25326 gen_formal_types_die (type, subr_die);
25328 if (get_AT (subr_die, DW_AT_name))
25329 add_pubtype (type, subr_die);
25330 if ((dwarf_version >= 5 || !dwarf_strict)
25331 && lang_hooks.types.type_dwarf_attribute (type, DW_AT_reference) != -1)
25332 add_AT_flag (subr_die, DW_AT_reference, 1);
25333 if ((dwarf_version >= 5 || !dwarf_strict)
25334 && lang_hooks.types.type_dwarf_attribute (type,
25335 DW_AT_rvalue_reference) != -1)
25336 add_AT_flag (subr_die, DW_AT_rvalue_reference, 1);
25339 /* Generate a DIE for a type definition. */
25342 gen_typedef_die (tree decl, dw_die_ref context_die)
25344 dw_die_ref type_die;
25347 if (TREE_ASM_WRITTEN (decl))
25349 if (DECL_ORIGINAL_TYPE (decl))
25350 fill_variable_array_bounds (DECL_ORIGINAL_TYPE (decl));
25354 /* As we avoid creating DIEs for local typedefs (see decl_ultimate_origin
25355 checks in process_scope_var and modified_type_die), this should be called
25356 only for original types. */
25357 gcc_assert (decl_ultimate_origin (decl) == NULL
25358 || decl_ultimate_origin (decl) == decl);
25360 TREE_ASM_WRITTEN (decl) = 1;
25361 type_die = new_die (DW_TAG_typedef, context_die, decl);
25363 add_name_and_src_coords_attributes (type_die, decl);
25364 if (DECL_ORIGINAL_TYPE (decl))
25366 type = DECL_ORIGINAL_TYPE (decl);
25367 if (type == error_mark_node)
25370 gcc_assert (type != TREE_TYPE (decl));
25371 equate_type_number_to_die (TREE_TYPE (decl), type_die);
25375 type = TREE_TYPE (decl);
25376 if (type == error_mark_node)
25379 if (is_naming_typedef_decl (TYPE_NAME (type)))
25381 /* Here, we are in the case of decl being a typedef naming
25382 an anonymous type, e.g:
25383 typedef struct {...} foo;
25384 In that case TREE_TYPE (decl) is not a typedef variant
25385 type and TYPE_NAME of the anonymous type is set to the
25386 TYPE_DECL of the typedef. This construct is emitted by
25389 TYPE is the anonymous struct named by the typedef
25390 DECL. As we need the DW_AT_type attribute of the
25391 DW_TAG_typedef to point to the DIE of TYPE, let's
25392 generate that DIE right away. add_type_attribute
25393 called below will then pick (via lookup_type_die) that
25394 anonymous struct DIE. */
25395 if (!TREE_ASM_WRITTEN (type))
25396 gen_tagged_type_die (type, context_die, DINFO_USAGE_DIR_USE);
25398 /* This is a GNU Extension. We are adding a
25399 DW_AT_linkage_name attribute to the DIE of the
25400 anonymous struct TYPE. The value of that attribute
25401 is the name of the typedef decl naming the anonymous
25402 struct. This greatly eases the work of consumers of
25403 this debug info. */
25404 add_linkage_name_raw (lookup_type_die (type), decl);
25408 add_type_attribute (type_die, type, decl_quals (decl), false,
25411 if (is_naming_typedef_decl (decl))
25412 /* We want that all subsequent calls to lookup_type_die with
25413 TYPE in argument yield the DW_TAG_typedef we have just
25415 equate_type_number_to_die (type, type_die);
25417 add_alignment_attribute (type_die, TREE_TYPE (decl));
25419 add_accessibility_attribute (type_die, decl);
25421 if (DECL_ABSTRACT_P (decl))
25422 equate_decl_number_to_die (decl, type_die);
25424 if (get_AT (type_die, DW_AT_name))
25425 add_pubtype (decl, type_die);
25428 /* Generate a DIE for a struct, class, enum or union type. */
25431 gen_tagged_type_die (tree type,
25432 dw_die_ref context_die,
25433 enum debug_info_usage usage)
25435 if (type == NULL_TREE
25436 || !is_tagged_type (type))
25439 if (TREE_ASM_WRITTEN (type))
25441 /* If this is a nested type whose containing class hasn't been written
25442 out yet, writing it out will cover this one, too. This does not apply
25443 to instantiations of member class templates; they need to be added to
25444 the containing class as they are generated. FIXME: This hurts the
25445 idea of combining type decls from multiple TUs, since we can't predict
25446 what set of template instantiations we'll get. */
25447 else if (TYPE_CONTEXT (type)
25448 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
25449 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
25451 gen_type_die_with_usage (TYPE_CONTEXT (type), context_die, usage);
25453 if (TREE_ASM_WRITTEN (type))
25456 /* If that failed, attach ourselves to the stub. */
25457 context_die = lookup_type_die (TYPE_CONTEXT (type));
25459 else if (TYPE_CONTEXT (type) != NULL_TREE
25460 && (TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL))
25462 /* If this type is local to a function that hasn't been written
25463 out yet, use a NULL context for now; it will be fixed up in
25464 decls_for_scope. */
25465 context_die = lookup_decl_die (TYPE_CONTEXT (type));
25466 /* A declaration DIE doesn't count; nested types need to go in the
25468 if (context_die && is_declaration_die (context_die))
25469 context_die = NULL;
25472 context_die = declare_in_namespace (type, context_die);
25474 if (TREE_CODE (type) == ENUMERAL_TYPE)
25476 /* This might have been written out by the call to
25477 declare_in_namespace. */
25478 if (!TREE_ASM_WRITTEN (type))
25479 gen_enumeration_type_die (type, context_die);
25482 gen_struct_or_union_type_die (type, context_die, usage);
25484 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
25485 it up if it is ever completed. gen_*_type_die will set it for us
25486 when appropriate. */
25489 /* Generate a type description DIE. */
25492 gen_type_die_with_usage (tree type, dw_die_ref context_die,
25493 enum debug_info_usage usage)
25495 struct array_descr_info info;
25497 if (type == NULL_TREE || type == error_mark_node)
25500 if (flag_checking && type)
25501 verify_type (type);
25503 if (TYPE_NAME (type) != NULL_TREE
25504 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
25505 && is_redundant_typedef (TYPE_NAME (type))
25506 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
25507 /* The DECL of this type is a typedef we don't want to emit debug
25508 info for but we want debug info for its underlying typedef.
25509 This can happen for e.g, the injected-class-name of a C++
25511 type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
25513 /* If TYPE is a typedef type variant, let's generate debug info
25514 for the parent typedef which TYPE is a type of. */
25515 if (typedef_variant_p (type))
25517 if (TREE_ASM_WRITTEN (type))
25520 tree name = TYPE_NAME (type);
25521 tree origin = decl_ultimate_origin (name);
25522 if (origin != NULL && origin != name)
25524 gen_decl_die (origin, NULL, NULL, context_die);
25528 /* Prevent broken recursion; we can't hand off to the same type. */
25529 gcc_assert (DECL_ORIGINAL_TYPE (name) != type);
25531 /* Give typedefs the right scope. */
25532 context_die = scope_die_for (type, context_die);
25534 TREE_ASM_WRITTEN (type) = 1;
25536 gen_decl_die (name, NULL, NULL, context_die);
25540 /* If type is an anonymous tagged type named by a typedef, let's
25541 generate debug info for the typedef. */
25542 if (is_naming_typedef_decl (TYPE_NAME (type)))
25544 /* Give typedefs the right scope. */
25545 context_die = scope_die_for (type, context_die);
25547 gen_decl_die (TYPE_NAME (type), NULL, NULL, context_die);
25551 if (lang_hooks.types.get_debug_type)
25553 tree debug_type = lang_hooks.types.get_debug_type (type);
25555 if (debug_type != NULL_TREE && debug_type != type)
25557 gen_type_die_with_usage (debug_type, context_die, usage);
25562 /* We are going to output a DIE to represent the unqualified version
25563 of this type (i.e. without any const or volatile qualifiers) so
25564 get the main variant (i.e. the unqualified version) of this type
25565 now. (Vectors and arrays are special because the debugging info is in the
25566 cloned type itself. Similarly function/method types can contain extra
25567 ref-qualification). */
25568 if (TREE_CODE (type) == FUNCTION_TYPE
25569 || TREE_CODE (type) == METHOD_TYPE)
25571 /* For function/method types, can't use type_main_variant here,
25572 because that can have different ref-qualifiers for C++,
25573 but try to canonicalize. */
25574 tree main = TYPE_MAIN_VARIANT (type);
25575 for (tree t = main; t; t = TYPE_NEXT_VARIANT (t))
25576 if (TYPE_QUALS_NO_ADDR_SPACE (t) == 0
25577 && check_base_type (t, main)
25578 && check_lang_type (t, type))
25584 else if (TREE_CODE (type) != VECTOR_TYPE
25585 && TREE_CODE (type) != ARRAY_TYPE)
25586 type = type_main_variant (type);
25588 /* If this is an array type with hidden descriptor, handle it first. */
25589 if (!TREE_ASM_WRITTEN (type)
25590 && lang_hooks.types.get_array_descr_info)
25592 memset (&info, 0, sizeof (info));
25593 if (lang_hooks.types.get_array_descr_info (type, &info))
25595 /* Fortran sometimes emits array types with no dimension. */
25596 gcc_assert (info.ndimensions >= 0
25597 && (info.ndimensions
25598 <= DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN));
25599 gen_descr_array_type_die (type, &info, context_die);
25600 TREE_ASM_WRITTEN (type) = 1;
25605 if (TREE_ASM_WRITTEN (type))
25607 /* Variable-length types may be incomplete even if
25608 TREE_ASM_WRITTEN. For such types, fall through to
25609 gen_array_type_die() and possibly fill in
25610 DW_AT_{upper,lower}_bound attributes. */
25611 if ((TREE_CODE (type) != ARRAY_TYPE
25612 && TREE_CODE (type) != RECORD_TYPE
25613 && TREE_CODE (type) != UNION_TYPE
25614 && TREE_CODE (type) != QUAL_UNION_TYPE)
25615 || !variably_modified_type_p (type, NULL))
25619 switch (TREE_CODE (type))
25625 case REFERENCE_TYPE:
25626 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
25627 ensures that the gen_type_die recursion will terminate even if the
25628 type is recursive. Recursive types are possible in Ada. */
25629 /* ??? We could perhaps do this for all types before the switch
25631 TREE_ASM_WRITTEN (type) = 1;
25633 /* For these types, all that is required is that we output a DIE (or a
25634 set of DIEs) to represent the "basis" type. */
25635 gen_type_die_with_usage (TREE_TYPE (type), context_die,
25636 DINFO_USAGE_IND_USE);
25640 /* This code is used for C++ pointer-to-data-member types.
25641 Output a description of the relevant class type. */
25642 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type), context_die,
25643 DINFO_USAGE_IND_USE);
25645 /* Output a description of the type of the object pointed to. */
25646 gen_type_die_with_usage (TREE_TYPE (type), context_die,
25647 DINFO_USAGE_IND_USE);
25649 /* Now output a DIE to represent this pointer-to-data-member type
25651 gen_ptr_to_mbr_type_die (type, context_die);
25654 case FUNCTION_TYPE:
25655 /* Force out return type (in case it wasn't forced out already). */
25656 gen_type_die_with_usage (TREE_TYPE (type), context_die,
25657 DINFO_USAGE_DIR_USE);
25658 gen_subroutine_type_die (type, context_die);
25662 /* Force out return type (in case it wasn't forced out already). */
25663 gen_type_die_with_usage (TREE_TYPE (type), context_die,
25664 DINFO_USAGE_DIR_USE);
25665 gen_subroutine_type_die (type, context_die);
25670 gen_array_type_die (type, context_die);
25673 case ENUMERAL_TYPE:
25676 case QUAL_UNION_TYPE:
25677 gen_tagged_type_die (type, context_die, usage);
25683 case FIXED_POINT_TYPE:
25686 /* No DIEs needed for fundamental types. */
25691 /* Just use DW_TAG_unspecified_type. */
25693 dw_die_ref type_die = lookup_type_die (type);
25694 if (type_die == NULL)
25696 tree name = TYPE_IDENTIFIER (type);
25697 type_die = new_die (DW_TAG_unspecified_type, comp_unit_die (),
25699 add_name_attribute (type_die, IDENTIFIER_POINTER (name));
25700 equate_type_number_to_die (type, type_die);
25706 if (is_cxx_auto (type))
25708 tree name = TYPE_IDENTIFIER (type);
25709 dw_die_ref *die = (name == get_identifier ("auto")
25710 ? &auto_die : &decltype_auto_die);
25713 *die = new_die (DW_TAG_unspecified_type,
25714 comp_unit_die (), NULL_TREE);
25715 add_name_attribute (*die, IDENTIFIER_POINTER (name));
25717 equate_type_number_to_die (type, *die);
25720 gcc_unreachable ();
25723 TREE_ASM_WRITTEN (type) = 1;
25727 gen_type_die (tree type, dw_die_ref context_die)
25729 if (type != error_mark_node)
25731 gen_type_die_with_usage (type, context_die, DINFO_USAGE_DIR_USE);
25734 dw_die_ref die = lookup_type_die (type);
25741 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
25742 things which are local to the given block. */
25745 gen_block_die (tree stmt, dw_die_ref context_die)
25747 int must_output_die = 0;
25750 /* Ignore blocks that are NULL. */
25751 if (stmt == NULL_TREE)
25754 inlined_func = inlined_function_outer_scope_p (stmt);
25756 /* If the block is one fragment of a non-contiguous block, do not
25757 process the variables, since they will have been done by the
25758 origin block. Do process subblocks. */
25759 if (BLOCK_FRAGMENT_ORIGIN (stmt))
25763 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
25764 gen_block_die (sub, context_die);
25769 /* Determine if we need to output any Dwarf DIEs at all to represent this
25772 /* The outer scopes for inlinings *must* always be represented. We
25773 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
25774 must_output_die = 1;
25775 else if (lookup_block_die (stmt))
25776 /* If we already have a DIE then it was filled early. Meanwhile
25777 we might have pruned all BLOCK_VARS as optimized out but we
25778 still want to generate high/low PC attributes so output it. */
25779 must_output_die = 1;
25780 else if (TREE_USED (stmt)
25781 || TREE_ASM_WRITTEN (stmt))
25783 /* Determine if this block directly contains any "significant"
25784 local declarations which we will need to output DIEs for. */
25785 if (debug_info_level > DINFO_LEVEL_TERSE)
25787 /* We are not in terse mode so any local declaration that
25788 is not ignored for debug purposes counts as being a
25789 "significant" one. */
25790 if (BLOCK_NUM_NONLOCALIZED_VARS (stmt))
25791 must_output_die = 1;
25793 for (tree var = BLOCK_VARS (stmt); var; var = DECL_CHAIN (var))
25794 if (!DECL_IGNORED_P (var))
25796 must_output_die = 1;
25800 else if (!dwarf2out_ignore_block (stmt))
25801 must_output_die = 1;
25804 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
25805 DIE for any block which contains no significant local declarations at
25806 all. Rather, in such cases we just call `decls_for_scope' so that any
25807 needed Dwarf info for any sub-blocks will get properly generated. Note
25808 that in terse mode, our definition of what constitutes a "significant"
25809 local declaration gets restricted to include only inlined function
25810 instances and local (nested) function definitions. */
25811 if (must_output_die)
25814 gen_inlined_subroutine_die (stmt, context_die);
25816 gen_lexical_block_die (stmt, context_die);
25819 decls_for_scope (stmt, context_die);
25822 /* Process variable DECL (or variable with origin ORIGIN) within
25823 block STMT and add it to CONTEXT_DIE. */
25825 process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
25828 tree decl_or_origin = decl ? decl : origin;
25830 if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
25831 die = lookup_decl_die (decl_or_origin);
25832 else if (TREE_CODE (decl_or_origin) == TYPE_DECL)
25834 if (TYPE_DECL_IS_STUB (decl_or_origin))
25835 die = lookup_type_die (TREE_TYPE (decl_or_origin));
25837 die = lookup_decl_die (decl_or_origin);
25838 /* Avoid re-creating the DIE late if it was optimized as unused early. */
25839 if (! die && ! early_dwarf)
25845 /* Avoid creating DIEs for local typedefs and concrete static variables that
25846 will only be pruned later. */
25847 if ((origin || decl_ultimate_origin (decl))
25848 && (TREE_CODE (decl_or_origin) == TYPE_DECL
25849 || (VAR_P (decl_or_origin) && TREE_STATIC (decl_or_origin))))
25851 origin = decl_ultimate_origin (decl_or_origin);
25852 if (decl && VAR_P (decl) && die != NULL)
25854 die = lookup_decl_die (origin);
25856 equate_decl_number_to_die (decl, die);
25861 if (die != NULL && die->die_parent == NULL)
25862 add_child_die (context_die, die);
25863 else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
25866 dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
25867 stmt, context_die);
25871 if (decl && DECL_P (decl))
25873 die = lookup_decl_die (decl);
25875 /* Early created DIEs do not have a parent as the decls refer
25876 to the function as DECL_CONTEXT rather than the BLOCK. */
25877 if (die && die->die_parent == NULL)
25879 gcc_assert (in_lto_p);
25880 add_child_die (context_die, die);
25884 gen_decl_die (decl, origin, NULL, context_die);
25888 /* Generate all of the decls declared within a given scope and (recursively)
25889 all of its sub-blocks. */
25892 decls_for_scope (tree stmt, dw_die_ref context_die, bool recurse)
25898 /* Ignore NULL blocks. */
25899 if (stmt == NULL_TREE)
25902 /* Output the DIEs to represent all of the data objects and typedefs
25903 declared directly within this block but not within any nested
25904 sub-blocks. Also, nested function and tag DIEs have been
25905 generated with a parent of NULL; fix that up now. We don't
25906 have to do this if we're at -g1. */
25907 if (debug_info_level > DINFO_LEVEL_TERSE)
25909 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = DECL_CHAIN (decl))
25910 process_scope_var (stmt, decl, NULL_TREE, context_die);
25911 /* BLOCK_NONLOCALIZED_VARs simply generate DIE stubs with abstract
25912 origin - avoid doing this twice as we have no good way to see
25913 if we've done it once already. */
25915 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
25917 decl = BLOCK_NONLOCALIZED_VAR (stmt, i);
25918 if (decl == current_function_decl)
25919 /* Ignore declarations of the current function, while they
25920 are declarations, gen_subprogram_die would treat them
25921 as definitions again, because they are equal to
25922 current_function_decl and endlessly recurse. */;
25923 else if (TREE_CODE (decl) == FUNCTION_DECL)
25924 process_scope_var (stmt, decl, NULL_TREE, context_die);
25926 process_scope_var (stmt, NULL_TREE, decl, context_die);
25930 /* Even if we're at -g1, we need to process the subblocks in order to get
25931 inlined call information. */
25933 /* Output the DIEs to represent all sub-blocks (and the items declared
25934 therein) of this block. */
25936 for (subblocks = BLOCK_SUBBLOCKS (stmt);
25938 subblocks = BLOCK_CHAIN (subblocks))
25939 gen_block_die (subblocks, context_die);
25942 /* Is this a typedef we can avoid emitting? */
25945 is_redundant_typedef (const_tree decl)
25947 if (TYPE_DECL_IS_STUB (decl))
25950 if (DECL_ARTIFICIAL (decl)
25951 && DECL_CONTEXT (decl)
25952 && is_tagged_type (DECL_CONTEXT (decl))
25953 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
25954 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
25955 /* Also ignore the artificial member typedef for the class name. */
25961 /* Return TRUE if TYPE is a typedef that names a type for linkage
25962 purposes. This kind of typedefs is produced by the C++ FE for
25965 typedef struct {...} foo;
25967 In that case, there is no typedef variant type produced for foo.
25968 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
25972 is_naming_typedef_decl (const_tree decl)
25974 if (decl == NULL_TREE
25975 || TREE_CODE (decl) != TYPE_DECL
25976 || DECL_NAMELESS (decl)
25977 || !is_tagged_type (TREE_TYPE (decl))
25978 || DECL_IS_BUILTIN (decl)
25979 || is_redundant_typedef (decl)
25980 /* It looks like Ada produces TYPE_DECLs that are very similar
25981 to C++ naming typedefs but that have different
25982 semantics. Let's be specific to c++ for now. */
25986 return (DECL_ORIGINAL_TYPE (decl) == NULL_TREE
25987 && TYPE_NAME (TREE_TYPE (decl)) == decl
25988 && (TYPE_STUB_DECL (TREE_TYPE (decl))
25989 != TYPE_NAME (TREE_TYPE (decl))));
25992 /* Looks up the DIE for a context. */
25994 static inline dw_die_ref
25995 lookup_context_die (tree context)
25999 /* Find die that represents this context. */
26000 if (TYPE_P (context))
26002 context = TYPE_MAIN_VARIANT (context);
26003 dw_die_ref ctx = lookup_type_die (context);
26006 return strip_naming_typedef (context, ctx);
26009 return lookup_decl_die (context);
26011 return comp_unit_die ();
26014 /* Returns the DIE for a context. */
26016 static inline dw_die_ref
26017 get_context_die (tree context)
26021 /* Find die that represents this context. */
26022 if (TYPE_P (context))
26024 context = TYPE_MAIN_VARIANT (context);
26025 return strip_naming_typedef (context, force_type_die (context));
26028 return force_decl_die (context);
26030 return comp_unit_die ();
26033 /* Returns the DIE for decl. A DIE will always be returned. */
26036 force_decl_die (tree decl)
26038 dw_die_ref decl_die;
26039 unsigned saved_external_flag;
26040 tree save_fn = NULL_TREE;
26041 decl_die = lookup_decl_die (decl);
26044 dw_die_ref context_die = get_context_die (DECL_CONTEXT (decl));
26046 decl_die = lookup_decl_die (decl);
26050 switch (TREE_CODE (decl))
26052 case FUNCTION_DECL:
26053 /* Clear current_function_decl, so that gen_subprogram_die thinks
26054 that this is a declaration. At this point, we just want to force
26055 declaration die. */
26056 save_fn = current_function_decl;
26057 current_function_decl = NULL_TREE;
26058 gen_subprogram_die (decl, context_die);
26059 current_function_decl = save_fn;
26063 /* Set external flag to force declaration die. Restore it after
26064 gen_decl_die() call. */
26065 saved_external_flag = DECL_EXTERNAL (decl);
26066 DECL_EXTERNAL (decl) = 1;
26067 gen_decl_die (decl, NULL, NULL, context_die);
26068 DECL_EXTERNAL (decl) = saved_external_flag;
26071 case NAMESPACE_DECL:
26072 if (dwarf_version >= 3 || !dwarf_strict)
26073 dwarf2out_decl (decl);
26075 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
26076 decl_die = comp_unit_die ();
26079 case TRANSLATION_UNIT_DECL:
26080 decl_die = comp_unit_die ();
26084 gcc_unreachable ();
26087 /* We should be able to find the DIE now. */
26089 decl_die = lookup_decl_die (decl);
26090 gcc_assert (decl_die);
26096 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
26097 always returned. */
26100 force_type_die (tree type)
26102 dw_die_ref type_die;
26104 type_die = lookup_type_die (type);
26107 dw_die_ref context_die = get_context_die (TYPE_CONTEXT (type));
26109 type_die = modified_type_die (type, TYPE_QUALS_NO_ADDR_SPACE (type),
26110 false, context_die);
26111 gcc_assert (type_die);
26116 /* Force out any required namespaces to be able to output DECL,
26117 and return the new context_die for it, if it's changed. */
26120 setup_namespace_context (tree thing, dw_die_ref context_die)
26122 tree context = (DECL_P (thing)
26123 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
26124 if (context && TREE_CODE (context) == NAMESPACE_DECL)
26125 /* Force out the namespace. */
26126 context_die = force_decl_die (context);
26128 return context_die;
26131 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
26132 type) within its namespace, if appropriate.
26134 For compatibility with older debuggers, namespace DIEs only contain
26135 declarations; all definitions are emitted at CU scope, with
26136 DW_AT_specification pointing to the declaration (like with class
26140 declare_in_namespace (tree thing, dw_die_ref context_die)
26142 dw_die_ref ns_context;
26144 if (debug_info_level <= DINFO_LEVEL_TERSE)
26145 return context_die;
26147 /* External declarations in the local scope only need to be emitted
26148 once, not once in the namespace and once in the scope.
26150 This avoids declaring the `extern' below in the
26151 namespace DIE as well as in the innermost scope:
26164 if (DECL_P (thing) && DECL_EXTERNAL (thing) && local_scope_p (context_die))
26165 return context_die;
26167 /* If this decl is from an inlined function, then don't try to emit it in its
26168 namespace, as we will get confused. It would have already been emitted
26169 when the abstract instance of the inline function was emitted anyways. */
26170 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
26171 return context_die;
26173 ns_context = setup_namespace_context (thing, context_die);
26175 if (ns_context != context_die)
26177 if (is_fortran () || is_dlang ())
26179 if (DECL_P (thing))
26180 gen_decl_die (thing, NULL, NULL, ns_context);
26182 gen_type_die (thing, ns_context);
26184 return context_die;
26187 /* Generate a DIE for a namespace or namespace alias. */
26190 gen_namespace_die (tree decl, dw_die_ref context_die)
26192 dw_die_ref namespace_die;
26194 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
26195 they are an alias of. */
26196 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
26198 /* Output a real namespace or module. */
26199 context_die = setup_namespace_context (decl, comp_unit_die ());
26200 namespace_die = new_die (is_fortran () || is_dlang ()
26201 ? DW_TAG_module : DW_TAG_namespace,
26202 context_die, decl);
26203 /* For Fortran modules defined in different CU don't add src coords. */
26204 if (namespace_die->die_tag == DW_TAG_module && DECL_EXTERNAL (decl))
26206 const char *name = dwarf2_name (decl, 0);
26208 add_name_attribute (namespace_die, name);
26211 add_name_and_src_coords_attributes (namespace_die, decl);
26212 if (DECL_EXTERNAL (decl))
26213 add_AT_flag (namespace_die, DW_AT_declaration, 1);
26214 equate_decl_number_to_die (decl, namespace_die);
26218 /* Output a namespace alias. */
26220 /* Force out the namespace we are an alias of, if necessary. */
26221 dw_die_ref origin_die
26222 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
26224 if (DECL_FILE_SCOPE_P (decl)
26225 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
26226 context_die = setup_namespace_context (decl, comp_unit_die ());
26227 /* Now create the namespace alias DIE. */
26228 namespace_die = new_die (DW_TAG_imported_declaration, context_die, decl);
26229 add_name_and_src_coords_attributes (namespace_die, decl);
26230 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
26231 equate_decl_number_to_die (decl, namespace_die);
26233 if ((dwarf_version >= 5 || !dwarf_strict)
26234 && lang_hooks.decls.decl_dwarf_attribute (decl,
26235 DW_AT_export_symbols) == 1)
26236 add_AT_flag (namespace_die, DW_AT_export_symbols, 1);
26238 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
26239 if (want_pubnames ())
26240 add_pubname_string (lang_hooks.dwarf_name (decl, 1), namespace_die);
26243 /* Generate Dwarf debug information for a decl described by DECL.
26244 The return value is currently only meaningful for PARM_DECLs,
26245 for all other decls it returns NULL.
26247 If DECL is a FIELD_DECL, CTX is required: see the comment for VLR_CONTEXT.
26248 It can be NULL otherwise. */
26251 gen_decl_die (tree decl, tree origin, struct vlr_context *ctx,
26252 dw_die_ref context_die)
26254 tree decl_or_origin = decl ? decl : origin;
26255 tree class_origin = NULL, ultimate_origin;
26257 if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
26260 switch (TREE_CODE (decl_or_origin))
26266 if (!is_fortran () && !is_ada () && !is_dlang ())
26268 /* The individual enumerators of an enum type get output when we output
26269 the Dwarf representation of the relevant enum type itself. */
26273 /* Emit its type. */
26274 gen_type_die (TREE_TYPE (decl), context_die);
26276 /* And its containing namespace. */
26277 context_die = declare_in_namespace (decl, context_die);
26279 gen_const_die (decl, context_die);
26282 case FUNCTION_DECL:
26285 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
26286 on local redeclarations of global functions. That seems broken. */
26287 if (current_function_decl != decl)
26288 /* This is only a declaration. */;
26291 /* We should have abstract copies already and should not generate
26292 stray type DIEs in late LTO dumping. */
26296 /* If we're emitting a clone, emit info for the abstract instance. */
26297 else if (origin || DECL_ORIGIN (decl) != decl)
26298 dwarf2out_abstract_function (origin
26299 ? DECL_ORIGIN (origin)
26300 : DECL_ABSTRACT_ORIGIN (decl));
26302 /* If we're emitting a possibly inlined function emit it as
26303 abstract instance. */
26304 else if (cgraph_function_possibly_inlined_p (decl)
26305 && ! DECL_ABSTRACT_P (decl)
26306 && ! class_or_namespace_scope_p (context_die)
26307 /* dwarf2out_abstract_function won't emit a die if this is just
26308 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
26309 that case, because that works only if we have a die. */
26310 && DECL_INITIAL (decl) != NULL_TREE)
26311 dwarf2out_abstract_function (decl);
26313 /* Otherwise we're emitting the primary DIE for this decl. */
26314 else if (debug_info_level > DINFO_LEVEL_TERSE)
26316 /* Before we describe the FUNCTION_DECL itself, make sure that we
26317 have its containing type. */
26319 origin = decl_class_context (decl);
26320 if (origin != NULL_TREE)
26321 gen_type_die (origin, context_die);
26323 /* And its return type. */
26324 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
26326 /* And its virtual context. */
26327 if (DECL_VINDEX (decl) != NULL_TREE)
26328 gen_type_die (DECL_CONTEXT (decl), context_die);
26330 /* Make sure we have a member DIE for decl. */
26331 if (origin != NULL_TREE)
26332 gen_type_die_for_member (origin, decl, context_die);
26334 /* And its containing namespace. */
26335 context_die = declare_in_namespace (decl, context_die);
26338 /* Now output a DIE to represent the function itself. */
26340 gen_subprogram_die (decl, context_die);
26344 /* If we are in terse mode, don't generate any DIEs to represent any
26345 actual typedefs. */
26346 if (debug_info_level <= DINFO_LEVEL_TERSE)
26349 /* In the special case of a TYPE_DECL node representing the declaration
26350 of some type tag, if the given TYPE_DECL is marked as having been
26351 instantiated from some other (original) TYPE_DECL node (e.g. one which
26352 was generated within the original definition of an inline function) we
26353 used to generate a special (abbreviated) DW_TAG_structure_type,
26354 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
26355 should be actually referencing those DIEs, as variable DIEs with that
26356 type would be emitted already in the abstract origin, so it was always
26357 removed during unused type prunning. Don't add anything in this
26359 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
26362 if (is_redundant_typedef (decl))
26363 gen_type_die (TREE_TYPE (decl), context_die);
26365 /* Output a DIE to represent the typedef itself. */
26366 gen_typedef_die (decl, context_die);
26370 if (debug_info_level >= DINFO_LEVEL_NORMAL)
26371 gen_label_die (decl, context_die);
26376 /* If we are in terse mode, don't generate any DIEs to represent any
26377 variable declarations or definitions unless it is external. */
26378 if (debug_info_level < DINFO_LEVEL_TERSE
26379 || (debug_info_level == DINFO_LEVEL_TERSE
26380 && !TREE_PUBLIC (decl_or_origin)))
26383 if (debug_info_level > DINFO_LEVEL_TERSE)
26385 /* Avoid generating stray type DIEs during late dwarf dumping.
26386 All types have been dumped early. */
26388 /* ??? But in LTRANS we cannot annotate early created variably
26389 modified type DIEs without copying them and adjusting all
26390 references to them. Dump them again as happens for inlining
26391 which copies both the decl and the types. */
26392 /* ??? And even non-LTO needs to re-visit type DIEs to fill
26393 in VLA bound information for example. */
26394 || (decl && variably_modified_type_p (TREE_TYPE (decl),
26395 current_function_decl)))
26397 /* Output any DIEs that are needed to specify the type of this data
26399 if (decl_by_reference_p (decl_or_origin))
26400 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
26402 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
26407 /* And its containing type. */
26408 class_origin = decl_class_context (decl_or_origin);
26409 if (class_origin != NULL_TREE)
26410 gen_type_die_for_member (class_origin, decl_or_origin, context_die);
26412 /* And its containing namespace. */
26413 context_die = declare_in_namespace (decl_or_origin, context_die);
26417 /* Now output the DIE to represent the data object itself. This gets
26418 complicated because of the possibility that the VAR_DECL really
26419 represents an inlined instance of a formal parameter for an inline
26421 ultimate_origin = decl_ultimate_origin (decl_or_origin);
26422 if (ultimate_origin != NULL_TREE
26423 && TREE_CODE (ultimate_origin) == PARM_DECL)
26424 gen_formal_parameter_die (decl, origin,
26425 true /* Emit name attribute. */,
26428 gen_variable_die (decl, origin, context_die);
26432 gcc_assert (ctx != NULL && ctx->struct_type != NULL);
26433 /* Ignore the nameless fields that are used to skip bits but handle C++
26434 anonymous unions and structs. */
26435 if (DECL_NAME (decl) != NULL_TREE
26436 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
26437 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
26439 gen_type_die (member_declared_type (decl), context_die);
26440 gen_field_die (decl, ctx, context_die);
26445 /* Avoid generating stray type DIEs during late dwarf dumping.
26446 All types have been dumped early. */
26448 /* ??? But in LTRANS we cannot annotate early created variably
26449 modified type DIEs without copying them and adjusting all
26450 references to them. Dump them again as happens for inlining
26451 which copies both the decl and the types. */
26452 /* ??? And even non-LTO needs to re-visit type DIEs to fill
26453 in VLA bound information for example. */
26454 || (decl && variably_modified_type_p (TREE_TYPE (decl),
26455 current_function_decl)))
26457 if (DECL_BY_REFERENCE (decl_or_origin))
26458 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
26460 gen_type_die (TREE_TYPE (decl_or_origin), context_die);
26462 return gen_formal_parameter_die (decl, origin,
26463 true /* Emit name attribute. */,
26466 case NAMESPACE_DECL:
26467 if (dwarf_version >= 3 || !dwarf_strict)
26468 gen_namespace_die (decl, context_die);
26471 case IMPORTED_DECL:
26472 dwarf2out_imported_module_or_decl_1 (decl, DECL_NAME (decl),
26473 DECL_CONTEXT (decl), context_die);
26476 case NAMELIST_DECL:
26477 gen_namelist_decl (DECL_NAME (decl), context_die,
26478 NAMELIST_DECL_ASSOCIATED_DECL (decl));
26482 /* Probably some frontend-internal decl. Assume we don't care. */
26483 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
26490 /* Output initial debug information for global DECL. Called at the
26491 end of the parsing process.
26493 This is the initial debug generation process. As such, the DIEs
26494 generated may be incomplete. A later debug generation pass
26495 (dwarf2out_late_global_decl) will augment the information generated
26496 in this pass (e.g., with complete location info). */
26499 dwarf2out_early_global_decl (tree decl)
26503 /* gen_decl_die() will set DECL_ABSTRACT because
26504 cgraph_function_possibly_inlined_p() returns true. This is in
26505 turn will cause DW_AT_inline attributes to be set.
26507 This happens because at early dwarf generation, there is no
26508 cgraph information, causing cgraph_function_possibly_inlined_p()
26509 to return true. Trick cgraph_function_possibly_inlined_p()
26510 while we generate dwarf early. */
26511 bool save = symtab->global_info_ready;
26512 symtab->global_info_ready = true;
26514 /* We don't handle TYPE_DECLs. If required, they'll be reached via
26515 other DECLs and they can point to template types or other things
26516 that dwarf2out can't handle when done via dwarf2out_decl. */
26517 if (TREE_CODE (decl) != TYPE_DECL
26518 && TREE_CODE (decl) != PARM_DECL)
26520 if (TREE_CODE (decl) == FUNCTION_DECL)
26522 tree save_fndecl = current_function_decl;
26524 /* For nested functions, make sure we have DIEs for the parents first
26525 so that all nested DIEs are generated at the proper scope in the
26527 tree context = decl_function_context (decl);
26528 if (context != NULL)
26530 dw_die_ref context_die = lookup_decl_die (context);
26531 current_function_decl = context;
26533 /* Avoid emitting DIEs multiple times, but still process CONTEXT
26534 enough so that it lands in its own context. This avoids type
26535 pruning issues later on. */
26536 if (context_die == NULL || is_declaration_die (context_die))
26537 dwarf2out_early_global_decl (context);
26540 /* Emit an abstract origin of a function first. This happens
26541 with C++ constructor clones for example and makes
26542 dwarf2out_abstract_function happy which requires the early
26543 DIE of the abstract instance to be present. */
26544 tree origin = DECL_ABSTRACT_ORIGIN (decl);
26545 dw_die_ref origin_die;
26547 /* Do not emit the DIE multiple times but make sure to
26548 process it fully here in case we just saw a declaration. */
26549 && ((origin_die = lookup_decl_die (origin)) == NULL
26550 || is_declaration_die (origin_die)))
26552 current_function_decl = origin;
26553 dwarf2out_decl (origin);
26556 /* Emit the DIE for decl but avoid doing that multiple times. */
26557 dw_die_ref old_die;
26558 if ((old_die = lookup_decl_die (decl)) == NULL
26559 || is_declaration_die (old_die))
26561 current_function_decl = decl;
26562 dwarf2out_decl (decl);
26565 current_function_decl = save_fndecl;
26568 dwarf2out_decl (decl);
26570 symtab->global_info_ready = save;
26573 /* Return whether EXPR is an expression with the following pattern:
26574 INDIRECT_REF (NOP_EXPR (INTEGER_CST)). */
26577 is_trivial_indirect_ref (tree expr)
26579 if (expr == NULL_TREE || TREE_CODE (expr) != INDIRECT_REF)
26582 tree nop = TREE_OPERAND (expr, 0);
26583 if (nop == NULL_TREE || TREE_CODE (nop) != NOP_EXPR)
26586 tree int_cst = TREE_OPERAND (nop, 0);
26587 return int_cst != NULL_TREE && TREE_CODE (int_cst) == INTEGER_CST;
26590 /* Output debug information for global decl DECL. Called from
26591 toplev.c after compilation proper has finished. */
26594 dwarf2out_late_global_decl (tree decl)
26596 /* Fill-in any location information we were unable to determine
26597 on the first pass. */
26600 dw_die_ref die = lookup_decl_die (decl);
26602 /* We may have to generate full debug late for LTO in case debug
26603 was not enabled at compile-time or the target doesn't support
26604 the LTO early debug scheme. */
26605 if (! die && in_lto_p)
26606 dwarf2out_decl (decl);
26609 /* We get called via the symtab code invoking late_global_decl
26610 for symbols that are optimized out.
26612 Do not add locations for those, except if they have a
26613 DECL_VALUE_EXPR, in which case they are relevant for debuggers.
26614 Still don't add a location if the DECL_VALUE_EXPR is not a trivial
26615 INDIRECT_REF expression, as this could generate relocations to
26616 text symbols in LTO object files, which is invalid. */
26617 varpool_node *node = varpool_node::get (decl);
26618 if ((! node || ! node->definition)
26619 && ! (DECL_HAS_VALUE_EXPR_P (decl)
26620 && is_trivial_indirect_ref (DECL_VALUE_EXPR (decl))))
26621 tree_add_const_value_attribute_for_decl (die, decl);
26623 add_location_or_const_value_attribute (die, decl, false);
26628 /* Output debug information for type decl DECL. Called from toplev.c
26629 and from language front ends (to record built-in types). */
26631 dwarf2out_type_decl (tree decl, int local)
26636 dwarf2out_decl (decl);
26640 /* Output debug information for imported module or decl DECL.
26641 NAME is non-NULL name in the lexical block if the decl has been renamed.
26642 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
26643 that DECL belongs to.
26644 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
26646 dwarf2out_imported_module_or_decl_1 (tree decl,
26648 tree lexical_block,
26649 dw_die_ref lexical_block_die)
26651 expanded_location xloc;
26652 dw_die_ref imported_die = NULL;
26653 dw_die_ref at_import_die;
26655 if (TREE_CODE (decl) == IMPORTED_DECL)
26657 xloc = expand_location (DECL_SOURCE_LOCATION (decl));
26658 decl = IMPORTED_DECL_ASSOCIATED_DECL (decl);
26662 xloc = expand_location (input_location);
26664 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
26666 at_import_die = force_type_die (TREE_TYPE (decl));
26667 /* For namespace N { typedef void T; } using N::T; base_type_die
26668 returns NULL, but DW_TAG_imported_declaration requires
26669 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
26670 if (!at_import_die)
26672 gcc_assert (TREE_CODE (decl) == TYPE_DECL);
26673 gen_typedef_die (decl, get_context_die (DECL_CONTEXT (decl)));
26674 at_import_die = lookup_type_die (TREE_TYPE (decl));
26675 gcc_assert (at_import_die);
26680 at_import_die = lookup_decl_die (decl);
26681 if (!at_import_die)
26683 /* If we're trying to avoid duplicate debug info, we may not have
26684 emitted the member decl for this field. Emit it now. */
26685 if (TREE_CODE (decl) == FIELD_DECL)
26687 tree type = DECL_CONTEXT (decl);
26689 if (TYPE_CONTEXT (type)
26690 && TYPE_P (TYPE_CONTEXT (type))
26691 && !should_emit_struct_debug (TYPE_CONTEXT (type),
26692 DINFO_USAGE_DIR_USE))
26694 gen_type_die_for_member (type, decl,
26695 get_context_die (TYPE_CONTEXT (type)));
26697 if (TREE_CODE (decl) == NAMELIST_DECL)
26698 at_import_die = gen_namelist_decl (DECL_NAME (decl),
26699 get_context_die (DECL_CONTEXT (decl)),
26702 at_import_die = force_decl_die (decl);
26706 if (TREE_CODE (decl) == NAMESPACE_DECL)
26708 if (dwarf_version >= 3 || !dwarf_strict)
26709 imported_die = new_die (DW_TAG_imported_module,
26716 imported_die = new_die (DW_TAG_imported_declaration,
26720 add_AT_file (imported_die, DW_AT_decl_file, lookup_filename (xloc.file));
26721 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
26722 if (debug_column_info && xloc.column)
26723 add_AT_unsigned (imported_die, DW_AT_decl_column, xloc.column);
26725 add_AT_string (imported_die, DW_AT_name,
26726 IDENTIFIER_POINTER (name));
26727 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
26730 /* Output debug information for imported module or decl DECL.
26731 NAME is non-NULL name in context if the decl has been renamed.
26732 CHILD is true if decl is one of the renamed decls as part of
26733 importing whole module.
26734 IMPLICIT is set if this hook is called for an implicit import
26735 such as inline namespace. */
26738 dwarf2out_imported_module_or_decl (tree decl, tree name, tree context,
26739 bool child, bool implicit)
26741 /* dw_die_ref at_import_die; */
26742 dw_die_ref scope_die;
26744 if (debug_info_level <= DINFO_LEVEL_TERSE)
26749 /* For DWARF5, just DW_AT_export_symbols on the DW_TAG_namespace
26750 should be enough, for DWARF4 and older even if we emit as extension
26751 DW_AT_export_symbols add the implicit DW_TAG_imported_module anyway
26752 for the benefit of consumers unaware of DW_AT_export_symbols. */
26754 && dwarf_version >= 5
26755 && lang_hooks.decls.decl_dwarf_attribute (decl,
26756 DW_AT_export_symbols) == 1)
26761 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
26762 We need decl DIE for reference and scope die. First, get DIE for the decl
26765 /* Get the scope die for decl context. Use comp_unit_die for global module
26766 or decl. If die is not found for non globals, force new die. */
26768 && TYPE_P (context)
26769 && !should_emit_struct_debug (context, DINFO_USAGE_DIR_USE))
26772 scope_die = get_context_die (context);
26776 /* DW_TAG_imported_module was introduced in the DWARFv3 specification, so
26777 there is nothing we can do, here. */
26778 if (dwarf_version < 3 && dwarf_strict)
26781 gcc_assert (scope_die->die_child);
26782 gcc_assert (scope_die->die_child->die_tag == DW_TAG_imported_module);
26783 gcc_assert (TREE_CODE (decl) != NAMESPACE_DECL);
26784 scope_die = scope_die->die_child;
26787 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
26788 dwarf2out_imported_module_or_decl_1 (decl, name, context, scope_die);
26791 /* Output debug information for namelists. */
26794 gen_namelist_decl (tree name, dw_die_ref scope_die, tree item_decls)
26796 dw_die_ref nml_die, nml_item_die, nml_item_ref_die;
26800 if (debug_info_level <= DINFO_LEVEL_TERSE)
26803 gcc_assert (scope_die != NULL);
26804 nml_die = new_die (DW_TAG_namelist, scope_die, NULL);
26805 add_AT_string (nml_die, DW_AT_name, IDENTIFIER_POINTER (name));
26807 /* If there are no item_decls, we have a nondefining namelist, e.g.
26808 with USE association; hence, set DW_AT_declaration. */
26809 if (item_decls == NULL_TREE)
26811 add_AT_flag (nml_die, DW_AT_declaration, 1);
26815 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls), i, value)
26817 nml_item_ref_die = lookup_decl_die (value);
26818 if (!nml_item_ref_die)
26819 nml_item_ref_die = force_decl_die (value);
26821 nml_item_die = new_die (DW_TAG_namelist_item, nml_die, NULL);
26822 add_AT_die_ref (nml_item_die, DW_AT_namelist_items, nml_item_ref_die);
26828 /* Write the debugging output for DECL and return the DIE. */
26831 dwarf2out_decl (tree decl)
26833 dw_die_ref context_die = comp_unit_die ();
26835 switch (TREE_CODE (decl))
26840 case FUNCTION_DECL:
26841 /* If we're a nested function, initially use a parent of NULL; if we're
26842 a plain function, this will be fixed up in decls_for_scope. If
26843 we're a method, it will be ignored, since we already have a DIE.
26844 Avoid doing this late though since clones of class methods may
26845 otherwise end up in limbo and create type DIEs late. */
26847 && decl_function_context (decl)
26848 /* But if we're in terse mode, we don't care about scope. */
26849 && debug_info_level > DINFO_LEVEL_TERSE)
26850 context_die = NULL;
26854 /* For local statics lookup proper context die. */
26855 if (local_function_static (decl))
26856 context_die = lookup_decl_die (DECL_CONTEXT (decl));
26858 /* If we are in terse mode, don't generate any DIEs to represent any
26859 variable declarations or definitions unless it is external. */
26860 if (debug_info_level < DINFO_LEVEL_TERSE
26861 || (debug_info_level == DINFO_LEVEL_TERSE
26862 && !TREE_PUBLIC (decl)))
26867 if (debug_info_level <= DINFO_LEVEL_TERSE)
26869 if (!is_fortran () && !is_ada () && !is_dlang ())
26871 if (TREE_STATIC (decl) && decl_function_context (decl))
26872 context_die = lookup_decl_die (DECL_CONTEXT (decl));
26875 case NAMESPACE_DECL:
26876 case IMPORTED_DECL:
26877 if (debug_info_level <= DINFO_LEVEL_TERSE)
26879 if (lookup_decl_die (decl) != NULL)
26884 /* Don't emit stubs for types unless they are needed by other DIEs. */
26885 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
26888 /* Don't bother trying to generate any DIEs to represent any of the
26889 normal built-in types for the language we are compiling. */
26890 if (DECL_IS_BUILTIN (decl))
26893 /* If we are in terse mode, don't generate any DIEs for types. */
26894 if (debug_info_level <= DINFO_LEVEL_TERSE)
26897 /* If we're a function-scope tag, initially use a parent of NULL;
26898 this will be fixed up in decls_for_scope. */
26899 if (decl_function_context (decl))
26900 context_die = NULL;
26904 case NAMELIST_DECL:
26911 gen_decl_die (decl, NULL, NULL, context_die);
26915 dw_die_ref die = lookup_decl_die (decl);
26921 /* Write the debugging output for DECL. */
26924 dwarf2out_function_decl (tree decl)
26926 dwarf2out_decl (decl);
26927 call_arg_locations = NULL;
26928 call_arg_loc_last = NULL;
26929 call_site_count = -1;
26930 tail_call_site_count = -1;
26931 decl_loc_table->empty ();
26932 cached_dw_loc_list_table->empty ();
26935 /* Output a marker (i.e. a label) for the beginning of the generated code for
26936 a lexical block. */
26939 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
26940 unsigned int blocknum)
26942 switch_to_section (current_function_section ());
26943 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
26946 /* Output a marker (i.e. a label) for the end of the generated code for a
26950 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
26952 switch_to_section (current_function_section ());
26953 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
26956 /* Returns nonzero if it is appropriate not to emit any debugging
26957 information for BLOCK, because it doesn't contain any instructions.
26959 Don't allow this for blocks with nested functions or local classes
26960 as we would end up with orphans, and in the presence of scheduling
26961 we may end up calling them anyway. */
26964 dwarf2out_ignore_block (const_tree block)
26969 for (decl = BLOCK_VARS (block); decl; decl = DECL_CHAIN (decl))
26970 if (TREE_CODE (decl) == FUNCTION_DECL
26971 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
26973 for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
26975 decl = BLOCK_NONLOCALIZED_VAR (block, i);
26976 if (TREE_CODE (decl) == FUNCTION_DECL
26977 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
26984 /* Hash table routines for file_hash. */
26987 dwarf_file_hasher::equal (dwarf_file_data *p1, const char *p2)
26989 return filename_cmp (p1->filename, p2) == 0;
26993 dwarf_file_hasher::hash (dwarf_file_data *p)
26995 return htab_hash_string (p->filename);
26998 /* Lookup FILE_NAME (in the list of filenames that we know about here in
26999 dwarf2out.c) and return its "index". The index of each (known) filename is
27000 just a unique number which is associated with only that one filename. We
27001 need such numbers for the sake of generating labels (in the .debug_sfnames
27002 section) and references to those files numbers (in the .debug_srcinfo
27003 and .debug_macinfo sections). If the filename given as an argument is not
27004 found in our current list, add it to the list and assign it the next
27005 available unique index number. */
27007 static struct dwarf_file_data *
27008 lookup_filename (const char *file_name)
27010 struct dwarf_file_data * created;
27016 file_name = "<stdin>";
27018 dwarf_file_data **slot
27019 = file_table->find_slot_with_hash (file_name, htab_hash_string (file_name),
27024 created = ggc_alloc<dwarf_file_data> ();
27025 created->filename = file_name;
27026 created->emitted_number = 0;
27031 /* If the assembler will construct the file table, then translate the compiler
27032 internal file table number into the assembler file table number, and emit
27033 a .file directive if we haven't already emitted one yet. The file table
27034 numbers are different because we prune debug info for unused variables and
27035 types, which may include filenames. */
27038 maybe_emit_file (struct dwarf_file_data * fd)
27040 if (! fd->emitted_number)
27042 if (last_emitted_file)
27043 fd->emitted_number = last_emitted_file->emitted_number + 1;
27045 fd->emitted_number = 1;
27046 last_emitted_file = fd;
27048 if (output_asm_line_debug_info ())
27050 fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
27051 output_quoted_string (asm_out_file,
27052 remap_debug_filename (fd->filename));
27053 fputc ('\n', asm_out_file);
27057 return fd->emitted_number;
27060 /* Schedule generation of a DW_AT_const_value attribute to DIE.
27061 That generation should happen after function debug info has been
27062 generated. The value of the attribute is the constant value of ARG. */
27065 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die, tree arg)
27067 die_arg_entry entry;
27072 gcc_assert (early_dwarf);
27074 if (!tmpl_value_parm_die_table)
27075 vec_alloc (tmpl_value_parm_die_table, 32);
27079 vec_safe_push (tmpl_value_parm_die_table, entry);
27082 /* Return TRUE if T is an instance of generic type, FALSE
27086 generic_type_p (tree t)
27088 if (t == NULL_TREE || !TYPE_P (t))
27090 return lang_hooks.get_innermost_generic_parms (t) != NULL_TREE;
27093 /* Schedule the generation of the generic parameter dies for the
27094 instance of generic type T. The proper generation itself is later
27095 done by gen_scheduled_generic_parms_dies. */
27098 schedule_generic_params_dies_gen (tree t)
27100 if (!generic_type_p (t))
27103 gcc_assert (early_dwarf);
27105 if (!generic_type_instances)
27106 vec_alloc (generic_type_instances, 256);
27108 vec_safe_push (generic_type_instances, t);
27111 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
27112 by append_entry_to_tmpl_value_parm_die_table. This function must
27113 be called after function DIEs have been generated. */
27116 gen_remaining_tmpl_value_param_die_attribute (void)
27118 if (tmpl_value_parm_die_table)
27123 /* We do this in two phases - first get the cases we can
27124 handle during early-finish, preserving those we cannot
27125 (containing symbolic constants where we don't yet know
27126 whether we are going to output the referenced symbols).
27127 For those we try again at late-finish. */
27129 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table, i, e)
27131 if (!e->die->removed
27132 && !tree_add_const_value_attribute (e->die, e->arg))
27134 dw_loc_descr_ref loc = NULL;
27136 && (dwarf_version >= 5 || !dwarf_strict))
27137 loc = loc_descriptor_from_tree (e->arg, 2, NULL);
27139 add_AT_loc (e->die, DW_AT_location, loc);
27141 (*tmpl_value_parm_die_table)[j++] = *e;
27144 tmpl_value_parm_die_table->truncate (j);
27148 /* Generate generic parameters DIEs for instances of generic types
27149 that have been previously scheduled by
27150 schedule_generic_params_dies_gen. This function must be called
27151 after all the types of the CU have been laid out. */
27154 gen_scheduled_generic_parms_dies (void)
27159 if (!generic_type_instances)
27162 FOR_EACH_VEC_ELT (*generic_type_instances, i, t)
27163 if (COMPLETE_TYPE_P (t))
27164 gen_generic_params_dies (t);
27166 generic_type_instances = NULL;
27170 /* Replace DW_AT_name for the decl with name. */
27173 dwarf2out_set_name (tree decl, tree name)
27176 dw_attr_node *attr;
27179 die = TYPE_SYMTAB_DIE (decl);
27183 dname = dwarf2_name (name, 0);
27187 attr = get_AT (die, DW_AT_name);
27190 struct indirect_string_node *node;
27192 node = find_AT_string (dname);
27193 /* replace the string. */
27194 attr->dw_attr_val.v.val_str = node;
27198 add_name_attribute (die, dname);
27201 /* True if before or during processing of the first function being emitted. */
27202 static bool in_first_function_p = true;
27203 /* True if loc_note during dwarf2out_var_location call might still be
27204 before first real instruction at address equal to .Ltext0. */
27205 static bool maybe_at_text_label_p = true;
27206 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
27207 static unsigned int first_loclabel_num_not_at_text_label;
27209 /* Look ahead for a real insn, or for a begin stmt marker. */
27212 dwarf2out_next_real_insn (rtx_insn *loc_note)
27214 rtx_insn *next_real = NEXT_INSN (loc_note);
27217 if (INSN_P (next_real))
27220 next_real = NEXT_INSN (next_real);
27225 /* Called by the final INSN scan whenever we see a var location. We
27226 use it to drop labels in the right places, and throw the location in
27227 our lookup table. */
27230 dwarf2out_var_location (rtx_insn *loc_note)
27232 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES + 2];
27233 struct var_loc_node *newloc;
27234 rtx_insn *next_real, *next_note;
27235 rtx_insn *call_insn = NULL;
27236 static const char *last_label;
27237 static const char *last_postcall_label;
27238 static bool last_in_cold_section_p;
27239 static rtx_insn *expected_next_loc_note;
27242 var_loc_view view = 0;
27244 if (!NOTE_P (loc_note))
27246 if (CALL_P (loc_note))
27248 maybe_reset_location_view (loc_note, cur_line_info_table);
27250 if (SIBLING_CALL_P (loc_note))
27251 tail_call_site_count++;
27252 if (find_reg_note (loc_note, REG_CALL_ARG_LOCATION, NULL_RTX))
27254 call_insn = loc_note;
27258 next_real = dwarf2out_next_real_insn (call_insn);
27260 cached_next_real_insn = NULL;
27263 if (optimize == 0 && !flag_var_tracking)
27265 /* When the var-tracking pass is not running, there is no note
27266 for indirect calls whose target is compile-time known. In this
27267 case, process such calls specifically so that we generate call
27268 sites for them anyway. */
27269 rtx x = PATTERN (loc_note);
27270 if (GET_CODE (x) == PARALLEL)
27271 x = XVECEXP (x, 0, 0);
27272 if (GET_CODE (x) == SET)
27274 if (GET_CODE (x) == CALL)
27277 || GET_CODE (XEXP (x, 0)) != SYMBOL_REF
27278 || !SYMBOL_REF_DECL (XEXP (x, 0))
27279 || (TREE_CODE (SYMBOL_REF_DECL (XEXP (x, 0)))
27282 call_insn = loc_note;
27286 next_real = dwarf2out_next_real_insn (call_insn);
27288 cached_next_real_insn = NULL;
27293 else if (!debug_variable_location_views)
27294 gcc_unreachable ();
27296 maybe_reset_location_view (loc_note, cur_line_info_table);
27301 var_loc_p = NOTE_KIND (loc_note) == NOTE_INSN_VAR_LOCATION;
27302 if (var_loc_p && !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
27305 /* Optimize processing a large consecutive sequence of location
27306 notes so we don't spend too much time in next_real_insn. If the
27307 next insn is another location note, remember the next_real_insn
27308 calculation for next time. */
27309 next_real = cached_next_real_insn;
27312 if (expected_next_loc_note != loc_note)
27316 next_note = NEXT_INSN (loc_note);
27318 || next_note->deleted ()
27319 || ! NOTE_P (next_note)
27320 || (NOTE_KIND (next_note) != NOTE_INSN_VAR_LOCATION
27321 && NOTE_KIND (next_note) != NOTE_INSN_BEGIN_STMT
27322 && NOTE_KIND (next_note) != NOTE_INSN_INLINE_ENTRY))
27326 next_real = dwarf2out_next_real_insn (loc_note);
27330 expected_next_loc_note = next_note;
27331 cached_next_real_insn = next_real;
27334 cached_next_real_insn = NULL;
27336 /* If there are no instructions which would be affected by this note,
27337 don't do anything. */
27339 && next_real == NULL_RTX
27340 && !NOTE_DURING_CALL_P (loc_note))
27345 if (next_real == NULL_RTX)
27346 next_real = get_last_insn ();
27348 /* If there were any real insns between note we processed last time
27349 and this note (or if it is the first note), clear
27350 last_{,postcall_}label so that they are not reused this time. */
27351 if (last_var_location_insn == NULL_RTX
27352 || last_var_location_insn != next_real
27353 || last_in_cold_section_p != in_cold_section_p)
27356 last_postcall_label = NULL;
27362 = NOTE_DURING_CALL_P (loc_note) ? last_postcall_label : last_label;
27363 view = cur_line_info_table->view;
27364 decl = NOTE_VAR_LOCATION_DECL (loc_note);
27365 newloc = add_var_loc_to_decl (decl, loc_note, label, view);
27366 if (newloc == NULL)
27375 /* If there were no real insns between note we processed last time
27376 and this note, use the label we emitted last time. Otherwise
27377 create a new label and emit it. */
27378 if (last_label == NULL)
27380 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
27381 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
27383 last_label = ggc_strdup (loclabel);
27384 /* See if loclabel might be equal to .Ltext0. If yes,
27385 bump first_loclabel_num_not_at_text_label. */
27386 if (!have_multiple_function_sections
27387 && in_first_function_p
27388 && maybe_at_text_label_p)
27390 static rtx_insn *last_start;
27392 for (insn = loc_note; insn; insn = previous_insn (insn))
27393 if (insn == last_start)
27395 else if (!NONDEBUG_INSN_P (insn))
27399 rtx body = PATTERN (insn);
27400 if (GET_CODE (body) == USE || GET_CODE (body) == CLOBBER)
27402 /* Inline asm could occupy zero bytes. */
27403 else if (GET_CODE (body) == ASM_INPUT
27404 || asm_noperands (body) >= 0)
27406 #ifdef HAVE_ATTR_length /* ??? We don't include insn-attr.h. */
27407 else if (HAVE_ATTR_length && get_attr_min_length (insn) == 0)
27412 /* Assume insn has non-zero length. */
27413 maybe_at_text_label_p = false;
27417 if (maybe_at_text_label_p)
27419 last_start = loc_note;
27420 first_loclabel_num_not_at_text_label = loclabel_num;
27425 gcc_assert ((loc_note == NULL_RTX && call_insn != NULL_RTX)
27426 || (loc_note != NULL_RTX && call_insn == NULL_RTX));
27430 struct call_arg_loc_node *ca_loc
27431 = ggc_cleared_alloc<call_arg_loc_node> ();
27432 rtx_insn *prev = call_insn;
27434 ca_loc->call_arg_loc_note
27435 = find_reg_note (call_insn, REG_CALL_ARG_LOCATION, NULL_RTX);
27436 ca_loc->next = NULL;
27437 ca_loc->label = last_label;
27440 || (NONJUMP_INSN_P (prev)
27441 && GET_CODE (PATTERN (prev)) == SEQUENCE
27442 && CALL_P (XVECEXP (PATTERN (prev), 0, 0)))));
27443 if (!CALL_P (prev))
27444 prev = as_a <rtx_sequence *> (PATTERN (prev))->insn (0);
27445 ca_loc->tail_call_p = SIBLING_CALL_P (prev);
27447 /* Look for a SYMBOL_REF in the "prev" instruction. */
27448 rtx x = get_call_rtx_from (prev);
27451 /* Try to get the call symbol, if any. */
27452 if (MEM_P (XEXP (x, 0)))
27454 /* First, look for a memory access to a symbol_ref. */
27455 if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
27456 && SYMBOL_REF_DECL (XEXP (x, 0))
27457 && TREE_CODE (SYMBOL_REF_DECL (XEXP (x, 0))) == FUNCTION_DECL)
27458 ca_loc->symbol_ref = XEXP (x, 0);
27459 /* Otherwise, look at a compile-time known user-level function
27463 && TREE_CODE (MEM_EXPR (x)) == FUNCTION_DECL)
27464 ca_loc->symbol_ref = XEXP (DECL_RTL (MEM_EXPR (x)), 0);
27467 ca_loc->block = insn_scope (prev);
27468 if (call_arg_locations)
27469 call_arg_loc_last->next = ca_loc;
27471 call_arg_locations = ca_loc;
27472 call_arg_loc_last = ca_loc;
27474 else if (loc_note != NULL_RTX && !NOTE_DURING_CALL_P (loc_note))
27476 newloc->label = last_label;
27477 newloc->view = view;
27481 if (!last_postcall_label)
27483 sprintf (loclabel, "%s-1", last_label);
27484 last_postcall_label = ggc_strdup (loclabel);
27486 newloc->label = last_postcall_label;
27487 /* ??? This view is at last_label, not last_label-1, but we
27488 could only assume view at last_label-1 is zero if we could
27489 assume calls always have length greater than one. This is
27490 probably true in general, though there might be a rare
27491 exception to this rule, e.g. if a call insn is optimized out
27492 by target magic. Then, even the -1 in the label will be
27493 wrong, which might invalidate the range. Anyway, using view,
27494 though technically possibly incorrect, will work as far as
27495 ranges go: since L-1 is in the middle of the call insn,
27496 (L-1).0 and (L-1).V shouldn't make any difference, and having
27497 the loclist entry refer to the .loc entry might be useful, so
27498 leave it like this. */
27499 newloc->view = view;
27502 if (var_loc_p && flag_debug_asm)
27504 const char *name, *sep, *patstr;
27505 if (decl && DECL_NAME (decl))
27506 name = IDENTIFIER_POINTER (DECL_NAME (decl));
27509 if (NOTE_VAR_LOCATION_LOC (loc_note))
27512 patstr = str_pattern_slim (NOTE_VAR_LOCATION_LOC (loc_note));
27519 fprintf (asm_out_file, "\t%s DEBUG %s%s%s\n", ASM_COMMENT_START,
27520 name, sep, patstr);
27523 last_var_location_insn = next_real;
27524 last_in_cold_section_p = in_cold_section_p;
27527 /* Check whether BLOCK, a lexical block, is nested within OUTER, or is
27528 OUTER itself. If BOTHWAYS, check not only that BLOCK can reach
27529 OUTER through BLOCK_SUPERCONTEXT links, but also that there is a
27530 path from OUTER to BLOCK through BLOCK_SUBBLOCKs and
27531 BLOCK_FRAGMENT_ORIGIN links. */
27533 block_within_block_p (tree block, tree outer, bool bothways)
27535 if (block == outer)
27538 /* Quickly check that OUTER is up BLOCK's supercontext chain. */
27539 for (tree context = BLOCK_SUPERCONTEXT (block);
27541 context = BLOCK_SUPERCONTEXT (context))
27542 if (!context || TREE_CODE (context) != BLOCK)
27548 /* Now check that each block is actually referenced by its
27550 for (tree context = BLOCK_SUPERCONTEXT (block); ;
27551 context = BLOCK_SUPERCONTEXT (context))
27553 if (BLOCK_FRAGMENT_ORIGIN (context))
27555 gcc_assert (!BLOCK_SUBBLOCKS (context));
27556 context = BLOCK_FRAGMENT_ORIGIN (context);
27558 for (tree sub = BLOCK_SUBBLOCKS (context);
27560 sub = BLOCK_CHAIN (sub))
27563 if (context == outer)
27570 /* Called during final while assembling the marker of the entry point
27571 for an inlined function. */
27574 dwarf2out_inline_entry (tree block)
27576 gcc_assert (debug_inline_points);
27578 /* If we can't represent it, don't bother. */
27579 if (!(dwarf_version >= 3 || !dwarf_strict))
27582 gcc_assert (DECL_P (block_ultimate_origin (block)));
27584 /* Sanity check the block tree. This would catch a case in which
27585 BLOCK got removed from the tree reachable from the outermost
27586 lexical block, but got retained in markers. It would still link
27587 back to its parents, but some ancestor would be missing a link
27588 down the path to the sub BLOCK. If the block got removed, its
27589 BLOCK_NUMBER will not be a usable value. */
27591 gcc_assert (block_within_block_p (block,
27592 DECL_INITIAL (current_function_decl),
27595 gcc_assert (inlined_function_outer_scope_p (block));
27596 gcc_assert (!lookup_block_die (block));
27598 if (BLOCK_FRAGMENT_ORIGIN (block))
27599 block = BLOCK_FRAGMENT_ORIGIN (block);
27600 /* Can the entry point ever not be at the beginning of an
27601 unfragmented lexical block? */
27602 else if (!(BLOCK_FRAGMENT_CHAIN (block)
27603 || (cur_line_info_table
27604 && !ZERO_VIEW_P (cur_line_info_table->view))))
27607 if (!inline_entry_data_table)
27608 inline_entry_data_table
27609 = hash_table<inline_entry_data_hasher>::create_ggc (10);
27612 inline_entry_data **iedp
27613 = inline_entry_data_table->find_slot_with_hash (block,
27614 htab_hash_pointer (block),
27617 /* ??? Ideally, we'd record all entry points for the same inlined
27618 function (some may have been duplicated by e.g. unrolling), but
27619 we have no way to represent that ATM. */
27622 inline_entry_data *ied = *iedp = ggc_cleared_alloc<inline_entry_data> ();
27623 ied->block = block;
27624 ied->label_pfx = BLOCK_INLINE_ENTRY_LABEL;
27625 ied->label_num = BLOCK_NUMBER (block);
27626 if (cur_line_info_table)
27627 ied->view = cur_line_info_table->view;
27629 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_INLINE_ENTRY_LABEL,
27630 BLOCK_NUMBER (block));
27633 /* Called from finalize_size_functions for size functions so that their body
27634 can be encoded in the debug info to describe the layout of variable-length
27638 dwarf2out_size_function (tree decl)
27641 function_to_dwarf_procedure (decl);
27644 /* Note in one location list that text section has changed. */
27647 var_location_switch_text_section_1 (var_loc_list **slot, void *)
27649 var_loc_list *list = *slot;
27651 list->last_before_switch
27652 = list->last->next ? list->last->next : list->last;
27656 /* Note in all location lists that text section has changed. */
27659 var_location_switch_text_section (void)
27661 if (decl_loc_table == NULL)
27664 decl_loc_table->traverse<void *, var_location_switch_text_section_1> (NULL);
27667 /* Create a new line number table. */
27669 static dw_line_info_table *
27670 new_line_info_table (void)
27672 dw_line_info_table *table;
27674 table = ggc_cleared_alloc<dw_line_info_table> ();
27675 table->file_num = 1;
27676 table->line_num = 1;
27677 table->is_stmt = DWARF_LINE_DEFAULT_IS_STMT_START;
27678 FORCE_RESET_NEXT_VIEW (table->view);
27679 table->symviews_since_reset = 0;
27684 /* Lookup the "current" table into which we emit line info, so
27685 that we don't have to do it for every source line. */
27688 set_cur_line_info_table (section *sec)
27690 dw_line_info_table *table;
27692 if (sec == text_section)
27693 table = text_section_line_info;
27694 else if (sec == cold_text_section)
27696 table = cold_text_section_line_info;
27699 cold_text_section_line_info = table = new_line_info_table ();
27700 table->end_label = cold_end_label;
27705 const char *end_label;
27707 if (crtl->has_bb_partition)
27709 if (in_cold_section_p)
27710 end_label = crtl->subsections.cold_section_end_label;
27712 end_label = crtl->subsections.hot_section_end_label;
27716 char label[MAX_ARTIFICIAL_LABEL_BYTES];
27717 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
27718 current_function_funcdef_no);
27719 end_label = ggc_strdup (label);
27722 table = new_line_info_table ();
27723 table->end_label = end_label;
27725 vec_safe_push (separate_line_info, table);
27728 if (output_asm_line_debug_info ())
27729 table->is_stmt = (cur_line_info_table
27730 ? cur_line_info_table->is_stmt
27731 : DWARF_LINE_DEFAULT_IS_STMT_START);
27732 cur_line_info_table = table;
27736 /* We need to reset the locations at the beginning of each
27737 function. We can't do this in the end_function hook, because the
27738 declarations that use the locations won't have been output when
27739 that hook is called. Also compute have_multiple_function_sections here. */
27742 dwarf2out_begin_function (tree fun)
27744 section *sec = function_section (fun);
27746 if (sec != text_section)
27747 have_multiple_function_sections = true;
27749 if (crtl->has_bb_partition && !cold_text_section)
27751 gcc_assert (current_function_decl == fun);
27752 cold_text_section = unlikely_text_section ();
27753 switch_to_section (cold_text_section);
27754 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
27755 switch_to_section (sec);
27758 dwarf2out_note_section_used ();
27759 call_site_count = 0;
27760 tail_call_site_count = 0;
27762 set_cur_line_info_table (sec);
27763 FORCE_RESET_NEXT_VIEW (cur_line_info_table->view);
27766 /* Helper function of dwarf2out_end_function, called only after emitting
27767 the very first function into assembly. Check if some .debug_loc range
27768 might end with a .LVL* label that could be equal to .Ltext0.
27769 In that case we must force using absolute addresses in .debug_loc ranges,
27770 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
27771 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
27773 Set have_multiple_function_sections to true in that case and
27774 terminate htab traversal. */
27777 find_empty_loc_ranges_at_text_label (var_loc_list **slot, int)
27779 var_loc_list *entry = *slot;
27780 struct var_loc_node *node;
27782 node = entry->first;
27783 if (node && node->next && node->next->label)
27786 const char *label = node->next->label;
27787 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
27789 for (i = 0; i < first_loclabel_num_not_at_text_label; i++)
27791 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", i);
27792 if (strcmp (label, loclabel) == 0)
27794 have_multiple_function_sections = true;
27802 /* Hook called after emitting a function into assembly.
27803 This does something only for the very first function emitted. */
27806 dwarf2out_end_function (unsigned int)
27808 if (in_first_function_p
27809 && !have_multiple_function_sections
27810 && first_loclabel_num_not_at_text_label
27812 decl_loc_table->traverse<int, find_empty_loc_ranges_at_text_label> (0);
27813 in_first_function_p = false;
27814 maybe_at_text_label_p = false;
27817 /* Temporary holder for dwarf2out_register_main_translation_unit. Used to let
27818 front-ends register a translation unit even before dwarf2out_init is
27820 static tree main_translation_unit = NULL_TREE;
27822 /* Hook called by front-ends after they built their main translation unit.
27823 Associate comp_unit_die to UNIT. */
27826 dwarf2out_register_main_translation_unit (tree unit)
27828 gcc_assert (TREE_CODE (unit) == TRANSLATION_UNIT_DECL
27829 && main_translation_unit == NULL_TREE);
27830 main_translation_unit = unit;
27831 /* If dwarf2out_init has not been called yet, it will perform the association
27832 itself looking at main_translation_unit. */
27833 if (decl_die_table != NULL)
27834 equate_decl_number_to_die (unit, comp_unit_die ());
27837 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
27840 push_dw_line_info_entry (dw_line_info_table *table,
27841 enum dw_line_info_opcode opcode, unsigned int val)
27843 dw_line_info_entry e;
27846 vec_safe_push (table->entries, e);
27849 /* Output a label to mark the beginning of a source code line entry
27850 and record information relating to this source line, in
27851 'line_info_table' for later output of the .debug_line section. */
27852 /* ??? The discriminator parameter ought to be unsigned. */
27855 dwarf2out_source_line (unsigned int line, unsigned int column,
27856 const char *filename,
27857 int discriminator, bool is_stmt)
27859 unsigned int file_num;
27860 dw_line_info_table *table;
27861 static var_loc_view lvugid;
27863 if (debug_info_level < DINFO_LEVEL_TERSE)
27866 table = cur_line_info_table;
27870 if (debug_variable_location_views
27871 && output_asm_line_debug_info ()
27872 && table && !RESETTING_VIEW_P (table->view))
27874 /* If we're using the assembler to compute view numbers, we
27875 can't issue a .loc directive for line zero, so we can't
27876 get a view number at this point. We might attempt to
27877 compute it from the previous view, or equate it to a
27878 subsequent view (though it might not be there!), but
27879 since we're omitting the line number entry, we might as
27880 well omit the view number as well. That means pretending
27881 it's a view number zero, which might very well turn out
27882 to be correct. ??? Extend the assembler so that the
27883 compiler could emit e.g. ".locview .LVU#", to output a
27884 view without changing line number information. We'd then
27885 have to count it in symviews_since_reset; when it's omitted,
27886 it doesn't count. */
27888 zero_view_p = BITMAP_GGC_ALLOC ();
27889 bitmap_set_bit (zero_view_p, table->view);
27890 if (flag_debug_asm)
27892 char label[MAX_ARTIFICIAL_LABEL_BYTES];
27893 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", table->view);
27894 fprintf (asm_out_file, "\t%s line 0, omitted view ",
27895 ASM_COMMENT_START);
27896 assemble_name (asm_out_file, label);
27897 putc ('\n', asm_out_file);
27899 table->view = ++lvugid;
27904 /* The discriminator column was added in dwarf4. Simplify the below
27905 by simply removing it if we're not supposed to output it. */
27906 if (dwarf_version < 4 && dwarf_strict)
27909 if (!debug_column_info)
27912 file_num = maybe_emit_file (lookup_filename (filename));
27914 /* ??? TODO: Elide duplicate line number entries. Traditionally,
27915 the debugger has used the second (possibly duplicate) line number
27916 at the beginning of the function to mark the end of the prologue.
27917 We could eliminate any other duplicates within the function. For
27918 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
27919 that second line number entry. */
27920 /* Recall that this end-of-prologue indication is *not* the same thing
27921 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
27922 to which the hook corresponds, follows the last insn that was
27923 emitted by gen_prologue. What we need is to precede the first insn
27924 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
27925 insn that corresponds to something the user wrote. These may be
27926 very different locations once scheduling is enabled. */
27928 if (0 && file_num == table->file_num
27929 && line == table->line_num
27930 && column == table->column_num
27931 && discriminator == table->discrim_num
27932 && is_stmt == table->is_stmt)
27935 switch_to_section (current_function_section ());
27937 /* If requested, emit something human-readable. */
27938 if (flag_debug_asm)
27940 if (debug_column_info)
27941 fprintf (asm_out_file, "\t%s %s:%d:%d\n", ASM_COMMENT_START,
27942 filename, line, column);
27944 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
27948 if (output_asm_line_debug_info ())
27950 /* Emit the .loc directive understood by GNU as. */
27951 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
27952 file_num, line, is_stmt, discriminator */
27953 fputs ("\t.loc ", asm_out_file);
27954 fprint_ul (asm_out_file, file_num);
27955 putc (' ', asm_out_file);
27956 fprint_ul (asm_out_file, line);
27957 putc (' ', asm_out_file);
27958 fprint_ul (asm_out_file, column);
27960 if (is_stmt != table->is_stmt)
27962 #if HAVE_GAS_LOC_STMT
27963 fputs (" is_stmt ", asm_out_file);
27964 putc (is_stmt ? '1' : '0', asm_out_file);
27967 if (SUPPORTS_DISCRIMINATOR && discriminator != 0)
27969 gcc_assert (discriminator > 0);
27970 fputs (" discriminator ", asm_out_file);
27971 fprint_ul (asm_out_file, (unsigned long) discriminator);
27973 if (debug_variable_location_views)
27975 if (!RESETTING_VIEW_P (table->view))
27977 table->symviews_since_reset++;
27978 if (table->symviews_since_reset > symview_upper_bound)
27979 symview_upper_bound = table->symviews_since_reset;
27980 /* When we're using the assembler to compute view
27981 numbers, we output symbolic labels after "view" in
27982 .loc directives, and the assembler will set them for
27983 us, so that we can refer to the view numbers in
27984 location lists. The only exceptions are when we know
27985 a view will be zero: "-0" is a forced reset, used
27986 e.g. in the beginning of functions, whereas "0" tells
27987 the assembler to check that there was a PC change
27988 since the previous view, in a way that implicitly
27989 resets the next view. */
27990 fputs (" view ", asm_out_file);
27991 char label[MAX_ARTIFICIAL_LABEL_BYTES];
27992 ASM_GENERATE_INTERNAL_LABEL (label, "LVU", table->view);
27993 assemble_name (asm_out_file, label);
27994 table->view = ++lvugid;
27998 table->symviews_since_reset = 0;
27999 if (FORCE_RESETTING_VIEW_P (table->view))
28000 fputs (" view -0", asm_out_file);
28002 fputs (" view 0", asm_out_file);
28003 /* Mark the present view as a zero view. Earlier debug
28004 binds may have already added its id to loclists to be
28005 emitted later, so we can't reuse the id for something
28006 else. However, it's good to know whether a view is
28007 known to be zero, because then we may be able to
28008 optimize out locviews that are all zeros, so take
28009 note of it in zero_view_p. */
28011 zero_view_p = BITMAP_GGC_ALLOC ();
28012 bitmap_set_bit (zero_view_p, lvugid);
28013 table->view = ++lvugid;
28016 putc ('\n', asm_out_file);
28020 unsigned int label_num = ++line_info_label_num;
28022 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL, label_num);
28024 if (debug_variable_location_views && !RESETTING_VIEW_P (table->view))
28025 push_dw_line_info_entry (table, LI_adv_address, label_num);
28027 push_dw_line_info_entry (table, LI_set_address, label_num);
28028 if (debug_variable_location_views)
28030 bool resetting = FORCE_RESETTING_VIEW_P (table->view);
28034 if (flag_debug_asm)
28035 fprintf (asm_out_file, "\t%s view %s%d\n",
28037 resetting ? "-" : "",
28042 if (file_num != table->file_num)
28043 push_dw_line_info_entry (table, LI_set_file, file_num);
28044 if (discriminator != table->discrim_num)
28045 push_dw_line_info_entry (table, LI_set_discriminator, discriminator);
28046 if (is_stmt != table->is_stmt)
28047 push_dw_line_info_entry (table, LI_negate_stmt, 0);
28048 push_dw_line_info_entry (table, LI_set_line, line);
28049 if (debug_column_info)
28050 push_dw_line_info_entry (table, LI_set_column, column);
28053 table->file_num = file_num;
28054 table->line_num = line;
28055 table->column_num = column;
28056 table->discrim_num = discriminator;
28057 table->is_stmt = is_stmt;
28058 table->in_use = true;
28061 /* Record the beginning of a new source file. */
28064 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
28066 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
28069 e.code = DW_MACINFO_start_file;
28071 e.info = ggc_strdup (filename);
28072 vec_safe_push (macinfo_table, e);
28076 /* Record the end of a source file. */
28079 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
28081 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
28084 e.code = DW_MACINFO_end_file;
28087 vec_safe_push (macinfo_table, e);
28091 /* Called from debug_define in toplev.c. The `buffer' parameter contains
28092 the tail part of the directive line, i.e. the part which is past the
28093 initial whitespace, #, whitespace, directive-name, whitespace part. */
28096 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
28097 const char *buffer ATTRIBUTE_UNUSED)
28099 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
28102 /* Insert a dummy first entry to be able to optimize the whole
28103 predefined macro block using DW_MACRO_import. */
28104 if (macinfo_table->is_empty () && lineno <= 1)
28109 vec_safe_push (macinfo_table, e);
28111 e.code = DW_MACINFO_define;
28113 e.info = ggc_strdup (buffer);
28114 vec_safe_push (macinfo_table, e);
28118 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
28119 the tail part of the directive line, i.e. the part which is past the
28120 initial whitespace, #, whitespace, directive-name, whitespace part. */
28123 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
28124 const char *buffer ATTRIBUTE_UNUSED)
28126 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
28129 /* Insert a dummy first entry to be able to optimize the whole
28130 predefined macro block using DW_MACRO_import. */
28131 if (macinfo_table->is_empty () && lineno <= 1)
28136 vec_safe_push (macinfo_table, e);
28138 e.code = DW_MACINFO_undef;
28140 e.info = ggc_strdup (buffer);
28141 vec_safe_push (macinfo_table, e);
28145 /* Helpers to manipulate hash table of CUs. */
28147 struct macinfo_entry_hasher : nofree_ptr_hash <macinfo_entry>
28149 static inline hashval_t hash (const macinfo_entry *);
28150 static inline bool equal (const macinfo_entry *, const macinfo_entry *);
28154 macinfo_entry_hasher::hash (const macinfo_entry *entry)
28156 return htab_hash_string (entry->info);
28160 macinfo_entry_hasher::equal (const macinfo_entry *entry1,
28161 const macinfo_entry *entry2)
28163 return !strcmp (entry1->info, entry2->info);
28166 typedef hash_table<macinfo_entry_hasher> macinfo_hash_type;
28168 /* Output a single .debug_macinfo entry. */
28171 output_macinfo_op (macinfo_entry *ref)
28175 struct indirect_string_node *node;
28176 char label[MAX_ARTIFICIAL_LABEL_BYTES];
28177 struct dwarf_file_data *fd;
28181 case DW_MACINFO_start_file:
28182 fd = lookup_filename (ref->info);
28183 file_num = maybe_emit_file (fd);
28184 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
28185 dw2_asm_output_data_uleb128 (ref->lineno,
28186 "Included from line number %lu",
28187 (unsigned long) ref->lineno);
28188 dw2_asm_output_data_uleb128 (file_num, "file %s", ref->info);
28190 case DW_MACINFO_end_file:
28191 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
28193 case DW_MACINFO_define:
28194 case DW_MACINFO_undef:
28195 len = strlen (ref->info) + 1;
28197 && len > DWARF_OFFSET_SIZE
28198 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
28199 && (debug_str_section->common.flags & SECTION_MERGE) != 0)
28201 ref->code = ref->code == DW_MACINFO_define
28202 ? DW_MACRO_define_strp : DW_MACRO_undef_strp;
28203 output_macinfo_op (ref);
28206 dw2_asm_output_data (1, ref->code,
28207 ref->code == DW_MACINFO_define
28208 ? "Define macro" : "Undefine macro");
28209 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
28210 (unsigned long) ref->lineno);
28211 dw2_asm_output_nstring (ref->info, -1, "The macro");
28213 case DW_MACRO_define_strp:
28214 case DW_MACRO_undef_strp:
28215 /* NB: dwarf2out_finish performs:
28216 1. save_macinfo_strings
28217 2. hash table traverse of index_string
28218 3. output_macinfo -> output_macinfo_op
28219 4. output_indirect_strings
28220 -> hash table traverse of output_index_string
28222 When output_macinfo_op is called, all index strings have been
28223 added to hash table by save_macinfo_strings and we can't pass
28224 INSERT to find_slot_with_hash which may expand hash table, even
28225 if no insertion is needed, and change hash table traverse order
28226 between index_string and output_index_string. */
28227 node = find_AT_string (ref->info, NO_INSERT);
28229 && (node->form == DW_FORM_strp
28230 || node->form == dwarf_FORM (DW_FORM_strx)));
28231 dw2_asm_output_data (1, ref->code,
28232 ref->code == DW_MACRO_define_strp
28233 ? "Define macro strp"
28234 : "Undefine macro strp");
28235 dw2_asm_output_data_uleb128 (ref->lineno, "At line number %lu",
28236 (unsigned long) ref->lineno);
28237 if (node->form == DW_FORM_strp)
28238 dw2_asm_output_offset (DWARF_OFFSET_SIZE, node->label,
28239 debug_str_section, "The macro: \"%s\"",
28242 dw2_asm_output_data_uleb128 (node->index, "The macro: \"%s\"",
28245 case DW_MACRO_import:
28246 dw2_asm_output_data (1, ref->code, "Import");
28247 ASM_GENERATE_INTERNAL_LABEL (label,
28248 DEBUG_MACRO_SECTION_LABEL,
28249 ref->lineno + macinfo_label_base);
28250 dw2_asm_output_offset (DWARF_OFFSET_SIZE, label, NULL, NULL);
28253 fprintf (asm_out_file, "%s unrecognized macinfo code %lu\n",
28254 ASM_COMMENT_START, (unsigned long) ref->code);
28259 /* Attempt to make a sequence of define/undef macinfo ops shareable with
28260 other compilation unit .debug_macinfo sections. IDX is the first
28261 index of a define/undef, return the number of ops that should be
28262 emitted in a comdat .debug_macinfo section and emit
28263 a DW_MACRO_import entry referencing it.
28264 If the define/undef entry should be emitted normally, return 0. */
28267 optimize_macinfo_range (unsigned int idx, vec<macinfo_entry, va_gc> *files,
28268 macinfo_hash_type **macinfo_htab)
28270 macinfo_entry *first, *second, *cur, *inc;
28271 char linebuf[sizeof (HOST_WIDE_INT) * 3 + 1];
28272 unsigned char checksum[16];
28273 struct md5_ctx ctx;
28274 char *grp_name, *tail;
28276 unsigned int i, count, encoded_filename_len, linebuf_len;
28277 macinfo_entry **slot;
28279 first = &(*macinfo_table)[idx];
28280 second = &(*macinfo_table)[idx + 1];
28282 /* Optimize only if there are at least two consecutive define/undef ops,
28283 and either all of them are before first DW_MACINFO_start_file
28284 with lineno {0,1} (i.e. predefined macro block), or all of them are
28285 in some included header file. */
28286 if (second->code != DW_MACINFO_define && second->code != DW_MACINFO_undef)
28288 if (vec_safe_is_empty (files))
28290 if (first->lineno > 1 || second->lineno > 1)
28293 else if (first->lineno == 0)
28296 /* Find the last define/undef entry that can be grouped together
28297 with first and at the same time compute md5 checksum of their
28298 codes, linenumbers and strings. */
28299 md5_init_ctx (&ctx);
28300 for (i = idx; macinfo_table->iterate (i, &cur); i++)
28301 if (cur->code != DW_MACINFO_define && cur->code != DW_MACINFO_undef)
28303 else if (vec_safe_is_empty (files) && cur->lineno > 1)
28307 unsigned char code = cur->code;
28308 md5_process_bytes (&code, 1, &ctx);
28309 checksum_uleb128 (cur->lineno, &ctx);
28310 md5_process_bytes (cur->info, strlen (cur->info) + 1, &ctx);
28312 md5_finish_ctx (&ctx, checksum);
28315 /* From the containing include filename (if any) pick up just
28316 usable characters from its basename. */
28317 if (vec_safe_is_empty (files))
28320 base = lbasename (files->last ().info);
28321 for (encoded_filename_len = 0, i = 0; base[i]; i++)
28322 if (ISIDNUM (base[i]) || base[i] == '.')
28323 encoded_filename_len++;
28324 /* Count . at the end. */
28325 if (encoded_filename_len)
28326 encoded_filename_len++;
28328 sprintf (linebuf, HOST_WIDE_INT_PRINT_UNSIGNED, first->lineno);
28329 linebuf_len = strlen (linebuf);
28331 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
28332 grp_name = XALLOCAVEC (char, 4 + encoded_filename_len + linebuf_len + 1
28334 memcpy (grp_name, DWARF_OFFSET_SIZE == 4 ? "wm4." : "wm8.", 4);
28335 tail = grp_name + 4;
28336 if (encoded_filename_len)
28338 for (i = 0; base[i]; i++)
28339 if (ISIDNUM (base[i]) || base[i] == '.')
28343 memcpy (tail, linebuf, linebuf_len);
28344 tail += linebuf_len;
28346 for (i = 0; i < 16; i++)
28347 sprintf (tail + i * 2, "%02x", checksum[i] & 0xff);
28349 /* Construct a macinfo_entry for DW_MACRO_import
28350 in the empty vector entry before the first define/undef. */
28351 inc = &(*macinfo_table)[idx - 1];
28352 inc->code = DW_MACRO_import;
28354 inc->info = ggc_strdup (grp_name);
28355 if (!*macinfo_htab)
28356 *macinfo_htab = new macinfo_hash_type (10);
28357 /* Avoid emitting duplicates. */
28358 slot = (*macinfo_htab)->find_slot (inc, INSERT);
28363 /* If such an entry has been used before, just emit
28364 a DW_MACRO_import op. */
28366 output_macinfo_op (inc);
28367 /* And clear all macinfo_entry in the range to avoid emitting them
28368 in the second pass. */
28369 for (i = idx; macinfo_table->iterate (i, &cur) && i < idx + count; i++)
28378 inc->lineno = (*macinfo_htab)->elements ();
28379 output_macinfo_op (inc);
28384 /* Save any strings needed by the macinfo table in the debug str
28385 table. All strings must be collected into the table by the time
28386 index_string is called. */
28389 save_macinfo_strings (void)
28393 macinfo_entry *ref;
28395 for (i = 0; macinfo_table && macinfo_table->iterate (i, &ref); i++)
28399 /* Match the logic in output_macinfo_op to decide on
28400 indirect strings. */
28401 case DW_MACINFO_define:
28402 case DW_MACINFO_undef:
28403 len = strlen (ref->info) + 1;
28405 && len > DWARF_OFFSET_SIZE
28406 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
28407 && (debug_str_section->common.flags & SECTION_MERGE) != 0)
28408 set_indirect_string (find_AT_string (ref->info));
28410 case DW_MACINFO_start_file:
28411 /* -gsplit-dwarf -g3 will also output filename as indirect
28413 if (!dwarf_split_debug_info)
28415 /* Fall through. */
28416 case DW_MACRO_define_strp:
28417 case DW_MACRO_undef_strp:
28418 set_indirect_string (find_AT_string (ref->info));
28426 /* Output macinfo section(s). */
28429 output_macinfo (const char *debug_line_label, bool early_lto_debug)
28432 unsigned long length = vec_safe_length (macinfo_table);
28433 macinfo_entry *ref;
28434 vec<macinfo_entry, va_gc> *files = NULL;
28435 macinfo_hash_type *macinfo_htab = NULL;
28436 char dl_section_ref[MAX_ARTIFICIAL_LABEL_BYTES];
28441 /* output_macinfo* uses these interchangeably. */
28442 gcc_assert ((int) DW_MACINFO_define == (int) DW_MACRO_define
28443 && (int) DW_MACINFO_undef == (int) DW_MACRO_undef
28444 && (int) DW_MACINFO_start_file == (int) DW_MACRO_start_file
28445 && (int) DW_MACINFO_end_file == (int) DW_MACRO_end_file);
28447 /* AIX Assembler inserts the length, so adjust the reference to match the
28448 offset expected by debuggers. */
28449 strcpy (dl_section_ref, debug_line_label);
28450 if (XCOFF_DEBUGGING_INFO)
28451 strcat (dl_section_ref, DWARF_INITIAL_LENGTH_SIZE_STR);
28453 /* For .debug_macro emit the section header. */
28454 if (!dwarf_strict || dwarf_version >= 5)
28456 dw2_asm_output_data (2, dwarf_version >= 5 ? 5 : 4,
28457 "DWARF macro version number");
28458 if (DWARF_OFFSET_SIZE == 8)
28459 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
28461 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
28462 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_line_label,
28463 debug_line_section, NULL);
28466 /* In the first loop, it emits the primary .debug_macinfo section
28467 and after each emitted op the macinfo_entry is cleared.
28468 If a longer range of define/undef ops can be optimized using
28469 DW_MACRO_import, the DW_MACRO_import op is emitted and kept in
28470 the vector before the first define/undef in the range and the
28471 whole range of define/undef ops is not emitted and kept. */
28472 for (i = 0; macinfo_table->iterate (i, &ref); i++)
28476 case DW_MACINFO_start_file:
28477 vec_safe_push (files, *ref);
28479 case DW_MACINFO_end_file:
28480 if (!vec_safe_is_empty (files))
28483 case DW_MACINFO_define:
28484 case DW_MACINFO_undef:
28485 if ((!dwarf_strict || dwarf_version >= 5)
28486 && HAVE_COMDAT_GROUP
28487 && vec_safe_length (files) != 1
28490 && (*macinfo_table)[i - 1].code == 0)
28492 unsigned count = optimize_macinfo_range (i, files, &macinfo_htab);
28501 /* A dummy entry may be inserted at the beginning to be able
28502 to optimize the whole block of predefined macros. */
28508 output_macinfo_op (ref);
28516 /* Save the number of transparent includes so we can adjust the
28517 label number for the fat LTO object DWARF. */
28518 unsigned macinfo_label_base_adj = macinfo_htab->elements ();
28520 delete macinfo_htab;
28521 macinfo_htab = NULL;
28523 /* If any DW_MACRO_import were used, on those DW_MACRO_import entries
28524 terminate the current chain and switch to a new comdat .debug_macinfo
28525 section and emit the define/undef entries within it. */
28526 for (i = 0; macinfo_table->iterate (i, &ref); i++)
28531 case DW_MACRO_import:
28533 char label[MAX_ARTIFICIAL_LABEL_BYTES];
28534 tree comdat_key = get_identifier (ref->info);
28535 /* Terminate the previous .debug_macinfo section. */
28536 dw2_asm_output_data (1, 0, "End compilation unit");
28537 targetm.asm_out.named_section (debug_macinfo_section_name,
28541 ? SECTION_EXCLUDE : 0),
28543 ASM_GENERATE_INTERNAL_LABEL (label,
28544 DEBUG_MACRO_SECTION_LABEL,
28545 ref->lineno + macinfo_label_base);
28546 ASM_OUTPUT_LABEL (asm_out_file, label);
28549 dw2_asm_output_data (2, dwarf_version >= 5 ? 5 : 4,
28550 "DWARF macro version number");
28551 if (DWARF_OFFSET_SIZE == 8)
28552 dw2_asm_output_data (1, 1, "Flags: 64-bit");
28554 dw2_asm_output_data (1, 0, "Flags: 32-bit");
28557 case DW_MACINFO_define:
28558 case DW_MACINFO_undef:
28559 output_macinfo_op (ref);
28564 gcc_unreachable ();
28567 macinfo_label_base += macinfo_label_base_adj;
28570 /* Initialize the various sections and labels for dwarf output and prefix
28571 them with PREFIX if non-NULL. Returns the generation (zero based
28572 number of times function was called). */
28575 init_sections_and_labels (bool early_lto_debug)
28577 /* As we may get called multiple times have a generation count for
28579 static unsigned generation = 0;
28581 if (early_lto_debug)
28583 if (!dwarf_split_debug_info)
28585 debug_info_section = get_section (DEBUG_LTO_INFO_SECTION,
28586 SECTION_DEBUG | SECTION_EXCLUDE,
28588 debug_abbrev_section = get_section (DEBUG_LTO_ABBREV_SECTION,
28589 SECTION_DEBUG | SECTION_EXCLUDE,
28591 debug_macinfo_section_name
28592 = ((dwarf_strict && dwarf_version < 5)
28593 ? DEBUG_LTO_MACINFO_SECTION : DEBUG_LTO_MACRO_SECTION);
28594 debug_macinfo_section = get_section (debug_macinfo_section_name,
28596 | SECTION_EXCLUDE, NULL);
28600 /* ??? Which of the following do we need early? */
28601 debug_info_section = get_section (DEBUG_LTO_DWO_INFO_SECTION,
28602 SECTION_DEBUG | SECTION_EXCLUDE,
28604 debug_abbrev_section = get_section (DEBUG_LTO_DWO_ABBREV_SECTION,
28605 SECTION_DEBUG | SECTION_EXCLUDE,
28607 debug_skeleton_info_section = get_section (DEBUG_LTO_INFO_SECTION,
28609 | SECTION_EXCLUDE, NULL);
28610 debug_skeleton_abbrev_section
28611 = get_section (DEBUG_LTO_ABBREV_SECTION,
28612 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
28613 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label,
28614 DEBUG_SKELETON_ABBREV_SECTION_LABEL,
28617 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
28618 stay in the main .o, but the skeleton_line goes into the split
28620 debug_skeleton_line_section
28621 = get_section (DEBUG_LTO_LINE_SECTION,
28622 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
28623 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label,
28624 DEBUG_SKELETON_LINE_SECTION_LABEL,
28626 debug_str_offsets_section
28627 = get_section (DEBUG_LTO_DWO_STR_OFFSETS_SECTION,
28628 SECTION_DEBUG | SECTION_EXCLUDE,
28630 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label,
28631 DEBUG_SKELETON_INFO_SECTION_LABEL,
28633 debug_str_dwo_section = get_section (DEBUG_LTO_STR_DWO_SECTION,
28634 DEBUG_STR_DWO_SECTION_FLAGS,
28636 debug_macinfo_section_name
28637 = ((dwarf_strict && dwarf_version < 5)
28638 ? DEBUG_LTO_DWO_MACINFO_SECTION : DEBUG_LTO_DWO_MACRO_SECTION);
28639 debug_macinfo_section = get_section (debug_macinfo_section_name,
28640 SECTION_DEBUG | SECTION_EXCLUDE,
28643 /* For macro info and the file table we have to refer to a
28644 debug_line section. */
28645 debug_line_section = get_section (DEBUG_LTO_LINE_SECTION,
28646 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
28647 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
28648 DEBUG_LINE_SECTION_LABEL, generation);
28650 debug_str_section = get_section (DEBUG_LTO_STR_SECTION,
28651 DEBUG_STR_SECTION_FLAGS
28652 | SECTION_EXCLUDE, NULL);
28653 if (!dwarf_split_debug_info)
28654 debug_line_str_section
28655 = get_section (DEBUG_LTO_LINE_STR_SECTION,
28656 DEBUG_STR_SECTION_FLAGS | SECTION_EXCLUDE, NULL);
28660 if (!dwarf_split_debug_info)
28662 debug_info_section = get_section (DEBUG_INFO_SECTION,
28663 SECTION_DEBUG, NULL);
28664 debug_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
28665 SECTION_DEBUG, NULL);
28666 debug_loc_section = get_section (dwarf_version >= 5
28667 ? DEBUG_LOCLISTS_SECTION
28668 : DEBUG_LOC_SECTION,
28669 SECTION_DEBUG, NULL);
28670 debug_macinfo_section_name
28671 = ((dwarf_strict && dwarf_version < 5)
28672 ? DEBUG_MACINFO_SECTION : DEBUG_MACRO_SECTION);
28673 debug_macinfo_section = get_section (debug_macinfo_section_name,
28674 SECTION_DEBUG, NULL);
28678 debug_info_section = get_section (DEBUG_DWO_INFO_SECTION,
28679 SECTION_DEBUG | SECTION_EXCLUDE,
28681 debug_abbrev_section = get_section (DEBUG_DWO_ABBREV_SECTION,
28682 SECTION_DEBUG | SECTION_EXCLUDE,
28684 debug_addr_section = get_section (DEBUG_ADDR_SECTION,
28685 SECTION_DEBUG, NULL);
28686 debug_skeleton_info_section = get_section (DEBUG_INFO_SECTION,
28687 SECTION_DEBUG, NULL);
28688 debug_skeleton_abbrev_section = get_section (DEBUG_ABBREV_SECTION,
28689 SECTION_DEBUG, NULL);
28690 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label,
28691 DEBUG_SKELETON_ABBREV_SECTION_LABEL,
28694 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
28695 stay in the main .o, but the skeleton_line goes into the
28697 debug_skeleton_line_section
28698 = get_section (DEBUG_DWO_LINE_SECTION,
28699 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
28700 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label,
28701 DEBUG_SKELETON_LINE_SECTION_LABEL,
28703 debug_str_offsets_section
28704 = get_section (DEBUG_DWO_STR_OFFSETS_SECTION,
28705 SECTION_DEBUG | SECTION_EXCLUDE, NULL);
28706 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label,
28707 DEBUG_SKELETON_INFO_SECTION_LABEL,
28709 debug_loc_section = get_section (dwarf_version >= 5
28710 ? DEBUG_DWO_LOCLISTS_SECTION
28711 : DEBUG_DWO_LOC_SECTION,
28712 SECTION_DEBUG | SECTION_EXCLUDE,
28714 debug_str_dwo_section = get_section (DEBUG_STR_DWO_SECTION,
28715 DEBUG_STR_DWO_SECTION_FLAGS,
28717 debug_macinfo_section_name
28718 = ((dwarf_strict && dwarf_version < 5)
28719 ? DEBUG_DWO_MACINFO_SECTION : DEBUG_DWO_MACRO_SECTION);
28720 debug_macinfo_section = get_section (debug_macinfo_section_name,
28721 SECTION_DEBUG | SECTION_EXCLUDE,
28724 debug_aranges_section = get_section (DEBUG_ARANGES_SECTION,
28725 SECTION_DEBUG, NULL);
28726 debug_line_section = get_section (DEBUG_LINE_SECTION,
28727 SECTION_DEBUG, NULL);
28728 debug_pubnames_section = get_section (DEBUG_PUBNAMES_SECTION,
28729 SECTION_DEBUG, NULL);
28730 debug_pubtypes_section = get_section (DEBUG_PUBTYPES_SECTION,
28731 SECTION_DEBUG, NULL);
28732 debug_str_section = get_section (DEBUG_STR_SECTION,
28733 DEBUG_STR_SECTION_FLAGS, NULL);
28734 if (!dwarf_split_debug_info && !output_asm_line_debug_info ())
28735 debug_line_str_section = get_section (DEBUG_LINE_STR_SECTION,
28736 DEBUG_STR_SECTION_FLAGS, NULL);
28738 debug_ranges_section = get_section (dwarf_version >= 5
28739 ? DEBUG_RNGLISTS_SECTION
28740 : DEBUG_RANGES_SECTION,
28741 SECTION_DEBUG, NULL);
28742 debug_frame_section = get_section (DEBUG_FRAME_SECTION,
28743 SECTION_DEBUG, NULL);
28746 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
28747 DEBUG_ABBREV_SECTION_LABEL, generation);
28748 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
28749 DEBUG_INFO_SECTION_LABEL, generation);
28750 info_section_emitted = false;
28751 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
28752 DEBUG_LINE_SECTION_LABEL, generation);
28753 /* There are up to 4 unique ranges labels per generation.
28754 See also output_rnglists. */
28755 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
28756 DEBUG_RANGES_SECTION_LABEL, generation * 4);
28757 if (dwarf_version >= 5 && dwarf_split_debug_info)
28758 ASM_GENERATE_INTERNAL_LABEL (ranges_base_label,
28759 DEBUG_RANGES_SECTION_LABEL,
28760 1 + generation * 4);
28761 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label,
28762 DEBUG_ADDR_SECTION_LABEL, generation);
28763 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
28764 (dwarf_strict && dwarf_version < 5)
28765 ? DEBUG_MACINFO_SECTION_LABEL
28766 : DEBUG_MACRO_SECTION_LABEL, generation);
28767 ASM_GENERATE_INTERNAL_LABEL (loc_section_label, DEBUG_LOC_SECTION_LABEL,
28771 return generation - 1;
28774 /* Set up for Dwarf output at the start of compilation. */
28777 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
28779 /* Allocate the file_table. */
28780 file_table = hash_table<dwarf_file_hasher>::create_ggc (50);
28782 #ifndef DWARF2_LINENO_DEBUGGING_INFO
28783 /* Allocate the decl_die_table. */
28784 decl_die_table = hash_table<decl_die_hasher>::create_ggc (10);
28786 /* Allocate the decl_loc_table. */
28787 decl_loc_table = hash_table<decl_loc_hasher>::create_ggc (10);
28789 /* Allocate the cached_dw_loc_list_table. */
28790 cached_dw_loc_list_table = hash_table<dw_loc_list_hasher>::create_ggc (10);
28792 /* Allocate the initial hunk of the abbrev_die_table. */
28793 vec_alloc (abbrev_die_table, 256);
28794 /* Zero-th entry is allocated, but unused. */
28795 abbrev_die_table->quick_push (NULL);
28797 /* Allocate the dwarf_proc_stack_usage_map. */
28798 dwarf_proc_stack_usage_map = new hash_map<dw_die_ref, int>;
28800 /* Allocate the pubtypes and pubnames vectors. */
28801 vec_alloc (pubname_table, 32);
28802 vec_alloc (pubtype_table, 32);
28804 vec_alloc (incomplete_types, 64);
28806 vec_alloc (used_rtx_array, 32);
28808 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
28809 vec_alloc (macinfo_table, 64);
28812 /* If front-ends already registered a main translation unit but we were not
28813 ready to perform the association, do this now. */
28814 if (main_translation_unit != NULL_TREE)
28815 equate_decl_number_to_die (main_translation_unit, comp_unit_die ());
28818 /* Called before compile () starts outputtting functions, variables
28819 and toplevel asms into assembly. */
28822 dwarf2out_assembly_start (void)
28824 if (text_section_line_info)
28827 #ifndef DWARF2_LINENO_DEBUGGING_INFO
28828 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
28829 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
28830 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
28831 COLD_TEXT_SECTION_LABEL, 0);
28832 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
28834 switch_to_section (text_section);
28835 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
28838 /* Make sure the line number table for .text always exists. */
28839 text_section_line_info = new_line_info_table ();
28840 text_section_line_info->end_label = text_end_label;
28842 #ifdef DWARF2_LINENO_DEBUGGING_INFO
28843 cur_line_info_table = text_section_line_info;
28846 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
28847 && dwarf2out_do_cfi_asm ()
28848 && !dwarf2out_do_eh_frame ())
28849 fprintf (asm_out_file, "\t.cfi_sections\t.debug_frame\n");
28852 /* A helper function for dwarf2out_finish called through
28853 htab_traverse. Assign a string its index. All strings must be
28854 collected into the table by the time index_string is called,
28855 because the indexing code relies on htab_traverse to traverse nodes
28856 in the same order for each run. */
28859 index_string (indirect_string_node **h, unsigned int *index)
28861 indirect_string_node *node = *h;
28863 find_string_form (node);
28864 if (node->form == dwarf_FORM (DW_FORM_strx) && node->refcount > 0)
28866 gcc_assert (node->index == NO_INDEX_ASSIGNED);
28867 node->index = *index;
28873 /* A helper function for output_indirect_strings called through
28874 htab_traverse. Output the offset to a string and update the
28878 output_index_string_offset (indirect_string_node **h, unsigned int *offset)
28880 indirect_string_node *node = *h;
28882 if (node->form == dwarf_FORM (DW_FORM_strx) && node->refcount > 0)
28884 /* Assert that this node has been assigned an index. */
28885 gcc_assert (node->index != NO_INDEX_ASSIGNED
28886 && node->index != NOT_INDEXED);
28887 dw2_asm_output_data (DWARF_OFFSET_SIZE, *offset,
28888 "indexed string 0x%x: %s", node->index, node->str);
28889 *offset += strlen (node->str) + 1;
28894 /* A helper function for dwarf2out_finish called through
28895 htab_traverse. Output the indexed string. */
28898 output_index_string (indirect_string_node **h, unsigned int *cur_idx)
28900 struct indirect_string_node *node = *h;
28902 if (node->form == dwarf_FORM (DW_FORM_strx) && node->refcount > 0)
28904 /* Assert that the strings are output in the same order as their
28905 indexes were assigned. */
28906 gcc_assert (*cur_idx == node->index);
28907 assemble_string (node->str, strlen (node->str) + 1);
28913 /* A helper function for output_indirect_strings. Counts the number
28914 of index strings offsets. Must match the logic of the functions
28915 output_index_string[_offsets] above. */
28917 count_index_strings (indirect_string_node **h, unsigned int *last_idx)
28919 struct indirect_string_node *node = *h;
28921 if (node->form == dwarf_FORM (DW_FORM_strx) && node->refcount > 0)
28926 /* A helper function for dwarf2out_finish called through
28927 htab_traverse. Emit one queued .debug_str string. */
28930 output_indirect_string (indirect_string_node **h, enum dwarf_form form)
28932 struct indirect_string_node *node = *h;
28934 node->form = find_string_form (node);
28935 if (node->form == form && node->refcount > 0)
28937 ASM_OUTPUT_LABEL (asm_out_file, node->label);
28938 assemble_string (node->str, strlen (node->str) + 1);
28944 /* Output the indexed string table. */
28947 output_indirect_strings (void)
28949 switch_to_section (debug_str_section);
28950 if (!dwarf_split_debug_info)
28951 debug_str_hash->traverse<enum dwarf_form,
28952 output_indirect_string> (DW_FORM_strp);
28955 unsigned int offset = 0;
28956 unsigned int cur_idx = 0;
28958 if (skeleton_debug_str_hash)
28959 skeleton_debug_str_hash->traverse<enum dwarf_form,
28960 output_indirect_string> (DW_FORM_strp);
28962 switch_to_section (debug_str_offsets_section);
28963 /* For DWARF5 the .debug_str_offsets[.dwo] section needs a unit
28964 header. Note that we don't need to generate a label to the
28965 actual index table following the header here, because this is
28966 for the split dwarf case only. In an .dwo file there is only
28967 one string offsets table (and one debug info section). But
28968 if we would start using string offset tables for the main (or
28969 skeleton) unit, then we have to add a DW_AT_str_offsets_base
28970 pointing to the actual index after the header. Split dwarf
28971 units will never have a string offsets base attribute. When
28972 a split unit is moved into a .dwp file the string offsets can
28973 be found through the .debug_cu_index section table. */
28974 if (dwarf_version >= 5)
28976 unsigned int last_idx = 0;
28977 unsigned long str_offsets_length;
28979 debug_str_hash->traverse_noresize
28980 <unsigned int *, count_index_strings> (&last_idx);
28981 str_offsets_length = last_idx * DWARF_OFFSET_SIZE + 4;
28982 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
28983 dw2_asm_output_data (4, 0xffffffff,
28984 "Escape value for 64-bit DWARF extension");
28985 dw2_asm_output_data (DWARF_OFFSET_SIZE, str_offsets_length,
28986 "Length of string offsets unit");
28987 dw2_asm_output_data (2, 5, "DWARF string offsets version");
28988 dw2_asm_output_data (2, 0, "Header zero padding");
28990 debug_str_hash->traverse_noresize
28991 <unsigned int *, output_index_string_offset> (&offset);
28992 switch_to_section (debug_str_dwo_section);
28993 debug_str_hash->traverse_noresize<unsigned int *, output_index_string>
28998 /* Callback for htab_traverse to assign an index to an entry in the
28999 table, and to write that entry to the .debug_addr section. */
29002 output_addr_table_entry (addr_table_entry **slot, unsigned int *cur_index)
29004 addr_table_entry *entry = *slot;
29006 if (entry->refcount == 0)
29008 gcc_assert (entry->index == NO_INDEX_ASSIGNED
29009 || entry->index == NOT_INDEXED);
29013 gcc_assert (entry->index == *cur_index);
29016 switch (entry->kind)
29019 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, entry->addr.rtl,
29020 "0x%x", entry->index);
29022 case ate_kind_rtx_dtprel:
29023 gcc_assert (targetm.asm_out.output_dwarf_dtprel);
29024 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
29027 fputc ('\n', asm_out_file);
29029 case ate_kind_label:
29030 dw2_asm_output_addr (DWARF2_ADDR_SIZE, entry->addr.label,
29031 "0x%x", entry->index);
29034 gcc_unreachable ();
29039 /* A helper function for dwarf2out_finish. Counts the number
29040 of indexed addresses. Must match the logic of the functions
29041 output_addr_table_entry above. */
29043 count_index_addrs (addr_table_entry **slot, unsigned int *last_idx)
29045 addr_table_entry *entry = *slot;
29047 if (entry->refcount > 0)
29052 /* Produce the .debug_addr section. */
29055 output_addr_table (void)
29057 unsigned int index = 0;
29058 if (addr_index_table == NULL || addr_index_table->size () == 0)
29061 switch_to_section (debug_addr_section);
29062 /* GNU DebugFission https://gcc.gnu.org/wiki/DebugFission
29063 which GCC uses to implement -gsplit-dwarf as DWARF GNU extension
29064 before DWARF5, didn't have a header for .debug_addr units.
29065 DWARF5 specifies a small header when address tables are used. */
29066 if (dwarf_version >= 5)
29068 unsigned int last_idx = 0;
29069 unsigned long addrs_length;
29071 addr_index_table->traverse_noresize
29072 <unsigned int *, count_index_addrs> (&last_idx);
29073 addrs_length = last_idx * DWARF2_ADDR_SIZE + 4;
29075 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
29076 dw2_asm_output_data (4, 0xffffffff,
29077 "Escape value for 64-bit DWARF extension");
29078 dw2_asm_output_data (DWARF_OFFSET_SIZE, addrs_length,
29079 "Length of Address Unit");
29080 dw2_asm_output_data (2, 5, "DWARF addr version");
29081 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
29082 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
29084 ASM_OUTPUT_LABEL (asm_out_file, debug_addr_section_label);
29087 ->traverse_noresize<unsigned int *, output_addr_table_entry> (&index);
29090 #if ENABLE_ASSERT_CHECKING
29091 /* Verify that all marks are clear. */
29094 verify_marks_clear (dw_die_ref die)
29098 gcc_assert (! die->die_mark);
29099 FOR_EACH_CHILD (die, c, verify_marks_clear (c));
29101 #endif /* ENABLE_ASSERT_CHECKING */
29103 /* Clear the marks for a die and its children.
29104 Be cool if the mark isn't set. */
29107 prune_unmark_dies (dw_die_ref die)
29113 FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
29116 /* Given LOC that is referenced by a DIE we're marking as used, find all
29117 referenced DWARF procedures it references and mark them as used. */
29120 prune_unused_types_walk_loc_descr (dw_loc_descr_ref loc)
29122 for (; loc != NULL; loc = loc->dw_loc_next)
29123 switch (loc->dw_loc_opc)
29125 case DW_OP_implicit_pointer:
29126 case DW_OP_convert:
29127 case DW_OP_reinterpret:
29128 case DW_OP_GNU_implicit_pointer:
29129 case DW_OP_GNU_convert:
29130 case DW_OP_GNU_reinterpret:
29131 if (loc->dw_loc_oprnd1.val_class == dw_val_class_die_ref)
29132 prune_unused_types_mark (loc->dw_loc_oprnd1.v.val_die_ref.die, 1);
29134 case DW_OP_GNU_variable_value:
29135 if (loc->dw_loc_oprnd1.val_class == dw_val_class_decl_ref)
29138 = lookup_decl_die (loc->dw_loc_oprnd1.v.val_decl_ref);
29141 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
29142 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
29143 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
29148 case DW_OP_call_ref:
29149 case DW_OP_const_type:
29150 case DW_OP_GNU_const_type:
29151 case DW_OP_GNU_parameter_ref:
29152 gcc_assert (loc->dw_loc_oprnd1.val_class == dw_val_class_die_ref);
29153 prune_unused_types_mark (loc->dw_loc_oprnd1.v.val_die_ref.die, 1);
29155 case DW_OP_regval_type:
29156 case DW_OP_deref_type:
29157 case DW_OP_GNU_regval_type:
29158 case DW_OP_GNU_deref_type:
29159 gcc_assert (loc->dw_loc_oprnd2.val_class == dw_val_class_die_ref);
29160 prune_unused_types_mark (loc->dw_loc_oprnd2.v.val_die_ref.die, 1);
29162 case DW_OP_entry_value:
29163 case DW_OP_GNU_entry_value:
29164 gcc_assert (loc->dw_loc_oprnd1.val_class == dw_val_class_loc);
29165 prune_unused_types_walk_loc_descr (loc->dw_loc_oprnd1.v.val_loc);
29172 /* Given DIE that we're marking as used, find any other dies
29173 it references as attributes and mark them as used. */
29176 prune_unused_types_walk_attribs (dw_die_ref die)
29181 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
29183 switch (AT_class (a))
29185 /* Make sure DWARF procedures referenced by location descriptions will
29187 case dw_val_class_loc:
29188 prune_unused_types_walk_loc_descr (AT_loc (a));
29190 case dw_val_class_loc_list:
29191 for (dw_loc_list_ref list = AT_loc_list (a);
29193 list = list->dw_loc_next)
29194 prune_unused_types_walk_loc_descr (list->expr);
29197 case dw_val_class_view_list:
29198 /* This points to a loc_list in another attribute, so it's
29199 already covered. */
29202 case dw_val_class_die_ref:
29203 /* A reference to another DIE.
29204 Make sure that it will get emitted.
29205 If it was broken out into a comdat group, don't follow it. */
29206 if (! AT_ref (a)->comdat_type_p
29207 || a->dw_attr == DW_AT_specification)
29208 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
29211 case dw_val_class_str:
29212 /* Set the string's refcount to 0 so that prune_unused_types_mark
29213 accounts properly for it. */
29214 a->dw_attr_val.v.val_str->refcount = 0;
29223 /* Mark the generic parameters and arguments children DIEs of DIE. */
29226 prune_unused_types_mark_generic_parms_dies (dw_die_ref die)
29230 if (die == NULL || die->die_child == NULL)
29232 c = die->die_child;
29235 if (is_template_parameter (c))
29236 prune_unused_types_mark (c, 1);
29238 } while (c && c != die->die_child);
29241 /* Mark DIE as being used. If DOKIDS is true, then walk down
29242 to DIE's children. */
29245 prune_unused_types_mark (dw_die_ref die, int dokids)
29249 if (die->die_mark == 0)
29251 /* We haven't done this node yet. Mark it as used. */
29253 /* If this is the DIE of a generic type instantiation,
29254 mark the children DIEs that describe its generic parms and
29256 prune_unused_types_mark_generic_parms_dies (die);
29258 /* We also have to mark its parents as used.
29259 (But we don't want to mark our parent's kids due to this,
29260 unless it is a class.) */
29261 if (die->die_parent)
29262 prune_unused_types_mark (die->die_parent,
29263 class_scope_p (die->die_parent));
29265 /* Mark any referenced nodes. */
29266 prune_unused_types_walk_attribs (die);
29268 /* If this node is a specification,
29269 also mark the definition, if it exists. */
29270 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
29271 prune_unused_types_mark (die->die_definition, 1);
29274 if (dokids && die->die_mark != 2)
29276 /* We need to walk the children, but haven't done so yet.
29277 Remember that we've walked the kids. */
29280 /* If this is an array type, we need to make sure our
29281 kids get marked, even if they're types. If we're
29282 breaking out types into comdat sections, do this
29283 for all type definitions. */
29284 if (die->die_tag == DW_TAG_array_type
29285 || (use_debug_types
29286 && is_type_die (die) && ! is_declaration_die (die)))
29287 FOR_EACH_CHILD (die, c, prune_unused_types_mark (c, 1));
29289 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
29293 /* For local classes, look if any static member functions were emitted
29294 and if so, mark them. */
29297 prune_unused_types_walk_local_classes (dw_die_ref die)
29301 if (die->die_mark == 2)
29304 switch (die->die_tag)
29306 case DW_TAG_structure_type:
29307 case DW_TAG_union_type:
29308 case DW_TAG_class_type:
29309 case DW_TAG_interface_type:
29312 case DW_TAG_subprogram:
29313 if (!get_AT_flag (die, DW_AT_declaration)
29314 || die->die_definition != NULL)
29315 prune_unused_types_mark (die, 1);
29322 /* Mark children. */
29323 FOR_EACH_CHILD (die, c, prune_unused_types_walk_local_classes (c));
29326 /* Walk the tree DIE and mark types that we actually use. */
29329 prune_unused_types_walk (dw_die_ref die)
29333 /* Don't do anything if this node is already marked and
29334 children have been marked as well. */
29335 if (die->die_mark == 2)
29338 switch (die->die_tag)
29340 case DW_TAG_structure_type:
29341 case DW_TAG_union_type:
29342 case DW_TAG_class_type:
29343 case DW_TAG_interface_type:
29344 if (die->die_perennial_p)
29347 for (c = die->die_parent; c; c = c->die_parent)
29348 if (c->die_tag == DW_TAG_subprogram)
29351 /* Finding used static member functions inside of classes
29352 is needed just for local classes, because for other classes
29353 static member function DIEs with DW_AT_specification
29354 are emitted outside of the DW_TAG_*_type. If we ever change
29355 it, we'd need to call this even for non-local classes. */
29357 prune_unused_types_walk_local_classes (die);
29359 /* It's a type node --- don't mark it. */
29362 case DW_TAG_const_type:
29363 case DW_TAG_packed_type:
29364 case DW_TAG_pointer_type:
29365 case DW_TAG_reference_type:
29366 case DW_TAG_rvalue_reference_type:
29367 case DW_TAG_volatile_type:
29368 case DW_TAG_typedef:
29369 case DW_TAG_array_type:
29370 case DW_TAG_friend:
29371 case DW_TAG_enumeration_type:
29372 case DW_TAG_subroutine_type:
29373 case DW_TAG_string_type:
29374 case DW_TAG_set_type:
29375 case DW_TAG_subrange_type:
29376 case DW_TAG_ptr_to_member_type:
29377 case DW_TAG_file_type:
29378 /* Type nodes are useful only when other DIEs reference them --- don't
29382 case DW_TAG_dwarf_procedure:
29383 /* Likewise for DWARF procedures. */
29385 if (die->die_perennial_p)
29390 case DW_TAG_variable:
29391 if (flag_debug_only_used_symbols)
29393 if (die->die_perennial_p)
29396 /* premark_used_variables marks external variables --- don't mark
29397 them here. But function-local externals are always considered
29399 if (get_AT (die, DW_AT_external))
29401 for (c = die->die_parent; c; c = c->die_parent)
29402 if (c->die_tag == DW_TAG_subprogram)
29411 /* Mark everything else. */
29415 if (die->die_mark == 0)
29419 /* Now, mark any dies referenced from here. */
29420 prune_unused_types_walk_attribs (die);
29425 /* Mark children. */
29426 FOR_EACH_CHILD (die, c, prune_unused_types_walk (c));
29429 /* Increment the string counts on strings referred to from DIE's
29433 prune_unused_types_update_strings (dw_die_ref die)
29438 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
29439 if (AT_class (a) == dw_val_class_str)
29441 struct indirect_string_node *s = a->dw_attr_val.v.val_str;
29443 /* Avoid unnecessarily putting strings that are used less than
29444 twice in the hash table. */
29446 == ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) ? 1 : 2))
29448 indirect_string_node **slot
29449 = debug_str_hash->find_slot_with_hash (s->str,
29450 htab_hash_string (s->str),
29452 gcc_assert (*slot == NULL);
29458 /* Mark DIE and its children as removed. */
29461 mark_removed (dw_die_ref die)
29464 die->removed = true;
29465 FOR_EACH_CHILD (die, c, mark_removed (c));
29468 /* Remove from the tree DIE any dies that aren't marked. */
29471 prune_unused_types_prune (dw_die_ref die)
29475 gcc_assert (die->die_mark);
29476 prune_unused_types_update_strings (die);
29478 if (! die->die_child)
29481 c = die->die_child;
29483 dw_die_ref prev = c, next;
29484 for (c = c->die_sib; ! c->die_mark; c = next)
29485 if (c == die->die_child)
29487 /* No marked children between 'prev' and the end of the list. */
29489 /* No marked children at all. */
29490 die->die_child = NULL;
29493 prev->die_sib = c->die_sib;
29494 die->die_child = prev;
29507 if (c != prev->die_sib)
29509 prune_unused_types_prune (c);
29510 } while (c != die->die_child);
29513 /* Remove dies representing declarations that we never use. */
29516 prune_unused_types (void)
29519 limbo_die_node *node;
29520 comdat_type_node *ctnode;
29521 pubname_entry *pub;
29522 dw_die_ref base_type;
29524 #if ENABLE_ASSERT_CHECKING
29525 /* All the marks should already be clear. */
29526 verify_marks_clear (comp_unit_die ());
29527 for (node = limbo_die_list; node; node = node->next)
29528 verify_marks_clear (node->die);
29529 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
29530 verify_marks_clear (ctnode->root_die);
29531 #endif /* ENABLE_ASSERT_CHECKING */
29533 /* Mark types that are used in global variables. */
29534 premark_types_used_by_global_vars ();
29536 /* Mark variables used in the symtab. */
29537 if (flag_debug_only_used_symbols)
29538 premark_used_variables ();
29540 /* Set the mark on nodes that are actually used. */
29541 prune_unused_types_walk (comp_unit_die ());
29542 for (node = limbo_die_list; node; node = node->next)
29543 prune_unused_types_walk (node->die);
29544 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
29546 prune_unused_types_walk (ctnode->root_die);
29547 prune_unused_types_mark (ctnode->type_die, 1);
29550 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
29551 are unusual in that they are pubnames that are the children of pubtypes.
29552 They should only be marked via their parent DW_TAG_enumeration_type die,
29553 not as roots in themselves. */
29554 FOR_EACH_VEC_ELT (*pubname_table, i, pub)
29555 if (pub->die->die_tag != DW_TAG_enumerator)
29556 prune_unused_types_mark (pub->die, 1);
29557 for (i = 0; base_types.iterate (i, &base_type); i++)
29558 prune_unused_types_mark (base_type, 1);
29560 /* Also set the mark on nodes that could be referenced by
29561 DW_TAG_call_site DW_AT_call_origin (i.e. direct call callees) or
29562 by DW_TAG_inlined_subroutine origins. */
29563 cgraph_node *cnode;
29564 FOR_EACH_FUNCTION (cnode)
29565 if (cnode->referred_to_p (false))
29567 dw_die_ref die = lookup_decl_die (cnode->decl);
29568 if (die == NULL || die->die_mark)
29570 for (cgraph_edge *e = cnode->callers; e; e = e->next_caller)
29571 if (e->caller != cnode)
29573 prune_unused_types_mark (die, 1);
29578 if (debug_str_hash)
29579 debug_str_hash->empty ();
29580 if (skeleton_debug_str_hash)
29581 skeleton_debug_str_hash->empty ();
29582 prune_unused_types_prune (comp_unit_die ());
29583 for (limbo_die_node **pnode = &limbo_die_list; *pnode; )
29586 if (!node->die->die_mark)
29587 *pnode = node->next;
29590 prune_unused_types_prune (node->die);
29591 pnode = &node->next;
29594 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
29595 prune_unused_types_prune (ctnode->root_die);
29597 /* Leave the marks clear. */
29598 prune_unmark_dies (comp_unit_die ());
29599 for (node = limbo_die_list; node; node = node->next)
29600 prune_unmark_dies (node->die);
29601 for (ctnode = comdat_type_list; ctnode; ctnode = ctnode->next)
29602 prune_unmark_dies (ctnode->root_die);
29605 /* Helpers to manipulate hash table of comdat type units. */
29607 struct comdat_type_hasher : nofree_ptr_hash <comdat_type_node>
29609 static inline hashval_t hash (const comdat_type_node *);
29610 static inline bool equal (const comdat_type_node *, const comdat_type_node *);
29614 comdat_type_hasher::hash (const comdat_type_node *type_node)
29617 memcpy (&h, type_node->signature, sizeof (h));
29622 comdat_type_hasher::equal (const comdat_type_node *type_node_1,
29623 const comdat_type_node *type_node_2)
29625 return (! memcmp (type_node_1->signature, type_node_2->signature,
29626 DWARF_TYPE_SIGNATURE_SIZE));
29629 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
29630 to the location it would have been added, should we know its
29631 DECL_ASSEMBLER_NAME when we added other attributes. This will
29632 probably improve compactness of debug info, removing equivalent
29633 abbrevs, and hide any differences caused by deferring the
29634 computation of the assembler name, triggered by e.g. PCH. */
29637 move_linkage_attr (dw_die_ref die)
29639 unsigned ix = vec_safe_length (die->die_attr);
29640 dw_attr_node linkage = (*die->die_attr)[ix - 1];
29642 gcc_assert (linkage.dw_attr == DW_AT_linkage_name
29643 || linkage.dw_attr == DW_AT_MIPS_linkage_name);
29647 dw_attr_node *prev = &(*die->die_attr)[ix - 1];
29649 if (prev->dw_attr == DW_AT_decl_line
29650 || prev->dw_attr == DW_AT_decl_column
29651 || prev->dw_attr == DW_AT_name)
29655 if (ix != vec_safe_length (die->die_attr) - 1)
29657 die->die_attr->pop ();
29658 die->die_attr->quick_insert (ix, linkage);
29662 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
29663 referenced from typed stack ops and count how often they are used. */
29666 mark_base_types (dw_loc_descr_ref loc)
29668 dw_die_ref base_type = NULL;
29670 for (; loc; loc = loc->dw_loc_next)
29672 switch (loc->dw_loc_opc)
29674 case DW_OP_regval_type:
29675 case DW_OP_deref_type:
29676 case DW_OP_GNU_regval_type:
29677 case DW_OP_GNU_deref_type:
29678 base_type = loc->dw_loc_oprnd2.v.val_die_ref.die;
29680 case DW_OP_convert:
29681 case DW_OP_reinterpret:
29682 case DW_OP_GNU_convert:
29683 case DW_OP_GNU_reinterpret:
29684 if (loc->dw_loc_oprnd1.val_class == dw_val_class_unsigned_const)
29687 case DW_OP_const_type:
29688 case DW_OP_GNU_const_type:
29689 base_type = loc->dw_loc_oprnd1.v.val_die_ref.die;
29691 case DW_OP_entry_value:
29692 case DW_OP_GNU_entry_value:
29693 mark_base_types (loc->dw_loc_oprnd1.v.val_loc);
29698 gcc_assert (base_type->die_parent == comp_unit_die ());
29699 if (base_type->die_mark)
29700 base_type->die_mark++;
29703 base_types.safe_push (base_type);
29704 base_type->die_mark = 1;
29709 /* Comparison function for sorting marked base types. */
29712 base_type_cmp (const void *x, const void *y)
29714 dw_die_ref dx = *(const dw_die_ref *) x;
29715 dw_die_ref dy = *(const dw_die_ref *) y;
29716 unsigned int byte_size1, byte_size2;
29717 unsigned int encoding1, encoding2;
29718 unsigned int align1, align2;
29719 if (dx->die_mark > dy->die_mark)
29721 if (dx->die_mark < dy->die_mark)
29723 byte_size1 = get_AT_unsigned (dx, DW_AT_byte_size);
29724 byte_size2 = get_AT_unsigned (dy, DW_AT_byte_size);
29725 if (byte_size1 < byte_size2)
29727 if (byte_size1 > byte_size2)
29729 encoding1 = get_AT_unsigned (dx, DW_AT_encoding);
29730 encoding2 = get_AT_unsigned (dy, DW_AT_encoding);
29731 if (encoding1 < encoding2)
29733 if (encoding1 > encoding2)
29735 align1 = get_AT_unsigned (dx, DW_AT_alignment);
29736 align2 = get_AT_unsigned (dy, DW_AT_alignment);
29737 if (align1 < align2)
29739 if (align1 > align2)
29744 /* Move base types marked by mark_base_types as early as possible
29745 in the CU, sorted by decreasing usage count both to make the
29746 uleb128 references as small as possible and to make sure they
29747 will have die_offset already computed by calc_die_sizes when
29748 sizes of typed stack loc ops is computed. */
29751 move_marked_base_types (void)
29754 dw_die_ref base_type, die, c;
29756 if (base_types.is_empty ())
29759 /* Sort by decreasing usage count, they will be added again in that
29761 base_types.qsort (base_type_cmp);
29762 die = comp_unit_die ();
29763 c = die->die_child;
29766 dw_die_ref prev = c;
29768 while (c->die_mark)
29770 remove_child_with_prev (c, prev);
29771 /* As base types got marked, there must be at least
29772 one node other than DW_TAG_base_type. */
29773 gcc_assert (die->die_child != NULL);
29777 while (c != die->die_child);
29778 gcc_assert (die->die_child);
29779 c = die->die_child;
29780 for (i = 0; base_types.iterate (i, &base_type); i++)
29782 base_type->die_mark = 0;
29783 base_type->die_sib = c->die_sib;
29784 c->die_sib = base_type;
29789 /* Helper function for resolve_addr, attempt to resolve
29790 one CONST_STRING, return true if successful. Similarly verify that
29791 SYMBOL_REFs refer to variables emitted in the current CU. */
29794 resolve_one_addr (rtx *addr)
29798 if (GET_CODE (rtl) == CONST_STRING)
29800 size_t len = strlen (XSTR (rtl, 0)) + 1;
29801 tree t = build_string (len, XSTR (rtl, 0));
29802 tree tlen = size_int (len - 1);
29804 = build_array_type (char_type_node, build_index_type (tlen));
29805 rtl = lookup_constant_def (t);
29806 if (!rtl || !MEM_P (rtl))
29808 rtl = XEXP (rtl, 0);
29809 if (GET_CODE (rtl) == SYMBOL_REF
29810 && SYMBOL_REF_DECL (rtl)
29811 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
29813 vec_safe_push (used_rtx_array, rtl);
29818 if (GET_CODE (rtl) == SYMBOL_REF
29819 && SYMBOL_REF_DECL (rtl))
29821 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl))
29823 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl))))
29826 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl)))
29830 if (GET_CODE (rtl) == CONST)
29832 subrtx_ptr_iterator::array_type array;
29833 FOR_EACH_SUBRTX_PTR (iter, array, &XEXP (rtl, 0), ALL)
29834 if (!resolve_one_addr (*iter))
29841 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
29842 if possible, and create DW_TAG_dwarf_procedure that can be referenced
29843 from DW_OP_implicit_pointer if the string hasn't been seen yet. */
29846 string_cst_pool_decl (tree t)
29848 rtx rtl = output_constant_def (t, 1);
29849 unsigned char *array;
29850 dw_loc_descr_ref l;
29855 if (!rtl || !MEM_P (rtl))
29857 rtl = XEXP (rtl, 0);
29858 if (GET_CODE (rtl) != SYMBOL_REF
29859 || SYMBOL_REF_DECL (rtl) == NULL_TREE)
29862 decl = SYMBOL_REF_DECL (rtl);
29863 if (!lookup_decl_die (decl))
29865 len = TREE_STRING_LENGTH (t);
29866 vec_safe_push (used_rtx_array, rtl);
29867 ref = new_die (DW_TAG_dwarf_procedure, comp_unit_die (), decl);
29868 array = ggc_vec_alloc<unsigned char> (len);
29869 memcpy (array, TREE_STRING_POINTER (t), len);
29870 l = new_loc_descr (DW_OP_implicit_value, len, 0);
29871 l->dw_loc_oprnd2.val_class = dw_val_class_vec;
29872 l->dw_loc_oprnd2.v.val_vec.length = len;
29873 l->dw_loc_oprnd2.v.val_vec.elt_size = 1;
29874 l->dw_loc_oprnd2.v.val_vec.array = array;
29875 add_AT_loc (ref, DW_AT_location, l);
29876 equate_decl_number_to_die (decl, ref);
29881 /* Helper function of resolve_addr_in_expr. LOC is
29882 a DW_OP_addr followed by DW_OP_stack_value, either at the start
29883 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
29884 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
29885 with DW_OP_implicit_pointer if possible
29886 and return true, if unsuccessful, return false. */
29889 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc)
29891 rtx rtl = loc->dw_loc_oprnd1.v.val_addr;
29892 HOST_WIDE_INT offset = 0;
29893 dw_die_ref ref = NULL;
29896 if (GET_CODE (rtl) == CONST
29897 && GET_CODE (XEXP (rtl, 0)) == PLUS
29898 && CONST_INT_P (XEXP (XEXP (rtl, 0), 1)))
29900 offset = INTVAL (XEXP (XEXP (rtl, 0), 1));
29901 rtl = XEXP (XEXP (rtl, 0), 0);
29903 if (GET_CODE (rtl) == CONST_STRING)
29905 size_t len = strlen (XSTR (rtl, 0)) + 1;
29906 tree t = build_string (len, XSTR (rtl, 0));
29907 tree tlen = size_int (len - 1);
29910 = build_array_type (char_type_node, build_index_type (tlen));
29911 rtl = string_cst_pool_decl (t);
29915 if (GET_CODE (rtl) == SYMBOL_REF && SYMBOL_REF_DECL (rtl))
29917 decl = SYMBOL_REF_DECL (rtl);
29918 if (VAR_P (decl) && !DECL_EXTERNAL (decl))
29920 ref = lookup_decl_die (decl);
29921 if (ref && (get_AT (ref, DW_AT_location)
29922 || get_AT (ref, DW_AT_const_value)))
29924 loc->dw_loc_opc = dwarf_OP (DW_OP_implicit_pointer);
29925 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
29926 loc->dw_loc_oprnd1.val_entry = NULL;
29927 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
29928 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
29929 loc->dw_loc_next = loc->dw_loc_next->dw_loc_next;
29930 loc->dw_loc_oprnd2.v.val_int = offset;
29938 /* Helper function for resolve_addr, handle one location
29939 expression, return false if at least one CONST_STRING or SYMBOL_REF in
29940 the location list couldn't be resolved. */
29943 resolve_addr_in_expr (dw_attr_node *a, dw_loc_descr_ref loc)
29945 dw_loc_descr_ref keep = NULL;
29946 for (dw_loc_descr_ref prev = NULL; loc; prev = loc, loc = loc->dw_loc_next)
29947 switch (loc->dw_loc_opc)
29950 if (!resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr))
29953 || prev->dw_loc_opc == DW_OP_piece
29954 || prev->dw_loc_opc == DW_OP_bit_piece)
29955 && loc->dw_loc_next
29956 && loc->dw_loc_next->dw_loc_opc == DW_OP_stack_value
29957 && (!dwarf_strict || dwarf_version >= 5)
29958 && optimize_one_addr_into_implicit_ptr (loc))
29963 case DW_OP_GNU_addr_index:
29965 case DW_OP_GNU_const_index:
29967 if ((loc->dw_loc_opc == DW_OP_GNU_addr_index
29968 || loc->dw_loc_opc == DW_OP_addrx)
29969 || ((loc->dw_loc_opc == DW_OP_GNU_const_index
29970 || loc->dw_loc_opc == DW_OP_constx)
29973 rtx rtl = loc->dw_loc_oprnd1.val_entry->addr.rtl;
29974 if (!resolve_one_addr (&rtl))
29976 remove_addr_table_entry (loc->dw_loc_oprnd1.val_entry);
29977 loc->dw_loc_oprnd1.val_entry
29978 = add_addr_table_entry (rtl, ate_kind_rtx);
29981 case DW_OP_const4u:
29982 case DW_OP_const8u:
29984 && !resolve_one_addr (&loc->dw_loc_oprnd1.v.val_addr))
29987 case DW_OP_plus_uconst:
29988 if (size_of_loc_descr (loc)
29989 > size_of_int_loc_descriptor (loc->dw_loc_oprnd1.v.val_unsigned)
29991 && loc->dw_loc_oprnd1.v.val_unsigned > 0)
29993 dw_loc_descr_ref repl
29994 = int_loc_descriptor (loc->dw_loc_oprnd1.v.val_unsigned);
29995 add_loc_descr (&repl, new_loc_descr (DW_OP_plus, 0, 0));
29996 add_loc_descr (&repl, loc->dw_loc_next);
30000 case DW_OP_implicit_value:
30001 if (loc->dw_loc_oprnd2.val_class == dw_val_class_addr
30002 && !resolve_one_addr (&loc->dw_loc_oprnd2.v.val_addr))
30005 case DW_OP_implicit_pointer:
30006 case DW_OP_GNU_implicit_pointer:
30007 case DW_OP_GNU_parameter_ref:
30008 case DW_OP_GNU_variable_value:
30009 if (loc->dw_loc_oprnd1.val_class == dw_val_class_decl_ref)
30012 = lookup_decl_die (loc->dw_loc_oprnd1.v.val_decl_ref);
30015 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
30016 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
30017 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
30019 if (loc->dw_loc_opc == DW_OP_GNU_variable_value)
30022 && loc->dw_loc_next == NULL
30023 && AT_class (a) == dw_val_class_loc)
30024 switch (a->dw_attr)
30026 /* Following attributes allow both exprloc and reference,
30027 so if the whole expression is DW_OP_GNU_variable_value
30028 alone we could transform it into reference. */
30029 case DW_AT_byte_size:
30030 case DW_AT_bit_size:
30031 case DW_AT_lower_bound:
30032 case DW_AT_upper_bound:
30033 case DW_AT_bit_stride:
30035 case DW_AT_allocated:
30036 case DW_AT_associated:
30037 case DW_AT_byte_stride:
30038 a->dw_attr_val.val_class = dw_val_class_die_ref;
30039 a->dw_attr_val.val_entry = NULL;
30040 a->dw_attr_val.v.val_die_ref.die
30041 = loc->dw_loc_oprnd1.v.val_die_ref.die;
30042 a->dw_attr_val.v.val_die_ref.external = 0;
30051 case DW_OP_const_type:
30052 case DW_OP_regval_type:
30053 case DW_OP_deref_type:
30054 case DW_OP_convert:
30055 case DW_OP_reinterpret:
30056 case DW_OP_GNU_const_type:
30057 case DW_OP_GNU_regval_type:
30058 case DW_OP_GNU_deref_type:
30059 case DW_OP_GNU_convert:
30060 case DW_OP_GNU_reinterpret:
30061 while (loc->dw_loc_next
30062 && (loc->dw_loc_next->dw_loc_opc == DW_OP_convert
30063 || loc->dw_loc_next->dw_loc_opc == DW_OP_GNU_convert))
30065 dw_die_ref base1, base2;
30066 unsigned enc1, enc2, size1, size2;
30067 if (loc->dw_loc_opc == DW_OP_regval_type
30068 || loc->dw_loc_opc == DW_OP_deref_type
30069 || loc->dw_loc_opc == DW_OP_GNU_regval_type
30070 || loc->dw_loc_opc == DW_OP_GNU_deref_type)
30071 base1 = loc->dw_loc_oprnd2.v.val_die_ref.die;
30072 else if (loc->dw_loc_oprnd1.val_class
30073 == dw_val_class_unsigned_const)
30076 base1 = loc->dw_loc_oprnd1.v.val_die_ref.die;
30077 if (loc->dw_loc_next->dw_loc_oprnd1.val_class
30078 == dw_val_class_unsigned_const)
30080 base2 = loc->dw_loc_next->dw_loc_oprnd1.v.val_die_ref.die;
30081 gcc_assert (base1->die_tag == DW_TAG_base_type
30082 && base2->die_tag == DW_TAG_base_type);
30083 enc1 = get_AT_unsigned (base1, DW_AT_encoding);
30084 enc2 = get_AT_unsigned (base2, DW_AT_encoding);
30085 size1 = get_AT_unsigned (base1, DW_AT_byte_size);
30086 size2 = get_AT_unsigned (base2, DW_AT_byte_size);
30088 && (((enc1 == DW_ATE_unsigned || enc1 == DW_ATE_signed)
30089 && (enc2 == DW_ATE_unsigned || enc2 == DW_ATE_signed)
30093 /* Optimize away next DW_OP_convert after
30094 adjusting LOC's base type die reference. */
30095 if (loc->dw_loc_opc == DW_OP_regval_type
30096 || loc->dw_loc_opc == DW_OP_deref_type
30097 || loc->dw_loc_opc == DW_OP_GNU_regval_type
30098 || loc->dw_loc_opc == DW_OP_GNU_deref_type)
30099 loc->dw_loc_oprnd2.v.val_die_ref.die = base2;
30101 loc->dw_loc_oprnd1.v.val_die_ref.die = base2;
30102 loc->dw_loc_next = loc->dw_loc_next->dw_loc_next;
30105 /* Don't change integer DW_OP_convert after e.g. floating
30106 point typed stack entry. */
30107 else if (enc1 != DW_ATE_unsigned && enc1 != DW_ATE_signed)
30108 keep = loc->dw_loc_next;
30118 /* Helper function of resolve_addr. DIE had DW_AT_location of
30119 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
30120 and DW_OP_addr couldn't be resolved. resolve_addr has already
30121 removed the DW_AT_location attribute. This function attempts to
30122 add a new DW_AT_location attribute with DW_OP_implicit_pointer
30123 to it or DW_AT_const_value attribute, if possible. */
30126 optimize_location_into_implicit_ptr (dw_die_ref die, tree decl)
30129 || lookup_decl_die (decl) != die
30130 || DECL_EXTERNAL (decl)
30131 || !TREE_STATIC (decl)
30132 || DECL_INITIAL (decl) == NULL_TREE
30133 || DECL_P (DECL_INITIAL (decl))
30134 || get_AT (die, DW_AT_const_value))
30137 tree init = DECL_INITIAL (decl);
30138 HOST_WIDE_INT offset = 0;
30139 /* For variables that have been optimized away and thus
30140 don't have a memory location, see if we can emit
30141 DW_AT_const_value instead. */
30142 if (tree_add_const_value_attribute (die, init))
30144 if (dwarf_strict && dwarf_version < 5)
30146 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
30147 and ADDR_EXPR refers to a decl that has DW_AT_location or
30148 DW_AT_const_value (but isn't addressable, otherwise
30149 resolving the original DW_OP_addr wouldn't fail), see if
30150 we can add DW_OP_implicit_pointer. */
30152 if (TREE_CODE (init) == POINTER_PLUS_EXPR
30153 && tree_fits_shwi_p (TREE_OPERAND (init, 1)))
30155 offset = tree_to_shwi (TREE_OPERAND (init, 1));
30156 init = TREE_OPERAND (init, 0);
30159 if (TREE_CODE (init) != ADDR_EXPR)
30161 if ((TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST
30162 && !TREE_ASM_WRITTEN (TREE_OPERAND (init, 0)))
30163 || (TREE_CODE (TREE_OPERAND (init, 0)) == VAR_DECL
30164 && !DECL_EXTERNAL (TREE_OPERAND (init, 0))
30165 && TREE_OPERAND (init, 0) != decl))
30168 dw_loc_descr_ref l;
30170 if (TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST)
30172 rtx rtl = string_cst_pool_decl (TREE_OPERAND (init, 0));
30175 decl = SYMBOL_REF_DECL (rtl);
30178 decl = TREE_OPERAND (init, 0);
30179 ref = lookup_decl_die (decl);
30181 || (!get_AT (ref, DW_AT_location)
30182 && !get_AT (ref, DW_AT_const_value)))
30184 l = new_loc_descr (dwarf_OP (DW_OP_implicit_pointer), 0, offset);
30185 l->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
30186 l->dw_loc_oprnd1.v.val_die_ref.die = ref;
30187 l->dw_loc_oprnd1.v.val_die_ref.external = 0;
30188 add_AT_loc (die, DW_AT_location, l);
30192 /* Return NULL if l is a DWARF expression, or first op that is not
30193 valid DWARF expression. */
30195 static dw_loc_descr_ref
30196 non_dwarf_expression (dw_loc_descr_ref l)
30200 if (l->dw_loc_opc >= DW_OP_reg0 && l->dw_loc_opc <= DW_OP_reg31)
30202 switch (l->dw_loc_opc)
30205 case DW_OP_implicit_value:
30206 case DW_OP_stack_value:
30207 case DW_OP_implicit_pointer:
30208 case DW_OP_GNU_implicit_pointer:
30209 case DW_OP_GNU_parameter_ref:
30211 case DW_OP_bit_piece:
30216 l = l->dw_loc_next;
30221 /* Return adjusted copy of EXPR:
30222 If it is empty DWARF expression, return it.
30223 If it is valid non-empty DWARF expression,
30224 return copy of EXPR with DW_OP_deref appended to it.
30225 If it is DWARF expression followed by DW_OP_reg{N,x}, return
30226 copy of the DWARF expression with DW_OP_breg{N,x} <0> appended.
30227 If it is DWARF expression followed by DW_OP_stack_value, return
30228 copy of the DWARF expression without anything appended.
30229 Otherwise, return NULL. */
30231 static dw_loc_descr_ref
30232 copy_deref_exprloc (dw_loc_descr_ref expr)
30234 dw_loc_descr_ref tail = NULL;
30239 dw_loc_descr_ref l = non_dwarf_expression (expr);
30240 if (l && l->dw_loc_next)
30245 if (l->dw_loc_opc >= DW_OP_reg0 && l->dw_loc_opc <= DW_OP_reg31)
30246 tail = new_loc_descr ((enum dwarf_location_atom)
30247 (DW_OP_breg0 + (l->dw_loc_opc - DW_OP_reg0)),
30250 switch (l->dw_loc_opc)
30253 tail = new_loc_descr (DW_OP_bregx,
30254 l->dw_loc_oprnd1.v.val_unsigned, 0);
30256 case DW_OP_stack_value:
30263 tail = new_loc_descr (DW_OP_deref, 0, 0);
30265 dw_loc_descr_ref ret = NULL, *p = &ret;
30268 *p = new_loc_descr (expr->dw_loc_opc, 0, 0);
30269 (*p)->dw_loc_oprnd1 = expr->dw_loc_oprnd1;
30270 (*p)->dw_loc_oprnd2 = expr->dw_loc_oprnd2;
30271 p = &(*p)->dw_loc_next;
30272 expr = expr->dw_loc_next;
30278 /* For DW_AT_string_length attribute with DW_OP_GNU_variable_value
30279 reference to a variable or argument, adjust it if needed and return:
30280 -1 if the DW_AT_string_length attribute and DW_AT_{string_length_,}byte_size
30281 attribute if present should be removed
30282 0 keep the attribute perhaps with minor modifications, no need to rescan
30283 1 if the attribute has been successfully adjusted. */
30286 optimize_string_length (dw_attr_node *a)
30288 dw_loc_descr_ref l = AT_loc (a), lv;
30290 if (l->dw_loc_oprnd1.val_class == dw_val_class_decl_ref)
30292 tree decl = l->dw_loc_oprnd1.v.val_decl_ref;
30293 die = lookup_decl_die (decl);
30296 l->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
30297 l->dw_loc_oprnd1.v.val_die_ref.die = die;
30298 l->dw_loc_oprnd1.v.val_die_ref.external = 0;
30304 die = l->dw_loc_oprnd1.v.val_die_ref.die;
30306 /* DWARF5 allows reference class, so we can then reference the DIE.
30307 Only do this for DW_OP_GNU_variable_value DW_OP_stack_value. */
30308 if (l->dw_loc_next != NULL && dwarf_version >= 5)
30310 a->dw_attr_val.val_class = dw_val_class_die_ref;
30311 a->dw_attr_val.val_entry = NULL;
30312 a->dw_attr_val.v.val_die_ref.die = die;
30313 a->dw_attr_val.v.val_die_ref.external = 0;
30317 dw_attr_node *av = get_AT (die, DW_AT_location);
30319 bool non_dwarf_expr = false;
30322 return dwarf_strict ? -1 : 0;
30323 switch (AT_class (av))
30325 case dw_val_class_loc_list:
30326 for (d = AT_loc_list (av); d != NULL; d = d->dw_loc_next)
30327 if (d->expr && non_dwarf_expression (d->expr))
30328 non_dwarf_expr = true;
30330 case dw_val_class_view_list:
30331 gcc_unreachable ();
30332 case dw_val_class_loc:
30335 return dwarf_strict ? -1 : 0;
30336 if (non_dwarf_expression (lv))
30337 non_dwarf_expr = true;
30340 return dwarf_strict ? -1 : 0;
30343 /* If it is safe to transform DW_OP_GNU_variable_value DW_OP_stack_value
30344 into DW_OP_call4 or DW_OP_GNU_variable_value into
30345 DW_OP_call4 DW_OP_deref, do so. */
30346 if (!non_dwarf_expr
30347 && (l->dw_loc_next != NULL || AT_class (av) == dw_val_class_loc))
30349 l->dw_loc_opc = DW_OP_call4;
30350 if (l->dw_loc_next)
30351 l->dw_loc_next = NULL;
30353 l->dw_loc_next = new_loc_descr (DW_OP_deref, 0, 0);
30357 /* For DW_OP_GNU_variable_value DW_OP_stack_value, we can just
30358 copy over the DW_AT_location attribute from die to a. */
30359 if (l->dw_loc_next != NULL)
30361 a->dw_attr_val = av->dw_attr_val;
30365 dw_loc_list_ref list, *p;
30366 switch (AT_class (av))
30368 case dw_val_class_loc_list:
30371 for (d = AT_loc_list (av); d != NULL; d = d->dw_loc_next)
30373 lv = copy_deref_exprloc (d->expr);
30376 *p = new_loc_list (lv, d->begin, d->vbegin, d->end, d->vend, d->section);
30377 p = &(*p)->dw_loc_next;
30379 else if (!dwarf_strict && d->expr)
30383 return dwarf_strict ? -1 : 0;
30384 a->dw_attr_val.val_class = dw_val_class_loc_list;
30386 *AT_loc_list_ptr (a) = list;
30388 case dw_val_class_loc:
30389 lv = copy_deref_exprloc (AT_loc (av));
30391 return dwarf_strict ? -1 : 0;
30392 a->dw_attr_val.v.val_loc = lv;
30395 gcc_unreachable ();
30399 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
30400 an address in .rodata section if the string literal is emitted there,
30401 or remove the containing location list or replace DW_AT_const_value
30402 with DW_AT_location and empty location expression, if it isn't found
30403 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
30404 to something that has been emitted in the current CU. */
30407 resolve_addr (dw_die_ref die)
30411 dw_loc_list_ref *curr, *start, loc;
30413 bool remove_AT_byte_size = false;
30415 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
30416 switch (AT_class (a))
30418 case dw_val_class_loc_list:
30419 start = curr = AT_loc_list_ptr (a);
30422 /* The same list can be referenced more than once. See if we have
30423 already recorded the result from a previous pass. */
30425 *curr = loc->dw_loc_next;
30426 else if (!loc->resolved_addr)
30428 /* As things stand, we do not expect or allow one die to
30429 reference a suffix of another die's location list chain.
30430 References must be identical or completely separate.
30431 There is therefore no need to cache the result of this
30432 pass on any list other than the first; doing so
30433 would lead to unnecessary writes. */
30436 gcc_assert (!(*curr)->replaced && !(*curr)->resolved_addr);
30437 if (!resolve_addr_in_expr (a, (*curr)->expr))
30439 dw_loc_list_ref next = (*curr)->dw_loc_next;
30440 dw_loc_descr_ref l = (*curr)->expr;
30442 if (next && (*curr)->ll_symbol)
30444 gcc_assert (!next->ll_symbol);
30445 next->ll_symbol = (*curr)->ll_symbol;
30446 next->vl_symbol = (*curr)->vl_symbol;
30448 if (dwarf_split_debug_info)
30449 remove_loc_list_addr_table_entries (l);
30454 mark_base_types ((*curr)->expr);
30455 curr = &(*curr)->dw_loc_next;
30459 loc->resolved_addr = 1;
30463 loc->dw_loc_next = *start;
30468 remove_AT (die, a->dw_attr);
30472 case dw_val_class_view_list:
30474 gcc_checking_assert (a->dw_attr == DW_AT_GNU_locviews);
30475 gcc_checking_assert (dwarf2out_locviews_in_attribute ());
30476 dw_val_node *llnode
30477 = view_list_to_loc_list_val_node (&a->dw_attr_val);
30478 /* If we no longer have a loclist, or it no longer needs
30479 views, drop this attribute. */
30480 if (!llnode || !llnode->v.val_loc_list->vl_symbol)
30482 remove_AT (die, a->dw_attr);
30487 case dw_val_class_loc:
30489 dw_loc_descr_ref l = AT_loc (a);
30490 /* DW_OP_GNU_variable_value DW_OP_stack_value or
30491 DW_OP_GNU_variable_value in DW_AT_string_length can be converted
30492 into DW_OP_call4 or DW_OP_call4 DW_OP_deref, which is standard
30493 DWARF4 unlike DW_OP_GNU_variable_value. Or for DWARF5
30494 DW_OP_GNU_variable_value DW_OP_stack_value can be replaced
30495 with DW_FORM_ref referencing the same DIE as
30496 DW_OP_GNU_variable_value used to reference. */
30497 if (a->dw_attr == DW_AT_string_length
30499 && l->dw_loc_opc == DW_OP_GNU_variable_value
30500 && (l->dw_loc_next == NULL
30501 || (l->dw_loc_next->dw_loc_next == NULL
30502 && l->dw_loc_next->dw_loc_opc == DW_OP_stack_value)))
30504 switch (optimize_string_length (a))
30507 remove_AT (die, a->dw_attr);
30509 /* If we drop DW_AT_string_length, we need to drop also
30510 DW_AT_{string_length_,}byte_size. */
30511 remove_AT_byte_size = true;
30516 /* Even if we keep the optimized DW_AT_string_length,
30517 it might have changed AT_class, so process it again. */
30522 /* For -gdwarf-2 don't attempt to optimize
30523 DW_AT_data_member_location containing
30524 DW_OP_plus_uconst - older consumers might
30525 rely on it being that op instead of a more complex,
30526 but shorter, location description. */
30527 if ((dwarf_version > 2
30528 || a->dw_attr != DW_AT_data_member_location
30530 || l->dw_loc_opc != DW_OP_plus_uconst
30531 || l->dw_loc_next != NULL)
30532 && !resolve_addr_in_expr (a, l))
30534 if (dwarf_split_debug_info)
30535 remove_loc_list_addr_table_entries (l);
30537 && l->dw_loc_next == NULL
30538 && l->dw_loc_opc == DW_OP_addr
30539 && GET_CODE (l->dw_loc_oprnd1.v.val_addr) == SYMBOL_REF
30540 && SYMBOL_REF_DECL (l->dw_loc_oprnd1.v.val_addr)
30541 && a->dw_attr == DW_AT_location)
30543 tree decl = SYMBOL_REF_DECL (l->dw_loc_oprnd1.v.val_addr);
30544 remove_AT (die, a->dw_attr);
30546 optimize_location_into_implicit_ptr (die, decl);
30549 if (a->dw_attr == DW_AT_string_length)
30550 /* If we drop DW_AT_string_length, we need to drop also
30551 DW_AT_{string_length_,}byte_size. */
30552 remove_AT_byte_size = true;
30553 remove_AT (die, a->dw_attr);
30557 mark_base_types (l);
30560 case dw_val_class_addr:
30561 if (a->dw_attr == DW_AT_const_value
30562 && !resolve_one_addr (&a->dw_attr_val.v.val_addr))
30564 if (AT_index (a) != NOT_INDEXED)
30565 remove_addr_table_entry (a->dw_attr_val.val_entry);
30566 remove_AT (die, a->dw_attr);
30569 if ((die->die_tag == DW_TAG_call_site
30570 && a->dw_attr == DW_AT_call_origin)
30571 || (die->die_tag == DW_TAG_GNU_call_site
30572 && a->dw_attr == DW_AT_abstract_origin))
30574 tree tdecl = SYMBOL_REF_DECL (a->dw_attr_val.v.val_addr);
30575 dw_die_ref tdie = lookup_decl_die (tdecl);
30578 && DECL_EXTERNAL (tdecl)
30579 && DECL_ABSTRACT_ORIGIN (tdecl) == NULL_TREE
30580 && (cdie = lookup_context_die (DECL_CONTEXT (tdecl))))
30582 dw_die_ref pdie = cdie;
30583 /* Make sure we don't add these DIEs into type units.
30584 We could emit skeleton DIEs for context (namespaces,
30585 outer structs/classes) and a skeleton DIE for the
30586 innermost context with DW_AT_signature pointing to the
30587 type unit. See PR78835. */
30588 while (pdie && pdie->die_tag != DW_TAG_type_unit)
30589 pdie = pdie->die_parent;
30592 /* Creating a full DIE for tdecl is overly expensive and
30593 at this point even wrong when in the LTO phase
30594 as it can end up generating new type DIEs we didn't
30595 output and thus optimize_external_refs will crash. */
30596 tdie = new_die (DW_TAG_subprogram, cdie, NULL_TREE);
30597 add_AT_flag (tdie, DW_AT_external, 1);
30598 add_AT_flag (tdie, DW_AT_declaration, 1);
30599 add_linkage_attr (tdie, tdecl);
30600 add_name_and_src_coords_attributes (tdie, tdecl, true);
30601 equate_decl_number_to_die (tdecl, tdie);
30606 a->dw_attr_val.val_class = dw_val_class_die_ref;
30607 a->dw_attr_val.v.val_die_ref.die = tdie;
30608 a->dw_attr_val.v.val_die_ref.external = 0;
30612 if (AT_index (a) != NOT_INDEXED)
30613 remove_addr_table_entry (a->dw_attr_val.val_entry);
30614 remove_AT (die, a->dw_attr);
30623 if (remove_AT_byte_size)
30624 remove_AT (die, dwarf_version >= 5
30625 ? DW_AT_string_length_byte_size
30626 : DW_AT_byte_size);
30628 FOR_EACH_CHILD (die, c, resolve_addr (c));
30631 /* Helper routines for optimize_location_lists.
30632 This pass tries to share identical local lists in .debug_loc
30635 /* Iteratively hash operands of LOC opcode into HSTATE. */
30638 hash_loc_operands (dw_loc_descr_ref loc, inchash::hash &hstate)
30640 dw_val_ref val1 = &loc->dw_loc_oprnd1;
30641 dw_val_ref val2 = &loc->dw_loc_oprnd2;
30643 switch (loc->dw_loc_opc)
30645 case DW_OP_const4u:
30646 case DW_OP_const8u:
30650 case DW_OP_const1u:
30651 case DW_OP_const1s:
30652 case DW_OP_const2u:
30653 case DW_OP_const2s:
30654 case DW_OP_const4s:
30655 case DW_OP_const8s:
30659 case DW_OP_plus_uconst:
30695 case DW_OP_deref_size:
30696 case DW_OP_xderef_size:
30697 hstate.add_object (val1->v.val_int);
30704 gcc_assert (val1->val_class == dw_val_class_loc);
30705 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
30706 hstate.add_object (offset);
30709 case DW_OP_implicit_value:
30710 hstate.add_object (val1->v.val_unsigned);
30711 switch (val2->val_class)
30713 case dw_val_class_const:
30714 hstate.add_object (val2->v.val_int);
30716 case dw_val_class_vec:
30718 unsigned int elt_size = val2->v.val_vec.elt_size;
30719 unsigned int len = val2->v.val_vec.length;
30721 hstate.add_int (elt_size);
30722 hstate.add_int (len);
30723 hstate.add (val2->v.val_vec.array, len * elt_size);
30726 case dw_val_class_const_double:
30727 hstate.add_object (val2->v.val_double.low);
30728 hstate.add_object (val2->v.val_double.high);
30730 case dw_val_class_wide_int:
30731 hstate.add (val2->v.val_wide->get_val (),
30732 get_full_len (*val2->v.val_wide)
30733 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
30735 case dw_val_class_addr:
30736 inchash::add_rtx (val2->v.val_addr, hstate);
30739 gcc_unreachable ();
30743 case DW_OP_bit_piece:
30744 hstate.add_object (val1->v.val_int);
30745 hstate.add_object (val2->v.val_int);
30751 unsigned char dtprel = 0xd1;
30752 hstate.add_object (dtprel);
30754 inchash::add_rtx (val1->v.val_addr, hstate);
30756 case DW_OP_GNU_addr_index:
30758 case DW_OP_GNU_const_index:
30763 unsigned char dtprel = 0xd1;
30764 hstate.add_object (dtprel);
30766 inchash::add_rtx (val1->val_entry->addr.rtl, hstate);
30769 case DW_OP_implicit_pointer:
30770 case DW_OP_GNU_implicit_pointer:
30771 hstate.add_int (val2->v.val_int);
30773 case DW_OP_entry_value:
30774 case DW_OP_GNU_entry_value:
30775 hstate.add_object (val1->v.val_loc);
30777 case DW_OP_regval_type:
30778 case DW_OP_deref_type:
30779 case DW_OP_GNU_regval_type:
30780 case DW_OP_GNU_deref_type:
30782 unsigned int byte_size
30783 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_byte_size);
30784 unsigned int encoding
30785 = get_AT_unsigned (val2->v.val_die_ref.die, DW_AT_encoding);
30786 hstate.add_object (val1->v.val_int);
30787 hstate.add_object (byte_size);
30788 hstate.add_object (encoding);
30791 case DW_OP_convert:
30792 case DW_OP_reinterpret:
30793 case DW_OP_GNU_convert:
30794 case DW_OP_GNU_reinterpret:
30795 if (val1->val_class == dw_val_class_unsigned_const)
30797 hstate.add_object (val1->v.val_unsigned);
30801 case DW_OP_const_type:
30802 case DW_OP_GNU_const_type:
30804 unsigned int byte_size
30805 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_byte_size);
30806 unsigned int encoding
30807 = get_AT_unsigned (val1->v.val_die_ref.die, DW_AT_encoding);
30808 hstate.add_object (byte_size);
30809 hstate.add_object (encoding);
30810 if (loc->dw_loc_opc != DW_OP_const_type
30811 && loc->dw_loc_opc != DW_OP_GNU_const_type)
30813 hstate.add_object (val2->val_class);
30814 switch (val2->val_class)
30816 case dw_val_class_const:
30817 hstate.add_object (val2->v.val_int);
30819 case dw_val_class_vec:
30821 unsigned int elt_size = val2->v.val_vec.elt_size;
30822 unsigned int len = val2->v.val_vec.length;
30824 hstate.add_object (elt_size);
30825 hstate.add_object (len);
30826 hstate.add (val2->v.val_vec.array, len * elt_size);
30829 case dw_val_class_const_double:
30830 hstate.add_object (val2->v.val_double.low);
30831 hstate.add_object (val2->v.val_double.high);
30833 case dw_val_class_wide_int:
30834 hstate.add (val2->v.val_wide->get_val (),
30835 get_full_len (*val2->v.val_wide)
30836 * HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR);
30839 gcc_unreachable ();
30845 /* Other codes have no operands. */
30850 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
30853 hash_locs (dw_loc_descr_ref loc, inchash::hash &hstate)
30855 dw_loc_descr_ref l;
30856 bool sizes_computed = false;
30857 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
30858 size_of_locs (loc);
30860 for (l = loc; l != NULL; l = l->dw_loc_next)
30862 enum dwarf_location_atom opc = l->dw_loc_opc;
30863 hstate.add_object (opc);
30864 if ((opc == DW_OP_skip || opc == DW_OP_bra) && !sizes_computed)
30866 size_of_locs (loc);
30867 sizes_computed = true;
30869 hash_loc_operands (l, hstate);
30873 /* Compute hash of the whole location list LIST_HEAD. */
30876 hash_loc_list (dw_loc_list_ref list_head)
30878 dw_loc_list_ref curr = list_head;
30879 inchash::hash hstate;
30881 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
30883 hstate.add (curr->begin, strlen (curr->begin) + 1);
30884 hstate.add (curr->end, strlen (curr->end) + 1);
30885 hstate.add_object (curr->vbegin);
30886 hstate.add_object (curr->vend);
30888 hstate.add (curr->section, strlen (curr->section) + 1);
30889 hash_locs (curr->expr, hstate);
30891 list_head->hash = hstate.end ();
30894 /* Return true if X and Y opcodes have the same operands. */
30897 compare_loc_operands (dw_loc_descr_ref x, dw_loc_descr_ref y)
30899 dw_val_ref valx1 = &x->dw_loc_oprnd1;
30900 dw_val_ref valx2 = &x->dw_loc_oprnd2;
30901 dw_val_ref valy1 = &y->dw_loc_oprnd1;
30902 dw_val_ref valy2 = &y->dw_loc_oprnd2;
30904 switch (x->dw_loc_opc)
30906 case DW_OP_const4u:
30907 case DW_OP_const8u:
30911 case DW_OP_const1u:
30912 case DW_OP_const1s:
30913 case DW_OP_const2u:
30914 case DW_OP_const2s:
30915 case DW_OP_const4s:
30916 case DW_OP_const8s:
30920 case DW_OP_plus_uconst:
30956 case DW_OP_deref_size:
30957 case DW_OP_xderef_size:
30958 return valx1->v.val_int == valy1->v.val_int;
30961 /* If splitting debug info, the use of DW_OP_GNU_addr_index
30962 can cause irrelevant differences in dw_loc_addr. */
30963 gcc_assert (valx1->val_class == dw_val_class_loc
30964 && valy1->val_class == dw_val_class_loc
30965 && (dwarf_split_debug_info
30966 || x->dw_loc_addr == y->dw_loc_addr));
30967 return valx1->v.val_loc->dw_loc_addr == valy1->v.val_loc->dw_loc_addr;
30968 case DW_OP_implicit_value:
30969 if (valx1->v.val_unsigned != valy1->v.val_unsigned
30970 || valx2->val_class != valy2->val_class)
30972 switch (valx2->val_class)
30974 case dw_val_class_const:
30975 return valx2->v.val_int == valy2->v.val_int;
30976 case dw_val_class_vec:
30977 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
30978 && valx2->v.val_vec.length == valy2->v.val_vec.length
30979 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
30980 valx2->v.val_vec.elt_size
30981 * valx2->v.val_vec.length) == 0;
30982 case dw_val_class_const_double:
30983 return valx2->v.val_double.low == valy2->v.val_double.low
30984 && valx2->v.val_double.high == valy2->v.val_double.high;
30985 case dw_val_class_wide_int:
30986 return *valx2->v.val_wide == *valy2->v.val_wide;
30987 case dw_val_class_addr:
30988 return rtx_equal_p (valx2->v.val_addr, valy2->v.val_addr);
30990 gcc_unreachable ();
30993 case DW_OP_bit_piece:
30994 return valx1->v.val_int == valy1->v.val_int
30995 && valx2->v.val_int == valy2->v.val_int;
30998 return rtx_equal_p (valx1->v.val_addr, valy1->v.val_addr);
30999 case DW_OP_GNU_addr_index:
31001 case DW_OP_GNU_const_index:
31004 rtx ax1 = valx1->val_entry->addr.rtl;
31005 rtx ay1 = valy1->val_entry->addr.rtl;
31006 return rtx_equal_p (ax1, ay1);
31008 case DW_OP_implicit_pointer:
31009 case DW_OP_GNU_implicit_pointer:
31010 return valx1->val_class == dw_val_class_die_ref
31011 && valx1->val_class == valy1->val_class
31012 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die
31013 && valx2->v.val_int == valy2->v.val_int;
31014 case DW_OP_entry_value:
31015 case DW_OP_GNU_entry_value:
31016 return compare_loc_operands (valx1->v.val_loc, valy1->v.val_loc);
31017 case DW_OP_const_type:
31018 case DW_OP_GNU_const_type:
31019 if (valx1->v.val_die_ref.die != valy1->v.val_die_ref.die
31020 || valx2->val_class != valy2->val_class)
31022 switch (valx2->val_class)
31024 case dw_val_class_const:
31025 return valx2->v.val_int == valy2->v.val_int;
31026 case dw_val_class_vec:
31027 return valx2->v.val_vec.elt_size == valy2->v.val_vec.elt_size
31028 && valx2->v.val_vec.length == valy2->v.val_vec.length
31029 && memcmp (valx2->v.val_vec.array, valy2->v.val_vec.array,
31030 valx2->v.val_vec.elt_size
31031 * valx2->v.val_vec.length) == 0;
31032 case dw_val_class_const_double:
31033 return valx2->v.val_double.low == valy2->v.val_double.low
31034 && valx2->v.val_double.high == valy2->v.val_double.high;
31035 case dw_val_class_wide_int:
31036 return *valx2->v.val_wide == *valy2->v.val_wide;
31038 gcc_unreachable ();
31040 case DW_OP_regval_type:
31041 case DW_OP_deref_type:
31042 case DW_OP_GNU_regval_type:
31043 case DW_OP_GNU_deref_type:
31044 return valx1->v.val_int == valy1->v.val_int
31045 && valx2->v.val_die_ref.die == valy2->v.val_die_ref.die;
31046 case DW_OP_convert:
31047 case DW_OP_reinterpret:
31048 case DW_OP_GNU_convert:
31049 case DW_OP_GNU_reinterpret:
31050 if (valx1->val_class != valy1->val_class)
31052 if (valx1->val_class == dw_val_class_unsigned_const)
31053 return valx1->v.val_unsigned == valy1->v.val_unsigned;
31054 return valx1->v.val_die_ref.die == valy1->v.val_die_ref.die;
31055 case DW_OP_GNU_parameter_ref:
31056 return valx1->val_class == dw_val_class_die_ref
31057 && valx1->val_class == valy1->val_class
31058 && valx1->v.val_die_ref.die == valy1->v.val_die_ref.die;
31060 /* Other codes have no operands. */
31065 /* Return true if DWARF location expressions X and Y are the same. */
31068 compare_locs (dw_loc_descr_ref x, dw_loc_descr_ref y)
31070 for (; x != NULL && y != NULL; x = x->dw_loc_next, y = y->dw_loc_next)
31071 if (x->dw_loc_opc != y->dw_loc_opc
31072 || x->dtprel != y->dtprel
31073 || !compare_loc_operands (x, y))
31075 return x == NULL && y == NULL;
31078 /* Hashtable helpers. */
31080 struct loc_list_hasher : nofree_ptr_hash <dw_loc_list_struct>
31082 static inline hashval_t hash (const dw_loc_list_struct *);
31083 static inline bool equal (const dw_loc_list_struct *,
31084 const dw_loc_list_struct *);
31087 /* Return precomputed hash of location list X. */
31090 loc_list_hasher::hash (const dw_loc_list_struct *x)
31095 /* Return true if location lists A and B are the same. */
31098 loc_list_hasher::equal (const dw_loc_list_struct *a,
31099 const dw_loc_list_struct *b)
31103 if (a->hash != b->hash)
31105 for (; a != NULL && b != NULL; a = a->dw_loc_next, b = b->dw_loc_next)
31106 if (strcmp (a->begin, b->begin) != 0
31107 || strcmp (a->end, b->end) != 0
31108 || (a->section == NULL) != (b->section == NULL)
31109 || (a->section && strcmp (a->section, b->section) != 0)
31110 || a->vbegin != b->vbegin || a->vend != b->vend
31111 || !compare_locs (a->expr, b->expr))
31113 return a == NULL && b == NULL;
31116 typedef hash_table<loc_list_hasher> loc_list_hash_type;
31119 /* Recursively optimize location lists referenced from DIE
31120 children and share them whenever possible. */
31123 optimize_location_lists_1 (dw_die_ref die, loc_list_hash_type *htab)
31128 dw_loc_list_struct **slot;
31129 bool drop_locviews = false;
31130 bool has_locviews = false;
31132 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
31133 if (AT_class (a) == dw_val_class_loc_list)
31135 dw_loc_list_ref list = AT_loc_list (a);
31136 /* TODO: perform some optimizations here, before hashing
31137 it and storing into the hash table. */
31138 hash_loc_list (list);
31139 slot = htab->find_slot_with_hash (list, list->hash, INSERT);
31143 if (loc_list_has_views (list))
31144 gcc_assert (list->vl_symbol);
31145 else if (list->vl_symbol)
31147 drop_locviews = true;
31148 list->vl_symbol = NULL;
31153 if (list->vl_symbol && !(*slot)->vl_symbol)
31154 drop_locviews = true;
31155 a->dw_attr_val.v.val_loc_list = *slot;
31158 else if (AT_class (a) == dw_val_class_view_list)
31160 gcc_checking_assert (a->dw_attr == DW_AT_GNU_locviews);
31161 has_locviews = true;
31165 if (drop_locviews && has_locviews)
31166 remove_AT (die, DW_AT_GNU_locviews);
31168 FOR_EACH_CHILD (die, c, optimize_location_lists_1 (c, htab));
31172 /* Recursively assign each location list a unique index into the debug_addr
31176 index_location_lists (dw_die_ref die)
31182 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
31183 if (AT_class (a) == dw_val_class_loc_list)
31185 dw_loc_list_ref list = AT_loc_list (a);
31186 dw_loc_list_ref curr;
31187 for (curr = list; curr != NULL; curr = curr->dw_loc_next)
31189 /* Don't index an entry that has already been indexed
31190 or won't be output. Make sure skip_loc_list_entry doesn't
31191 call size_of_locs, because that might cause circular dependency,
31192 index_location_lists requiring address table indexes to be
31193 computed, but adding new indexes through add_addr_table_entry
31194 and address table index computation requiring no new additions
31195 to the hash table. In the rare case of DWARF[234] >= 64KB
31196 location expression, we'll just waste unused address table entry
31198 if (curr->begin_entry != NULL
31199 || skip_loc_list_entry (curr))
31203 = add_addr_table_entry (xstrdup (curr->begin), ate_kind_label);
31207 FOR_EACH_CHILD (die, c, index_location_lists (c));
31210 /* Optimize location lists referenced from DIE
31211 children and share them whenever possible. */
31214 optimize_location_lists (dw_die_ref die)
31216 loc_list_hash_type htab (500);
31217 optimize_location_lists_1 (die, &htab);
31220 /* Traverse the limbo die list, and add parent/child links. The only
31221 dies without parents that should be here are concrete instances of
31222 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
31223 For concrete instances, we can get the parent die from the abstract
31227 flush_limbo_die_list (void)
31229 limbo_die_node *node;
31231 /* get_context_die calls force_decl_die, which can put new DIEs on the
31232 limbo list in LTO mode when nested functions are put in a different
31233 partition than that of their parent function. */
31234 while ((node = limbo_die_list))
31236 dw_die_ref die = node->die;
31237 limbo_die_list = node->next;
31239 if (die->die_parent == NULL)
31241 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
31243 if (origin && origin->die_parent)
31244 add_child_die (origin->die_parent, die);
31245 else if (is_cu_die (die))
31247 else if (seen_error ())
31248 /* It's OK to be confused by errors in the input. */
31249 add_child_die (comp_unit_die (), die);
31252 /* In certain situations, the lexical block containing a
31253 nested function can be optimized away, which results
31254 in the nested function die being orphaned. Likewise
31255 with the return type of that nested function. Force
31256 this to be a child of the containing function.
31258 It may happen that even the containing function got fully
31259 inlined and optimized out. In that case we are lost and
31260 assign the empty child. This should not be big issue as
31261 the function is likely unreachable too. */
31262 gcc_assert (node->created_for);
31264 if (DECL_P (node->created_for))
31265 origin = get_context_die (DECL_CONTEXT (node->created_for));
31266 else if (TYPE_P (node->created_for))
31267 origin = scope_die_for (node->created_for, comp_unit_die ());
31269 origin = comp_unit_die ();
31271 add_child_die (origin, die);
31277 /* Reset DIEs so we can output them again. */
31280 reset_dies (dw_die_ref die)
31284 /* Remove stuff we re-generate. */
31286 die->die_offset = 0;
31287 die->die_abbrev = 0;
31288 remove_AT (die, DW_AT_sibling);
31290 FOR_EACH_CHILD (die, c, reset_dies (c));
31293 /* Output stuff that dwarf requires at the end of every file,
31294 and generate the DWARF-2 debugging info. */
31297 dwarf2out_finish (const char *filename)
31299 comdat_type_node *ctnode;
31300 dw_die_ref main_comp_unit_die;
31301 unsigned char checksum[16];
31302 char dl_section_ref[MAX_ARTIFICIAL_LABEL_BYTES];
31304 /* Flush out any latecomers to the limbo party. */
31305 flush_limbo_die_list ();
31307 if (inline_entry_data_table)
31308 gcc_assert (inline_entry_data_table->is_empty ());
31312 verify_die (comp_unit_die ());
31313 for (limbo_die_node *node = cu_die_list; node; node = node->next)
31314 verify_die (node->die);
31317 /* We shouldn't have any symbols with delayed asm names for
31318 DIEs generated after early finish. */
31319 gcc_assert (deferred_asm_name == NULL);
31321 gen_remaining_tmpl_value_param_die_attribute ();
31323 if (flag_generate_lto || flag_generate_offload)
31325 gcc_assert (flag_fat_lto_objects || flag_generate_offload);
31327 /* Prune stuff so that dwarf2out_finish runs successfully
31328 for the fat part of the object. */
31329 reset_dies (comp_unit_die ());
31330 for (limbo_die_node *node = cu_die_list; node; node = node->next)
31331 reset_dies (node->die);
31333 hash_table<comdat_type_hasher> comdat_type_table (100);
31334 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
31336 comdat_type_node **slot
31337 = comdat_type_table.find_slot (ctnode, INSERT);
31339 /* Don't reset types twice. */
31340 if (*slot != HTAB_EMPTY_ENTRY)
31343 /* Remove the pointer to the line table. */
31344 remove_AT (ctnode->root_die, DW_AT_stmt_list);
31346 if (debug_info_level >= DINFO_LEVEL_TERSE)
31347 reset_dies (ctnode->root_die);
31352 /* Reset die CU symbol so we don't output it twice. */
31353 comp_unit_die ()->die_id.die_symbol = NULL;
31355 /* Remove DW_AT_macro and DW_AT_stmt_list from the early output. */
31356 remove_AT (comp_unit_die (), DW_AT_stmt_list);
31358 remove_AT (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE);
31360 /* Remove indirect string decisions. */
31361 debug_str_hash->traverse<void *, reset_indirect_string> (NULL);
31362 if (debug_line_str_hash)
31364 debug_line_str_hash->traverse<void *, reset_indirect_string> (NULL);
31365 debug_line_str_hash = NULL;
31369 #if ENABLE_ASSERT_CHECKING
31371 dw_die_ref die = comp_unit_die (), c;
31372 FOR_EACH_CHILD (die, c, gcc_assert (! c->die_mark));
31375 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
31376 resolve_addr (ctnode->root_die);
31377 resolve_addr (comp_unit_die ());
31378 move_marked_base_types ();
31382 fprintf (dump_file, "DWARF for %s\n", filename);
31383 print_die (comp_unit_die (), dump_file);
31386 /* Initialize sections and labels used for actual assembler output. */
31387 unsigned generation = init_sections_and_labels (false);
31389 /* Traverse the DIE's and add sibling attributes to those DIE's that
31391 add_sibling_attributes (comp_unit_die ());
31392 limbo_die_node *node;
31393 for (node = cu_die_list; node; node = node->next)
31394 add_sibling_attributes (node->die);
31395 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
31396 add_sibling_attributes (ctnode->root_die);
31398 /* When splitting DWARF info, we put some attributes in the
31399 skeleton compile_unit DIE that remains in the .o, while
31400 most attributes go in the DWO compile_unit_die. */
31401 if (dwarf_split_debug_info)
31403 limbo_die_node *cu;
31404 main_comp_unit_die = gen_compile_unit_die (NULL);
31405 if (dwarf_version >= 5)
31406 main_comp_unit_die->die_tag = DW_TAG_skeleton_unit;
31407 cu = limbo_die_list;
31408 gcc_assert (cu->die == main_comp_unit_die);
31409 limbo_die_list = limbo_die_list->next;
31410 cu->next = cu_die_list;
31414 main_comp_unit_die = comp_unit_die ();
31416 /* Output a terminator label for the .text section. */
31417 switch_to_section (text_section);
31418 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
31419 if (cold_text_section)
31421 switch_to_section (cold_text_section);
31422 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
31425 /* We can only use the low/high_pc attributes if all of the code was
31427 if (!have_multiple_function_sections
31428 || (dwarf_version < 3 && dwarf_strict))
31430 /* Don't add if the CU has no associated code. */
31431 if (text_section_used)
31432 add_AT_low_high_pc (main_comp_unit_die, text_section_label,
31433 text_end_label, true);
31439 bool range_list_added = false;
31441 if (text_section_used)
31442 add_ranges_by_labels (main_comp_unit_die, text_section_label,
31443 text_end_label, &range_list_added, true);
31444 if (cold_text_section_used)
31445 add_ranges_by_labels (main_comp_unit_die, cold_text_section_label,
31446 cold_end_label, &range_list_added, true);
31448 FOR_EACH_VEC_ELT (*fde_vec, fde_idx, fde)
31450 if (DECL_IGNORED_P (fde->decl))
31452 if (!fde->in_std_section)
31453 add_ranges_by_labels (main_comp_unit_die, fde->dw_fde_begin,
31454 fde->dw_fde_end, &range_list_added,
31456 if (fde->dw_fde_second_begin && !fde->second_in_std_section)
31457 add_ranges_by_labels (main_comp_unit_die, fde->dw_fde_second_begin,
31458 fde->dw_fde_second_end, &range_list_added,
31462 if (range_list_added)
31464 /* We need to give .debug_loc and .debug_ranges an appropriate
31465 "base address". Use zero so that these addresses become
31466 absolute. Historically, we've emitted the unexpected
31467 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
31468 Emit both to give time for other tools to adapt. */
31469 add_AT_addr (main_comp_unit_die, DW_AT_low_pc, const0_rtx, true);
31470 if (! dwarf_strict && dwarf_version < 4)
31471 add_AT_addr (main_comp_unit_die, DW_AT_entry_pc, const0_rtx, true);
31477 /* AIX Assembler inserts the length, so adjust the reference to match the
31478 offset expected by debuggers. */
31479 strcpy (dl_section_ref, debug_line_section_label);
31480 if (XCOFF_DEBUGGING_INFO)
31481 strcat (dl_section_ref, DWARF_INITIAL_LENGTH_SIZE_STR);
31483 if (debug_info_level >= DINFO_LEVEL_TERSE)
31484 add_AT_lineptr (main_comp_unit_die, DW_AT_stmt_list,
31488 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE,
31489 macinfo_section_label);
31491 if (dwarf_split_debug_info)
31493 if (have_location_lists)
31495 /* Since we generate the loclists in the split DWARF .dwo
31496 file itself, we don't need to generate a loclists_base
31497 attribute for the split compile unit DIE. That attribute
31498 (and using relocatable sec_offset FORMs) isn't allowed
31499 for a split compile unit. Only if the .debug_loclists
31500 section was in the main file, would we need to generate a
31501 loclists_base attribute here (for the full or skeleton
31504 /* optimize_location_lists calculates the size of the lists,
31505 so index them first, and assign indices to the entries.
31506 Although optimize_location_lists will remove entries from
31507 the table, it only does so for duplicates, and therefore
31508 only reduces ref_counts to 1. */
31509 index_location_lists (comp_unit_die ());
31512 if (addr_index_table != NULL)
31514 unsigned int index = 0;
31516 ->traverse_noresize<unsigned int *, index_addr_table_entry>
31522 if (have_location_lists)
31524 optimize_location_lists (comp_unit_die ());
31525 /* And finally assign indexes to the entries for -gsplit-dwarf. */
31526 if (dwarf_version >= 5 && dwarf_split_debug_info)
31527 assign_location_list_indexes (comp_unit_die ());
31530 save_macinfo_strings ();
31532 if (dwarf_split_debug_info)
31534 unsigned int index = 0;
31536 /* Add attributes common to skeleton compile_units and
31537 type_units. Because these attributes include strings, it
31538 must be done before freezing the string table. Top-level
31539 skeleton die attrs are added when the skeleton type unit is
31540 created, so ensure it is created by this point. */
31541 add_top_level_skeleton_die_attrs (main_comp_unit_die);
31542 debug_str_hash->traverse_noresize<unsigned int *, index_string> (&index);
31545 /* Output all of the compilation units. We put the main one last so that
31546 the offsets are available to output_pubnames. */
31547 for (node = cu_die_list; node; node = node->next)
31548 output_comp_unit (node->die, 0, NULL);
31550 hash_table<comdat_type_hasher> comdat_type_table (100);
31551 for (ctnode = comdat_type_list; ctnode != NULL; ctnode = ctnode->next)
31553 comdat_type_node **slot = comdat_type_table.find_slot (ctnode, INSERT);
31555 /* Don't output duplicate types. */
31556 if (*slot != HTAB_EMPTY_ENTRY)
31559 /* Add a pointer to the line table for the main compilation unit
31560 so that the debugger can make sense of DW_AT_decl_file
31562 if (debug_info_level >= DINFO_LEVEL_TERSE)
31563 add_AT_lineptr (ctnode->root_die, DW_AT_stmt_list,
31564 (!dwarf_split_debug_info
31566 : debug_skeleton_line_section_label));
31568 output_comdat_type_unit (ctnode, false);
31572 if (dwarf_split_debug_info)
31575 struct md5_ctx ctx;
31577 if (dwarf_version >= 5 && !vec_safe_is_empty (ranges_table))
31580 /* Compute a checksum of the comp_unit to use as the dwo_id. */
31581 md5_init_ctx (&ctx);
31583 die_checksum (comp_unit_die (), &ctx, &mark);
31584 unmark_all_dies (comp_unit_die ());
31585 md5_finish_ctx (&ctx, checksum);
31587 if (dwarf_version < 5)
31589 /* Use the first 8 bytes of the checksum as the dwo_id,
31590 and add it to both comp-unit DIEs. */
31591 add_AT_data8 (main_comp_unit_die, DW_AT_GNU_dwo_id, checksum);
31592 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id, checksum);
31595 /* Add the base offset of the ranges table to the skeleton
31597 if (!vec_safe_is_empty (ranges_table))
31599 if (dwarf_version >= 5)
31600 add_AT_lineptr (main_comp_unit_die, DW_AT_rnglists_base,
31601 ranges_base_label);
31603 add_AT_lineptr (main_comp_unit_die, DW_AT_GNU_ranges_base,
31604 ranges_section_label);
31607 output_addr_table ();
31610 /* Output the main compilation unit if non-empty or if .debug_macinfo
31611 or .debug_macro will be emitted. */
31612 output_comp_unit (comp_unit_die (), have_macinfo,
31613 dwarf_split_debug_info ? checksum : NULL);
31615 if (dwarf_split_debug_info && info_section_emitted)
31616 output_skeleton_debug_sections (main_comp_unit_die, checksum);
31618 /* Output the abbreviation table. */
31619 if (vec_safe_length (abbrev_die_table) != 1)
31621 switch_to_section (debug_abbrev_section);
31622 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
31623 output_abbrev_section ();
31626 /* Output location list section if necessary. */
31627 if (have_location_lists)
31629 char l1[MAX_ARTIFICIAL_LABEL_BYTES];
31630 char l2[MAX_ARTIFICIAL_LABEL_BYTES];
31631 /* Output the location lists info. */
31632 switch_to_section (debug_loc_section);
31633 if (dwarf_version >= 5)
31635 ASM_GENERATE_INTERNAL_LABEL (l1, DEBUG_LOC_SECTION_LABEL, 2);
31636 ASM_GENERATE_INTERNAL_LABEL (l2, DEBUG_LOC_SECTION_LABEL, 3);
31637 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
31638 dw2_asm_output_data (4, 0xffffffff,
31639 "Initial length escape value indicating "
31640 "64-bit DWARF extension");
31641 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
31642 "Length of Location Lists");
31643 ASM_OUTPUT_LABEL (asm_out_file, l1);
31644 output_dwarf_version ();
31645 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Address Size");
31646 dw2_asm_output_data (1, 0, "Segment Size");
31647 dw2_asm_output_data (4, dwarf_split_debug_info ? loc_list_idx : 0,
31648 "Offset Entry Count");
31650 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
31651 if (dwarf_version >= 5 && dwarf_split_debug_info)
31653 unsigned int save_loc_list_idx = loc_list_idx;
31655 output_loclists_offsets (comp_unit_die ());
31656 gcc_assert (save_loc_list_idx == loc_list_idx);
31658 output_location_lists (comp_unit_die ());
31659 if (dwarf_version >= 5)
31660 ASM_OUTPUT_LABEL (asm_out_file, l2);
31663 output_pubtables ();
31665 /* Output the address range information if a CU (.debug_info section)
31666 was emitted. We output an empty table even if we had no functions
31667 to put in it. This because the consumer has no way to tell the
31668 difference between an empty table that we omitted and failure to
31669 generate a table that would have contained data. */
31670 if (info_section_emitted)
31672 switch_to_section (debug_aranges_section);
31676 /* Output ranges section if necessary. */
31677 if (!vec_safe_is_empty (ranges_table))
31679 if (dwarf_version >= 5)
31680 output_rnglists (generation);
31685 /* Have to end the macro section. */
31688 switch_to_section (debug_macinfo_section);
31689 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
31690 output_macinfo (!dwarf_split_debug_info ? debug_line_section_label
31691 : debug_skeleton_line_section_label, false);
31692 dw2_asm_output_data (1, 0, "End compilation unit");
31695 /* Output the source line correspondence table. We must do this
31696 even if there is no line information. Otherwise, on an empty
31697 translation unit, we will generate a present, but empty,
31698 .debug_info section. IRIX 6.5 `nm' will then complain when
31699 examining the file. This is done late so that any filenames
31700 used by the debug_info section are marked as 'used'. */
31701 switch_to_section (debug_line_section);
31702 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
31703 if (! output_asm_line_debug_info ())
31704 output_line_info (false);
31706 if (dwarf_split_debug_info && info_section_emitted)
31708 switch_to_section (debug_skeleton_line_section);
31709 ASM_OUTPUT_LABEL (asm_out_file, debug_skeleton_line_section_label);
31710 output_line_info (true);
31713 /* If we emitted any indirect strings, output the string table too. */
31714 if (debug_str_hash || skeleton_debug_str_hash)
31715 output_indirect_strings ();
31716 if (debug_line_str_hash)
31718 switch_to_section (debug_line_str_section);
31719 const enum dwarf_form form = DW_FORM_line_strp;
31720 debug_line_str_hash->traverse<enum dwarf_form,
31721 output_indirect_string> (form);
31724 /* ??? Move lvugid out of dwarf2out_source_line and reset it too? */
31725 symview_upper_bound = 0;
31727 bitmap_clear (zero_view_p);
31730 /* Returns a hash value for X (which really is a variable_value_struct). */
31733 variable_value_hasher::hash (variable_value_struct *x)
31735 return (hashval_t) x->decl_id;
31738 /* Return nonzero if decl_id of variable_value_struct X is the same as
31742 variable_value_hasher::equal (variable_value_struct *x, tree y)
31744 return x->decl_id == DECL_UID (y);
31747 /* Helper function for resolve_variable_value, handle
31748 DW_OP_GNU_variable_value in one location expression.
31749 Return true if exprloc has been changed into loclist. */
31752 resolve_variable_value_in_expr (dw_attr_node *a, dw_loc_descr_ref loc)
31754 dw_loc_descr_ref next;
31755 for (dw_loc_descr_ref prev = NULL; loc; prev = loc, loc = next)
31757 next = loc->dw_loc_next;
31758 if (loc->dw_loc_opc != DW_OP_GNU_variable_value
31759 || loc->dw_loc_oprnd1.val_class != dw_val_class_decl_ref)
31762 tree decl = loc->dw_loc_oprnd1.v.val_decl_ref;
31763 if (DECL_CONTEXT (decl) != current_function_decl)
31766 dw_die_ref ref = lookup_decl_die (decl);
31769 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
31770 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
31771 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
31774 dw_loc_list_ref l = loc_list_from_tree (decl, 0, NULL);
31777 if (l->dw_loc_next)
31779 if (AT_class (a) != dw_val_class_loc)
31781 switch (a->dw_attr)
31783 /* Following attributes allow both exprloc and loclist
31784 classes, so we can change them into a loclist. */
31785 case DW_AT_location:
31786 case DW_AT_string_length:
31787 case DW_AT_return_addr:
31788 case DW_AT_data_member_location:
31789 case DW_AT_frame_base:
31790 case DW_AT_segment:
31791 case DW_AT_static_link:
31792 case DW_AT_use_location:
31793 case DW_AT_vtable_elem_location:
31796 prev->dw_loc_next = NULL;
31797 prepend_loc_descr_to_each (l, AT_loc (a));
31800 add_loc_descr_to_each (l, next);
31801 a->dw_attr_val.val_class = dw_val_class_loc_list;
31802 a->dw_attr_val.val_entry = NULL;
31803 a->dw_attr_val.v.val_loc_list = l;
31804 have_location_lists = true;
31806 /* Following attributes allow both exprloc and reference,
31807 so if the whole expression is DW_OP_GNU_variable_value alone
31808 we could transform it into reference. */
31809 case DW_AT_byte_size:
31810 case DW_AT_bit_size:
31811 case DW_AT_lower_bound:
31812 case DW_AT_upper_bound:
31813 case DW_AT_bit_stride:
31815 case DW_AT_allocated:
31816 case DW_AT_associated:
31817 case DW_AT_byte_stride:
31818 if (prev == NULL && next == NULL)
31826 /* Create DW_TAG_variable that we can refer to. */
31827 gen_decl_die (decl, NULL_TREE, NULL,
31828 lookup_decl_die (current_function_decl));
31829 ref = lookup_decl_die (decl);
31832 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
31833 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
31834 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
31840 prev->dw_loc_next = l->expr;
31841 add_loc_descr (&prev->dw_loc_next, next);
31842 free_loc_descr (loc, NULL);
31843 next = prev->dw_loc_next;
31847 memcpy (loc, l->expr, sizeof (dw_loc_descr_node));
31848 add_loc_descr (&loc, next);
31856 /* Attempt to resolve DW_OP_GNU_variable_value using loc_list_from_tree. */
31859 resolve_variable_value (dw_die_ref die)
31862 dw_loc_list_ref loc;
31865 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
31866 switch (AT_class (a))
31868 case dw_val_class_loc:
31869 if (!resolve_variable_value_in_expr (a, AT_loc (a)))
31872 case dw_val_class_loc_list:
31873 loc = AT_loc_list (a);
31875 for (; loc; loc = loc->dw_loc_next)
31876 resolve_variable_value_in_expr (a, loc->expr);
31883 /* Attempt to optimize DW_OP_GNU_variable_value refering to
31884 temporaries in the current function. */
31887 resolve_variable_values (void)
31889 if (!variable_value_hash || !current_function_decl)
31892 struct variable_value_struct *node
31893 = variable_value_hash->find_with_hash (current_function_decl,
31894 DECL_UID (current_function_decl));
31901 FOR_EACH_VEC_SAFE_ELT (node->dies, i, die)
31902 resolve_variable_value (die);
31905 /* Helper function for note_variable_value, handle one location
31909 note_variable_value_in_expr (dw_die_ref die, dw_loc_descr_ref loc)
31911 for (; loc; loc = loc->dw_loc_next)
31912 if (loc->dw_loc_opc == DW_OP_GNU_variable_value
31913 && loc->dw_loc_oprnd1.val_class == dw_val_class_decl_ref)
31915 tree decl = loc->dw_loc_oprnd1.v.val_decl_ref;
31916 dw_die_ref ref = lookup_decl_die (decl);
31917 if (! ref && (flag_generate_lto || flag_generate_offload))
31919 /* ??? This is somewhat a hack because we do not create DIEs
31920 for variables not in BLOCK trees early but when generating
31921 early LTO output we need the dw_val_class_decl_ref to be
31922 fully resolved. For fat LTO objects we'd also like to
31923 undo this after LTO dwarf output. */
31924 gcc_assert (DECL_CONTEXT (decl));
31925 dw_die_ref ctx = lookup_decl_die (DECL_CONTEXT (decl));
31926 gcc_assert (ctx != NULL);
31927 gen_decl_die (decl, NULL_TREE, NULL, ctx);
31928 ref = lookup_decl_die (decl);
31929 gcc_assert (ref != NULL);
31933 loc->dw_loc_oprnd1.val_class = dw_val_class_die_ref;
31934 loc->dw_loc_oprnd1.v.val_die_ref.die = ref;
31935 loc->dw_loc_oprnd1.v.val_die_ref.external = 0;
31939 && DECL_CONTEXT (decl)
31940 && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL
31941 && lookup_decl_die (DECL_CONTEXT (decl)))
31943 if (!variable_value_hash)
31944 variable_value_hash
31945 = hash_table<variable_value_hasher>::create_ggc (10);
31947 tree fndecl = DECL_CONTEXT (decl);
31948 struct variable_value_struct *node;
31949 struct variable_value_struct **slot
31950 = variable_value_hash->find_slot_with_hash (fndecl,
31955 node = ggc_cleared_alloc<variable_value_struct> ();
31956 node->decl_id = DECL_UID (fndecl);
31962 vec_safe_push (node->dies, die);
31967 /* Walk the tree DIE and note DIEs with DW_OP_GNU_variable_value still
31968 with dw_val_class_decl_ref operand. */
31971 note_variable_value (dw_die_ref die)
31975 dw_loc_list_ref loc;
31978 FOR_EACH_VEC_SAFE_ELT (die->die_attr, ix, a)
31979 switch (AT_class (a))
31981 case dw_val_class_loc_list:
31982 loc = AT_loc_list (a);
31984 if (!loc->noted_variable_value)
31986 loc->noted_variable_value = 1;
31987 for (; loc; loc = loc->dw_loc_next)
31988 note_variable_value_in_expr (die, loc->expr);
31991 case dw_val_class_loc:
31992 note_variable_value_in_expr (die, AT_loc (a));
31998 /* Mark children. */
31999 FOR_EACH_CHILD (die, c, note_variable_value (c));
32002 /* Perform any cleanups needed after the early debug generation pass
32006 dwarf2out_early_finish (const char *filename)
32009 char dl_section_ref[MAX_ARTIFICIAL_LABEL_BYTES];
32011 /* PCH might result in DW_AT_producer string being restored from the
32012 header compilation, so always fill it with empty string initially
32013 and overwrite only here. */
32014 dw_attr_node *producer = get_AT (comp_unit_die (), DW_AT_producer);
32015 producer_string = gen_producer_string ();
32016 producer->dw_attr_val.v.val_str->refcount--;
32017 producer->dw_attr_val.v.val_str = find_AT_string (producer_string);
32019 /* Add the name for the main input file now. We delayed this from
32020 dwarf2out_init to avoid complications with PCH. */
32021 add_name_attribute (comp_unit_die (), remap_debug_filename (filename));
32022 add_comp_dir_attribute (comp_unit_die ());
32024 /* When emitting DWARF5 .debug_line_str, move DW_AT_name and
32025 DW_AT_comp_dir into .debug_line_str section. */
32026 if (!output_asm_line_debug_info ()
32027 && dwarf_version >= 5
32028 && DWARF5_USE_DEBUG_LINE_STR)
32030 for (int i = 0; i < 2; i++)
32032 dw_attr_node *a = get_AT (comp_unit_die (),
32033 i ? DW_AT_comp_dir : DW_AT_name);
32035 || AT_class (a) != dw_val_class_str
32036 || strlen (AT_string (a)) + 1 <= DWARF_OFFSET_SIZE)
32039 if (! debug_line_str_hash)
32040 debug_line_str_hash
32041 = hash_table<indirect_string_hasher>::create_ggc (10);
32043 struct indirect_string_node *node
32044 = find_AT_string_in_table (AT_string (a), debug_line_str_hash);
32045 set_indirect_string (node);
32046 node->form = DW_FORM_line_strp;
32047 a->dw_attr_val.v.val_str->refcount--;
32048 a->dw_attr_val.v.val_str = node;
32052 /* With LTO early dwarf was really finished at compile-time, so make
32053 sure to adjust the phase after annotating the LTRANS CU DIE. */
32056 early_dwarf_finished = true;
32059 fprintf (dump_file, "LTO EARLY DWARF for %s\n", filename);
32060 print_die (comp_unit_die (), dump_file);
32065 /* Walk through the list of incomplete types again, trying once more to
32066 emit full debugging info for them. */
32067 retry_incomplete_types ();
32069 /* The point here is to flush out the limbo list so that it is empty
32070 and we don't need to stream it for LTO. */
32071 flush_limbo_die_list ();
32073 gen_scheduled_generic_parms_dies ();
32074 gen_remaining_tmpl_value_param_die_attribute ();
32076 /* Add DW_AT_linkage_name for all deferred DIEs. */
32077 for (limbo_die_node *node = deferred_asm_name; node; node = node->next)
32079 tree decl = node->created_for;
32080 if (DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
32081 /* A missing DECL_ASSEMBLER_NAME can be a constant DIE that
32082 ended up in deferred_asm_name before we knew it was
32083 constant and never written to disk. */
32084 && DECL_ASSEMBLER_NAME (decl))
32086 add_linkage_attr (node->die, decl);
32087 move_linkage_attr (node->die);
32090 deferred_asm_name = NULL;
32092 if (flag_eliminate_unused_debug_types)
32093 prune_unused_types ();
32095 /* Generate separate COMDAT sections for type DIEs. */
32096 if (use_debug_types)
32098 break_out_comdat_types (comp_unit_die ());
32100 /* Each new type_unit DIE was added to the limbo die list when created.
32101 Since these have all been added to comdat_type_list, clear the
32103 limbo_die_list = NULL;
32105 /* For each new comdat type unit, copy declarations for incomplete
32106 types to make the new unit self-contained (i.e., no direct
32107 references to the main compile unit). */
32108 for (comdat_type_node *ctnode = comdat_type_list;
32109 ctnode != NULL; ctnode = ctnode->next)
32110 copy_decls_for_unworthy_types (ctnode->root_die);
32111 copy_decls_for_unworthy_types (comp_unit_die ());
32113 /* In the process of copying declarations from one unit to another,
32114 we may have left some declarations behind that are no longer
32115 referenced. Prune them. */
32116 prune_unused_types ();
32119 /* Traverse the DIE's and note DIEs with DW_OP_GNU_variable_value still
32120 with dw_val_class_decl_ref operand. */
32121 note_variable_value (comp_unit_die ());
32122 for (limbo_die_node *node = cu_die_list; node; node = node->next)
32123 note_variable_value (node->die);
32124 for (comdat_type_node *ctnode = comdat_type_list; ctnode != NULL;
32125 ctnode = ctnode->next)
32126 note_variable_value (ctnode->root_die);
32127 for (limbo_die_node *node = limbo_die_list; node; node = node->next)
32128 note_variable_value (node->die);
32130 /* The AT_pubnames attribute needs to go in all skeleton dies, including
32131 both the main_cu and all skeleton TUs. Making this call unconditional
32132 would end up either adding a second copy of the AT_pubnames attribute, or
32133 requiring a special case in add_top_level_skeleton_die_attrs. */
32134 if (!dwarf_split_debug_info)
32135 add_AT_pubnames (comp_unit_die ());
32137 /* The early debug phase is now finished. */
32138 early_dwarf_finished = true;
32141 fprintf (dump_file, "EARLY DWARF for %s\n", filename);
32142 print_die (comp_unit_die (), dump_file);
32145 /* Do not generate DWARF assembler now when not producing LTO bytecode. */
32146 if ((!flag_generate_lto && !flag_generate_offload)
32147 /* FIXME: Disable debug info generation for (PE-)COFF targets since the
32148 copy_lto_debug_sections operation of the simple object support in
32149 libiberty is not implemented for them yet. */
32150 || TARGET_PECOFF || TARGET_COFF)
32153 /* Now as we are going to output for LTO initialize sections and labels
32154 to the LTO variants. We don't need a random-seed postfix as other
32155 LTO sections as linking the LTO debug sections into one in a partial
32157 init_sections_and_labels (true);
32159 /* The output below is modeled after dwarf2out_finish with all
32160 location related output removed and some LTO specific changes.
32161 Some refactoring might make both smaller and easier to match up. */
32163 /* Traverse the DIE's and add sibling attributes to those DIE's
32164 that have children. */
32165 add_sibling_attributes (comp_unit_die ());
32166 for (limbo_die_node *node = limbo_die_list; node; node = node->next)
32167 add_sibling_attributes (node->die);
32168 for (comdat_type_node *ctnode = comdat_type_list;
32169 ctnode != NULL; ctnode = ctnode->next)
32170 add_sibling_attributes (ctnode->root_die);
32172 /* AIX Assembler inserts the length, so adjust the reference to match the
32173 offset expected by debuggers. */
32174 strcpy (dl_section_ref, debug_line_section_label);
32175 if (XCOFF_DEBUGGING_INFO)
32176 strcat (dl_section_ref, DWARF_INITIAL_LENGTH_SIZE_STR);
32178 if (debug_info_level >= DINFO_LEVEL_TERSE)
32179 add_AT_lineptr (comp_unit_die (), DW_AT_stmt_list, dl_section_ref);
32182 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE,
32183 macinfo_section_label);
32185 save_macinfo_strings ();
32187 if (dwarf_split_debug_info)
32189 unsigned int index = 0;
32190 debug_str_hash->traverse_noresize<unsigned int *, index_string> (&index);
32193 /* Output all of the compilation units. We put the main one last so that
32194 the offsets are available to output_pubnames. */
32195 for (limbo_die_node *node = limbo_die_list; node; node = node->next)
32196 output_comp_unit (node->die, 0, NULL);
32198 hash_table<comdat_type_hasher> comdat_type_table (100);
32199 for (comdat_type_node *ctnode = comdat_type_list;
32200 ctnode != NULL; ctnode = ctnode->next)
32202 comdat_type_node **slot = comdat_type_table.find_slot (ctnode, INSERT);
32204 /* Don't output duplicate types. */
32205 if (*slot != HTAB_EMPTY_ENTRY)
32208 /* Add a pointer to the line table for the main compilation unit
32209 so that the debugger can make sense of DW_AT_decl_file
32211 if (debug_info_level >= DINFO_LEVEL_TERSE)
32212 add_AT_lineptr (ctnode->root_die, DW_AT_stmt_list,
32213 (!dwarf_split_debug_info
32214 ? debug_line_section_label
32215 : debug_skeleton_line_section_label));
32217 output_comdat_type_unit (ctnode, true);
32221 /* Stick a unique symbol to the main debuginfo section. */
32222 compute_comp_unit_symbol (comp_unit_die ());
32224 /* Output the main compilation unit. We always need it if only for
32226 output_comp_unit (comp_unit_die (), true, NULL);
32228 /* Output the abbreviation table. */
32229 if (vec_safe_length (abbrev_die_table) != 1)
32231 switch_to_section (debug_abbrev_section);
32232 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
32233 output_abbrev_section ();
32236 /* Have to end the macro section. */
32239 /* We have to save macinfo state if we need to output it again
32240 for the FAT part of the object. */
32241 vec<macinfo_entry, va_gc> *saved_macinfo_table = macinfo_table;
32242 if (flag_fat_lto_objects)
32243 macinfo_table = macinfo_table->copy ();
32245 switch_to_section (debug_macinfo_section);
32246 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
32247 output_macinfo (debug_line_section_label, true);
32248 dw2_asm_output_data (1, 0, "End compilation unit");
32250 if (flag_fat_lto_objects)
32252 vec_free (macinfo_table);
32253 macinfo_table = saved_macinfo_table;
32257 /* Emit a skeleton debug_line section. */
32258 switch_to_section (debug_line_section);
32259 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
32260 output_line_info (true);
32262 /* If we emitted any indirect strings, output the string table too. */
32263 if (debug_str_hash || skeleton_debug_str_hash)
32264 output_indirect_strings ();
32265 if (debug_line_str_hash)
32267 switch_to_section (debug_line_str_section);
32268 const enum dwarf_form form = DW_FORM_line_strp;
32269 debug_line_str_hash->traverse<enum dwarf_form,
32270 output_indirect_string> (form);
32273 /* Switch back to the text section. */
32274 switch_to_section (text_section);
32277 /* Reset all state within dwarf2out.c so that we can rerun the compiler
32278 within the same process. For use by toplev::finalize. */
32281 dwarf2out_c_finalize (void)
32283 last_var_location_insn = NULL;
32284 cached_next_real_insn = NULL;
32285 used_rtx_array = NULL;
32286 incomplete_types = NULL;
32287 debug_info_section = NULL;
32288 debug_skeleton_info_section = NULL;
32289 debug_abbrev_section = NULL;
32290 debug_skeleton_abbrev_section = NULL;
32291 debug_aranges_section = NULL;
32292 debug_addr_section = NULL;
32293 debug_macinfo_section = NULL;
32294 debug_line_section = NULL;
32295 debug_skeleton_line_section = NULL;
32296 debug_loc_section = NULL;
32297 debug_pubnames_section = NULL;
32298 debug_pubtypes_section = NULL;
32299 debug_str_section = NULL;
32300 debug_line_str_section = NULL;
32301 debug_str_dwo_section = NULL;
32302 debug_str_offsets_section = NULL;
32303 debug_ranges_section = NULL;
32304 debug_frame_section = NULL;
32306 debug_str_hash = NULL;
32307 debug_line_str_hash = NULL;
32308 skeleton_debug_str_hash = NULL;
32309 dw2_string_counter = 0;
32310 have_multiple_function_sections = false;
32311 text_section_used = false;
32312 cold_text_section_used = false;
32313 cold_text_section = NULL;
32314 current_unit_personality = NULL;
32316 early_dwarf = false;
32317 early_dwarf_finished = false;
32319 next_die_offset = 0;
32320 single_comp_unit_die = NULL;
32321 comdat_type_list = NULL;
32322 limbo_die_list = NULL;
32324 decl_die_table = NULL;
32325 common_block_die_table = NULL;
32326 decl_loc_table = NULL;
32327 call_arg_locations = NULL;
32328 call_arg_loc_last = NULL;
32329 call_site_count = -1;
32330 tail_call_site_count = -1;
32331 cached_dw_loc_list_table = NULL;
32332 abbrev_die_table = NULL;
32333 delete dwarf_proc_stack_usage_map;
32334 dwarf_proc_stack_usage_map = NULL;
32335 line_info_label_num = 0;
32336 cur_line_info_table = NULL;
32337 text_section_line_info = NULL;
32338 cold_text_section_line_info = NULL;
32339 separate_line_info = NULL;
32340 info_section_emitted = false;
32341 pubname_table = NULL;
32342 pubtype_table = NULL;
32343 macinfo_table = NULL;
32344 ranges_table = NULL;
32345 ranges_by_label = NULL;
32347 have_location_lists = false;
32350 last_emitted_file = NULL;
32352 tmpl_value_parm_die_table = NULL;
32353 generic_type_instances = NULL;
32354 frame_pointer_fb_offset = 0;
32355 frame_pointer_fb_offset_valid = false;
32356 base_types.release ();
32357 XDELETEVEC (producer_string);
32358 producer_string = NULL;
32361 #include "gt-dwarf2out.h"