1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992-2023 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 "dwarf2ctf.h"
83 #include "dwarf2asm.h"
86 #include "tree-pretty-print.h"
87 #include "print-rtl.h"
89 #include "common/common-target.h"
90 #include "langhooks.h"
95 #include "gdb/gdb-index.h"
97 #include "stringpool.h"
99 #include "file-prefix-map.h" /* remap_debug_filename() */
101 static void dwarf2out_source_line (unsigned int, unsigned int, const char *,
103 static rtx_insn
*last_var_location_insn
;
104 static rtx_insn
*cached_next_real_insn
;
105 static void dwarf2out_decl (tree
);
106 static bool is_redundant_typedef (const_tree
);
108 #ifndef XCOFF_DEBUGGING_INFO
109 #define XCOFF_DEBUGGING_INFO 0
112 #ifndef HAVE_XCOFF_DWARF_EXTRAS
113 #define HAVE_XCOFF_DWARF_EXTRAS 0
116 #ifdef VMS_DEBUGGING_INFO
117 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
119 /* Define this macro to be a nonzero value if the directory specifications
120 which are output in the debug info should end with a separator. */
121 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
122 /* Define this macro to evaluate to a nonzero value if GCC should refrain
123 from generating indirect strings in DWARF2 debug information, for instance
124 if your target is stuck with an old version of GDB that is unable to
125 process them properly or uses VMS Debug. */
126 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
128 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
129 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
132 /* ??? Poison these here until it can be done generically. They've been
133 totally replaced in this file; make sure it stays that way. */
134 #undef DWARF2_UNWIND_INFO
135 #undef DWARF2_FRAME_INFO
136 #if (GCC_VERSION >= 3000)
137 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
140 /* The size of the target's pointer type. */
142 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
145 /* Array of RTXes referenced by the debugging information, which therefore
146 must be kept around forever. */
147 static GTY(()) vec
<rtx
, va_gc
> *used_rtx_array
;
149 /* A pointer to the base of a list of incomplete types which might be
150 completed at some later time. incomplete_types_list needs to be a
151 vec<tree, va_gc> *because we want to tell the garbage collector about
153 static GTY(()) vec
<tree
, va_gc
> *incomplete_types
;
155 /* Pointers to various DWARF2 sections. */
156 static GTY(()) section
*debug_info_section
;
157 static GTY(()) section
*debug_skeleton_info_section
;
158 static GTY(()) section
*debug_abbrev_section
;
159 static GTY(()) section
*debug_skeleton_abbrev_section
;
160 static GTY(()) section
*debug_aranges_section
;
161 static GTY(()) section
*debug_addr_section
;
162 static GTY(()) section
*debug_macinfo_section
;
163 static const char *debug_macinfo_section_name
;
164 static unsigned macinfo_label_base
= 1;
165 static GTY(()) section
*debug_line_section
;
166 static GTY(()) section
*debug_skeleton_line_section
;
167 static GTY(()) section
*debug_loc_section
;
168 static GTY(()) section
*debug_pubnames_section
;
169 static GTY(()) section
*debug_pubtypes_section
;
170 static GTY(()) section
*debug_str_section
;
171 static GTY(()) section
*debug_line_str_section
;
172 static GTY(()) section
*debug_str_dwo_section
;
173 static GTY(()) section
*debug_str_offsets_section
;
174 static GTY(()) section
*debug_ranges_section
;
175 static GTY(()) section
*debug_ranges_dwo_section
;
176 static GTY(()) section
*debug_frame_section
;
178 /* Maximum size (in bytes) of an artificially generated label. */
179 #define MAX_ARTIFICIAL_LABEL_BYTES 40
181 /* According to the (draft) DWARF 3 specification, the initial length
182 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
183 bytes are 0xffffffff, followed by the length stored in the next 8
186 However, the SGI/MIPS ABI uses an initial length which is equal to
187 dwarf_offset_size. It is defined (elsewhere) accordingly. */
189 #ifndef DWARF_INITIAL_LENGTH_SIZE
190 #define DWARF_INITIAL_LENGTH_SIZE (dwarf_offset_size == 4 ? 4 : 12)
193 #ifndef DWARF_INITIAL_LENGTH_SIZE_STR
194 #define DWARF_INITIAL_LENGTH_SIZE_STR (dwarf_offset_size == 4 ? "-4" : "-12")
197 /* Round SIZE up to the nearest BOUNDARY. */
198 #define DWARF_ROUND(SIZE,BOUNDARY) \
199 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
201 /* CIE identifier. */
202 #if HOST_BITS_PER_WIDE_INT >= 64
203 #define DWARF_CIE_ID \
204 (unsigned HOST_WIDE_INT) (dwarf_offset_size == 4 ? DW_CIE_ID : DW64_CIE_ID)
206 #define DWARF_CIE_ID DW_CIE_ID
210 /* A vector for a table that contains frame description
211 information for each routine. */
212 #define NOT_INDEXED (-1U)
213 #define NO_INDEX_ASSIGNED (-2U)
215 static GTY(()) vec
<dw_fde_ref
, va_gc
> *fde_vec
;
217 struct GTY((for_user
)) indirect_string_node
{
219 unsigned int refcount
;
220 enum dwarf_form form
;
225 struct indirect_string_hasher
: ggc_ptr_hash
<indirect_string_node
>
227 typedef const char *compare_type
;
229 static hashval_t
hash (indirect_string_node
*);
230 static bool equal (indirect_string_node
*, const char *);
233 static GTY (()) hash_table
<indirect_string_hasher
> *debug_str_hash
;
235 static GTY (()) hash_table
<indirect_string_hasher
> *debug_line_str_hash
;
237 /* With split_debug_info, both the comp_dir and dwo_name go in the
238 main object file, rather than the dwo, similar to the force_direct
239 parameter elsewhere but with additional complications:
241 1) The string is needed in both the main object file and the dwo.
242 That is, the comp_dir and dwo_name will appear in both places.
244 2) Strings can use four forms: DW_FORM_string, DW_FORM_strp,
245 DW_FORM_line_strp or DW_FORM_strx/GNU_str_index.
247 3) GCC chooses the form to use late, depending on the size and
250 Rather than forcing the all debug string handling functions and
251 callers to deal with these complications, simply use a separate,
252 special-cased string table for any attribute that should go in the
253 main object file. This limits the complexity to just the places
256 static GTY (()) hash_table
<indirect_string_hasher
> *skeleton_debug_str_hash
;
258 static GTY(()) int dw2_string_counter
;
260 /* True if the compilation unit places functions in more than one section. */
261 static GTY(()) bool have_multiple_function_sections
= false;
263 /* The default cold text section. */
264 static GTY(()) section
*cold_text_section
;
266 /* True if currently in text section. */
267 static GTY(()) bool in_text_section_p
= false;
269 /* Last debug-on location in corresponding section. */
270 static GTY(()) const char *last_text_label
;
271 static GTY(()) const char *last_cold_label
;
273 /* Mark debug-on/off locations per section.
274 NULL means the section is not used at all. */
275 static GTY(()) vec
<const char *, va_gc
> *switch_text_ranges
;
276 static GTY(()) vec
<const char *, va_gc
> *switch_cold_ranges
;
278 /* The DIE for C++14 'auto' in a function return type. */
279 static GTY(()) dw_die_ref auto_die
;
281 /* The DIE for C++14 'decltype(auto)' in a function return type. */
282 static GTY(()) dw_die_ref decltype_auto_die
;
284 /* Forward declarations for functions defined in this file. */
286 static void output_call_frame_info (int);
288 /* Personality decl of current unit. Used only when assembler does not support
290 static GTY(()) rtx current_unit_personality
;
292 /* Whether an eh_frame section is required. */
293 static GTY(()) bool do_eh_frame
= false;
295 /* .debug_rnglists next index. */
296 static unsigned int rnglist_idx
;
298 /* Data and reference forms for relocatable data. */
299 #define DW_FORM_data (dwarf_offset_size == 8 ? DW_FORM_data8 : DW_FORM_data4)
300 #define DW_FORM_ref (dwarf_offset_size == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
302 #ifndef DEBUG_FRAME_SECTION
303 #define DEBUG_FRAME_SECTION ".debug_frame"
306 #ifndef FUNC_BEGIN_LABEL
307 #define FUNC_BEGIN_LABEL "LFB"
310 #ifndef FUNC_SECOND_SECT_LABEL
311 #define FUNC_SECOND_SECT_LABEL "LFSB"
314 #ifndef FUNC_END_LABEL
315 #define FUNC_END_LABEL "LFE"
318 #ifndef PROLOGUE_END_LABEL
319 #define PROLOGUE_END_LABEL "LPE"
322 #ifndef EPILOGUE_BEGIN_LABEL
323 #define EPILOGUE_BEGIN_LABEL "LEB"
326 #ifndef FRAME_BEGIN_LABEL
327 #define FRAME_BEGIN_LABEL "Lframe"
329 #define CIE_AFTER_SIZE_LABEL "LSCIE"
330 #define CIE_END_LABEL "LECIE"
331 #define FDE_LABEL "LSFDE"
332 #define FDE_AFTER_SIZE_LABEL "LASFDE"
333 #define FDE_END_LABEL "LEFDE"
334 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
335 #define LINE_NUMBER_END_LABEL "LELT"
336 #define LN_PROLOG_AS_LABEL "LASLTP"
337 #define LN_PROLOG_END_LABEL "LELTP"
338 #define DIE_LABEL_PREFIX "DW"
340 /* Match the base name of a file to the base name of a compilation unit. */
343 matches_main_base (const char *path
)
345 /* Cache the last query. */
346 static const char *last_path
= NULL
;
347 static bool last_match
= false;
348 if (path
!= last_path
)
351 int length
= base_of_path (path
, &base
);
353 last_match
= (length
== main_input_baselength
354 && memcmp (base
, main_input_basename
, length
) == 0);
359 #ifdef DEBUG_DEBUG_STRUCT
362 dump_struct_debug (tree type
, enum debug_info_usage usage
,
363 enum debug_struct_file criterion
, int generic
,
364 bool matches
, bool result
)
366 /* Find the type name. */
367 tree type_decl
= TYPE_STUB_DECL (type
);
369 const char *name
= 0;
370 if (TREE_CODE (t
) == TYPE_DECL
)
373 name
= IDENTIFIER_POINTER (t
);
375 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
377 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
378 matches
? "bas" : "hdr",
379 generic
? "gen" : "ord",
380 usage
== DINFO_USAGE_DFN
? ";" :
381 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
383 (void*) type_decl
, name
);
386 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
387 dump_struct_debug (type, usage, criterion, generic, matches, result)
391 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
396 /* Get the number of HOST_WIDE_INTs needed to represent the precision
400 get_full_len (const dw_wide_int
&op
)
402 return CEIL (op
.get_precision (), HOST_BITS_PER_WIDE_INT
);
406 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
408 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
411 enum debug_struct_file criterion
;
413 bool generic
= lang_hooks
.types
.generic_p (type
);
416 criterion
= debug_struct_generic
[usage
];
418 criterion
= debug_struct_ordinary
[usage
];
420 if (criterion
== DINFO_STRUCT_FILE_NONE
)
421 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
422 if (criterion
== DINFO_STRUCT_FILE_ANY
)
423 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
425 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
427 if (type_decl
!= NULL
)
429 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
430 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
432 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
433 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
436 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
439 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
440 switch to the data section instead, and write out a synthetic start label
441 for collect2 the first time around. */
444 switch_to_eh_frame_section (bool back ATTRIBUTE_UNUSED
)
446 if (eh_frame_section
== 0)
450 if (EH_TABLES_CAN_BE_READ_ONLY
)
456 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
458 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
460 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
463 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
464 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
465 && (per_encoding
& 0x70) != DW_EH_PE_absptr
466 && (per_encoding
& 0x70) != DW_EH_PE_aligned
467 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
468 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
469 ? 0 : SECTION_WRITE
);
472 flags
= SECTION_WRITE
;
474 #ifdef EH_FRAME_SECTION_NAME
475 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
477 eh_frame_section
= ((flags
== SECTION_WRITE
)
478 ? data_section
: readonly_data_section
);
479 #endif /* EH_FRAME_SECTION_NAME */
482 switch_to_section (eh_frame_section
);
484 #ifdef EH_FRAME_THROUGH_COLLECT2
485 /* We have no special eh_frame section. Emit special labels to guide
489 tree label
= get_file_function_name ("F");
490 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
491 targetm
.asm_out
.globalize_label (asm_out_file
,
492 IDENTIFIER_POINTER (label
));
493 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
498 /* Switch [BACK] to the eh or debug frame table section, depending on
502 switch_to_frame_table_section (int for_eh
, bool back
)
505 switch_to_eh_frame_section (back
);
508 if (!debug_frame_section
)
509 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
510 SECTION_DEBUG
, NULL
);
511 switch_to_section (debug_frame_section
);
515 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
517 enum dw_cfi_oprnd_type
518 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
523 case DW_CFA_GNU_window_save
:
524 case DW_CFA_remember_state
:
525 case DW_CFA_restore_state
:
526 return dw_cfi_oprnd_unused
;
529 case DW_CFA_advance_loc1
:
530 case DW_CFA_advance_loc2
:
531 case DW_CFA_advance_loc4
:
532 case DW_CFA_MIPS_advance_loc8
:
533 return dw_cfi_oprnd_addr
;
536 case DW_CFA_offset_extended
:
538 case DW_CFA_offset_extended_sf
:
539 case DW_CFA_def_cfa_sf
:
541 case DW_CFA_restore_extended
:
542 case DW_CFA_undefined
:
543 case DW_CFA_same_value
:
544 case DW_CFA_def_cfa_register
:
545 case DW_CFA_register
:
546 case DW_CFA_expression
:
547 case DW_CFA_val_expression
:
548 return dw_cfi_oprnd_reg_num
;
550 case DW_CFA_def_cfa_offset
:
551 case DW_CFA_GNU_args_size
:
552 case DW_CFA_def_cfa_offset_sf
:
553 return dw_cfi_oprnd_offset
;
555 case DW_CFA_def_cfa_expression
:
556 return dw_cfi_oprnd_loc
;
563 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
565 enum dw_cfi_oprnd_type
566 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
571 case DW_CFA_def_cfa_sf
:
573 case DW_CFA_offset_extended_sf
:
574 case DW_CFA_offset_extended
:
575 return dw_cfi_oprnd_offset
;
577 case DW_CFA_register
:
578 return dw_cfi_oprnd_reg_num
;
580 case DW_CFA_expression
:
581 case DW_CFA_val_expression
:
582 return dw_cfi_oprnd_loc
;
584 case DW_CFA_def_cfa_expression
:
585 return dw_cfi_oprnd_cfa_loc
;
588 return dw_cfi_oprnd_unused
;
592 /* Output one FDE. */
595 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
596 char *section_start_label
, int fde_encoding
, char *augmentation
,
597 bool any_lsda_needed
, int lsda_encoding
)
599 const char *begin
, *end
;
600 static unsigned int j
;
601 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
603 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
605 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
607 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
608 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
609 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
611 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4 && !for_eh
)
612 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
613 " indicating 64-bit DWARF extension");
614 dw2_asm_output_delta (for_eh
? 4 : dwarf_offset_size
, l2
, l1
,
617 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
620 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
622 dw2_asm_output_offset (dwarf_offset_size
, section_start_label
,
623 debug_frame_section
, "FDE CIE offset");
625 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
626 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
630 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
631 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
632 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
633 "FDE initial location");
634 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
635 end
, begin
, "FDE address range");
639 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
640 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
647 int size
= size_of_encoded_value (lsda_encoding
);
649 if (lsda_encoding
== DW_EH_PE_aligned
)
651 int offset
= ( 4 /* Length */
653 + 2 * size_of_encoded_value (fde_encoding
)
654 + 1 /* Augmentation size */ );
655 int pad
= -offset
& (PTR_SIZE
- 1);
658 gcc_assert (size_of_uleb128 (size
) == 1);
661 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
663 if (fde
->uses_eh_lsda
)
665 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
666 fde
->funcdef_number
);
667 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
668 gen_rtx_SYMBOL_REF (Pmode
, l1
),
670 "Language Specific Data Area");
674 if (lsda_encoding
== DW_EH_PE_aligned
)
675 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
676 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
677 "Language Specific Data Area (none)");
681 dw2_asm_output_data_uleb128 (0, "Augmentation size");
684 /* Loop through the Call Frame Instructions associated with this FDE. */
685 fde
->dw_fde_current_label
= begin
;
687 size_t from
, until
, i
;
690 until
= vec_safe_length (fde
->dw_fde_cfi
);
692 if (fde
->dw_fde_second_begin
== NULL
)
695 until
= fde
->dw_fde_switch_cfi_index
;
697 from
= fde
->dw_fde_switch_cfi_index
;
699 for (i
= from
; i
< until
; i
++)
700 output_cfi ((*fde
->dw_fde_cfi
)[i
], fde
, for_eh
);
703 /* If we are to emit a ref/link from function bodies to their frame tables,
704 do it now. This is typically performed to make sure that tables
705 associated with functions are dragged with them and not discarded in
706 garbage collecting links. We need to do this on a per function basis to
707 cope with -ffunction-sections. */
709 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
710 /* Switch to the function section, emit the ref to the tables, and
711 switch *back* into the table section. */
712 switch_to_section (function_section (fde
->decl
));
713 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
714 switch_to_frame_table_section (for_eh
, true);
717 /* Pad the FDE out to an address sized boundary. */
718 ASM_OUTPUT_ALIGN (asm_out_file
,
719 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
720 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
725 /* Return true if frame description entry FDE is needed for EH. */
728 fde_needed_for_eh_p (dw_fde_ref fde
)
730 if (flag_asynchronous_unwind_tables
)
733 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
736 if (fde
->uses_eh_lsda
)
739 /* If exceptions are enabled, we have collected nothrow info. */
740 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
746 /* Output the call frame information used to record information
747 that relates to calculating the frame pointer, and records the
748 location of saved registers. */
751 output_call_frame_info (int for_eh
)
756 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
757 char section_start_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
758 bool any_lsda_needed
= false;
759 char augmentation
[6];
760 int augmentation_size
;
761 int fde_encoding
= DW_EH_PE_absptr
;
762 int per_encoding
= DW_EH_PE_absptr
;
763 int lsda_encoding
= DW_EH_PE_absptr
;
765 rtx personality
= NULL
;
768 /* Don't emit a CIE if there won't be any FDEs. */
772 /* Nothing to do if the assembler's doing it all. */
773 if (dwarf2out_do_cfi_asm ())
776 /* If we don't have any functions we'll want to unwind out of, don't emit
777 any EH unwind information. If we make FDEs linkonce, we may have to
778 emit an empty label for an FDE that wouldn't otherwise be emitted. We
779 want to avoid having an FDE kept around when the function it refers to
780 is discarded. Example where this matters: a primary function template
781 in C++ requires EH information, an explicit specialization doesn't. */
784 bool any_eh_needed
= false;
786 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
788 if (fde
->uses_eh_lsda
)
789 any_eh_needed
= any_lsda_needed
= true;
790 else if (fde_needed_for_eh_p (fde
))
791 any_eh_needed
= true;
792 else if (TARGET_USES_WEAK_UNWIND_INFO
)
793 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, 1, 1);
800 /* We're going to be generating comments, so turn on app. */
804 /* Switch to the proper frame section, first time. */
805 switch_to_frame_table_section (for_eh
, false);
807 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
808 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
810 /* Output the CIE. */
811 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
812 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
813 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
815 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4 && !for_eh
)
816 dw2_asm_output_data (4, 0xffffffff,
817 "Initial length escape value indicating 64-bit DWARF extension");
818 dw2_asm_output_delta (for_eh
? 4 : dwarf_offset_size
, l2
, l1
,
819 "Length of Common Information Entry");
821 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
823 /* Now that the CIE pointer is PC-relative for EH,
824 use 0 to identify the CIE. */
825 dw2_asm_output_data ((for_eh
? 4 : dwarf_offset_size
),
826 (for_eh
? 0 : DWARF_CIE_ID
),
827 "CIE Identifier Tag");
829 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
830 use CIE version 1, unless that would produce incorrect results
831 due to overflowing the return register column. */
832 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
834 if (return_reg
>= 256 || dwarf_version
> 2)
836 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
839 augmentation_size
= 0;
841 personality
= current_unit_personality
;
847 z Indicates that a uleb128 is present to size the
848 augmentation section.
849 L Indicates the encoding (and thus presence) of
850 an LSDA pointer in the FDE augmentation.
851 R Indicates a non-default pointer encoding for
853 P Indicates the presence of an encoding + language
854 personality routine in the CIE augmentation. */
856 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
857 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
858 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
860 p
= augmentation
+ 1;
864 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
865 assemble_external_libcall (personality
);
870 augmentation_size
+= 1;
872 if (fde_encoding
!= DW_EH_PE_absptr
)
875 augmentation_size
+= 1;
877 if (p
> augmentation
+ 1)
879 augmentation
[0] = 'z';
883 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
884 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
886 int offset
= ( 4 /* Length */
888 + 1 /* CIE version */
889 + strlen (augmentation
) + 1 /* Augmentation */
890 + size_of_uleb128 (1) /* Code alignment */
891 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
893 + 1 /* Augmentation size */
894 + 1 /* Personality encoding */ );
895 int pad
= -offset
& (PTR_SIZE
- 1);
897 augmentation_size
+= pad
;
899 /* Augmentations should be small, so there's scarce need to
900 iterate for a solution. Die if we exceed one uleb128 byte. */
901 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
905 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
906 if (dw_cie_version
>= 4)
908 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
909 dw2_asm_output_data (1, 0, "CIE Segment Size");
911 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
912 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
913 "CIE Data Alignment Factor");
915 if (dw_cie_version
== 1)
916 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
918 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
922 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
925 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
926 eh_data_format_name (per_encoding
));
927 dw2_asm_output_encoded_addr_rtx (per_encoding
,
933 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
934 eh_data_format_name (lsda_encoding
));
936 if (fde_encoding
!= DW_EH_PE_absptr
)
937 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
938 eh_data_format_name (fde_encoding
));
941 FOR_EACH_VEC_ELT (*cie_cfi_vec
, i
, cfi
)
942 output_cfi (cfi
, NULL
, for_eh
);
944 /* Pad the CIE out to an address sized boundary. */
945 ASM_OUTPUT_ALIGN (asm_out_file
,
946 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
947 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
949 /* Loop through all of the FDE's. */
950 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
954 /* Don't emit EH unwind info for leaf functions that don't need it. */
955 if (for_eh
&& !fde_needed_for_eh_p (fde
))
958 for (k
= 0; k
< (fde
->dw_fde_second_begin
? 2 : 1); k
++)
959 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
960 augmentation
, any_lsda_needed
, lsda_encoding
);
963 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
964 dw2_asm_output_data (4, 0, "End of Table");
966 /* Turn off app to make assembly quicker. */
971 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
974 dwarf2out_do_cfi_startproc (bool second
)
979 fprintf (asm_out_file
, "\t.cfi_startproc\n");
981 targetm
.asm_out
.post_cfi_startproc (asm_out_file
, current_function_decl
);
983 /* .cfi_personality and .cfi_lsda are only relevant to DWARF2
985 if (targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
)
988 rtx personality
= get_personality_function (current_function_decl
);
992 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
995 /* ??? The GAS support isn't entirely consistent. We have to
996 handle indirect support ourselves, but PC-relative is done
997 in the assembler. Further, the assembler can't handle any
998 of the weirder relocation types. */
999 if (enc
& DW_EH_PE_indirect
)
1001 if (targetm
.asm_out
.make_eh_symbol_indirect
!= NULL
)
1002 ref
= targetm
.asm_out
.make_eh_symbol_indirect (ref
, true);
1004 ref
= dw2_force_const_mem (ref
, true);
1007 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
1008 output_addr_const (asm_out_file
, ref
);
1009 fputc ('\n', asm_out_file
);
1012 if (crtl
->uses_eh_lsda
)
1014 char lab
[MAX_ARTIFICIAL_LABEL_BYTES
];
1016 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1017 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
1018 current_function_funcdef_no
);
1019 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
1020 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
1022 if (enc
& DW_EH_PE_indirect
)
1024 if (targetm
.asm_out
.make_eh_symbol_indirect
!= NULL
)
1025 ref
= targetm
.asm_out
.make_eh_symbol_indirect (ref
, true);
1027 ref
= dw2_force_const_mem (ref
, true);
1030 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
1031 output_addr_const (asm_out_file
, ref
);
1032 fputc ('\n', asm_out_file
);
1036 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
1037 this allocation may be done before pass_final. */
1040 dwarf2out_alloc_current_fde (void)
1044 fde
= ggc_cleared_alloc
<dw_fde_node
> ();
1045 fde
->decl
= current_function_decl
;
1046 fde
->funcdef_number
= current_function_funcdef_no
;
1047 fde
->fde_index
= vec_safe_length (fde_vec
);
1048 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
1049 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
1050 fde
->nothrow
= crtl
->nothrow
;
1051 fde
->drap_reg
= INVALID_REGNUM
;
1052 fde
->vdrap_reg
= INVALID_REGNUM
;
1054 /* Record the FDE associated with this function. */
1056 vec_safe_push (fde_vec
, fde
);
1061 /* Output a marker (i.e. a label) for the beginning of a function, before
1065 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1066 unsigned int column ATTRIBUTE_UNUSED
,
1067 const char *file ATTRIBUTE_UNUSED
)
1069 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1075 current_function_func_begin_label
= NULL
;
1077 do_frame
= dwarf2out_do_frame ();
1079 /* ??? current_function_func_begin_label is also used by except.cc for
1080 call-site information. We must emit this label if it might be used. */
1082 && (!flag_exceptions
1083 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1086 fnsec
= function_section (current_function_decl
);
1087 switch_to_section (fnsec
);
1088 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1089 current_function_funcdef_no
);
1090 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1091 current_function_funcdef_no
);
1092 dup_label
= xstrdup (label
);
1093 current_function_func_begin_label
= dup_label
;
1095 /* We can elide FDE allocation if we're not emitting frame unwind info. */
1099 /* Unlike the debug version, the EH version of frame unwind info is a per-
1100 function setting so we need to record whether we need it for the unit. */
1101 do_eh_frame
|= dwarf2out_do_eh_frame ();
1103 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1104 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1105 would include pass_dwarf2_frame. If we've not created the FDE yet,
1109 fde
= dwarf2out_alloc_current_fde ();
1111 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1112 fde
->dw_fde_begin
= dup_label
;
1113 fde
->dw_fde_current_label
= dup_label
;
1114 fde
->in_std_section
= (fnsec
== text_section
1115 || (cold_text_section
&& fnsec
== cold_text_section
));
1116 fde
->ignored_debug
= DECL_IGNORED_P (current_function_decl
);
1117 in_text_section_p
= fnsec
== text_section
;
1119 /* We only want to output line number information for the genuine dwarf2
1120 prologue case, not the eh frame case. */
1121 #ifdef DWARF2_DEBUGGING_INFO
1123 dwarf2out_source_line (line
, column
, file
, 0, true);
1126 if (dwarf2out_do_cfi_asm ())
1127 dwarf2out_do_cfi_startproc (false);
1130 rtx personality
= get_personality_function (current_function_decl
);
1131 if (!current_unit_personality
)
1132 current_unit_personality
= personality
;
1134 /* We cannot keep a current personality per function as without CFI
1135 asm, at the point where we emit the CFI data, there is no current
1136 function anymore. */
1137 if (personality
&& current_unit_personality
!= personality
)
1138 sorry ("multiple EH personalities are supported only with assemblers "
1139 "supporting %<.cfi_personality%> directive");
1143 /* Output a marker (i.e. a label) for the end of the generated code
1144 for a function prologue. This gets called *after* the prologue code has
1148 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1149 const char *file ATTRIBUTE_UNUSED
)
1151 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1153 /* Output a label to mark the endpoint of the code generated for this
1155 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1156 current_function_funcdef_no
);
1157 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1158 current_function_funcdef_no
);
1159 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1162 /* Output a marker (i.e. a label) for the beginning of the generated code
1163 for a function epilogue. This gets called *before* the prologue code has
1167 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1168 const char *file ATTRIBUTE_UNUSED
)
1170 dw_fde_ref fde
= cfun
->fde
;
1171 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1173 if (fde
->dw_fde_vms_begin_epilogue
)
1176 /* Output a label to mark the endpoint of the code generated for this
1178 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1179 current_function_funcdef_no
);
1180 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1181 current_function_funcdef_no
);
1182 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1185 /* Mark the ranges of non-debug subsections in the std text sections. */
1188 mark_ignored_debug_section (dw_fde_ref fde
, bool second
)
1191 const char *begin_label
, *end_label
;
1192 const char **last_end_label
;
1193 vec
<const char *, va_gc
> **switch_ranges
;
1197 std_section
= fde
->second_in_std_section
;
1198 begin_label
= fde
->dw_fde_second_begin
;
1199 end_label
= fde
->dw_fde_second_end
;
1203 std_section
= fde
->in_std_section
;
1204 begin_label
= fde
->dw_fde_begin
;
1205 end_label
= fde
->dw_fde_end
;
1211 if (in_text_section_p
)
1213 last_end_label
= &last_text_label
;
1214 switch_ranges
= &switch_text_ranges
;
1218 last_end_label
= &last_cold_label
;
1219 switch_ranges
= &switch_cold_ranges
;
1222 if (fde
->ignored_debug
)
1224 if (*switch_ranges
&& !(vec_safe_length (*switch_ranges
) & 1))
1225 vec_safe_push (*switch_ranges
, *last_end_label
);
1229 *last_end_label
= end_label
;
1231 if (!*switch_ranges
)
1232 vec_alloc (*switch_ranges
, 16);
1233 else if (vec_safe_length (*switch_ranges
) & 1)
1234 vec_safe_push (*switch_ranges
, begin_label
);
1238 /* Output a marker (i.e. a label) for the absolute end of the generated code
1239 for a function definition. This gets called *after* the epilogue code has
1243 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1244 const char *file ATTRIBUTE_UNUSED
)
1247 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1249 last_var_location_insn
= NULL
;
1250 cached_next_real_insn
= NULL
;
1252 if (dwarf2out_do_cfi_asm ())
1253 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1255 /* Output a label to mark the endpoint of the code generated for this
1257 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1258 current_function_funcdef_no
);
1259 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1261 gcc_assert (fde
!= NULL
);
1262 if (fde
->dw_fde_second_begin
== NULL
)
1263 fde
->dw_fde_end
= xstrdup (label
);
1265 mark_ignored_debug_section (fde
, fde
->dw_fde_second_begin
!= NULL
);
1269 dwarf2out_frame_finish (void)
1271 /* Output call frame information. */
1272 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1273 output_call_frame_info (0);
1275 /* Output another copy for the unwinder. */
1277 output_call_frame_info (1);
1280 static void var_location_switch_text_section (void);
1281 static void set_cur_line_info_table (section
*);
1284 dwarf2out_switch_text_section (void)
1286 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1288 dw_fde_ref fde
= cfun
->fde
;
1290 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1292 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_SECOND_SECT_LABEL
,
1293 current_function_funcdef_no
);
1295 fde
->dw_fde_second_begin
= ggc_strdup (label
);
1296 if (!in_cold_section_p
)
1298 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1299 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1303 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1304 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1306 have_multiple_function_sections
= true;
1308 if (dwarf2out_do_cfi_asm ())
1309 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1311 mark_ignored_debug_section (fde
, false);
1313 /* Now do the real section switch. */
1314 sect
= current_function_section ();
1315 switch_to_section (sect
);
1317 fde
->second_in_std_section
1318 = (sect
== text_section
1319 || (cold_text_section
&& sect
== cold_text_section
));
1320 in_text_section_p
= sect
== text_section
;
1322 if (dwarf2out_do_cfi_asm ())
1323 dwarf2out_do_cfi_startproc (true);
1325 var_location_switch_text_section ();
1327 if (cold_text_section
!= NULL
)
1328 set_cur_line_info_table (sect
);
1331 /* And now, the subset of the debugging information support code necessary
1332 for emitting location expressions. */
1334 /* Describe an entry into the .debug_addr section. */
1338 ate_kind_rtx_dtprel
,
1342 struct GTY((for_user
)) addr_table_entry
{
1344 unsigned int refcount
;
1346 union addr_table_entry_struct_union
1348 rtx
GTY ((tag ("0"))) rtl
;
1349 char * GTY ((tag ("1"))) label
;
1351 GTY ((desc ("%1.kind"))) addr
;
1354 typedef unsigned int var_loc_view
;
1356 /* Location lists are ranges + location descriptions for that range,
1357 so you can track variables that are in different places over
1358 their entire life. */
1359 typedef struct GTY(()) dw_loc_list_struct
{
1360 dw_loc_list_ref dw_loc_next
;
1361 const char *begin
; /* Label and addr_entry for start of range */
1362 addr_table_entry
*begin_entry
;
1363 const char *end
; /* Label for end of range */
1364 addr_table_entry
*end_entry
;
1365 char *ll_symbol
; /* Label for beginning of location list.
1366 Only on head of list. */
1367 char *vl_symbol
; /* Label for beginning of view list. Ditto. */
1368 const char *section
; /* Section this loclist is relative to */
1369 dw_loc_descr_ref expr
;
1370 var_loc_view vbegin
, vend
;
1372 /* True if all addresses in this and subsequent lists are known to be
1375 /* True if this list has been replaced by dw_loc_next. */
1377 /* True if it has been emitted into .debug_loc* / .debug_loclists*
1379 unsigned char emitted
: 1;
1380 /* True if hash field is index rather than hash value. */
1381 unsigned char num_assigned
: 1;
1382 /* True if .debug_loclists.dwo offset has been emitted for it already. */
1383 unsigned char offset_emitted
: 1;
1384 /* True if note_variable_value_in_expr has been called on it. */
1385 unsigned char noted_variable_value
: 1;
1386 /* True if the range should be emitted even if begin and end
1391 static dw_loc_descr_ref
int_loc_descriptor (poly_int64
);
1392 static dw_loc_descr_ref
uint_loc_descriptor (unsigned HOST_WIDE_INT
);
1394 /* Convert a DWARF stack opcode into its string name. */
1397 dwarf_stack_op_name (unsigned int op
)
1399 const char *name
= get_DW_OP_name (op
);
1404 return "OP_<unknown>";
1407 /* Return TRUE iff we're to output location view lists as a separate
1408 attribute next to the location lists, as an extension compatible
1409 with DWARF 2 and above. */
1412 dwarf2out_locviews_in_attribute ()
1414 return debug_variable_location_views
== 1;
1417 /* Return TRUE iff we're to output location view lists as part of the
1418 location lists, as proposed for standardization after DWARF 5. */
1421 dwarf2out_locviews_in_loclist ()
1423 #ifndef DW_LLE_view_pair
1426 return debug_variable_location_views
== -1;
1430 /* Return a pointer to a newly allocated location description. Location
1431 descriptions are simple expression terms that can be strung
1432 together to form more complicated location (address) descriptions. */
1434 static inline dw_loc_descr_ref
1435 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1436 unsigned HOST_WIDE_INT oprnd2
)
1438 dw_loc_descr_ref descr
= ggc_cleared_alloc
<dw_loc_descr_node
> ();
1440 descr
->dw_loc_opc
= op
;
1441 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1442 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1443 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1444 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1445 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1446 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1451 /* Add a location description term to a location description expression. */
1454 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1456 dw_loc_descr_ref
*d
;
1458 /* Find the end of the chain. */
1459 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1465 /* Compare two location operands for exact equality. */
1468 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1470 if (a
->val_class
!= b
->val_class
)
1472 switch (a
->val_class
)
1474 case dw_val_class_none
:
1476 case dw_val_class_addr
:
1477 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1479 case dw_val_class_offset
:
1480 case dw_val_class_unsigned_const
:
1481 case dw_val_class_const
:
1482 case dw_val_class_unsigned_const_implicit
:
1483 case dw_val_class_const_implicit
:
1484 case dw_val_class_range_list
:
1485 /* These are all HOST_WIDE_INT, signed or unsigned. */
1486 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1488 case dw_val_class_loc
:
1489 return a
->v
.val_loc
== b
->v
.val_loc
;
1490 case dw_val_class_loc_list
:
1491 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1492 case dw_val_class_view_list
:
1493 return a
->v
.val_view_list
== b
->v
.val_view_list
;
1494 case dw_val_class_die_ref
:
1495 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1496 case dw_val_class_fde_ref
:
1497 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1498 case dw_val_class_symview
:
1499 return strcmp (a
->v
.val_symbolic_view
, b
->v
.val_symbolic_view
) == 0;
1500 case dw_val_class_lbl_id
:
1501 case dw_val_class_lineptr
:
1502 case dw_val_class_macptr
:
1503 case dw_val_class_loclistsptr
:
1504 case dw_val_class_high_pc
:
1505 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1506 case dw_val_class_str
:
1507 return a
->v
.val_str
== b
->v
.val_str
;
1508 case dw_val_class_flag
:
1509 return a
->v
.val_flag
== b
->v
.val_flag
;
1510 case dw_val_class_file
:
1511 case dw_val_class_file_implicit
:
1512 return a
->v
.val_file
== b
->v
.val_file
;
1513 case dw_val_class_decl_ref
:
1514 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1516 case dw_val_class_const_double
:
1517 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1518 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1520 case dw_val_class_wide_int
:
1521 return *a
->v
.val_wide
== *b
->v
.val_wide
;
1523 case dw_val_class_vec
:
1525 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1526 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1528 return (a_len
== b_len
1529 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1532 case dw_val_class_data8
:
1533 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1535 case dw_val_class_vms_delta
:
1536 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1537 && !strcmp (a
->v
.val_vms_delta
.lbl2
, b
->v
.val_vms_delta
.lbl2
));
1539 case dw_val_class_discr_value
:
1540 return (a
->v
.val_discr_value
.pos
== b
->v
.val_discr_value
.pos
1541 && a
->v
.val_discr_value
.v
.uval
== b
->v
.val_discr_value
.v
.uval
);
1542 case dw_val_class_discr_list
:
1543 /* It makes no sense comparing two discriminant value lists. */
1549 /* Compare two location atoms for exact equality. */
1552 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1554 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1557 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1558 address size, but since we always allocate cleared storage it
1559 should be zero for other types of locations. */
1560 if (a
->dtprel
!= b
->dtprel
)
1563 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1564 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1567 /* Compare two complete location expressions for exact equality. */
1570 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1576 if (a
== NULL
|| b
== NULL
)
1578 if (!loc_descr_equal_p_1 (a
, b
))
1587 /* Add a constant POLY_OFFSET to a location expression. */
1590 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, poly_int64 poly_offset
)
1592 dw_loc_descr_ref loc
;
1595 gcc_assert (*list_head
!= NULL
);
1597 if (known_eq (poly_offset
, 0))
1600 /* Find the end of the chain. */
1601 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1604 HOST_WIDE_INT offset
;
1605 if (!poly_offset
.is_constant (&offset
))
1607 loc
->dw_loc_next
= int_loc_descriptor (poly_offset
);
1608 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_plus
, 0, 0));
1613 if (loc
->dw_loc_opc
== DW_OP_fbreg
1614 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1615 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1616 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1617 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1619 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1620 offset. Don't optimize if an signed integer overflow would happen. */
1622 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1623 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1626 else if (offset
> 0)
1627 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1632 = uint_loc_descriptor (-(unsigned HOST_WIDE_INT
) offset
);
1633 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1637 /* Return a pointer to a newly allocated location description for
1640 static inline dw_loc_descr_ref
1641 new_reg_loc_descr (unsigned int reg
, poly_int64 offset
)
1643 HOST_WIDE_INT const_offset
;
1644 if (offset
.is_constant (&const_offset
))
1647 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1650 return new_loc_descr (DW_OP_bregx
, reg
, const_offset
);
1654 dw_loc_descr_ref ret
= new_reg_loc_descr (reg
, 0);
1655 loc_descr_plus_const (&ret
, offset
);
1660 /* Add a constant OFFSET to a location list. */
1663 loc_list_plus_const (dw_loc_list_ref list_head
, poly_int64 offset
)
1666 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1667 loc_descr_plus_const (&d
->expr
, offset
);
1670 #define DWARF_REF_SIZE \
1671 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : dwarf_offset_size)
1673 /* The number of bits that can be encoded by largest DW_FORM_dataN.
1674 In DWARF4 and earlier it is DW_FORM_data8 with 64 bits, in DWARF5
1675 DW_FORM_data16 with 128 bits. */
1676 #define DWARF_LARGEST_DATA_FORM_BITS \
1677 (dwarf_version >= 5 ? 128 : 64)
1679 /* Utility inline function for construction of ops that were GNU extension
1681 static inline enum dwarf_location_atom
1682 dwarf_OP (enum dwarf_location_atom op
)
1686 case DW_OP_implicit_pointer
:
1687 if (dwarf_version
< 5)
1688 return DW_OP_GNU_implicit_pointer
;
1691 case DW_OP_entry_value
:
1692 if (dwarf_version
< 5)
1693 return DW_OP_GNU_entry_value
;
1696 case DW_OP_const_type
:
1697 if (dwarf_version
< 5)
1698 return DW_OP_GNU_const_type
;
1701 case DW_OP_regval_type
:
1702 if (dwarf_version
< 5)
1703 return DW_OP_GNU_regval_type
;
1706 case DW_OP_deref_type
:
1707 if (dwarf_version
< 5)
1708 return DW_OP_GNU_deref_type
;
1712 if (dwarf_version
< 5)
1713 return DW_OP_GNU_convert
;
1716 case DW_OP_reinterpret
:
1717 if (dwarf_version
< 5)
1718 return DW_OP_GNU_reinterpret
;
1722 if (dwarf_version
< 5)
1723 return DW_OP_GNU_addr_index
;
1727 if (dwarf_version
< 5)
1728 return DW_OP_GNU_const_index
;
1737 /* Similarly for attributes. */
1738 static inline enum dwarf_attribute
1739 dwarf_AT (enum dwarf_attribute at
)
1743 case DW_AT_call_return_pc
:
1744 if (dwarf_version
< 5)
1745 return DW_AT_low_pc
;
1748 case DW_AT_call_tail_call
:
1749 if (dwarf_version
< 5)
1750 return DW_AT_GNU_tail_call
;
1753 case DW_AT_call_origin
:
1754 if (dwarf_version
< 5)
1755 return DW_AT_abstract_origin
;
1758 case DW_AT_call_target
:
1759 if (dwarf_version
< 5)
1760 return DW_AT_GNU_call_site_target
;
1763 case DW_AT_call_target_clobbered
:
1764 if (dwarf_version
< 5)
1765 return DW_AT_GNU_call_site_target_clobbered
;
1768 case DW_AT_call_parameter
:
1769 if (dwarf_version
< 5)
1770 return DW_AT_abstract_origin
;
1773 case DW_AT_call_value
:
1774 if (dwarf_version
< 5)
1775 return DW_AT_GNU_call_site_value
;
1778 case DW_AT_call_data_value
:
1779 if (dwarf_version
< 5)
1780 return DW_AT_GNU_call_site_data_value
;
1783 case DW_AT_call_all_calls
:
1784 if (dwarf_version
< 5)
1785 return DW_AT_GNU_all_call_sites
;
1788 case DW_AT_call_all_tail_calls
:
1789 if (dwarf_version
< 5)
1790 return DW_AT_GNU_all_tail_call_sites
;
1793 case DW_AT_dwo_name
:
1794 if (dwarf_version
< 5)
1795 return DW_AT_GNU_dwo_name
;
1798 case DW_AT_addr_base
:
1799 if (dwarf_version
< 5)
1800 return DW_AT_GNU_addr_base
;
1809 /* And similarly for tags. */
1810 static inline enum dwarf_tag
1811 dwarf_TAG (enum dwarf_tag tag
)
1815 case DW_TAG_call_site
:
1816 if (dwarf_version
< 5)
1817 return DW_TAG_GNU_call_site
;
1820 case DW_TAG_call_site_parameter
:
1821 if (dwarf_version
< 5)
1822 return DW_TAG_GNU_call_site_parameter
;
1831 /* And similarly for forms. */
1832 static inline enum dwarf_form
1833 dwarf_FORM (enum dwarf_form form
)
1838 if (dwarf_version
< 5)
1839 return DW_FORM_GNU_addr_index
;
1843 if (dwarf_version
< 5)
1844 return DW_FORM_GNU_str_index
;
1853 static unsigned long int get_base_type_offset (dw_die_ref
);
1855 /* Return the size of a location descriptor. */
1857 static unsigned long
1858 size_of_loc_descr (dw_loc_descr_ref loc
)
1860 unsigned long size
= 1;
1862 switch (loc
->dw_loc_opc
)
1865 size
+= DWARF2_ADDR_SIZE
;
1867 case DW_OP_GNU_addr_index
:
1869 case DW_OP_GNU_const_index
:
1871 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1872 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1891 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1894 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1899 case DW_OP_plus_uconst
:
1900 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1938 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1941 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1944 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1947 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1948 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1951 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1953 case DW_OP_bit_piece
:
1954 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1955 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1957 case DW_OP_deref_size
:
1958 case DW_OP_xderef_size
:
1967 case DW_OP_call_ref
:
1968 case DW_OP_GNU_variable_value
:
1969 size
+= DWARF_REF_SIZE
;
1971 case DW_OP_implicit_value
:
1972 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1973 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1975 case DW_OP_implicit_pointer
:
1976 case DW_OP_GNU_implicit_pointer
:
1977 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1979 case DW_OP_entry_value
:
1980 case DW_OP_GNU_entry_value
:
1982 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1983 size
+= size_of_uleb128 (op_size
) + op_size
;
1986 case DW_OP_const_type
:
1987 case DW_OP_GNU_const_type
:
1990 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1991 size
+= size_of_uleb128 (o
) + 1;
1992 switch (loc
->dw_loc_oprnd2
.val_class
)
1994 case dw_val_class_vec
:
1995 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1996 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1998 case dw_val_class_const
:
1999 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
2001 case dw_val_class_const_double
:
2002 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
2004 case dw_val_class_wide_int
:
2005 size
+= (get_full_len (*loc
->dw_loc_oprnd2
.v
.val_wide
)
2006 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
2013 case DW_OP_regval_type
:
2014 case DW_OP_GNU_regval_type
:
2017 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
2018 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
2019 + size_of_uleb128 (o
);
2022 case DW_OP_deref_type
:
2023 case DW_OP_GNU_deref_type
:
2026 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
2027 size
+= 1 + size_of_uleb128 (o
);
2031 case DW_OP_reinterpret
:
2032 case DW_OP_GNU_convert
:
2033 case DW_OP_GNU_reinterpret
:
2034 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2035 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2039 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
2040 size
+= size_of_uleb128 (o
);
2043 case DW_OP_GNU_parameter_ref
:
2053 /* Return the size of a series of location descriptors. */
2056 size_of_locs (dw_loc_descr_ref loc
)
2061 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
2062 field, to avoid writing to a PCH file. */
2063 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
2065 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
2067 size
+= size_of_loc_descr (l
);
2072 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
2074 l
->dw_loc_addr
= size
;
2075 size
+= size_of_loc_descr (l
);
2081 /* Return the size of the value in a DW_AT_discr_value attribute. */
2084 size_of_discr_value (dw_discr_value
*discr_value
)
2086 if (discr_value
->pos
)
2087 return size_of_uleb128 (discr_value
->v
.uval
);
2089 return size_of_sleb128 (discr_value
->v
.sval
);
2092 /* Return the size of the value in a DW_AT_discr_list attribute. */
2095 size_of_discr_list (dw_discr_list_ref discr_list
)
2099 for (dw_discr_list_ref list
= discr_list
;
2101 list
= list
->dw_discr_next
)
2103 /* One byte for the discriminant value descriptor, and then one or two
2104 LEB128 numbers, depending on whether it's a single case label or a
2107 size
+= size_of_discr_value (&list
->dw_discr_lower_bound
);
2108 if (list
->dw_discr_range
!= 0)
2109 size
+= size_of_discr_value (&list
->dw_discr_upper_bound
);
2114 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
2115 static void get_ref_die_offset_label (char *, dw_die_ref
);
2116 static unsigned long int get_ref_die_offset (dw_die_ref
);
2118 /* Output location description stack opcode's operands (if any).
2119 The for_eh_or_skip parameter controls whether register numbers are
2120 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2121 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2122 info). This should be suppressed for the cases that have not been converted
2123 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2126 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2128 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2129 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2131 switch (loc
->dw_loc_opc
)
2133 #ifdef DWARF2_DEBUGGING_INFO
2136 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
2141 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2142 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
2144 fputc ('\n', asm_out_file
);
2149 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
2154 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2155 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
2157 fputc ('\n', asm_out_file
);
2162 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2163 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
2170 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2171 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2173 dw2_asm_output_data (2, offset
, NULL
);
2176 case DW_OP_implicit_value
:
2177 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2178 switch (val2
->val_class
)
2180 case dw_val_class_const
:
2181 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
2183 case dw_val_class_vec
:
2185 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2186 unsigned int len
= val2
->v
.val_vec
.length
;
2190 if (elt_size
> sizeof (HOST_WIDE_INT
))
2195 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2198 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2199 "fp or vector constant word %u", i
);
2202 case dw_val_class_const_double
:
2204 unsigned HOST_WIDE_INT first
, second
;
2206 if (WORDS_BIG_ENDIAN
)
2208 first
= val2
->v
.val_double
.high
;
2209 second
= val2
->v
.val_double
.low
;
2213 first
= val2
->v
.val_double
.low
;
2214 second
= val2
->v
.val_double
.high
;
2216 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2218 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2222 case dw_val_class_wide_int
:
2225 int len
= get_full_len (*val2
->v
.val_wide
);
2226 if (WORDS_BIG_ENDIAN
)
2227 for (i
= len
- 1; i
>= 0; --i
)
2228 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2229 val2
->v
.val_wide
->elt (i
), NULL
);
2231 for (i
= 0; i
< len
; ++i
)
2232 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2233 val2
->v
.val_wide
->elt (i
), NULL
);
2236 case dw_val_class_addr
:
2237 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
2238 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
2253 case DW_OP_implicit_value
:
2254 /* We currently don't make any attempt to make sure these are
2255 aligned properly like we do for the main unwind info, so
2256 don't support emitting things larger than a byte if we're
2257 only doing unwinding. */
2262 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2265 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2268 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2271 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2273 case DW_OP_plus_uconst
:
2274 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2308 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2312 unsigned r
= val1
->v
.val_unsigned
;
2313 if (for_eh_or_skip
>= 0)
2314 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2315 gcc_assert (size_of_uleb128 (r
)
2316 == size_of_uleb128 (val1
->v
.val_unsigned
));
2317 dw2_asm_output_data_uleb128 (r
, NULL
);
2321 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2325 unsigned r
= val1
->v
.val_unsigned
;
2326 if (for_eh_or_skip
>= 0)
2327 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2328 gcc_assert (size_of_uleb128 (r
)
2329 == size_of_uleb128 (val1
->v
.val_unsigned
));
2330 dw2_asm_output_data_uleb128 (r
, NULL
);
2331 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2335 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2337 case DW_OP_bit_piece
:
2338 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2339 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
2341 case DW_OP_deref_size
:
2342 case DW_OP_xderef_size
:
2343 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2349 if (targetm
.asm_out
.output_dwarf_dtprel
)
2351 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
2354 fputc ('\n', asm_out_file
);
2361 #ifdef DWARF2_DEBUGGING_INFO
2362 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
2369 case DW_OP_GNU_addr_index
:
2371 case DW_OP_GNU_const_index
:
2373 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
2374 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
2375 "(index into .debug_addr)");
2381 unsigned long die_offset
2382 = get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2383 /* Make sure the offset has been computed and that we can encode it as
2385 gcc_assert (die_offset
> 0
2386 && die_offset
<= (loc
->dw_loc_opc
== DW_OP_call2
2389 dw2_asm_output_data ((loc
->dw_loc_opc
== DW_OP_call2
) ? 2 : 4,
2394 case DW_OP_call_ref
:
2395 case DW_OP_GNU_variable_value
:
2397 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2398 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2399 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2400 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2401 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2405 case DW_OP_implicit_pointer
:
2406 case DW_OP_GNU_implicit_pointer
:
2408 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2409 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2410 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2411 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2412 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2413 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2417 case DW_OP_entry_value
:
2418 case DW_OP_GNU_entry_value
:
2419 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
2420 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
2423 case DW_OP_const_type
:
2424 case DW_OP_GNU_const_type
:
2426 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
2428 dw2_asm_output_data_uleb128 (o
, NULL
);
2429 switch (val2
->val_class
)
2431 case dw_val_class_const
:
2432 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2433 dw2_asm_output_data (1, l
, NULL
);
2434 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
2436 case dw_val_class_vec
:
2438 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2439 unsigned int len
= val2
->v
.val_vec
.length
;
2444 dw2_asm_output_data (1, l
, NULL
);
2445 if (elt_size
> sizeof (HOST_WIDE_INT
))
2450 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2453 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2454 "fp or vector constant word %u", i
);
2457 case dw_val_class_const_double
:
2459 unsigned HOST_WIDE_INT first
, second
;
2460 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2462 dw2_asm_output_data (1, 2 * l
, NULL
);
2463 if (WORDS_BIG_ENDIAN
)
2465 first
= val2
->v
.val_double
.high
;
2466 second
= val2
->v
.val_double
.low
;
2470 first
= val2
->v
.val_double
.low
;
2471 second
= val2
->v
.val_double
.high
;
2473 dw2_asm_output_data (l
, first
, NULL
);
2474 dw2_asm_output_data (l
, second
, NULL
);
2477 case dw_val_class_wide_int
:
2480 int len
= get_full_len (*val2
->v
.val_wide
);
2481 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2483 dw2_asm_output_data (1, len
* l
, NULL
);
2484 if (WORDS_BIG_ENDIAN
)
2485 for (i
= len
- 1; i
>= 0; --i
)
2486 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2488 for (i
= 0; i
< len
; ++i
)
2489 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2497 case DW_OP_regval_type
:
2498 case DW_OP_GNU_regval_type
:
2500 unsigned r
= val1
->v
.val_unsigned
;
2501 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2503 if (for_eh_or_skip
>= 0)
2505 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2506 gcc_assert (size_of_uleb128 (r
)
2507 == size_of_uleb128 (val1
->v
.val_unsigned
));
2509 dw2_asm_output_data_uleb128 (r
, NULL
);
2510 dw2_asm_output_data_uleb128 (o
, NULL
);
2513 case DW_OP_deref_type
:
2514 case DW_OP_GNU_deref_type
:
2516 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2518 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2519 dw2_asm_output_data_uleb128 (o
, NULL
);
2523 case DW_OP_reinterpret
:
2524 case DW_OP_GNU_convert
:
2525 case DW_OP_GNU_reinterpret
:
2526 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2527 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2530 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2532 dw2_asm_output_data_uleb128 (o
, NULL
);
2536 case DW_OP_GNU_parameter_ref
:
2539 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2540 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2541 dw2_asm_output_data (4, o
, NULL
);
2546 /* Other codes have no operands. */
2551 /* Output a sequence of location operations.
2552 The for_eh_or_skip parameter controls whether register numbers are
2553 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2554 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2555 info). This should be suppressed for the cases that have not been converted
2556 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2559 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2561 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2563 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2564 /* Output the opcode. */
2565 if (for_eh_or_skip
>= 0
2566 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2568 unsigned r
= (opc
- DW_OP_breg0
);
2569 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2570 gcc_assert (r
<= 31);
2571 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2573 else if (for_eh_or_skip
>= 0
2574 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2576 unsigned r
= (opc
- DW_OP_reg0
);
2577 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2578 gcc_assert (r
<= 31);
2579 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2582 dw2_asm_output_data (1, opc
,
2583 "%s", dwarf_stack_op_name (opc
));
2585 /* Output the operand(s) (if any). */
2586 output_loc_operands (loc
, for_eh_or_skip
);
2590 /* Output location description stack opcode's operands (if any).
2591 The output is single bytes on a line, suitable for .cfi_escape. */
2594 output_loc_operands_raw (dw_loc_descr_ref loc
)
2596 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2597 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2599 switch (loc
->dw_loc_opc
)
2602 case DW_OP_GNU_addr_index
:
2604 case DW_OP_GNU_const_index
:
2606 case DW_OP_implicit_value
:
2607 /* We cannot output addresses in .cfi_escape, only bytes. */
2613 case DW_OP_deref_size
:
2614 case DW_OP_xderef_size
:
2615 fputc (',', asm_out_file
);
2616 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2621 fputc (',', asm_out_file
);
2622 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2627 fputc (',', asm_out_file
);
2628 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2633 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2634 fputc (',', asm_out_file
);
2635 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2643 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2644 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2646 fputc (',', asm_out_file
);
2647 dw2_asm_output_data_raw (2, offset
);
2653 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2654 gcc_assert (size_of_uleb128 (r
)
2655 == size_of_uleb128 (val1
->v
.val_unsigned
));
2656 fputc (',', asm_out_file
);
2657 dw2_asm_output_data_uleb128_raw (r
);
2662 case DW_OP_plus_uconst
:
2664 fputc (',', asm_out_file
);
2665 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2668 case DW_OP_bit_piece
:
2669 fputc (',', asm_out_file
);
2670 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2671 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2708 fputc (',', asm_out_file
);
2709 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2714 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2715 gcc_assert (size_of_uleb128 (r
)
2716 == size_of_uleb128 (val1
->v
.val_unsigned
));
2717 fputc (',', asm_out_file
);
2718 dw2_asm_output_data_uleb128_raw (r
);
2719 fputc (',', asm_out_file
);
2720 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2724 case DW_OP_implicit_pointer
:
2725 case DW_OP_entry_value
:
2726 case DW_OP_const_type
:
2727 case DW_OP_regval_type
:
2728 case DW_OP_deref_type
:
2730 case DW_OP_reinterpret
:
2731 case DW_OP_GNU_implicit_pointer
:
2732 case DW_OP_GNU_entry_value
:
2733 case DW_OP_GNU_const_type
:
2734 case DW_OP_GNU_regval_type
:
2735 case DW_OP_GNU_deref_type
:
2736 case DW_OP_GNU_convert
:
2737 case DW_OP_GNU_reinterpret
:
2738 case DW_OP_GNU_parameter_ref
:
2743 /* Other codes have no operands. */
2749 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2753 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2754 /* Output the opcode. */
2755 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2757 unsigned r
= (opc
- DW_OP_breg0
);
2758 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2759 gcc_assert (r
<= 31);
2760 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2762 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2764 unsigned r
= (opc
- DW_OP_reg0
);
2765 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2766 gcc_assert (r
<= 31);
2767 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2769 /* Output the opcode. */
2770 fprintf (asm_out_file
, "%#x", opc
);
2771 output_loc_operands_raw (loc
);
2773 if (!loc
->dw_loc_next
)
2775 loc
= loc
->dw_loc_next
;
2777 fputc (',', asm_out_file
);
2782 build_breg_loc (struct dw_loc_descr_node
**head
, unsigned int regno
)
2785 add_loc_descr (head
, new_loc_descr ((enum dwarf_location_atom
)
2786 (DW_OP_breg0
+ regno
), 0, 0));
2788 add_loc_descr (head
, new_loc_descr (DW_OP_bregx
, regno
, 0));
2791 /* Build a dwarf location for a cfa_reg spanning multiple
2792 consecutive registers. */
2794 struct dw_loc_descr_node
*
2795 build_span_loc (struct cfa_reg reg
)
2797 struct dw_loc_descr_node
*head
= NULL
;
2799 gcc_assert (reg
.span_width
> 0);
2800 gcc_assert (reg
.span
> 1);
2802 /* Start from the highest number register as it goes in the upper bits. */
2803 unsigned int regno
= reg
.reg
+ reg
.span
- 1;
2804 build_breg_loc (&head
, regno
);
2806 /* Deal with the remaining registers in the span. */
2807 for (int i
= reg
.span
- 2; i
>= 0; i
--)
2809 add_loc_descr (&head
, int_loc_descriptor (reg
.span_width
* 8));
2810 add_loc_descr (&head
, new_loc_descr (DW_OP_shl
, 0, 0));
2812 build_breg_loc (&head
, regno
);
2813 add_loc_descr (&head
, new_loc_descr (DW_OP_plus
, 0, 0));
2818 /* This function builds a dwarf location descriptor sequence from a
2819 dw_cfa_location, adding the given OFFSET to the result of the
2822 struct dw_loc_descr_node
*
2823 build_cfa_loc (dw_cfa_location
*cfa
, poly_int64 offset
)
2825 struct dw_loc_descr_node
*head
, *tmp
;
2827 offset
+= cfa
->offset
;
2829 if (cfa
->reg
.span
> 1)
2831 head
= build_span_loc (cfa
->reg
);
2833 if (maybe_ne (offset
, 0))
2834 loc_descr_plus_const (&head
, offset
);
2836 else if (cfa
->indirect
)
2838 head
= new_reg_loc_descr (cfa
->reg
.reg
, cfa
->base_offset
);
2839 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2840 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2841 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2842 add_loc_descr (&head
, tmp
);
2843 loc_descr_plus_const (&head
, offset
);
2846 head
= new_reg_loc_descr (cfa
->reg
.reg
, offset
);
2851 /* This function builds a dwarf location descriptor sequence for
2852 the address at OFFSET from the CFA when stack is aligned to
2855 struct dw_loc_descr_node
*
2856 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2857 poly_int64 offset
, HOST_WIDE_INT alignment
)
2859 struct dw_loc_descr_node
*head
;
2860 unsigned int dwarf_fp
2861 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2863 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2864 if (cfa
->reg
.reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2866 head
= new_reg_loc_descr (dwarf_fp
, 0);
2867 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2868 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2869 loc_descr_plus_const (&head
, offset
);
2872 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2876 /* And now, the support for symbolic debugging information. */
2878 /* .debug_str support. */
2880 static void dwarf2out_init (const char *);
2881 static void dwarf2out_finish (const char *);
2882 static void dwarf2out_early_finish (const char *);
2883 static void dwarf2out_assembly_start (void);
2884 static void dwarf2out_define (unsigned int, const char *);
2885 static void dwarf2out_undef (unsigned int, const char *);
2886 static void dwarf2out_start_source_file (unsigned, const char *);
2887 static void dwarf2out_end_source_file (unsigned);
2888 static void dwarf2out_function_decl (tree
);
2889 static void dwarf2out_begin_block (unsigned, unsigned);
2890 static void dwarf2out_end_block (unsigned, unsigned);
2891 static bool dwarf2out_ignore_block (const_tree
);
2892 static void dwarf2out_set_ignored_loc (unsigned, unsigned, const char *);
2893 static void dwarf2out_early_global_decl (tree
);
2894 static void dwarf2out_late_global_decl (tree
);
2895 static void dwarf2out_type_decl (tree
, int);
2896 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool, bool);
2897 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2899 static void dwarf2out_abstract_function (tree
);
2900 static void dwarf2out_var_location (rtx_insn
*);
2901 static void dwarf2out_inline_entry (tree
);
2902 static void dwarf2out_size_function (tree
);
2903 static void dwarf2out_begin_function (tree
);
2904 static void dwarf2out_end_function (unsigned int);
2905 static void dwarf2out_register_main_translation_unit (tree unit
);
2906 static void dwarf2out_set_name (tree
, tree
);
2907 static void dwarf2out_register_external_die (tree decl
, const char *sym
,
2908 unsigned HOST_WIDE_INT off
);
2909 static bool dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
2910 unsigned HOST_WIDE_INT
*off
);
2912 /* The debug hooks structure. */
2914 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2918 dwarf2out_early_finish
,
2919 dwarf2out_assembly_start
,
2922 dwarf2out_start_source_file
,
2923 dwarf2out_end_source_file
,
2924 dwarf2out_begin_block
,
2925 dwarf2out_end_block
,
2926 dwarf2out_ignore_block
,
2927 dwarf2out_source_line
,
2928 dwarf2out_set_ignored_loc
,
2929 dwarf2out_begin_prologue
,
2930 #if VMS_DEBUGGING_INFO
2931 dwarf2out_vms_end_prologue
,
2932 dwarf2out_vms_begin_epilogue
,
2934 debug_nothing_int_charstar
,
2935 debug_nothing_int_charstar
,
2937 dwarf2out_end_epilogue
,
2938 dwarf2out_begin_function
,
2939 dwarf2out_end_function
, /* end_function */
2940 dwarf2out_register_main_translation_unit
,
2941 dwarf2out_function_decl
, /* function_decl */
2942 dwarf2out_early_global_decl
,
2943 dwarf2out_late_global_decl
,
2944 dwarf2out_type_decl
, /* type_decl */
2945 dwarf2out_imported_module_or_decl
,
2946 dwarf2out_die_ref_for_decl
,
2947 dwarf2out_register_external_die
,
2948 debug_nothing_tree
, /* deferred_inline_function */
2949 /* The DWARF 2 backend tries to reduce debugging bloat by not
2950 emitting the abstract description of inline functions until
2951 something tries to reference them. */
2952 dwarf2out_abstract_function
, /* outlining_inline_function */
2953 debug_nothing_rtx_code_label
, /* label */
2954 debug_nothing_int
, /* handle_pch */
2955 dwarf2out_var_location
,
2956 dwarf2out_inline_entry
, /* inline_entry */
2957 dwarf2out_size_function
, /* size_function */
2958 dwarf2out_switch_text_section
,
2960 1, /* start_end_main_source_file */
2961 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2964 const struct gcc_debug_hooks dwarf2_lineno_debug_hooks
=
2967 debug_nothing_charstar
,
2968 debug_nothing_charstar
,
2969 dwarf2out_assembly_start
,
2970 debug_nothing_int_charstar
,
2971 debug_nothing_int_charstar
,
2972 debug_nothing_int_charstar
,
2974 debug_nothing_int_int
, /* begin_block */
2975 debug_nothing_int_int
, /* end_block */
2976 debug_true_const_tree
, /* ignore_block */
2977 dwarf2out_source_line
, /* source_line */
2978 debug_nothing_int_int_charstar
, /* set_ignored_loc */
2979 debug_nothing_int_int_charstar
, /* begin_prologue */
2980 debug_nothing_int_charstar
, /* end_prologue */
2981 debug_nothing_int_charstar
, /* begin_epilogue */
2982 debug_nothing_int_charstar
, /* end_epilogue */
2983 debug_nothing_tree
, /* begin_function */
2984 debug_nothing_int
, /* end_function */
2985 debug_nothing_tree
, /* register_main_translation_unit */
2986 debug_nothing_tree
, /* function_decl */
2987 debug_nothing_tree
, /* early_global_decl */
2988 debug_nothing_tree
, /* late_global_decl */
2989 debug_nothing_tree_int
, /* type_decl */
2990 debug_nothing_tree_tree_tree_bool_bool
,/* imported_module_or_decl */
2991 debug_false_tree_charstarstar_uhwistar
,/* die_ref_for_decl */
2992 debug_nothing_tree_charstar_uhwi
, /* register_external_die */
2993 debug_nothing_tree
, /* deferred_inline_function */
2994 debug_nothing_tree
, /* outlining_inline_function */
2995 debug_nothing_rtx_code_label
, /* label */
2996 debug_nothing_int
, /* handle_pch */
2997 debug_nothing_rtx_insn
, /* var_location */
2998 debug_nothing_tree
, /* inline_entry */
2999 debug_nothing_tree
, /* size_function */
3000 debug_nothing_void
, /* switch_text_section */
3001 debug_nothing_tree_tree
, /* set_name */
3002 0, /* start_end_main_source_file */
3003 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
3006 /* NOTE: In the comments in this file, many references are made to
3007 "Debugging Information Entries". This term is abbreviated as `DIE'
3008 throughout the remainder of this file. */
3010 /* An internal representation of the DWARF output is built, and then
3011 walked to generate the DWARF debugging info. The walk of the internal
3012 representation is done after the entire program has been compiled.
3013 The types below are used to describe the internal representation. */
3015 /* Whether to put type DIEs into their own section .debug_types instead
3016 of making them part of the .debug_info section. Only supported for
3017 Dwarf V4 or higher and the user didn't disable them through
3018 -fno-debug-types-section. It is more efficient to put them in a
3019 separate comdat sections since the linker will then be able to
3020 remove duplicates. But not all tools support .debug_types sections
3021 yet. For Dwarf V5 or higher .debug_types doesn't exist any more,
3022 it is DW_UT_type unit type in .debug_info section. For late LTO
3023 debug there should be almost no types emitted so avoid enabling
3024 -fdebug-types-section there. */
3026 #define use_debug_types (dwarf_version >= 4 \
3027 && flag_debug_types_section \
3030 /* Various DIE's use offsets relative to the beginning of the
3031 .debug_info section to refer to each other. */
3033 typedef long int dw_offset
;
3035 struct comdat_type_node
;
3037 /* The entries in the line_info table more-or-less mirror the opcodes
3038 that are used in the real dwarf line table. Arrays of these entries
3039 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
3042 enum dw_line_info_opcode
{
3043 /* Emit DW_LNE_set_address; the operand is the label index. */
3046 /* Emit a row to the matrix with the given line. This may be done
3047 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
3051 /* Emit a DW_LNS_set_file. */
3054 /* Emit a DW_LNS_set_column. */
3057 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
3060 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
3061 LI_set_prologue_end
,
3062 LI_set_epilogue_begin
,
3064 /* Emit a DW_LNE_set_discriminator. */
3065 LI_set_discriminator
,
3067 /* Output a Fixed Advance PC; the target PC is the label index; the
3068 base PC is the previous LI_adv_address or LI_set_address entry.
3069 We only use this when emitting debug views without assembler
3070 support, at explicit user request. Ideally, we should only use
3071 it when the offset might be zero but we can't tell: it's the only
3072 way to maybe change the PC without resetting the view number. */
3076 typedef struct GTY(()) dw_line_info_struct
{
3077 enum dw_line_info_opcode opcode
;
3079 } dw_line_info_entry
;
3082 struct GTY(()) dw_line_info_table
{
3083 /* The label that marks the end of this section. */
3084 const char *end_label
;
3086 /* The values for the last row of the matrix, as collected in the table.
3087 These are used to minimize the changes to the next row. */
3088 unsigned int file_num
;
3089 unsigned int line_num
;
3090 unsigned int column_num
;
3095 /* This denotes the NEXT view number.
3097 If it is 0, it is known that the NEXT view will be the first view
3100 If it is -1, we're forcing the view number to be reset, e.g. at a
3103 The meaning of other nonzero values depends on whether we're
3104 computing views internally or leaving it for the assembler to do
3105 so. If we're emitting them internally, view denotes the view
3106 number since the last known advance of PC. If we're leaving it
3107 for the assembler, it denotes the LVU label number that we're
3108 going to ask the assembler to assign. */
3111 /* This counts the number of symbolic views emitted in this table
3112 since the latest view reset. Its max value, over all tables,
3113 sets symview_upper_bound. */
3114 var_loc_view symviews_since_reset
;
3116 #define FORCE_RESET_NEXT_VIEW(x) ((x) = (var_loc_view)-1)
3117 #define RESET_NEXT_VIEW(x) ((x) = (var_loc_view)0)
3118 #define FORCE_RESETTING_VIEW_P(x) ((x) == (var_loc_view)-1)
3119 #define RESETTING_VIEW_P(x) ((x) == (var_loc_view)0 || FORCE_RESETTING_VIEW_P (x))
3121 vec
<dw_line_info_entry
, va_gc
> *entries
;
3124 /* This is an upper bound for view numbers that the assembler may
3125 assign to symbolic views output in this translation. It is used to
3126 decide how big a field to use to represent view numbers in
3127 symview-classed attributes. */
3129 static var_loc_view symview_upper_bound
;
3131 /* If we're keep track of location views and their reset points, and
3132 INSN is a reset point (i.e., it necessarily advances the PC), mark
3133 the next view in TABLE as reset. */
3136 maybe_reset_location_view (rtx_insn
*insn
, dw_line_info_table
*table
)
3138 if (!debug_internal_reset_location_views
)
3141 /* Maybe turn (part of?) this test into a default target hook. */
3144 if (targetm
.reset_location_view
)
3145 reset
= targetm
.reset_location_view (insn
);
3149 else if (JUMP_TABLE_DATA_P (insn
))
3151 else if (GET_CODE (insn
) == USE
3152 || GET_CODE (insn
) == CLOBBER
3153 || GET_CODE (insn
) == ASM_INPUT
3154 || asm_noperands (insn
) >= 0)
3156 else if (get_attr_min_length (insn
) > 0)
3159 if (reset
> 0 && !RESETTING_VIEW_P (table
->view
))
3160 RESET_NEXT_VIEW (table
->view
);
3163 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
3164 The children of each node form a circular list linked by
3165 die_sib. die_child points to the node *before* the "first" child node. */
3167 typedef struct GTY((chain_circular ("%h.die_sib"), for_user
)) die_struct
{
3168 union die_symbol_or_type_node
3170 const char * GTY ((tag ("0"))) die_symbol
;
3171 comdat_type_node
*GTY ((tag ("1"))) die_type_node
;
3173 GTY ((desc ("%0.comdat_type_p"))) die_id
;
3174 vec
<dw_attr_node
, va_gc
> *die_attr
;
3175 dw_die_ref die_parent
;
3176 dw_die_ref die_child
;
3178 dw_die_ref die_definition
; /* ref from a specification to its definition */
3179 dw_offset die_offset
;
3180 unsigned long die_abbrev
;
3182 unsigned int decl_id
;
3183 enum dwarf_tag die_tag
;
3184 /* Die is used and must not be pruned as unused. */
3185 BOOL_BITFIELD die_perennial_p
: 1;
3186 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
3187 /* For an external ref to die_symbol if die_offset contains an extra
3188 offset to that symbol. */
3189 BOOL_BITFIELD with_offset
: 1;
3190 /* Whether this DIE was removed from the DIE tree, for example via
3191 prune_unused_types. We don't consider those present from the
3192 DIE lookup routines. */
3193 BOOL_BITFIELD removed
: 1;
3194 /* Lots of spare bits. */
3198 /* Set to TRUE while dwarf2out_early_global_decl is running. */
3199 static bool early_dwarf
;
3200 static bool early_dwarf_finished
;
3201 class set_early_dwarf
{
3204 set_early_dwarf () : saved(early_dwarf
)
3206 gcc_assert (! early_dwarf_finished
);
3209 ~set_early_dwarf () { early_dwarf
= saved
; }
3212 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
3213 #define FOR_EACH_CHILD(die, c, expr) do { \
3214 c = die->die_child; \
3218 } while (c != die->die_child); \
3221 /* The pubname structure */
3223 typedef struct GTY(()) pubname_struct
{
3230 struct GTY(()) dw_ranges
{
3232 /* If this is positive, it's a block number, otherwise it's a
3233 bitwise-negated index into dw_ranges_by_label. */
3235 /* If idx is equal to DW_RANGES_IDX_SKELETON, it should be emitted
3236 into .debug_rnglists section rather than .debug_rnglists.dwo
3237 for -gsplit-dwarf and DWARF >= 5. */
3238 #define DW_RANGES_IDX_SKELETON ((1U << 31) - 1)
3239 /* Index for the range list for DW_FORM_rnglistx. */
3240 unsigned int idx
: 31;
3241 /* True if this range might be possibly in a different section
3242 from previous entry. */
3243 unsigned int maybe_new_sec
: 1;
3244 addr_table_entry
*begin_entry
;
3245 addr_table_entry
*end_entry
;
3248 /* A structure to hold a macinfo entry. */
3250 typedef struct GTY(()) macinfo_struct
{
3252 unsigned HOST_WIDE_INT lineno
;
3258 struct GTY(()) dw_ranges_by_label
{
3263 /* The comdat type node structure. */
3264 struct GTY(()) comdat_type_node
3266 dw_die_ref root_die
;
3267 dw_die_ref type_die
;
3268 dw_die_ref skeleton_die
;
3269 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
3270 comdat_type_node
*next
;
3273 /* A list of DIEs for which we can't determine ancestry (parent_die
3274 field) just yet. Later in dwarf2out_finish we will fill in the
3276 typedef struct GTY(()) limbo_die_struct
{
3278 /* The tree for which this DIE was created. We use this to
3279 determine ancestry later. */
3281 struct limbo_die_struct
*next
;
3285 typedef struct skeleton_chain_struct
3289 struct skeleton_chain_struct
*parent
;
3291 skeleton_chain_node
;
3293 /* Define a macro which returns nonzero for a TYPE_DECL which was
3294 implicitly generated for a type.
3296 Note that, unlike the C front-end (which generates a NULL named
3297 TYPE_DECL node for each complete tagged type, each array type,
3298 and each function type node created) the C++ front-end generates
3299 a _named_ TYPE_DECL node for each tagged type node created.
3300 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3301 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
3302 front-end, but for each type, tagged or not. */
3304 #define TYPE_DECL_IS_STUB(decl) \
3305 (DECL_NAME (decl) == NULL_TREE \
3306 || (DECL_ARTIFICIAL (decl) \
3307 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3308 /* This is necessary for stub decls that \
3309 appear in nested inline functions. */ \
3310 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3311 && (decl_ultimate_origin (decl) \
3312 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3314 /* Information concerning the compilation unit's programming
3315 language, and compiler version. */
3317 /* Fixed size portion of the DWARF compilation unit header. */
3318 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3319 (DWARF_INITIAL_LENGTH_SIZE + dwarf_offset_size \
3320 + (dwarf_version >= 5 ? 4 : 3))
3322 /* Fixed size portion of the DWARF comdat type unit header. */
3323 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
3324 (DWARF_COMPILE_UNIT_HEADER_SIZE \
3325 + DWARF_TYPE_SIGNATURE_SIZE + dwarf_offset_size)
3327 /* Fixed size portion of the DWARF skeleton compilation unit header. */
3328 #define DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE \
3329 (DWARF_COMPILE_UNIT_HEADER_SIZE + (dwarf_version >= 5 ? 8 : 0))
3331 /* Fixed size portion of public names info. */
3332 #define DWARF_PUBNAMES_HEADER_SIZE (2 * dwarf_offset_size + 2)
3334 /* Fixed size portion of the address range info. */
3335 #define DWARF_ARANGES_HEADER_SIZE \
3336 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + dwarf_offset_size + 4, \
3337 DWARF2_ADDR_SIZE * 2) \
3338 - DWARF_INITIAL_LENGTH_SIZE)
3340 /* Size of padding portion in the address range info. It must be
3341 aligned to twice the pointer size. */
3342 #define DWARF_ARANGES_PAD_SIZE \
3343 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + dwarf_offset_size + 4, \
3344 DWARF2_ADDR_SIZE * 2) \
3345 - (DWARF_INITIAL_LENGTH_SIZE + dwarf_offset_size + 4))
3347 /* Use assembler line directives if available. */
3348 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3349 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3350 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3352 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3356 /* Use assembler views in line directives if available. */
3357 #ifndef DWARF2_ASM_VIEW_DEBUG_INFO
3358 #ifdef HAVE_AS_DWARF2_DEBUG_VIEW
3359 #define DWARF2_ASM_VIEW_DEBUG_INFO 1
3361 #define DWARF2_ASM_VIEW_DEBUG_INFO 0
3365 /* Return true if GCC configure detected assembler support for .loc. */
3368 dwarf2out_default_as_loc_support (void)
3370 return DWARF2_ASM_LINE_DEBUG_INFO
;
3371 #if (GCC_VERSION >= 3000)
3372 # undef DWARF2_ASM_LINE_DEBUG_INFO
3373 # pragma GCC poison DWARF2_ASM_LINE_DEBUG_INFO
3377 /* Return true if GCC configure detected assembler support for views
3378 in .loc directives. */
3381 dwarf2out_default_as_locview_support (void)
3383 return DWARF2_ASM_VIEW_DEBUG_INFO
;
3384 #if (GCC_VERSION >= 3000)
3385 # undef DWARF2_ASM_VIEW_DEBUG_INFO
3386 # pragma GCC poison DWARF2_ASM_VIEW_DEBUG_INFO
3390 /* A bit is set in ZERO_VIEW_P if we are using the assembler-supported
3391 view computation, and it refers to a view identifier for which we
3392 will not emit a label because it is known to map to a view number
3393 zero. We won't allocate the bitmap if we're not using assembler
3394 support for location views, but we have to make the variable
3395 visible for GGC and for code that will be optimized out for lack of
3396 support but that's still parsed and compiled. We could abstract it
3397 out with macros, but it's not worth it. */
3398 static GTY(()) bitmap zero_view_p
;
3400 /* Evaluate to TRUE iff N is known to identify the first location view
3401 at its PC. When not using assembler location view computation,
3402 that must be view number zero. Otherwise, ZERO_VIEW_P is allocated
3403 and views label numbers recorded in it are the ones known to be
3405 #define ZERO_VIEW_P(N) ((N) == (var_loc_view)0 \
3406 || (N) == (var_loc_view)-1 \
3408 && bitmap_bit_p (zero_view_p, (N))))
3410 /* Return true iff we're to emit .loc directives for the assembler to
3411 generate line number sections.
3413 When we're not emitting views, all we need from the assembler is
3414 support for .loc directives.
3416 If we are emitting views, we can only use the assembler's .loc
3417 support if it also supports views.
3419 When the compiler is emitting the line number programs and
3420 computing view numbers itself, it resets view numbers at known PC
3421 changes and counts from that, and then it emits view numbers as
3422 literal constants in locviewlists. There are cases in which the
3423 compiler is not sure about PC changes, e.g. when extra alignment is
3424 requested for a label. In these cases, the compiler may not reset
3425 the view counter, and the potential PC advance in the line number
3426 program will use an opcode that does not reset the view counter
3427 even if the PC actually changes, so that compiler and debug info
3428 consumer can keep view numbers in sync.
3430 When the compiler defers view computation to the assembler, it
3431 emits symbolic view numbers in locviewlists, with the exception of
3432 views known to be zero (forced resets, or reset after
3433 compiler-visible PC changes): instead of emitting symbols for
3434 these, we emit literal zero and assert the assembler agrees with
3435 the compiler's assessment. We could use symbolic views everywhere,
3436 instead of special-casing zero views, but then we'd be unable to
3437 optimize out locviewlists that contain only zeros. */
3440 output_asm_line_debug_info (void)
3442 return (dwarf2out_as_loc_support
3443 && (dwarf2out_as_locview_support
3444 || !debug_variable_location_views
));
3447 static bool asm_outputs_debug_line_str (void);
3449 /* Minimum line offset in a special line info. opcode.
3450 This value was chosen to give a reasonable range of values. */
3451 #define DWARF_LINE_BASE -10
3453 /* First special line opcode - leave room for the standard opcodes. */
3454 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
3456 /* Range of line offsets in a special line info. opcode. */
3457 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3459 /* Flag that indicates the initial value of the is_stmt_start flag.
3460 In the present implementation, we do not mark any lines as
3461 the beginning of a source statement, because that information
3462 is not made available by the GCC front-end. */
3463 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3465 /* Maximum number of operations per instruction bundle. */
3466 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
3467 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
3470 /* This location is used by calc_die_sizes() to keep track
3471 the offset of each DIE within the .debug_info section. */
3472 static unsigned long next_die_offset
;
3474 /* Record the root of the DIE's built for the current compilation unit. */
3475 static GTY(()) dw_die_ref single_comp_unit_die
;
3477 /* A list of type DIEs that have been separated into comdat sections. */
3478 static GTY(()) comdat_type_node
*comdat_type_list
;
3480 /* A list of CU DIEs that have been separated. */
3481 static GTY(()) limbo_die_node
*cu_die_list
;
3483 /* A list of DIEs with a NULL parent waiting to be relocated. */
3484 static GTY(()) limbo_die_node
*limbo_die_list
;
3486 /* A list of DIEs for which we may have to generate
3487 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
3488 static GTY(()) limbo_die_node
*deferred_asm_name
;
3490 struct dwarf_file_hasher
: ggc_ptr_hash
<dwarf_file_data
>
3492 typedef const char *compare_type
;
3494 static hashval_t
hash (dwarf_file_data
*);
3495 static bool equal (dwarf_file_data
*, const char *);
3498 /* Filenames referenced by this compilation unit. */
3499 static GTY(()) hash_table
<dwarf_file_hasher
> *file_table
;
3501 struct decl_die_hasher
: ggc_ptr_hash
<die_node
>
3503 typedef tree compare_type
;
3505 static hashval_t
hash (die_node
*);
3506 static bool equal (die_node
*, tree
);
3508 /* A hash table of references to DIE's that describe declarations.
3509 The key is a DECL_UID() which is a unique number identifying each decl. */
3510 static GTY (()) hash_table
<decl_die_hasher
> *decl_die_table
;
3512 struct GTY ((for_user
)) variable_value_struct
{
3513 unsigned int decl_id
;
3514 vec
<dw_die_ref
, va_gc
> *dies
;
3517 struct variable_value_hasher
: ggc_ptr_hash
<variable_value_struct
>
3519 typedef tree compare_type
;
3521 static hashval_t
hash (variable_value_struct
*);
3522 static bool equal (variable_value_struct
*, tree
);
3524 /* A hash table of DIEs that contain DW_OP_GNU_variable_value with
3525 dw_val_class_decl_ref class, indexed by FUNCTION_DECLs which is
3526 DECL_CONTEXT of the referenced VAR_DECLs. */
3527 static GTY (()) hash_table
<variable_value_hasher
> *variable_value_hash
;
3529 struct block_die_hasher
: ggc_ptr_hash
<die_struct
>
3531 static hashval_t
hash (die_struct
*);
3532 static bool equal (die_struct
*, die_struct
*);
3535 /* A hash table of references to DIE's that describe COMMON blocks.
3536 The key is DECL_UID() ^ die_parent. */
3537 static GTY (()) hash_table
<block_die_hasher
> *common_block_die_table
;
3539 typedef struct GTY(()) die_arg_entry_struct
{
3545 /* Node of the variable location list. */
3546 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
3547 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
3548 EXPR_LIST chain. For small bitsizes, bitsize is encoded
3549 in mode of the EXPR_LIST node and first EXPR_LIST operand
3550 is either NOTE_INSN_VAR_LOCATION for a piece with a known
3551 location or NULL for padding. For larger bitsizes,
3552 mode is 0 and first operand is a CONCAT with bitsize
3553 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
3554 NULL as second operand. */
3556 const char * GTY (()) label
;
3557 struct var_loc_node
* GTY (()) next
;
3561 /* Variable location list. */
3562 struct GTY ((for_user
)) var_loc_list_def
{
3563 struct var_loc_node
* GTY (()) first
;
3565 /* Pointer to the last but one or last element of the
3566 chained list. If the list is empty, both first and
3567 last are NULL, if the list contains just one node
3568 or the last node certainly is not redundant, it points
3569 to the last node, otherwise points to the last but one.
3570 Do not mark it for GC because it is marked through the chain. */
3571 struct var_loc_node
* GTY ((skip ("%h"))) last
;
3573 /* Pointer to the last element before section switch,
3574 if NULL, either sections weren't switched or first
3575 is after section switch. */
3576 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
3578 /* DECL_UID of the variable decl. */
3579 unsigned int decl_id
;
3581 typedef struct var_loc_list_def var_loc_list
;
3583 /* Call argument location list. */
3584 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
3585 rtx
GTY (()) call_arg_loc_note
;
3586 const char * GTY (()) label
;
3587 tree
GTY (()) block
;
3589 rtx
GTY (()) symbol_ref
;
3590 struct call_arg_loc_node
* GTY (()) next
;
3594 struct decl_loc_hasher
: ggc_ptr_hash
<var_loc_list
>
3596 typedef const_tree compare_type
;
3598 static hashval_t
hash (var_loc_list
*);
3599 static bool equal (var_loc_list
*, const_tree
);
3602 /* Table of decl location linked lists. */
3603 static GTY (()) hash_table
<decl_loc_hasher
> *decl_loc_table
;
3605 /* Head and tail of call_arg_loc chain. */
3606 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
3607 static struct call_arg_loc_node
*call_arg_loc_last
;
3609 /* Number of call sites in the current function. */
3610 static int call_site_count
= -1;
3611 /* Number of tail call sites in the current function. */
3612 static int tail_call_site_count
= -1;
3614 /* A cached location list. */
3615 struct GTY ((for_user
)) cached_dw_loc_list_def
{
3616 /* The DECL_UID of the decl that this entry describes. */
3617 unsigned int decl_id
;
3619 /* The cached location list. */
3620 dw_loc_list_ref loc_list
;
3622 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
3624 struct dw_loc_list_hasher
: ggc_ptr_hash
<cached_dw_loc_list
>
3627 typedef const_tree compare_type
;
3629 static hashval_t
hash (cached_dw_loc_list
*);
3630 static bool equal (cached_dw_loc_list
*, const_tree
);
3633 /* Table of cached location lists. */
3634 static GTY (()) hash_table
<dw_loc_list_hasher
> *cached_dw_loc_list_table
;
3636 /* A vector of references to DIE's that are uniquely identified by their tag,
3637 presence/absence of children DIE's, and list of attribute/value pairs. */
3638 static GTY(()) vec
<dw_die_ref
, va_gc
> *abbrev_die_table
;
3640 /* A hash map to remember the stack usage for DWARF procedures. The value
3641 stored is the stack size difference between before the DWARF procedure
3642 invokation and after it returned. In other words, for a DWARF procedure
3643 that consumes N stack slots and that pushes M ones, this stores M - N. */
3644 static hash_map
<dw_die_ref
, int> *dwarf_proc_stack_usage_map
;
3646 /* A global counter for generating labels for line number data. */
3647 static unsigned int line_info_label_num
;
3649 /* The current table to which we should emit line number information
3650 for the current function. This will be set up at the beginning of
3651 assembly for the function. */
3652 static GTY(()) dw_line_info_table
*cur_line_info_table
;
3654 /* The two default tables of line number info. */
3655 static GTY(()) dw_line_info_table
*text_section_line_info
;
3656 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
3658 /* The set of all non-default tables of line number info. */
3659 static GTY(()) vec
<dw_line_info_table
*, va_gc
> *separate_line_info
;
3661 /* A flag to tell pubnames/types export if there is an info section to
3663 static bool info_section_emitted
;
3665 /* A pointer to the base of a table that contains a list of publicly
3666 accessible names. */
3667 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
3669 /* A pointer to the base of a table that contains a list of publicly
3670 accessible types. */
3671 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
3673 /* A pointer to the base of a table that contains a list of macro
3674 defines/undefines (and file start/end markers). */
3675 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
3677 /* True if .debug_macinfo or .debug_macros section is going to be
3679 #define have_macinfo \
3680 ((!XCOFF_DEBUGGING_INFO || HAVE_XCOFF_DWARF_EXTRAS) \
3681 && debug_info_level >= DINFO_LEVEL_VERBOSE \
3682 && !macinfo_table->is_empty ())
3684 /* Vector of dies for which we should generate .debug_ranges info. */
3685 static GTY (()) vec
<dw_ranges
, va_gc
> *ranges_table
;
3687 /* Vector of pairs of labels referenced in ranges_table. */
3688 static GTY (()) vec
<dw_ranges_by_label
, va_gc
> *ranges_by_label
;
3690 /* Whether we have location lists that need outputting */
3691 static GTY(()) bool have_location_lists
;
3693 /* Unique label counter. */
3694 static GTY(()) unsigned int loclabel_num
;
3696 /* Unique label counter for point-of-call tables. */
3697 static GTY(()) unsigned int poc_label_num
;
3699 /* The last file entry emitted by maybe_emit_file(). */
3700 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
3702 /* Number of internal labels generated by gen_internal_sym(). */
3703 static GTY(()) int label_num
;
3705 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
3707 /* Instances of generic types for which we need to generate debug
3708 info that describe their generic parameters and arguments. That
3709 generation needs to happen once all types are properly laid out so
3710 we do it at the end of compilation. */
3711 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
3713 /* Offset from the "steady-state frame pointer" to the frame base,
3714 within the current function. */
3715 static poly_int64 frame_pointer_fb_offset
;
3716 static bool frame_pointer_fb_offset_valid
;
3718 static vec
<dw_die_ref
> base_types
;
3720 /* Flags to represent a set of attribute classes for attributes that represent
3721 a scalar value (bounds, pointers, ...). */
3724 dw_scalar_form_constant
= 0x01,
3725 dw_scalar_form_exprloc
= 0x02,
3726 dw_scalar_form_reference
= 0x04
3729 /* Forward declarations for functions defined in this file. */
3731 static bool is_pseudo_reg (const_rtx
);
3732 static tree
type_main_variant (tree
);
3733 static bool is_tagged_type (const_tree
);
3734 static const char *dwarf_tag_name (unsigned);
3735 static const char *dwarf_attr_name (unsigned);
3736 static const char *dwarf_form_name (unsigned);
3737 static tree
decl_ultimate_origin (const_tree
);
3738 static tree
decl_class_context (tree
);
3739 static void add_dwarf_attr (dw_die_ref
, dw_attr_node
*);
3740 static inline unsigned int AT_index (dw_attr_node
*);
3741 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3742 static inline unsigned AT_flag (dw_attr_node
*);
3743 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3744 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3745 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
3746 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
3747 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3748 unsigned int, unsigned char *);
3749 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
3750 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3751 static inline const char *AT_string (dw_attr_node
*);
3752 static enum dwarf_form
AT_string_form (dw_attr_node
*);
3753 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3754 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3755 static inline dw_die_ref
AT_ref (dw_attr_node
*);
3756 static inline int AT_ref_external (dw_attr_node
*);
3757 static inline void set_AT_ref_external (dw_attr_node
*, int);
3758 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3759 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3761 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3762 static void add_AT_view_list (dw_die_ref
, enum dwarf_attribute
);
3763 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3764 static addr_table_entry
*add_addr_table_entry (void *, enum ate_kind
);
3765 static void remove_addr_table_entry (addr_table_entry
*);
3766 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
, bool);
3767 static inline rtx
AT_addr (dw_attr_node
*);
3768 static void add_AT_symview (dw_die_ref
, enum dwarf_attribute
, const char *);
3769 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3770 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3771 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3772 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3773 unsigned long, bool);
3774 static inline const char *AT_lbl (dw_attr_node
*);
3775 static const char *get_AT_low_pc (dw_die_ref
);
3776 static bool is_c (void);
3777 static bool is_cxx (void);
3778 static bool is_cxx (const_tree
);
3779 static bool is_fortran (void);
3780 static bool is_ada (void);
3781 static bool remove_AT (dw_die_ref
, enum dwarf_attribute
);
3782 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3783 static void add_child_die (dw_die_ref
, dw_die_ref
);
3784 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3785 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3786 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3787 static void equate_type_number_to_die (tree
, dw_die_ref
);
3788 static var_loc_list
*lookup_decl_loc (const_tree
);
3789 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3790 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *, var_loc_view
);
3791 static void print_spaces (FILE *);
3792 static void print_die (dw_die_ref
, FILE *);
3793 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3794 static void attr_checksum (dw_attr_node
*, struct md5_ctx
*, int *);
3795 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3796 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3797 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3798 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3799 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_node
*,
3800 struct md5_ctx
*, int *);
3801 struct checksum_attributes
;
3802 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3803 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3804 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3805 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3806 static bool same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3807 static bool same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3808 static bool same_attr_p (dw_attr_node
*, dw_attr_node
*, int *);
3809 static bool same_die_p (dw_die_ref
, dw_die_ref
, int *);
3810 static bool is_type_die (dw_die_ref
);
3811 static inline bool is_template_instantiation (dw_die_ref
);
3812 static bool is_declaration_die (dw_die_ref
);
3813 static bool should_move_die_to_comdat (dw_die_ref
);
3814 static dw_die_ref
clone_as_declaration (dw_die_ref
);
3815 static dw_die_ref
clone_die (dw_die_ref
);
3816 static dw_die_ref
clone_tree (dw_die_ref
);
3817 static dw_die_ref
copy_declaration_context (dw_die_ref
, dw_die_ref
);
3818 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
3819 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
3820 static dw_die_ref
generate_skeleton (dw_die_ref
);
3821 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
3824 static void break_out_comdat_types (dw_die_ref
);
3825 static void copy_decls_for_unworthy_types (dw_die_ref
);
3827 static void add_sibling_attributes (dw_die_ref
);
3828 static void output_location_lists (dw_die_ref
);
3829 static int constant_size (unsigned HOST_WIDE_INT
);
3830 static unsigned long size_of_die (dw_die_ref
);
3831 static void calc_die_sizes (dw_die_ref
);
3832 static void calc_base_type_die_sizes (void);
3833 static void mark_dies (dw_die_ref
);
3834 static void unmark_dies (dw_die_ref
);
3835 static void unmark_all_dies (dw_die_ref
);
3836 static unsigned long size_of_pubnames (vec
<pubname_entry
, va_gc
> *);
3837 static unsigned long size_of_aranges (void);
3838 static enum dwarf_form
value_format (dw_attr_node
*);
3839 static void output_value_format (dw_attr_node
*);
3840 static void output_abbrev_section (void);
3841 static void output_die_abbrevs (unsigned long, dw_die_ref
);
3842 static void output_die (dw_die_ref
);
3843 static void output_compilation_unit_header (enum dwarf_unit_type
);
3844 static void output_comp_unit (dw_die_ref
, int, const unsigned char *);
3845 static void output_comdat_type_unit (comdat_type_node
*, bool);
3846 static const char *dwarf2_name (tree
, int);
3847 static void add_pubname (tree
, dw_die_ref
);
3848 static void add_enumerator_pubname (const char *, dw_die_ref
);
3849 static void add_pubname_string (const char *, dw_die_ref
);
3850 static void add_pubtype (tree
, dw_die_ref
);
3851 static void output_pubnames (vec
<pubname_entry
, va_gc
> *);
3852 static void output_aranges (void);
3853 static unsigned int add_ranges (const_tree
, bool = false);
3854 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
3856 static void output_ranges (void);
3857 static dw_line_info_table
*new_line_info_table (void);
3858 static void output_line_info (bool);
3859 static void output_file_names (void);
3860 static bool is_base_type (tree
);
3861 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, tree
, dw_die_ref
);
3862 static int decl_quals (const_tree
);
3863 static dw_die_ref
modified_type_die (tree
, int, bool, dw_die_ref
);
3864 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
3865 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
3866 static unsigned int debugger_reg_number (const_rtx
);
3867 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3868 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3869 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3870 enum var_init_status
);
3871 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3872 enum var_init_status
);
3873 static dw_loc_descr_ref
based_loc_descr (rtx
, poly_int64
,
3874 enum var_init_status
);
3875 static bool is_based_loc (const_rtx
);
3876 static bool resolve_one_addr (rtx
*);
3877 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3878 enum var_init_status
);
3879 static dw_loc_descr_ref
loc_descriptor (rtx
, machine_mode mode
,
3880 enum var_init_status
);
3881 struct loc_descr_context
;
3882 static void add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
);
3883 static void add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
);
3884 static dw_loc_list_ref
loc_list_from_tree (tree
, int,
3885 struct loc_descr_context
*);
3886 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int,
3887 struct loc_descr_context
*);
3888 static tree
field_type (const_tree
);
3889 static unsigned int simple_type_align_in_bits (const_tree
);
3890 static unsigned int simple_decl_align_in_bits (const_tree
);
3891 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3893 static dw_loc_descr_ref
field_byte_offset (const_tree
, struct vlr_context
*,
3895 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3897 static void add_data_member_location_attribute (dw_die_ref
, tree
,
3898 struct vlr_context
*);
3899 static bool add_const_value_attribute (dw_die_ref
, machine_mode
, rtx
);
3900 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3901 static void insert_wide_int (const wide_int_ref
&, unsigned char *, int);
3902 static unsigned insert_float (const_rtx
, unsigned char *);
3903 static rtx
rtl_for_decl_location (tree
);
3904 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool);
3905 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3906 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3907 static void add_desc_attribute (dw_die_ref
, tree
);
3908 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3909 static void add_comp_dir_attribute (dw_die_ref
);
3910 static void add_scalar_info (dw_die_ref
, enum dwarf_attribute
, tree
, int,
3911 struct loc_descr_context
*);
3912 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
,
3913 struct loc_descr_context
*);
3914 static void add_subscript_info (dw_die_ref
, tree
, bool);
3915 static void add_byte_size_attribute (dw_die_ref
, tree
);
3916 static void add_alignment_attribute (dw_die_ref
, tree
);
3917 static void add_bit_offset_attribute (dw_die_ref
, tree
);
3918 static void add_bit_size_attribute (dw_die_ref
, tree
);
3919 static void add_prototyped_attribute (dw_die_ref
, tree
);
3920 static void add_abstract_origin_attribute (dw_die_ref
, tree
);
3921 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3922 static void add_src_coords_attributes (dw_die_ref
, tree
);
3923 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
, bool = false);
3924 static void add_discr_value (dw_die_ref
, dw_discr_value
*);
3925 static void add_discr_list (dw_die_ref
, dw_discr_list_ref
);
3926 static inline dw_discr_list_ref
AT_discr_list (dw_attr_node
*);
3927 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3928 static inline bool local_scope_p (dw_die_ref
);
3929 static inline bool class_scope_p (dw_die_ref
);
3930 static inline bool class_or_namespace_scope_p (dw_die_ref
);
3931 static void add_type_attribute (dw_die_ref
, tree
, int, bool, dw_die_ref
);
3932 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3933 static const char *type_tag (const_tree
);
3934 static tree
member_declared_type (const_tree
);
3936 static const char *decl_start_label (tree
);
3938 static void gen_array_type_die (tree
, dw_die_ref
);
3939 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3941 static void gen_entry_point_die (tree
, dw_die_ref
);
3943 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3944 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3945 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3946 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3947 static void gen_formal_types_die (tree
, dw_die_ref
);
3948 static void gen_subprogram_die (tree
, dw_die_ref
);
3949 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3950 static void gen_const_die (tree
, dw_die_ref
);
3951 static void gen_label_die (tree
, dw_die_ref
);
3952 static void gen_lexical_block_die (tree
, dw_die_ref
);
3953 static void gen_inlined_subroutine_die (tree
, dw_die_ref
);
3954 static void gen_field_die (tree
, struct vlr_context
*, dw_die_ref
);
3955 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3956 static dw_die_ref
gen_compile_unit_die (const char *);
3957 static void gen_inheritance_die (tree
, tree
, tree
, dw_die_ref
);
3958 static void gen_member_die (tree
, dw_die_ref
);
3959 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3960 enum debug_info_usage
);
3961 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3962 static void gen_typedef_die (tree
, dw_die_ref
);
3963 static void gen_type_die (tree
, dw_die_ref
);
3964 static void gen_block_die (tree
, dw_die_ref
);
3965 static void decls_for_scope (tree
, dw_die_ref
, bool = true);
3966 static bool is_naming_typedef_decl (const_tree
);
3967 static inline dw_die_ref
get_context_die (tree
);
3968 static void gen_namespace_die (tree
, dw_die_ref
);
3969 static dw_die_ref
gen_namelist_decl (tree
, dw_die_ref
, tree
);
3970 static dw_die_ref
gen_decl_die (tree
, tree
, struct vlr_context
*, dw_die_ref
);
3971 static dw_die_ref
force_decl_die (tree
);
3972 static dw_die_ref
force_type_die (tree
);
3973 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3974 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3975 static struct dwarf_file_data
* lookup_filename (const char *);
3976 static void retry_incomplete_types (void);
3977 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3978 static void gen_generic_params_dies (tree
);
3979 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3980 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3981 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3982 static int file_info_cmp (const void *, const void *);
3983 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *, var_loc_view
,
3984 const char *, var_loc_view
, const char *);
3985 static void output_loc_list (dw_loc_list_ref
);
3986 static char *gen_internal_sym (const char *);
3987 static bool want_pubnames (void);
3989 static void prune_unmark_dies (dw_die_ref
);
3990 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3991 static void prune_unused_types_mark (dw_die_ref
, int);
3992 static void prune_unused_types_walk (dw_die_ref
);
3993 static void prune_unused_types_walk_attribs (dw_die_ref
);
3994 static void prune_unused_types_prune (dw_die_ref
);
3995 static void prune_unused_types (void);
3996 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3997 static inline const char *AT_vms_delta1 (dw_attr_node
*);
3998 static inline const char *AT_vms_delta2 (dw_attr_node
*);
3999 #if VMS_DEBUGGING_INFO
4000 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
4001 const char *, const char *);
4003 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
4004 static void gen_remaining_tmpl_value_param_die_attribute (void);
4005 static bool generic_type_p (tree
);
4006 static void schedule_generic_params_dies_gen (tree t
);
4007 static void gen_scheduled_generic_parms_dies (void);
4008 static void resolve_variable_values (void);
4010 static const char *comp_dir_string (void);
4012 static void hash_loc_operands (dw_loc_descr_ref
, inchash::hash
&);
4014 /* enum for tracking thread-local variables whose address is really an offset
4015 relative to the TLS pointer, which will need link-time relocation, but will
4016 not need relocation by the DWARF consumer. */
4024 /* Return the operator to use for an address of a variable. For dtprel_true, we
4025 use DW_OP_const*. For regular variables, which need both link-time
4026 relocation and consumer-level relocation (e.g., to account for shared objects
4027 loaded at a random address), we use DW_OP_addr*. */
4029 static inline enum dwarf_location_atom
4030 dw_addr_op (enum dtprel_bool dtprel
)
4032 if (dtprel
== dtprel_true
)
4033 return (dwarf_split_debug_info
? dwarf_OP (DW_OP_constx
)
4034 : (DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
));
4036 return dwarf_split_debug_info
? dwarf_OP (DW_OP_addrx
) : DW_OP_addr
;
4039 /* Return a pointer to a newly allocated address location description. If
4040 dwarf_split_debug_info is true, then record the address with the appropriate
4042 static inline dw_loc_descr_ref
4043 new_addr_loc_descr (rtx addr
, enum dtprel_bool dtprel
)
4045 dw_loc_descr_ref ref
= new_loc_descr (dw_addr_op (dtprel
), 0, 0);
4047 ref
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
4048 ref
->dw_loc_oprnd1
.v
.val_addr
= addr
;
4049 ref
->dtprel
= dtprel
;
4050 if (dwarf_split_debug_info
)
4051 ref
->dw_loc_oprnd1
.val_entry
4052 = add_addr_table_entry (addr
,
4053 dtprel
? ate_kind_rtx_dtprel
: ate_kind_rtx
);
4055 ref
->dw_loc_oprnd1
.val_entry
= NULL
;
4060 /* Section names used to hold DWARF debugging information. */
4062 #ifndef DEBUG_INFO_SECTION
4063 #define DEBUG_INFO_SECTION ".debug_info"
4065 #ifndef DEBUG_DWO_INFO_SECTION
4066 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
4068 #ifndef DEBUG_LTO_INFO_SECTION
4069 #define DEBUG_LTO_INFO_SECTION ".gnu.debuglto_.debug_info"
4071 #ifndef DEBUG_LTO_DWO_INFO_SECTION
4072 #define DEBUG_LTO_DWO_INFO_SECTION ".gnu.debuglto_.debug_info.dwo"
4074 #ifndef DEBUG_ABBREV_SECTION
4075 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
4077 #ifndef DEBUG_LTO_ABBREV_SECTION
4078 #define DEBUG_LTO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev"
4080 #ifndef DEBUG_DWO_ABBREV_SECTION
4081 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
4083 #ifndef DEBUG_LTO_DWO_ABBREV_SECTION
4084 #define DEBUG_LTO_DWO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev.dwo"
4086 #ifndef DEBUG_ARANGES_SECTION
4087 #define DEBUG_ARANGES_SECTION ".debug_aranges"
4089 #ifndef DEBUG_ADDR_SECTION
4090 #define DEBUG_ADDR_SECTION ".debug_addr"
4092 #ifndef DEBUG_MACINFO_SECTION
4093 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
4095 #ifndef DEBUG_LTO_MACINFO_SECTION
4096 #define DEBUG_LTO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo"
4098 #ifndef DEBUG_DWO_MACINFO_SECTION
4099 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
4101 #ifndef DEBUG_LTO_DWO_MACINFO_SECTION
4102 #define DEBUG_LTO_DWO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo.dwo"
4104 #ifndef DEBUG_MACRO_SECTION
4105 #define DEBUG_MACRO_SECTION ".debug_macro"
4107 #ifndef DEBUG_LTO_MACRO_SECTION
4108 #define DEBUG_LTO_MACRO_SECTION ".gnu.debuglto_.debug_macro"
4110 #ifndef DEBUG_DWO_MACRO_SECTION
4111 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
4113 #ifndef DEBUG_LTO_DWO_MACRO_SECTION
4114 #define DEBUG_LTO_DWO_MACRO_SECTION ".gnu.debuglto_.debug_macro.dwo"
4116 #ifndef DEBUG_LINE_SECTION
4117 #define DEBUG_LINE_SECTION ".debug_line"
4119 #ifndef DEBUG_LTO_LINE_SECTION
4120 #define DEBUG_LTO_LINE_SECTION ".gnu.debuglto_.debug_line"
4122 #ifndef DEBUG_DWO_LINE_SECTION
4123 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
4125 #ifndef DEBUG_LTO_DWO_LINE_SECTION
4126 #define DEBUG_LTO_DWO_LINE_SECTION ".gnu.debuglto_.debug_line.dwo"
4128 #ifndef DEBUG_LOC_SECTION
4129 #define DEBUG_LOC_SECTION ".debug_loc"
4131 #ifndef DEBUG_DWO_LOC_SECTION
4132 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
4134 #ifndef DEBUG_LOCLISTS_SECTION
4135 #define DEBUG_LOCLISTS_SECTION ".debug_loclists"
4137 #ifndef DEBUG_DWO_LOCLISTS_SECTION
4138 #define DEBUG_DWO_LOCLISTS_SECTION ".debug_loclists.dwo"
4140 #ifndef DEBUG_PUBNAMES_SECTION
4141 #define DEBUG_PUBNAMES_SECTION \
4142 ((debug_generate_pub_sections == 2) \
4143 ? ".debug_gnu_pubnames" : ".debug_pubnames")
4145 #ifndef DEBUG_PUBTYPES_SECTION
4146 #define DEBUG_PUBTYPES_SECTION \
4147 ((debug_generate_pub_sections == 2) \
4148 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
4150 #ifndef DEBUG_STR_OFFSETS_SECTION
4151 #define DEBUG_STR_OFFSETS_SECTION ".debug_str_offsets"
4153 #ifndef DEBUG_DWO_STR_OFFSETS_SECTION
4154 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
4156 #ifndef DEBUG_LTO_DWO_STR_OFFSETS_SECTION
4157 #define DEBUG_LTO_DWO_STR_OFFSETS_SECTION ".gnu.debuglto_.debug_str_offsets.dwo"
4159 #ifndef DEBUG_STR_SECTION
4160 #define DEBUG_STR_SECTION ".debug_str"
4162 #ifndef DEBUG_LTO_STR_SECTION
4163 #define DEBUG_LTO_STR_SECTION ".gnu.debuglto_.debug_str"
4165 #ifndef DEBUG_STR_DWO_SECTION
4166 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
4168 #ifndef DEBUG_LTO_STR_DWO_SECTION
4169 #define DEBUG_LTO_STR_DWO_SECTION ".gnu.debuglto_.debug_str.dwo"
4171 #ifndef DEBUG_RANGES_SECTION
4172 #define DEBUG_RANGES_SECTION ".debug_ranges"
4174 #ifndef DEBUG_RNGLISTS_SECTION
4175 #define DEBUG_RNGLISTS_SECTION ".debug_rnglists"
4177 #ifndef DEBUG_DWO_RNGLISTS_SECTION
4178 #define DEBUG_DWO_RNGLISTS_SECTION ".debug_rnglists.dwo"
4180 #ifndef DEBUG_LINE_STR_SECTION
4181 #define DEBUG_LINE_STR_SECTION ".debug_line_str"
4183 #ifndef DEBUG_LTO_LINE_STR_SECTION
4184 #define DEBUG_LTO_LINE_STR_SECTION ".gnu.debuglto_.debug_line_str"
4187 /* Section flags for .debug_str section. */
4188 #define DEBUG_STR_SECTION_FLAGS \
4189 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
4190 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4193 /* Section flags for .debug_str.dwo section. */
4194 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
4196 /* Attribute used to refer to the macro section. */
4197 #define DEBUG_MACRO_ATTRIBUTE (dwarf_version >= 5 ? DW_AT_macros \
4198 : dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros)
4200 /* Labels we insert at beginning sections we can reference instead of
4201 the section names themselves. */
4203 #ifndef TEXT_SECTION_LABEL
4204 #define TEXT_SECTION_LABEL "Ltext"
4206 #ifndef COLD_TEXT_SECTION_LABEL
4207 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
4209 #ifndef DEBUG_LINE_SECTION_LABEL
4210 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4212 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
4213 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
4215 #ifndef DEBUG_INFO_SECTION_LABEL
4216 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4218 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
4219 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
4221 #ifndef DEBUG_ABBREV_SECTION_LABEL
4222 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4224 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
4225 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
4227 #ifndef DEBUG_ADDR_SECTION_LABEL
4228 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
4230 #ifndef DEBUG_LOC_SECTION_LABEL
4231 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4233 #ifndef DEBUG_RANGES_SECTION_LABEL
4234 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4236 #ifndef DEBUG_MACINFO_SECTION_LABEL
4237 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4239 #ifndef DEBUG_MACRO_SECTION_LABEL
4240 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
4242 #define SKELETON_COMP_DIE_ABBREV 1
4243 #define SKELETON_TYPE_DIE_ABBREV 2
4245 /* Definitions of defaults for formats and names of various special
4246 (artificial) labels which may be generated within this file (when the -g
4247 options is used and DWARF2_DEBUGGING_INFO is in effect.
4248 If necessary, these may be overridden from within the tm.h file, but
4249 typically, overriding these defaults is unnecessary. */
4251 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4252 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4253 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4254 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4255 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4256 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4257 static char debug_skeleton_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4258 static char debug_skeleton_abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4259 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4260 static char debug_addr_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4261 static char debug_skeleton_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4262 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4263 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4264 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4265 static char ranges_base_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4267 #ifndef TEXT_END_LABEL
4268 #define TEXT_END_LABEL "Letext"
4270 #ifndef COLD_END_LABEL
4271 #define COLD_END_LABEL "Letext_cold"
4273 #ifndef BLOCK_BEGIN_LABEL
4274 #define BLOCK_BEGIN_LABEL "LBB"
4276 #ifndef BLOCK_INLINE_ENTRY_LABEL
4277 #define BLOCK_INLINE_ENTRY_LABEL "LBI"
4279 #ifndef BLOCK_END_LABEL
4280 #define BLOCK_END_LABEL "LBE"
4282 #ifndef LINE_CODE_LABEL
4283 #define LINE_CODE_LABEL "LM"
4287 /* Return the root of the DIE's built for the current compilation unit. */
4289 comp_unit_die (void)
4291 if (!single_comp_unit_die
)
4292 single_comp_unit_die
= gen_compile_unit_die (NULL
);
4293 return single_comp_unit_die
;
4296 /* We allow a language front-end to designate a function that is to be
4297 called to "demangle" any name before it is put into a DIE. */
4299 static const char *(*demangle_name_func
) (const char *);
4302 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
4304 demangle_name_func
= func
;
4307 /* Test if rtl node points to a pseudo register. */
4310 is_pseudo_reg (const_rtx rtl
)
4312 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
4313 || (GET_CODE (rtl
) == SUBREG
4314 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
4317 /* Return a reference to a type, with its const and volatile qualifiers
4321 type_main_variant (tree type
)
4323 type
= TYPE_MAIN_VARIANT (type
);
4325 /* ??? There really should be only one main variant among any group of
4326 variants of a given type (and all of the MAIN_VARIANT values for all
4327 members of the group should point to that one type) but sometimes the C
4328 front-end messes this up for array types, so we work around that bug
4330 if (TREE_CODE (type
) == ARRAY_TYPE
)
4331 while (type
!= TYPE_MAIN_VARIANT (type
))
4332 type
= TYPE_MAIN_VARIANT (type
);
4337 /* Return true if the given type node represents a tagged type. */
4340 is_tagged_type (const_tree type
)
4342 enum tree_code code
= TREE_CODE (type
);
4344 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
4345 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
4348 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
4351 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
4353 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
4356 /* Return die_offset of a DIE reference to a base type. */
4358 static unsigned long int
4359 get_base_type_offset (dw_die_ref ref
)
4361 if (ref
->die_offset
)
4362 return ref
->die_offset
;
4363 if (comp_unit_die ()->die_abbrev
)
4365 calc_base_type_die_sizes ();
4366 gcc_assert (ref
->die_offset
);
4368 return ref
->die_offset
;
4371 /* Return die_offset of a DIE reference other than base type. */
4373 static unsigned long int
4374 get_ref_die_offset (dw_die_ref ref
)
4376 gcc_assert (ref
->die_offset
);
4377 return ref
->die_offset
;
4380 /* Convert a DIE tag into its string name. */
4383 dwarf_tag_name (unsigned int tag
)
4385 const char *name
= get_DW_TAG_name (tag
);
4390 return "DW_TAG_<unknown>";
4393 /* Convert a DWARF attribute code into its string name. */
4396 dwarf_attr_name (unsigned int attr
)
4402 #if VMS_DEBUGGING_INFO
4403 case DW_AT_HP_prologue
:
4404 return "DW_AT_HP_prologue";
4406 case DW_AT_MIPS_loop_unroll_factor
:
4407 return "DW_AT_MIPS_loop_unroll_factor";
4410 #if VMS_DEBUGGING_INFO
4411 case DW_AT_HP_epilogue
:
4412 return "DW_AT_HP_epilogue";
4414 case DW_AT_MIPS_stride
:
4415 return "DW_AT_MIPS_stride";
4419 name
= get_DW_AT_name (attr
);
4424 return "DW_AT_<unknown>";
4427 /* Convert a DWARF value form code into its string name. */
4430 dwarf_form_name (unsigned int form
)
4432 const char *name
= get_DW_FORM_name (form
);
4437 return "DW_FORM_<unknown>";
4440 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4441 instance of an inlined instance of a decl which is local to an inline
4442 function, so we have to trace all of the way back through the origin chain
4443 to find out what sort of node actually served as the original seed for the
4447 decl_ultimate_origin (const_tree decl
)
4449 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
4452 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
4453 we're trying to output the abstract instance of this function. */
4454 if (DECL_ABSTRACT_P (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
4457 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4458 most distant ancestor, this should never happen. */
4459 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
4461 return DECL_ABSTRACT_ORIGIN (decl
);
4464 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4465 of a virtual function may refer to a base class, so we check the 'this'
4469 decl_class_context (tree decl
)
4471 tree context
= NULL_TREE
;
4473 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
4474 context
= DECL_CONTEXT (decl
);
4476 context
= TYPE_MAIN_VARIANT
4477 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
4479 if (context
&& !TYPE_P (context
))
4480 context
= NULL_TREE
;
4485 /* Add an attribute/value pair to a DIE. */
4488 add_dwarf_attr (dw_die_ref die
, dw_attr_node
*attr
)
4490 /* Maybe this should be an assert? */
4496 /* Check we do not add duplicate attrs. Can't use get_AT here
4497 because that recurses to the specification/abstract origin DIE. */
4500 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4501 gcc_assert (a
->dw_attr
!= attr
->dw_attr
);
4504 vec_safe_reserve (die
->die_attr
, 1);
4505 vec_safe_push (die
->die_attr
, *attr
);
4509 AT_class (dw_attr_node
*a
)
4511 return a
->dw_attr_val
.val_class
;
4514 /* Return the index for any attribute that will be referenced with a
4515 DW_FORM_addrx/GNU_addr_index or DW_FORM_strx/GNU_str_index. String
4516 indices are stored in dw_attr_val.v.val_str for reference counting
4519 static inline unsigned int
4520 AT_index (dw_attr_node
*a
)
4522 if (AT_class (a
) == dw_val_class_str
)
4523 return a
->dw_attr_val
.v
.val_str
->index
;
4524 else if (a
->dw_attr_val
.val_entry
!= NULL
)
4525 return a
->dw_attr_val
.val_entry
->index
;
4529 /* Add a flag value attribute to a DIE. */
4532 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
4536 attr
.dw_attr
= attr_kind
;
4537 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
4538 attr
.dw_attr_val
.val_entry
= NULL
;
4539 attr
.dw_attr_val
.v
.val_flag
= flag
;
4540 add_dwarf_attr (die
, &attr
);
4543 static inline unsigned
4544 AT_flag (dw_attr_node
*a
)
4546 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
4547 return a
->dw_attr_val
.v
.val_flag
;
4550 /* Add a signed integer attribute value to a DIE. */
4553 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
4557 attr
.dw_attr
= attr_kind
;
4558 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
4559 attr
.dw_attr_val
.val_entry
= NULL
;
4560 attr
.dw_attr_val
.v
.val_int
= int_val
;
4561 add_dwarf_attr (die
, &attr
);
4565 AT_int (dw_attr_node
*a
)
4567 gcc_assert (a
&& (AT_class (a
) == dw_val_class_const
4568 || AT_class (a
) == dw_val_class_const_implicit
));
4569 return a
->dw_attr_val
.v
.val_int
;
4572 /* Add an unsigned integer attribute value to a DIE. */
4575 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4576 unsigned HOST_WIDE_INT unsigned_val
)
4580 attr
.dw_attr
= attr_kind
;
4581 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
4582 attr
.dw_attr_val
.val_entry
= NULL
;
4583 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
4584 add_dwarf_attr (die
, &attr
);
4587 unsigned HOST_WIDE_INT
4588 AT_unsigned (dw_attr_node
*a
)
4590 gcc_assert (a
&& (AT_class (a
) == dw_val_class_unsigned_const
4591 || AT_class (a
) == dw_val_class_unsigned_const_implicit
));
4592 return a
->dw_attr_val
.v
.val_unsigned
;
4596 alloc_dw_wide_int (const wide_int_ref
&w
)
4599 = (dw_wide_int
*) ggc_internal_alloc (sizeof (dw_wide_int
)
4600 + ((w
.get_len () - 1)
4601 * sizeof (HOST_WIDE_INT
)));
4602 p
->precision
= w
.get_precision ();
4603 p
->len
= w
.get_len ();
4604 memcpy (p
->val
, w
.get_val (), p
->len
* sizeof (HOST_WIDE_INT
));
4608 /* Add an unsigned wide integer attribute value to a DIE. */
4611 add_AT_wide (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4612 const wide_int_ref
&w
)
4616 attr
.dw_attr
= attr_kind
;
4617 attr
.dw_attr_val
.val_class
= dw_val_class_wide_int
;
4618 attr
.dw_attr_val
.val_entry
= NULL
;
4619 attr
.dw_attr_val
.v
.val_wide
= alloc_dw_wide_int (w
);
4620 add_dwarf_attr (die
, &attr
);
4623 /* Add an unsigned double integer attribute value to a DIE. */
4626 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4627 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
4631 attr
.dw_attr
= attr_kind
;
4632 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
4633 attr
.dw_attr_val
.val_entry
= NULL
;
4634 attr
.dw_attr_val
.v
.val_double
.high
= high
;
4635 attr
.dw_attr_val
.v
.val_double
.low
= low
;
4636 add_dwarf_attr (die
, &attr
);
4639 /* Add a floating point attribute value to a DIE and return it. */
4642 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4643 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
4647 attr
.dw_attr
= attr_kind
;
4648 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
4649 attr
.dw_attr_val
.val_entry
= NULL
;
4650 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
4651 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
4652 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
4653 add_dwarf_attr (die
, &attr
);
4656 /* Add an 8-byte data attribute value to a DIE. */
4659 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4660 unsigned char data8
[8])
4664 attr
.dw_attr
= attr_kind
;
4665 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
4666 attr
.dw_attr_val
.val_entry
= NULL
;
4667 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
4668 add_dwarf_attr (die
, &attr
);
4671 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
4672 dwarf_split_debug_info, address attributes in dies destined for the
4673 final executable have force_direct set to avoid using indexed
4677 add_AT_low_high_pc (dw_die_ref die
, const char *lbl_low
, const char *lbl_high
,
4683 lbl_id
= xstrdup (lbl_low
);
4684 attr
.dw_attr
= DW_AT_low_pc
;
4685 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4686 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4687 if (dwarf_split_debug_info
&& !force_direct
)
4688 attr
.dw_attr_val
.val_entry
4689 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4691 attr
.dw_attr_val
.val_entry
= NULL
;
4692 add_dwarf_attr (die
, &attr
);
4694 attr
.dw_attr
= DW_AT_high_pc
;
4695 if (dwarf_version
< 4)
4696 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4698 attr
.dw_attr_val
.val_class
= dw_val_class_high_pc
;
4699 lbl_id
= xstrdup (lbl_high
);
4700 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4701 if (attr
.dw_attr_val
.val_class
== dw_val_class_lbl_id
4702 && dwarf_split_debug_info
&& !force_direct
)
4703 attr
.dw_attr_val
.val_entry
4704 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4706 attr
.dw_attr_val
.val_entry
= NULL
;
4707 add_dwarf_attr (die
, &attr
);
4710 /* Hash and equality functions for debug_str_hash. */
4713 indirect_string_hasher::hash (indirect_string_node
*x
)
4715 return htab_hash_string (x
->str
);
4719 indirect_string_hasher::equal (indirect_string_node
*x1
, const char *x2
)
4721 return strcmp (x1
->str
, x2
) == 0;
4724 /* Add STR to the given string hash table. */
4726 static struct indirect_string_node
*
4727 find_AT_string_in_table (const char *str
,
4728 hash_table
<indirect_string_hasher
> *table
,
4729 enum insert_option insert
= INSERT
)
4731 struct indirect_string_node
*node
;
4733 indirect_string_node
**slot
4734 = table
->find_slot_with_hash (str
, htab_hash_string (str
), insert
);
4737 node
= ggc_cleared_alloc
<indirect_string_node
> ();
4738 node
->str
= ggc_strdup (str
);
4748 /* Add STR to the indirect string hash table. */
4750 static struct indirect_string_node
*
4751 find_AT_string (const char *str
, enum insert_option insert
= INSERT
)
4753 if (! debug_str_hash
)
4754 debug_str_hash
= hash_table
<indirect_string_hasher
>::create_ggc (10);
4756 return find_AT_string_in_table (str
, debug_str_hash
, insert
);
4759 /* Add a string attribute value to a DIE. */
4762 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
4765 struct indirect_string_node
*node
;
4767 node
= find_AT_string (str
);
4769 attr
.dw_attr
= attr_kind
;
4770 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
4771 attr
.dw_attr_val
.val_entry
= NULL
;
4772 attr
.dw_attr_val
.v
.val_str
= node
;
4773 add_dwarf_attr (die
, &attr
);
4776 static inline const char *
4777 AT_string (dw_attr_node
*a
)
4779 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4780 return a
->dw_attr_val
.v
.val_str
->str
;
4783 /* Call this function directly to bypass AT_string_form's logic to put
4784 the string inline in the die. */
4787 set_indirect_string (struct indirect_string_node
*node
)
4789 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4790 /* Already indirect is a no op. */
4791 if (node
->form
== DW_FORM_strp
4792 || node
->form
== DW_FORM_line_strp
4793 || node
->form
== dwarf_FORM (DW_FORM_strx
))
4795 gcc_assert (node
->label
);
4798 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4799 ++dw2_string_counter
;
4800 node
->label
= xstrdup (label
);
4802 if (!dwarf_split_debug_info
)
4804 node
->form
= DW_FORM_strp
;
4805 node
->index
= NOT_INDEXED
;
4809 node
->form
= dwarf_FORM (DW_FORM_strx
);
4810 node
->index
= NO_INDEX_ASSIGNED
;
4814 /* A helper function for dwarf2out_finish, called to reset indirect
4815 string decisions done for early LTO dwarf output before fat object
4819 reset_indirect_string (indirect_string_node
**h
, void *)
4821 struct indirect_string_node
*node
= *h
;
4822 if (node
->form
== DW_FORM_strp
4823 || node
->form
== DW_FORM_line_strp
4824 || node
->form
== dwarf_FORM (DW_FORM_strx
))
4828 node
->form
= (dwarf_form
) 0;
4834 /* Add a string representing a file or filepath attribute value to a DIE. */
4837 add_filepath_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4840 if (! asm_outputs_debug_line_str ())
4841 add_AT_string (die
, attr_kind
, str
);
4845 struct indirect_string_node
*node
;
4847 if (!debug_line_str_hash
)
4849 = hash_table
<indirect_string_hasher
>::create_ggc (10);
4851 node
= find_AT_string_in_table (str
, debug_line_str_hash
);
4852 set_indirect_string (node
);
4853 node
->form
= DW_FORM_line_strp
;
4855 attr
.dw_attr
= attr_kind
;
4856 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
4857 attr
.dw_attr_val
.val_entry
= NULL
;
4858 attr
.dw_attr_val
.v
.val_str
= node
;
4859 add_dwarf_attr (die
, &attr
);
4863 /* Find out whether a string should be output inline in DIE
4864 or out-of-line in .debug_str section. */
4866 static enum dwarf_form
4867 find_string_form (struct indirect_string_node
*node
)
4874 len
= strlen (node
->str
) + 1;
4876 /* If the string is shorter or equal to the size of the reference, it is
4877 always better to put it inline. */
4878 if (len
<= (unsigned) dwarf_offset_size
|| node
->refcount
== 0)
4879 return node
->form
= DW_FORM_string
;
4881 /* If we cannot expect the linker to merge strings in .debug_str
4882 section, only put it into .debug_str if it is worth even in this
4884 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4885 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
4886 && (len
- dwarf_offset_size
) * node
->refcount
<= len
))
4887 return node
->form
= DW_FORM_string
;
4889 set_indirect_string (node
);
4894 /* Find out whether the string referenced from the attribute should be
4895 output inline in DIE or out-of-line in .debug_str section. */
4897 static enum dwarf_form
4898 AT_string_form (dw_attr_node
*a
)
4900 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4901 return find_string_form (a
->dw_attr_val
.v
.val_str
);
4904 /* Add a DIE reference attribute value to a DIE. */
4907 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4910 gcc_checking_assert (targ_die
!= NULL
);
4912 /* With LTO we can end up trying to reference something we didn't create
4913 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4914 if (targ_die
== NULL
)
4917 attr
.dw_attr
= attr_kind
;
4918 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
4919 attr
.dw_attr_val
.val_entry
= NULL
;
4920 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4921 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
4922 add_dwarf_attr (die
, &attr
);
4925 /* Change DIE reference REF to point to NEW_DIE instead. */
4928 change_AT_die_ref (dw_attr_node
*ref
, dw_die_ref new_die
)
4930 gcc_assert (ref
->dw_attr_val
.val_class
== dw_val_class_die_ref
);
4931 ref
->dw_attr_val
.v
.val_die_ref
.die
= new_die
;
4932 ref
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4935 /* Add an AT_specification attribute to a DIE, and also make the back
4936 pointer from the specification to the definition. */
4939 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4941 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4942 gcc_assert (!targ_die
->die_definition
);
4943 targ_die
->die_definition
= die
;
4946 static inline dw_die_ref
4947 AT_ref (dw_attr_node
*a
)
4949 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4950 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4954 AT_ref_external (dw_attr_node
*a
)
4956 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4957 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4963 set_AT_ref_external (dw_attr_node
*a
, int i
)
4965 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4966 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4969 /* Add a location description attribute value to a DIE. */
4972 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4976 attr
.dw_attr
= attr_kind
;
4977 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4978 attr
.dw_attr_val
.val_entry
= NULL
;
4979 attr
.dw_attr_val
.v
.val_loc
= loc
;
4980 add_dwarf_attr (die
, &attr
);
4984 AT_loc (dw_attr_node
*a
)
4986 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4987 return a
->dw_attr_val
.v
.val_loc
;
4991 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4995 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4998 attr
.dw_attr
= attr_kind
;
4999 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
5000 attr
.dw_attr_val
.val_entry
= NULL
;
5001 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
5002 add_dwarf_attr (die
, &attr
);
5003 have_location_lists
= true;
5006 static inline dw_loc_list_ref
5007 AT_loc_list (dw_attr_node
*a
)
5009 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
5010 return a
->dw_attr_val
.v
.val_loc_list
;
5013 /* Add a view list attribute to DIE. It must have a DW_AT_location
5014 attribute, because the view list complements the location list. */
5017 add_AT_view_list (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5021 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
5024 attr
.dw_attr
= attr_kind
;
5025 attr
.dw_attr_val
.val_class
= dw_val_class_view_list
;
5026 attr
.dw_attr_val
.val_entry
= NULL
;
5027 attr
.dw_attr_val
.v
.val_view_list
= die
;
5028 add_dwarf_attr (die
, &attr
);
5029 gcc_checking_assert (get_AT (die
, DW_AT_location
));
5030 gcc_assert (have_location_lists
);
5033 /* Return a pointer to the location list referenced by the attribute.
5034 If the named attribute is a view list, look up the corresponding
5035 DW_AT_location attribute and return its location list. */
5037 static inline dw_loc_list_ref
*
5038 AT_loc_list_ptr (dw_attr_node
*a
)
5041 switch (AT_class (a
))
5043 case dw_val_class_loc_list
:
5044 return &a
->dw_attr_val
.v
.val_loc_list
;
5045 case dw_val_class_view_list
:
5048 l
= get_AT (a
->dw_attr_val
.v
.val_view_list
, DW_AT_location
);
5051 gcc_checking_assert (l
+ 1 == a
);
5052 return AT_loc_list_ptr (l
);
5059 /* Return the location attribute value associated with a view list
5062 static inline dw_val_node
*
5063 view_list_to_loc_list_val_node (dw_val_node
*val
)
5065 gcc_assert (val
->val_class
== dw_val_class_view_list
);
5066 dw_attr_node
*loc
= get_AT (val
->v
.val_view_list
, DW_AT_location
);
5069 gcc_checking_assert (&(loc
+ 1)->dw_attr_val
== val
);
5070 gcc_assert (AT_class (loc
) == dw_val_class_loc_list
);
5071 return &loc
->dw_attr_val
;
5074 struct addr_hasher
: ggc_ptr_hash
<addr_table_entry
>
5076 static hashval_t
hash (addr_table_entry
*);
5077 static bool equal (addr_table_entry
*, addr_table_entry
*);
5080 /* Table of entries into the .debug_addr section. */
5082 static GTY (()) hash_table
<addr_hasher
> *addr_index_table
;
5084 /* Hash an address_table_entry. */
5087 addr_hasher::hash (addr_table_entry
*a
)
5089 inchash::hash hstate
;
5095 case ate_kind_rtx_dtprel
:
5098 case ate_kind_label
:
5099 return htab_hash_string (a
->addr
.label
);
5103 inchash::add_rtx (a
->addr
.rtl
, hstate
);
5104 return hstate
.end ();
5107 /* Determine equality for two address_table_entries. */
5110 addr_hasher::equal (addr_table_entry
*a1
, addr_table_entry
*a2
)
5112 if (a1
->kind
!= a2
->kind
)
5117 case ate_kind_rtx_dtprel
:
5118 return rtx_equal_p (a1
->addr
.rtl
, a2
->addr
.rtl
);
5119 case ate_kind_label
:
5120 return strcmp (a1
->addr
.label
, a2
->addr
.label
) == 0;
5126 /* Initialize an addr_table_entry. */
5129 init_addr_table_entry (addr_table_entry
*e
, enum ate_kind kind
, void *addr
)
5135 case ate_kind_rtx_dtprel
:
5136 e
->addr
.rtl
= (rtx
) addr
;
5138 case ate_kind_label
:
5139 e
->addr
.label
= (char *) addr
;
5143 e
->index
= NO_INDEX_ASSIGNED
;
5146 /* Add attr to the address table entry to the table. Defer setting an
5147 index until output time. */
5149 static addr_table_entry
*
5150 add_addr_table_entry (void *addr
, enum ate_kind kind
)
5152 addr_table_entry
*node
;
5153 addr_table_entry finder
;
5155 gcc_assert (dwarf_split_debug_info
);
5156 if (! addr_index_table
)
5157 addr_index_table
= hash_table
<addr_hasher
>::create_ggc (10);
5158 init_addr_table_entry (&finder
, kind
, addr
);
5159 addr_table_entry
**slot
= addr_index_table
->find_slot (&finder
, INSERT
);
5161 if (*slot
== HTAB_EMPTY_ENTRY
)
5163 node
= ggc_cleared_alloc
<addr_table_entry
> ();
5164 init_addr_table_entry (node
, kind
, addr
);
5174 /* Remove an entry from the addr table by decrementing its refcount.
5175 Strictly, decrementing the refcount would be enough, but the
5176 assertion that the entry is actually in the table has found
5180 remove_addr_table_entry (addr_table_entry
*entry
)
5182 gcc_assert (dwarf_split_debug_info
&& addr_index_table
);
5183 /* After an index is assigned, the table is frozen. */
5184 gcc_assert (entry
->refcount
> 0 && entry
->index
== NO_INDEX_ASSIGNED
);
5188 /* Given a location list, remove all addresses it refers to from the
5192 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr
)
5194 for (; descr
; descr
= descr
->dw_loc_next
)
5195 if (descr
->dw_loc_oprnd1
.val_entry
!= NULL
)
5197 gcc_assert (descr
->dw_loc_oprnd1
.val_entry
->index
== NO_INDEX_ASSIGNED
);
5198 remove_addr_table_entry (descr
->dw_loc_oprnd1
.val_entry
);
5202 /* A helper function for dwarf2out_finish called through
5203 htab_traverse. Assign an addr_table_entry its index. All entries
5204 must be collected into the table when this function is called,
5205 because the indexing code relies on htab_traverse to traverse nodes
5206 in the same order for each run. */
5209 index_addr_table_entry (addr_table_entry
**h
, unsigned int *index
)
5211 addr_table_entry
*node
= *h
;
5213 /* Don't index unreferenced nodes. */
5214 if (node
->refcount
== 0)
5217 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
5218 node
->index
= *index
;
5224 /* Return the tag of a given DIE. */
5227 dw_get_die_tag (dw_die_ref die
)
5229 return die
->die_tag
;
5232 /* Return a reference to the children list of a given DIE. */
5235 dw_get_die_child (dw_die_ref die
)
5237 return die
->die_child
;
5240 /* Return a reference to the sibling of a given DIE. */
5243 dw_get_die_sib (dw_die_ref die
)
5245 return die
->die_sib
;
5248 /* Add an address constant attribute value to a DIE. When using
5249 dwarf_split_debug_info, address attributes in dies destined for the
5250 final executable should be direct references--setting the parameter
5251 force_direct ensures this behavior. */
5254 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
,
5259 attr
.dw_attr
= attr_kind
;
5260 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
5261 attr
.dw_attr_val
.v
.val_addr
= addr
;
5262 if (dwarf_split_debug_info
&& !force_direct
)
5263 attr
.dw_attr_val
.val_entry
= add_addr_table_entry (addr
, ate_kind_rtx
);
5265 attr
.dw_attr_val
.val_entry
= NULL
;
5266 add_dwarf_attr (die
, &attr
);
5269 /* Get the RTX from to an address DIE attribute. */
5272 AT_addr (dw_attr_node
*a
)
5274 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
5275 return a
->dw_attr_val
.v
.val_addr
;
5278 /* Add a file attribute value to a DIE. */
5281 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5282 struct dwarf_file_data
*fd
)
5286 attr
.dw_attr
= attr_kind
;
5287 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
5288 attr
.dw_attr_val
.val_entry
= NULL
;
5289 attr
.dw_attr_val
.v
.val_file
= fd
;
5290 add_dwarf_attr (die
, &attr
);
5293 /* Get the dwarf_file_data from a file DIE attribute. */
5295 static inline struct dwarf_file_data
*
5296 AT_file (dw_attr_node
*a
)
5298 gcc_assert (a
&& (AT_class (a
) == dw_val_class_file
5299 || AT_class (a
) == dw_val_class_file_implicit
));
5300 return a
->dw_attr_val
.v
.val_file
;
5303 #if VMS_DEBUGGING_INFO
5304 /* Add a vms delta attribute value to a DIE. */
5307 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5308 const char *lbl1
, const char *lbl2
)
5312 attr
.dw_attr
= attr_kind
;
5313 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
5314 attr
.dw_attr_val
.val_entry
= NULL
;
5315 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
5316 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
5317 add_dwarf_attr (die
, &attr
);
5321 /* Add a symbolic view identifier attribute value to a DIE. */
5324 add_AT_symview (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5325 const char *view_label
)
5329 attr
.dw_attr
= attr_kind
;
5330 attr
.dw_attr_val
.val_class
= dw_val_class_symview
;
5331 attr
.dw_attr_val
.val_entry
= NULL
;
5332 attr
.dw_attr_val
.v
.val_symbolic_view
= xstrdup (view_label
);
5333 add_dwarf_attr (die
, &attr
);
5336 /* Add a label identifier attribute value to a DIE. */
5339 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5344 attr
.dw_attr
= attr_kind
;
5345 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
5346 attr
.dw_attr_val
.val_entry
= NULL
;
5347 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
5348 if (dwarf_split_debug_info
)
5349 attr
.dw_attr_val
.val_entry
5350 = add_addr_table_entry (attr
.dw_attr_val
.v
.val_lbl_id
,
5352 add_dwarf_attr (die
, &attr
);
5355 /* Add a section offset attribute value to a DIE, an offset into the
5356 debug_line section. */
5359 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5364 attr
.dw_attr
= attr_kind
;
5365 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
5366 attr
.dw_attr_val
.val_entry
= NULL
;
5367 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5368 add_dwarf_attr (die
, &attr
);
5371 /* Add a section offset attribute value to a DIE, an offset into the
5372 debug_macinfo section. */
5375 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5380 attr
.dw_attr
= attr_kind
;
5381 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
5382 attr
.dw_attr_val
.val_entry
= NULL
;
5383 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5384 add_dwarf_attr (die
, &attr
);
5387 /* Add a range_list attribute value to a DIE. When using
5388 dwarf_split_debug_info, address attributes in dies destined for the
5389 final executable should be direct references--setting the parameter
5390 force_direct ensures this behavior. */
5392 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
5393 #define RELOCATED_OFFSET (NULL)
5396 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5397 long unsigned int offset
, bool force_direct
)
5401 attr
.dw_attr
= attr_kind
;
5402 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
5403 /* For the range_list attribute, use val_entry to store whether the
5404 offset should follow split-debug-info or normal semantics. This
5405 value is read in output_range_list_offset. */
5406 if (dwarf_split_debug_info
&& !force_direct
)
5407 attr
.dw_attr_val
.val_entry
= UNRELOCATED_OFFSET
;
5409 attr
.dw_attr_val
.val_entry
= RELOCATED_OFFSET
;
5410 attr
.dw_attr_val
.v
.val_offset
= offset
;
5411 add_dwarf_attr (die
, &attr
);
5414 /* Return the start label of a delta attribute. */
5416 static inline const char *
5417 AT_vms_delta1 (dw_attr_node
*a
)
5419 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5420 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
5423 /* Return the end label of a delta attribute. */
5425 static inline const char *
5426 AT_vms_delta2 (dw_attr_node
*a
)
5428 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5429 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
5432 static inline const char *
5433 AT_lbl (dw_attr_node
*a
)
5435 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
5436 || AT_class (a
) == dw_val_class_lineptr
5437 || AT_class (a
) == dw_val_class_macptr
5438 || AT_class (a
) == dw_val_class_loclistsptr
5439 || AT_class (a
) == dw_val_class_high_pc
));
5440 return a
->dw_attr_val
.v
.val_lbl_id
;
5443 /* Get the attribute of type attr_kind. */
5446 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5450 dw_die_ref spec
= NULL
;
5455 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5456 if (a
->dw_attr
== attr_kind
)
5458 else if (a
->dw_attr
== DW_AT_specification
5459 || a
->dw_attr
== DW_AT_abstract_origin
)
5463 return get_AT (spec
, attr_kind
);
5468 /* Returns the parent of the declaration of DIE. */
5471 get_die_parent (dw_die_ref die
)
5478 if ((t
= get_AT_ref (die
, DW_AT_abstract_origin
))
5479 || (t
= get_AT_ref (die
, DW_AT_specification
)))
5482 return die
->die_parent
;
5485 /* Return the "low pc" attribute value, typically associated with a subprogram
5486 DIE. Return null if the "low pc" attribute is either not present, or if it
5487 cannot be represented as an assembler label identifier. */
5489 static inline const char *
5490 get_AT_low_pc (dw_die_ref die
)
5492 dw_attr_node
*a
= get_AT (die
, DW_AT_low_pc
);
5494 return a
? AT_lbl (a
) : NULL
;
5497 /* Return the value of the string attribute designated by ATTR_KIND, or
5498 NULL if it is not present. */
5501 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5503 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5505 return a
? AT_string (a
) : NULL
;
5508 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5509 if it is not present. */
5512 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5514 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5516 return a
? AT_flag (a
) : 0;
5519 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5520 if it is not present. */
5523 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5525 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5527 return a
? AT_unsigned (a
) : 0;
5531 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5533 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5535 return a
? AT_ref (a
) : NULL
;
5538 struct dwarf_file_data
*
5539 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5541 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5543 return a
? AT_file (a
) : NULL
;
5546 /* Return TRUE if the language is C. */
5551 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5553 return (lang
== DW_LANG_C
|| lang
== DW_LANG_C89
|| lang
== DW_LANG_C99
5554 || lang
== DW_LANG_C11
|| lang
== DW_LANG_ObjC
);
5559 /* Return TRUE if the language is C++. */
5564 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5566 return (lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
5567 || lang
== DW_LANG_C_plus_plus_11
|| lang
== DW_LANG_C_plus_plus_14
);
5570 /* Return TRUE if DECL was created by the C++ frontend. */
5573 is_cxx (const_tree decl
)
5577 const_tree context
= get_ultimate_context (decl
);
5578 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5579 return startswith (TRANSLATION_UNIT_LANGUAGE (context
), "GNU C++");
5584 /* Return TRUE if the language is Fortran. */
5589 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5591 return (lang
== DW_LANG_Fortran77
5592 || lang
== DW_LANG_Fortran90
5593 || lang
== DW_LANG_Fortran95
5594 || lang
== DW_LANG_Fortran03
5595 || lang
== DW_LANG_Fortran08
);
5599 is_fortran (const_tree decl
)
5603 const_tree context
= get_ultimate_context (decl
);
5604 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5605 return (strncmp (TRANSLATION_UNIT_LANGUAGE (context
),
5606 "GNU Fortran", 11) == 0
5607 || strcmp (TRANSLATION_UNIT_LANGUAGE (context
),
5610 return is_fortran ();
5613 /* Return TRUE if the language is Rust.
5614 Note, returns FALSE for dwarf_version < 5 && dwarf_strict. */
5619 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5621 return lang
== DW_LANG_Rust
;
5624 /* Return TRUE if the language is Ada. */
5629 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5631 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
5634 /* Return TRUE if the language is D. */
5639 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5641 return lang
== DW_LANG_D
;
5644 /* Remove the specified attribute if present. Return TRUE if removal
5648 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5656 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5657 if (a
->dw_attr
== attr_kind
)
5659 if (AT_class (a
) == dw_val_class_str
)
5660 if (a
->dw_attr_val
.v
.val_str
->refcount
)
5661 a
->dw_attr_val
.v
.val_str
->refcount
--;
5663 /* vec::ordered_remove should help reduce the number of abbrevs
5665 die
->die_attr
->ordered_remove (ix
);
5671 /* Remove CHILD from its parent. PREV must have the property that
5672 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
5675 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
5677 gcc_assert (child
->die_parent
== prev
->die_parent
);
5678 gcc_assert (prev
->die_sib
== child
);
5681 gcc_assert (child
->die_parent
->die_child
== child
);
5685 prev
->die_sib
= child
->die_sib
;
5686 if (child
->die_parent
->die_child
== child
)
5687 child
->die_parent
->die_child
= prev
;
5688 child
->die_sib
= NULL
;
5691 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
5692 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
5695 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
5697 dw_die_ref parent
= old_child
->die_parent
;
5699 gcc_assert (parent
== prev
->die_parent
);
5700 gcc_assert (prev
->die_sib
== old_child
);
5702 new_child
->die_parent
= parent
;
5703 if (prev
== old_child
)
5705 gcc_assert (parent
->die_child
== old_child
);
5706 new_child
->die_sib
= new_child
;
5710 prev
->die_sib
= new_child
;
5711 new_child
->die_sib
= old_child
->die_sib
;
5713 if (old_child
->die_parent
->die_child
== old_child
)
5714 old_child
->die_parent
->die_child
= new_child
;
5715 old_child
->die_sib
= NULL
;
5718 /* Move all children from OLD_PARENT to NEW_PARENT. */
5721 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
5724 new_parent
->die_child
= old_parent
->die_child
;
5725 old_parent
->die_child
= NULL
;
5726 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
5729 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
5733 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
5739 dw_die_ref prev
= c
;
5741 while (c
->die_tag
== tag
)
5743 remove_child_with_prev (c
, prev
);
5744 c
->die_parent
= NULL
;
5745 /* Might have removed every child. */
5746 if (die
->die_child
== NULL
)
5750 } while (c
!= die
->die_child
);
5753 /* Add a CHILD_DIE as the last child of DIE. */
5756 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
5758 /* FIXME this should probably be an assert. */
5759 if (! die
|| ! child_die
)
5761 gcc_assert (die
!= child_die
);
5763 child_die
->die_parent
= die
;
5766 child_die
->die_sib
= die
->die_child
->die_sib
;
5767 die
->die_child
->die_sib
= child_die
;
5770 child_die
->die_sib
= child_die
;
5771 die
->die_child
= child_die
;
5774 /* Like add_child_die, but put CHILD_DIE after AFTER_DIE. */
5777 add_child_die_after (dw_die_ref die
, dw_die_ref child_die
,
5778 dw_die_ref after_die
)
5784 && die
!= child_die
);
5786 child_die
->die_parent
= die
;
5787 child_die
->die_sib
= after_die
->die_sib
;
5788 after_die
->die_sib
= child_die
;
5789 if (die
->die_child
== after_die
)
5790 die
->die_child
= child_die
;
5793 /* Unassociate CHILD from its parent, and make its parent be
5797 reparent_child (dw_die_ref child
, dw_die_ref new_parent
)
5799 for (dw_die_ref p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
5800 if (p
->die_sib
== child
)
5802 remove_child_with_prev (child
, p
);
5805 add_child_die (new_parent
, child
);
5808 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5809 is the specification, to the end of PARENT's list of children.
5810 This is done by removing and re-adding it. */
5813 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
5815 /* We want the declaration DIE from inside the class, not the
5816 specification DIE at toplevel. */
5817 if (child
->die_parent
!= parent
)
5819 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5825 gcc_assert (child
->die_parent
== parent
5826 || (child
->die_parent
5827 == get_AT_ref (parent
, DW_AT_specification
)));
5829 reparent_child (child
, parent
);
5832 /* Create and return a new die with TAG_VALUE as tag. */
5835 new_die_raw (enum dwarf_tag tag_value
)
5837 dw_die_ref die
= ggc_cleared_alloc
<die_node
> ();
5838 die
->die_tag
= tag_value
;
5842 /* Create and return a new die with a parent of PARENT_DIE. If
5843 PARENT_DIE is NULL, the new DIE is placed in limbo and an
5844 associated tree T must be supplied to determine parenthood
5847 static inline dw_die_ref
5848 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5850 dw_die_ref die
= new_die_raw (tag_value
);
5852 if (parent_die
!= NULL
)
5853 add_child_die (parent_die
, die
);
5856 limbo_die_node
*limbo_node
;
5858 /* No DIEs created after early dwarf should end up in limbo,
5859 because the limbo list should not persist past LTO
5861 if (tag_value
!= DW_TAG_compile_unit
5862 /* These are allowed because they're generated while
5863 breaking out COMDAT units late. */
5864 && tag_value
!= DW_TAG_type_unit
5865 && tag_value
!= DW_TAG_skeleton_unit
5867 /* Allow nested functions to live in limbo because they will
5868 only temporarily live there, as decls_for_scope will fix
5870 && (TREE_CODE (t
) != FUNCTION_DECL
5871 || !decl_function_context (t
))
5872 /* Same as nested functions above but for types. Types that
5873 are local to a function will be fixed in
5875 && (!RECORD_OR_UNION_TYPE_P (t
)
5876 || !TYPE_CONTEXT (t
)
5877 || TREE_CODE (TYPE_CONTEXT (t
)) != FUNCTION_DECL
)
5878 /* FIXME debug-early: Allow late limbo DIE creation for LTO,
5879 especially in the ltrans stage, but once we implement LTO
5880 dwarf streaming, we should remove this exception. */
5883 fprintf (stderr
, "symbol ended up in limbo too late:");
5884 debug_generic_stmt (t
);
5888 limbo_node
= ggc_cleared_alloc
<limbo_die_node
> ();
5889 limbo_node
->die
= die
;
5890 limbo_node
->created_for
= t
;
5891 limbo_node
->next
= limbo_die_list
;
5892 limbo_die_list
= limbo_node
;
5898 /* Return the DIE associated with the given type specifier. */
5901 lookup_type_die (tree type
)
5903 dw_die_ref die
= TYPE_SYMTAB_DIE (type
);
5904 if (die
&& die
->removed
)
5906 TYPE_SYMTAB_DIE (type
) = NULL
;
5907 TREE_ASM_WRITTEN (type
) = 0;
5913 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
5914 anonymous type named by the typedef TYPE_DIE, return the DIE of the
5915 anonymous type instead the one of the naming typedef. */
5917 static inline dw_die_ref
5918 strip_naming_typedef (tree type
, dw_die_ref type_die
)
5921 && TREE_CODE (type
) == RECORD_TYPE
5923 && type_die
->die_tag
== DW_TAG_typedef
5924 && is_naming_typedef_decl (TYPE_NAME (type
)))
5925 type_die
= get_AT_ref (type_die
, DW_AT_type
);
5929 /* Like lookup_type_die, but if type is an anonymous type named by a
5930 typedef[1], return the DIE of the anonymous type instead the one of
5931 the naming typedef. This is because in gen_typedef_die, we did
5932 equate the anonymous struct named by the typedef with the DIE of
5933 the naming typedef. So by default, lookup_type_die on an anonymous
5934 struct yields the DIE of the naming typedef.
5936 [1]: Read the comment of is_naming_typedef_decl to learn about what
5937 a naming typedef is. */
5939 static inline dw_die_ref
5940 lookup_type_die_strip_naming_typedef (tree type
)
5942 dw_die_ref die
= lookup_type_die (type
);
5943 return strip_naming_typedef (type
, die
);
5946 /* Equate a DIE to a given type specifier. */
5949 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5951 TYPE_SYMTAB_DIE (type
) = type_die
;
5954 static dw_die_ref
maybe_create_die_with_external_ref (tree
);
5955 struct GTY(()) sym_off_pair
5957 const char * GTY((skip
)) sym
;
5958 unsigned HOST_WIDE_INT off
;
5960 static GTY(()) hash_map
<tree
, sym_off_pair
> *external_die_map
;
5962 /* Returns a hash value for X (which really is a die_struct). */
5965 decl_die_hasher::hash (die_node
*x
)
5967 return (hashval_t
) x
->decl_id
;
5970 /* Return true if decl_id of die_struct X is the same as UID of decl *Y. */
5973 decl_die_hasher::equal (die_node
*x
, tree y
)
5975 return (x
->decl_id
== DECL_UID (y
));
5978 /* Return the DIE associated with a given declaration. */
5981 lookup_decl_die (tree decl
)
5983 dw_die_ref
*die
= decl_die_table
->find_slot_with_hash (decl
, DECL_UID (decl
),
5988 return maybe_create_die_with_external_ref (decl
);
5991 if ((*die
)->removed
)
5993 decl_die_table
->clear_slot (die
);
6000 /* Return the DIE associated with BLOCK. */
6002 static inline dw_die_ref
6003 lookup_block_die (tree block
)
6005 dw_die_ref die
= BLOCK_DIE (block
);
6006 if (!die
&& in_lto_p
)
6007 return maybe_create_die_with_external_ref (block
);
6011 /* Associate DIE with BLOCK. */
6014 equate_block_to_die (tree block
, dw_die_ref die
)
6016 BLOCK_DIE (block
) = die
;
6021 /* For DECL which might have early dwarf output query a SYMBOL + OFFSET
6022 style reference. Return true if we found one refering to a DIE for
6023 DECL, otherwise return false. */
6026 dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
6027 unsigned HOST_WIDE_INT
*off
)
6033 /* During WPA stage and incremental linking we use a hash-map
6034 to store the decl <-> label + offset map. */
6035 if (!external_die_map
)
6037 sym_off_pair
*desc
= external_die_map
->get (decl
);
6045 if (TREE_CODE (decl
) == BLOCK
)
6046 die
= lookup_block_die (decl
);
6048 die
= lookup_decl_die (decl
);
6052 /* Similar to get_ref_die_offset_label, but using the "correct"
6054 *off
= die
->die_offset
;
6055 while (die
->die_parent
)
6056 die
= die
->die_parent
;
6057 /* For the containing CU DIE we compute a die_symbol in
6058 compute_comp_unit_symbol. */
6059 gcc_assert (die
->die_tag
== DW_TAG_compile_unit
6060 && die
->die_id
.die_symbol
!= NULL
);
6061 *sym
= die
->die_id
.die_symbol
;
6065 /* Add a reference of kind ATTR_KIND to a DIE at SYMBOL + OFFSET to DIE. */
6068 add_AT_external_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
,
6069 const char *symbol
, HOST_WIDE_INT offset
)
6071 /* Create a fake DIE that contains the reference. Don't use
6072 new_die because we don't want to end up in the limbo list. */
6073 /* ??? We probably want to share these, thus put a ref to the DIE
6074 we create here to the external_die_map entry. */
6075 dw_die_ref ref
= new_die_raw (die
->die_tag
);
6076 ref
->die_id
.die_symbol
= symbol
;
6077 ref
->die_offset
= offset
;
6078 ref
->with_offset
= 1;
6079 add_AT_die_ref (die
, attr_kind
, ref
);
6082 /* Create a DIE for DECL if required and add a reference to a DIE
6083 at SYMBOL + OFFSET which contains attributes dumped early. */
6086 dwarf2out_register_external_die (tree decl
, const char *sym
,
6087 unsigned HOST_WIDE_INT off
)
6089 if (debug_info_level
== DINFO_LEVEL_NONE
)
6092 if (!external_die_map
)
6093 external_die_map
= hash_map
<tree
, sym_off_pair
>::create_ggc (1000);
6094 gcc_checking_assert (!external_die_map
->get (decl
));
6095 sym_off_pair p
= { IDENTIFIER_POINTER (get_identifier (sym
)), off
};
6096 external_die_map
->put (decl
, p
);
6099 /* If we have a registered external DIE for DECL return a new DIE for
6100 the concrete instance with an appropriate abstract origin. */
6103 maybe_create_die_with_external_ref (tree decl
)
6105 if (!external_die_map
)
6107 sym_off_pair
*desc
= external_die_map
->get (decl
);
6111 const char *sym
= desc
->sym
;
6112 unsigned HOST_WIDE_INT off
= desc
->off
;
6113 external_die_map
->remove (decl
);
6116 dw_die_ref die
= (TREE_CODE (decl
) == BLOCK
6117 ? lookup_block_die (decl
) : lookup_decl_die (decl
));
6122 dw_die_ref parent
= NULL
;
6123 /* Need to lookup a DIE for the decls context - the containing
6124 function or translation unit. */
6125 if (TREE_CODE (decl
) == BLOCK
)
6127 ctx
= BLOCK_SUPERCONTEXT (decl
);
6128 /* ??? We do not output DIEs for all scopes thus skip as
6129 many DIEs as needed. */
6130 while (TREE_CODE (ctx
) == BLOCK
6131 && !lookup_block_die (ctx
))
6132 ctx
= BLOCK_SUPERCONTEXT (ctx
);
6135 ctx
= DECL_CONTEXT (decl
);
6136 /* Peel types in the context stack. */
6137 while (ctx
&& TYPE_P (ctx
))
6138 ctx
= TYPE_CONTEXT (ctx
);
6139 /* Likewise namespaces in case we do not want to emit DIEs for them. */
6140 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
6141 while (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
6142 ctx
= DECL_CONTEXT (ctx
);
6145 if (TREE_CODE (ctx
) == BLOCK
)
6146 parent
= lookup_block_die (ctx
);
6147 else if (TREE_CODE (ctx
) == TRANSLATION_UNIT_DECL
6148 /* Keep the 1:1 association during WPA. */
6150 && flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
6151 /* Otherwise all late annotations go to the main CU which
6152 imports the original CUs. */
6153 parent
= comp_unit_die ();
6154 else if (TREE_CODE (ctx
) == FUNCTION_DECL
6155 && TREE_CODE (decl
) != FUNCTION_DECL
6156 && TREE_CODE (decl
) != PARM_DECL
6157 && TREE_CODE (decl
) != RESULT_DECL
6158 && TREE_CODE (decl
) != BLOCK
)
6159 /* Leave function local entities parent determination to when
6160 we process scope vars. */
6163 parent
= lookup_decl_die (ctx
);
6166 /* In some cases the FEs fail to set DECL_CONTEXT properly.
6167 Handle this case gracefully by globalizing stuff. */
6168 parent
= comp_unit_die ();
6169 /* Create a DIE "stub". */
6170 switch (TREE_CODE (decl
))
6172 case TRANSLATION_UNIT_DECL
:
6174 die
= comp_unit_die ();
6175 /* We re-target all CU decls to the LTRANS CU DIE, so no need
6176 to create a DIE for the original CUs. */
6179 case NAMESPACE_DECL
:
6180 if (is_fortran (decl
))
6181 die
= new_die (DW_TAG_module
, parent
, decl
);
6183 die
= new_die (DW_TAG_namespace
, parent
, decl
);
6186 die
= new_die (DW_TAG_subprogram
, parent
, decl
);
6189 die
= new_die (DW_TAG_variable
, parent
, decl
);
6192 die
= new_die (DW_TAG_variable
, parent
, decl
);
6195 die
= new_die (DW_TAG_formal_parameter
, parent
, decl
);
6198 die
= new_die (DW_TAG_constant
, parent
, decl
);
6201 die
= new_die (DW_TAG_label
, parent
, decl
);
6204 die
= new_die (DW_TAG_lexical_block
, parent
, decl
);
6209 if (TREE_CODE (decl
) == BLOCK
)
6210 equate_block_to_die (decl
, die
);
6212 equate_decl_number_to_die (decl
, die
);
6214 add_desc_attribute (die
, decl
);
6216 /* Add a reference to the DIE providing early debug at $sym + off. */
6217 add_AT_external_die_ref (die
, DW_AT_abstract_origin
, sym
, off
);
6222 /* Returns a hash value for X (which really is a var_loc_list). */
6225 decl_loc_hasher::hash (var_loc_list
*x
)
6227 return (hashval_t
) x
->decl_id
;
6230 /* Return true if decl_id of var_loc_list X is the same as
6234 decl_loc_hasher::equal (var_loc_list
*x
, const_tree y
)
6236 return (x
->decl_id
== DECL_UID (y
));
6239 /* Return the var_loc list associated with a given declaration. */
6241 static inline var_loc_list
*
6242 lookup_decl_loc (const_tree decl
)
6244 if (!decl_loc_table
)
6246 return decl_loc_table
->find_with_hash (decl
, DECL_UID (decl
));
6249 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
6252 dw_loc_list_hasher::hash (cached_dw_loc_list
*x
)
6254 return (hashval_t
) x
->decl_id
;
6257 /* Return true if decl_id of cached_dw_loc_list X is the same as
6261 dw_loc_list_hasher::equal (cached_dw_loc_list
*x
, const_tree y
)
6263 return (x
->decl_id
== DECL_UID (y
));
6266 /* Equate a DIE to a particular declaration. */
6269 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
6271 unsigned int decl_id
= DECL_UID (decl
);
6273 *decl_die_table
->find_slot_with_hash (decl
, decl_id
, INSERT
) = decl_die
;
6274 decl_die
->decl_id
= decl_id
;
6277 /* Return how many bits covers PIECE EXPR_LIST. */
6279 static HOST_WIDE_INT
6280 decl_piece_bitsize (rtx piece
)
6282 int ret
= (int) GET_MODE (piece
);
6285 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
6286 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
6287 return INTVAL (XEXP (XEXP (piece
, 0), 0));
6290 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
6293 decl_piece_varloc_ptr (rtx piece
)
6295 if ((int) GET_MODE (piece
))
6296 return &XEXP (piece
, 0);
6298 return &XEXP (XEXP (piece
, 0), 1);
6301 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
6302 Next is the chain of following piece nodes. */
6304 static rtx_expr_list
*
6305 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
6307 if (bitsize
> 0 && bitsize
<= (int) MAX_MACHINE_MODE
)
6308 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
6310 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
6315 /* Return rtx that should be stored into loc field for
6316 LOC_NOTE and BITPOS/BITSIZE. */
6319 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
6320 HOST_WIDE_INT bitsize
)
6324 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
6326 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
6331 /* This function either modifies location piece list *DEST in
6332 place (if SRC and INNER is NULL), or copies location piece list
6333 *SRC to *DEST while modifying it. Location BITPOS is modified
6334 to contain LOC_NOTE, any pieces overlapping it are removed resp.
6335 not copied and if needed some padding around it is added.
6336 When modifying in place, DEST should point to EXPR_LIST where
6337 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
6338 to the start of the whole list and INNER points to the EXPR_LIST
6339 where earlier pieces cover PIECE_BITPOS bits. */
6342 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
6343 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
6344 HOST_WIDE_INT bitsize
, rtx loc_note
)
6347 bool copy
= inner
!= NULL
;
6351 /* First copy all nodes preceding the current bitpos. */
6352 while (src
!= inner
)
6354 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
6355 decl_piece_bitsize (*src
), NULL_RTX
);
6356 dest
= &XEXP (*dest
, 1);
6357 src
= &XEXP (*src
, 1);
6360 /* Add padding if needed. */
6361 if (bitpos
!= piece_bitpos
)
6363 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
6364 copy
? NULL_RTX
: *dest
);
6365 dest
= &XEXP (*dest
, 1);
6367 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
6370 /* A piece with correct bitpos and bitsize already exist,
6371 just update the location for it and return. */
6372 *decl_piece_varloc_ptr (*dest
) = loc_note
;
6375 /* Add the piece that changed. */
6376 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
6377 dest
= &XEXP (*dest
, 1);
6378 /* Skip over pieces that overlap it. */
6379 diff
= bitpos
- piece_bitpos
+ bitsize
;
6382 while (diff
> 0 && *src
)
6385 diff
-= decl_piece_bitsize (piece
);
6387 src
= &XEXP (piece
, 1);
6390 *src
= XEXP (piece
, 1);
6391 free_EXPR_LIST_node (piece
);
6394 /* Add padding if needed. */
6395 if (diff
< 0 && *src
)
6399 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
6400 dest
= &XEXP (*dest
, 1);
6404 /* Finally copy all nodes following it. */
6407 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
6408 decl_piece_bitsize (*src
), NULL_RTX
);
6409 dest
= &XEXP (*dest
, 1);
6410 src
= &XEXP (*src
, 1);
6414 /* Add a variable location node to the linked list for DECL. */
6416 static struct var_loc_node
*
6417 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
, var_loc_view view
)
6419 unsigned int decl_id
;
6421 struct var_loc_node
*loc
= NULL
;
6422 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
6424 if (VAR_P (decl
) && DECL_HAS_DEBUG_EXPR_P (decl
))
6426 tree realdecl
= DECL_DEBUG_EXPR (decl
);
6427 if (handled_component_p (realdecl
)
6428 || (TREE_CODE (realdecl
) == MEM_REF
6429 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
6432 tree innerdecl
= get_ref_base_and_extent_hwi (realdecl
, &bitpos
,
6433 &bitsize
, &reverse
);
6435 || !DECL_P (innerdecl
)
6436 || DECL_IGNORED_P (innerdecl
)
6437 || TREE_STATIC (innerdecl
)
6439 || bitpos
+ bitsize
> 256)
6445 decl_id
= DECL_UID (decl
);
6447 = decl_loc_table
->find_slot_with_hash (decl
, decl_id
, INSERT
);
6450 temp
= ggc_cleared_alloc
<var_loc_list
> ();
6451 temp
->decl_id
= decl_id
;
6457 /* For PARM_DECLs try to keep around the original incoming value,
6458 even if that means we'll emit a zero-range .debug_loc entry. */
6460 && temp
->first
== temp
->last
6461 && TREE_CODE (decl
) == PARM_DECL
6462 && NOTE_P (temp
->first
->loc
)
6463 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
6464 && DECL_INCOMING_RTL (decl
)
6465 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
6466 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
6467 == GET_CODE (DECL_INCOMING_RTL (decl
))
6468 && prev_real_insn (as_a
<rtx_insn
*> (temp
->first
->loc
)) == NULL_RTX
6470 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
6471 NOTE_VAR_LOCATION_LOC (loc_note
))
6472 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
6473 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
6475 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6476 temp
->first
->next
= loc
;
6478 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6480 else if (temp
->last
)
6482 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
6483 rtx
*piece_loc
= NULL
, last_loc_note
;
6484 HOST_WIDE_INT piece_bitpos
= 0;
6488 gcc_assert (last
->next
== NULL
);
6490 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
6492 piece_loc
= &last
->loc
;
6495 HOST_WIDE_INT cur_bitsize
= decl_piece_bitsize (*piece_loc
);
6496 if (piece_bitpos
+ cur_bitsize
> bitpos
)
6498 piece_bitpos
+= cur_bitsize
;
6499 piece_loc
= &XEXP (*piece_loc
, 1);
6503 /* TEMP->LAST here is either pointer to the last but one or
6504 last element in the chained list, LAST is pointer to the
6506 if (label
&& strcmp (last
->label
, label
) == 0 && last
->view
== view
)
6508 /* For SRA optimized variables if there weren't any real
6509 insns since last note, just modify the last node. */
6510 if (piece_loc
!= NULL
)
6512 adjust_piece_list (piece_loc
, NULL
, NULL
,
6513 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6516 /* If the last note doesn't cover any instructions, remove it. */
6517 if (temp
->last
!= last
)
6519 temp
->last
->next
= NULL
;
6522 gcc_assert (strcmp (last
->label
, label
) != 0 || last
->view
!= view
);
6526 gcc_assert (temp
->first
== temp
->last
6527 || (temp
->first
->next
== temp
->last
6528 && TREE_CODE (decl
) == PARM_DECL
));
6529 memset (temp
->last
, '\0', sizeof (*temp
->last
));
6530 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6534 if (bitsize
== -1 && NOTE_P (last
->loc
))
6535 last_loc_note
= last
->loc
;
6536 else if (piece_loc
!= NULL
6537 && *piece_loc
!= NULL_RTX
6538 && piece_bitpos
== bitpos
6539 && decl_piece_bitsize (*piece_loc
) == bitsize
)
6540 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
6542 last_loc_note
= NULL_RTX
;
6543 /* If the current location is the same as the end of the list,
6544 and either both or neither of the locations is uninitialized,
6545 we have nothing to do. */
6546 if (last_loc_note
== NULL_RTX
6547 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
6548 NOTE_VAR_LOCATION_LOC (loc_note
)))
6549 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6550 != NOTE_VAR_LOCATION_STATUS (loc_note
))
6551 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6552 == VAR_INIT_STATUS_UNINITIALIZED
)
6553 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
6554 == VAR_INIT_STATUS_UNINITIALIZED
))))
6556 /* Add LOC to the end of list and update LAST. If the last
6557 element of the list has been removed above, reuse its
6558 memory for the new node, otherwise allocate a new one. */
6562 memset (loc
, '\0', sizeof (*loc
));
6565 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6566 if (bitsize
== -1 || piece_loc
== NULL
)
6567 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6569 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
6570 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6572 /* Ensure TEMP->LAST will point either to the new last but one
6573 element of the chain, or to the last element in it. */
6574 if (last
!= temp
->last
)
6582 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6585 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6590 /* Keep track of the number of spaces used to indent the
6591 output of the debugging routines that print the structure of
6592 the DIE internal representation. */
6593 static int print_indent
;
6595 /* Indent the line the number of spaces given by print_indent. */
6598 print_spaces (FILE *outfile
)
6600 fprintf (outfile
, "%*s", print_indent
, "");
6603 /* Print a type signature in hex. */
6606 print_signature (FILE *outfile
, char *sig
)
6610 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
6611 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
6615 print_discr_value (FILE *outfile
, dw_discr_value
*discr_value
)
6617 if (discr_value
->pos
)
6618 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, discr_value
->v
.sval
);
6620 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, discr_value
->v
.uval
);
6623 static void print_loc_descr (dw_loc_descr_ref
, FILE *);
6625 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
6626 RECURSE, output location descriptor operations. */
6629 print_dw_val (dw_val_node
*val
, bool recurse
, FILE *outfile
)
6631 switch (val
->val_class
)
6633 case dw_val_class_addr
:
6634 fprintf (outfile
, "address");
6636 case dw_val_class_offset
:
6637 fprintf (outfile
, "offset");
6639 case dw_val_class_loc
:
6640 fprintf (outfile
, "location descriptor");
6641 if (val
->v
.val_loc
== NULL
)
6642 fprintf (outfile
, " -> <null>\n");
6645 fprintf (outfile
, ":\n");
6647 print_loc_descr (val
->v
.val_loc
, outfile
);
6652 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6653 fprintf (outfile
, " #\n");
6655 fprintf (outfile
, " (%p)\n", (void *) val
->v
.val_loc
);
6658 case dw_val_class_loc_list
:
6659 fprintf (outfile
, "location list -> label:%s",
6660 val
->v
.val_loc_list
->ll_symbol
);
6662 case dw_val_class_view_list
:
6663 val
= view_list_to_loc_list_val_node (val
);
6664 fprintf (outfile
, "location list with views -> labels:%s and %s",
6665 val
->v
.val_loc_list
->ll_symbol
,
6666 val
->v
.val_loc_list
->vl_symbol
);
6668 case dw_val_class_range_list
:
6669 fprintf (outfile
, "range list");
6671 case dw_val_class_const
:
6672 case dw_val_class_const_implicit
:
6673 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, val
->v
.val_int
);
6675 case dw_val_class_unsigned_const
:
6676 case dw_val_class_unsigned_const_implicit
:
6677 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, val
->v
.val_unsigned
);
6679 case dw_val_class_const_double
:
6680 fprintf (outfile
, "constant (" HOST_WIDE_INT_PRINT_DEC
","\
6681 HOST_WIDE_INT_PRINT_UNSIGNED
")",
6682 val
->v
.val_double
.high
,
6683 val
->v
.val_double
.low
);
6685 case dw_val_class_wide_int
:
6687 int i
= val
->v
.val_wide
->get_len ();
6688 fprintf (outfile
, "constant (");
6690 if (val
->v
.val_wide
->elt (i
- 1) == 0)
6691 fprintf (outfile
, "0x");
6692 fprintf (outfile
, HOST_WIDE_INT_PRINT_HEX
,
6693 val
->v
.val_wide
->elt (--i
));
6695 fprintf (outfile
, HOST_WIDE_INT_PRINT_PADDED_HEX
,
6696 val
->v
.val_wide
->elt (i
));
6697 fprintf (outfile
, ")");
6700 case dw_val_class_vec
:
6701 fprintf (outfile
, "floating-point or vector constant");
6703 case dw_val_class_flag
:
6704 fprintf (outfile
, "%u", val
->v
.val_flag
);
6706 case dw_val_class_die_ref
:
6707 if (val
->v
.val_die_ref
.die
!= NULL
)
6709 dw_die_ref die
= val
->v
.val_die_ref
.die
;
6711 if (die
->comdat_type_p
)
6713 fprintf (outfile
, "die -> signature: ");
6714 print_signature (outfile
,
6715 die
->die_id
.die_type_node
->signature
);
6717 else if (die
->die_id
.die_symbol
)
6719 fprintf (outfile
, "die -> label: %s", die
->die_id
.die_symbol
);
6720 if (die
->with_offset
)
6721 fprintf (outfile
, " + %ld", die
->die_offset
);
6724 fprintf (outfile
, "die -> %ld", die
->die_offset
);
6725 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6726 fprintf (outfile
, " #");
6728 fprintf (outfile
, " (%p)", (void *) die
);
6731 fprintf (outfile
, "die -> <null>");
6733 case dw_val_class_vms_delta
:
6734 fprintf (outfile
, "delta: @slotcount(%s-%s)",
6735 val
->v
.val_vms_delta
.lbl2
, val
->v
.val_vms_delta
.lbl1
);
6737 case dw_val_class_symview
:
6738 fprintf (outfile
, "view: %s", val
->v
.val_symbolic_view
);
6740 case dw_val_class_lbl_id
:
6741 case dw_val_class_lineptr
:
6742 case dw_val_class_macptr
:
6743 case dw_val_class_loclistsptr
:
6744 case dw_val_class_high_pc
:
6745 fprintf (outfile
, "label: %s", val
->v
.val_lbl_id
);
6747 case dw_val_class_str
:
6748 if (val
->v
.val_str
->str
!= NULL
)
6749 fprintf (outfile
, "\"%s\"", val
->v
.val_str
->str
);
6751 fprintf (outfile
, "<null>");
6753 case dw_val_class_file
:
6754 case dw_val_class_file_implicit
:
6755 fprintf (outfile
, "\"%s\" (%d)", val
->v
.val_file
->filename
,
6756 val
->v
.val_file
->emitted_number
);
6758 case dw_val_class_data8
:
6762 for (i
= 0; i
< 8; i
++)
6763 fprintf (outfile
, "%02x", val
->v
.val_data8
[i
]);
6766 case dw_val_class_discr_value
:
6767 print_discr_value (outfile
, &val
->v
.val_discr_value
);
6769 case dw_val_class_discr_list
:
6770 for (dw_discr_list_ref node
= val
->v
.val_discr_list
;
6772 node
= node
->dw_discr_next
)
6774 if (node
->dw_discr_range
)
6776 fprintf (outfile
, " .. ");
6777 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6778 print_discr_value (outfile
, &node
->dw_discr_upper_bound
);
6781 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6783 if (node
->dw_discr_next
!= NULL
)
6784 fprintf (outfile
, " | ");
6791 /* Likewise, for a DIE attribute. */
6794 print_attribute (dw_attr_node
*a
, bool recurse
, FILE *outfile
)
6796 print_dw_val (&a
->dw_attr_val
, recurse
, outfile
);
6800 /* Print the list of operands in the LOC location description to OUTFILE. This
6801 routine is a debugging aid only. */
6804 print_loc_descr (dw_loc_descr_ref loc
, FILE *outfile
)
6806 dw_loc_descr_ref l
= loc
;
6810 print_spaces (outfile
);
6811 fprintf (outfile
, "<null>\n");
6815 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
6817 print_spaces (outfile
);
6818 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6819 fprintf (outfile
, "#");
6821 fprintf (outfile
, "(%p)", (void *) l
);
6822 fprintf (outfile
, " %s",
6823 dwarf_stack_op_name (l
->dw_loc_opc
));
6824 if (l
->dw_loc_oprnd1
.val_class
!= dw_val_class_none
)
6826 fprintf (outfile
, " ");
6827 print_dw_val (&l
->dw_loc_oprnd1
, false, outfile
);
6829 if (l
->dw_loc_oprnd2
.val_class
!= dw_val_class_none
)
6831 fprintf (outfile
, ", ");
6832 print_dw_val (&l
->dw_loc_oprnd2
, false, outfile
);
6834 fprintf (outfile
, "\n");
6838 /* Print the information associated with a given DIE, and its children.
6839 This routine is a debugging aid only. */
6842 print_die (dw_die_ref die
, FILE *outfile
)
6848 print_spaces (outfile
);
6849 fprintf (outfile
, "DIE %4ld: %s ",
6850 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
6851 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6852 fprintf (outfile
, "#\n");
6854 fprintf (outfile
, "(%p)\n", (void*) die
);
6855 print_spaces (outfile
);
6856 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
6857 fprintf (outfile
, " offset: %ld", die
->die_offset
);
6858 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
6860 if (die
->comdat_type_p
)
6862 print_spaces (outfile
);
6863 fprintf (outfile
, " signature: ");
6864 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
6865 fprintf (outfile
, "\n");
6868 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6870 print_spaces (outfile
);
6871 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
6873 print_attribute (a
, true, outfile
);
6874 fprintf (outfile
, "\n");
6877 if (die
->die_child
!= NULL
)
6880 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
6883 if (print_indent
== 0)
6884 fprintf (outfile
, "\n");
6887 /* Print the list of operations in the LOC location description. */
6890 debug_dwarf_loc_descr (dw_loc_descr_ref loc
)
6892 print_loc_descr (loc
, stderr
);
6895 /* Print the information collected for a given DIE. */
6898 debug_dwarf_die (dw_die_ref die
)
6900 print_die (die
, stderr
);
6904 debug (die_struct
&ref
)
6906 print_die (&ref
, stderr
);
6910 debug (die_struct
*ptr
)
6915 fprintf (stderr
, "<nil>\n");
6919 /* Print all DWARF information collected for the compilation unit.
6920 This routine is a debugging aid only. */
6926 print_die (comp_unit_die (), stderr
);
6929 /* Verify the DIE tree structure. */
6932 verify_die (dw_die_ref die
)
6934 gcc_assert (!die
->die_mark
);
6935 if (die
->die_parent
== NULL
6936 && die
->die_sib
== NULL
)
6938 /* Verify the die_sib list is cyclic. */
6945 while (x
&& !x
->die_mark
);
6946 gcc_assert (x
== die
);
6950 /* Verify all dies have the same parent. */
6951 gcc_assert (x
->die_parent
== die
->die_parent
);
6954 /* Verify the child has the proper parent and recurse. */
6955 gcc_assert (x
->die_child
->die_parent
== x
);
6956 verify_die (x
->die_child
);
6961 while (x
&& x
->die_mark
);
6964 /* Sanity checks on DIEs. */
6967 check_die (dw_die_ref die
)
6971 bool inline_found
= false;
6972 int n_location
= 0, n_low_pc
= 0, n_high_pc
= 0, n_artificial
= 0;
6973 int n_decl_line
= 0, n_decl_column
= 0, n_decl_file
= 0;
6974 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6979 if (a
->dw_attr_val
.v
.val_unsigned
)
6980 inline_found
= true;
6982 case DW_AT_location
:
6991 case DW_AT_artificial
:
6994 case DW_AT_decl_column
:
6997 case DW_AT_decl_line
:
7000 case DW_AT_decl_file
:
7007 if (n_location
> 1 || n_low_pc
> 1 || n_high_pc
> 1 || n_artificial
> 1
7008 || n_decl_column
> 1 || n_decl_line
> 1 || n_decl_file
> 1)
7010 fprintf (stderr
, "Duplicate attributes in DIE:\n");
7011 debug_dwarf_die (die
);
7016 /* A debugging information entry that is a member of an abstract
7017 instance tree [that has DW_AT_inline] should not contain any
7018 attributes which describe aspects of the subroutine which vary
7019 between distinct inlined expansions or distinct out-of-line
7021 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7022 gcc_assert (a
->dw_attr
!= DW_AT_low_pc
7023 && a
->dw_attr
!= DW_AT_high_pc
7024 && a
->dw_attr
!= DW_AT_location
7025 && a
->dw_attr
!= DW_AT_frame_base
7026 && a
->dw_attr
!= DW_AT_call_all_calls
7027 && a
->dw_attr
!= DW_AT_GNU_all_call_sites
);
7031 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
7032 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
7033 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
7035 /* Calculate the checksum of a location expression. */
7038 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
7041 inchash::hash hstate
;
7044 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
7046 hash_loc_operands (loc
, hstate
);
7047 hash
= hstate
.end();
7051 /* Calculate the checksum of an attribute. */
7054 attr_checksum (dw_attr_node
*at
, struct md5_ctx
*ctx
, int *mark
)
7056 dw_loc_descr_ref loc
;
7059 CHECKSUM (at
->dw_attr
);
7061 /* We don't care that this was compiled with a different compiler
7062 snapshot; if the output is the same, that's what matters. */
7063 if (at
->dw_attr
== DW_AT_producer
)
7066 switch (AT_class (at
))
7068 case dw_val_class_const
:
7069 case dw_val_class_const_implicit
:
7070 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
7072 case dw_val_class_unsigned_const
:
7073 case dw_val_class_unsigned_const_implicit
:
7074 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
7076 case dw_val_class_const_double
:
7077 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
7079 case dw_val_class_wide_int
:
7080 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
7081 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7082 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
7084 case dw_val_class_vec
:
7085 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
7086 (at
->dw_attr_val
.v
.val_vec
.length
7087 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
7089 case dw_val_class_flag
:
7090 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
7092 case dw_val_class_str
:
7093 CHECKSUM_STRING (AT_string (at
));
7096 case dw_val_class_addr
:
7098 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
7099 CHECKSUM_STRING (XSTR (r
, 0));
7102 case dw_val_class_offset
:
7103 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
7106 case dw_val_class_loc
:
7107 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
7108 loc_checksum (loc
, ctx
);
7111 case dw_val_class_die_ref
:
7112 die_checksum (AT_ref (at
), ctx
, mark
);
7115 case dw_val_class_fde_ref
:
7116 case dw_val_class_vms_delta
:
7117 case dw_val_class_symview
:
7118 case dw_val_class_lbl_id
:
7119 case dw_val_class_lineptr
:
7120 case dw_val_class_macptr
:
7121 case dw_val_class_loclistsptr
:
7122 case dw_val_class_high_pc
:
7125 case dw_val_class_file
:
7126 case dw_val_class_file_implicit
:
7127 CHECKSUM_STRING (AT_file (at
)->filename
);
7130 case dw_val_class_data8
:
7131 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
7139 /* Calculate the checksum of a DIE. */
7142 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
7148 /* To avoid infinite recursion. */
7151 CHECKSUM (die
->die_mark
);
7154 die
->die_mark
= ++(*mark
);
7156 CHECKSUM (die
->die_tag
);
7158 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7159 attr_checksum (a
, ctx
, mark
);
7161 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
7165 #undef CHECKSUM_BLOCK
7166 #undef CHECKSUM_STRING
7168 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
7169 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
7170 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
7171 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
7172 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
7173 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
7174 #define CHECKSUM_ATTR(FOO) \
7175 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
7177 /* Calculate the checksum of a number in signed LEB128 format. */
7180 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
7187 byte
= (value
& 0x7f);
7189 more
= !((value
== 0 && (byte
& 0x40) == 0)
7190 || (value
== -1 && (byte
& 0x40) != 0));
7199 /* Calculate the checksum of a number in unsigned LEB128 format. */
7202 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
7206 unsigned char byte
= (value
& 0x7f);
7209 /* More bytes to follow. */
7217 /* Checksum the context of the DIE. This adds the names of any
7218 surrounding namespaces or structures to the checksum. */
7221 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
7225 int tag
= die
->die_tag
;
7227 if (tag
!= DW_TAG_namespace
7228 && tag
!= DW_TAG_structure_type
7229 && tag
!= DW_TAG_class_type
)
7232 name
= get_AT_string (die
, DW_AT_name
);
7234 spec
= get_AT_ref (die
, DW_AT_specification
);
7238 if (die
->die_parent
!= NULL
)
7239 checksum_die_context (die
->die_parent
, ctx
);
7241 CHECKSUM_ULEB128 ('C');
7242 CHECKSUM_ULEB128 (tag
);
7244 CHECKSUM_STRING (name
);
7247 /* Calculate the checksum of a location expression. */
7250 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
7252 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
7253 were emitted as a DW_FORM_sdata instead of a location expression. */
7254 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
7256 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7257 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
7261 /* Otherwise, just checksum the raw location expression. */
7264 inchash::hash hstate
;
7267 CHECKSUM_ULEB128 (loc
->dtprel
);
7268 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
7269 hash_loc_operands (loc
, hstate
);
7270 hash
= hstate
.end ();
7272 loc
= loc
->dw_loc_next
;
7276 /* Calculate the checksum of an attribute. */
7279 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_node
*at
,
7280 struct md5_ctx
*ctx
, int *mark
)
7282 dw_loc_descr_ref loc
;
7285 if (AT_class (at
) == dw_val_class_die_ref
)
7287 dw_die_ref target_die
= AT_ref (at
);
7289 /* For pointer and reference types, we checksum only the (qualified)
7290 name of the target type (if there is a name). For friend entries,
7291 we checksum only the (qualified) name of the target type or function.
7292 This allows the checksum to remain the same whether the target type
7293 is complete or not. */
7294 if ((at
->dw_attr
== DW_AT_type
7295 && (tag
== DW_TAG_pointer_type
7296 || tag
== DW_TAG_reference_type
7297 || tag
== DW_TAG_rvalue_reference_type
7298 || tag
== DW_TAG_ptr_to_member_type
))
7299 || (at
->dw_attr
== DW_AT_friend
7300 && tag
== DW_TAG_friend
))
7302 dw_attr_node
*name_attr
= get_AT (target_die
, DW_AT_name
);
7304 if (name_attr
!= NULL
)
7306 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
7310 CHECKSUM_ULEB128 ('N');
7311 CHECKSUM_ULEB128 (at
->dw_attr
);
7312 if (decl
->die_parent
!= NULL
)
7313 checksum_die_context (decl
->die_parent
, ctx
);
7314 CHECKSUM_ULEB128 ('E');
7315 CHECKSUM_STRING (AT_string (name_attr
));
7320 /* For all other references to another DIE, we check to see if the
7321 target DIE has already been visited. If it has, we emit a
7322 backward reference; if not, we descend recursively. */
7323 if (target_die
->die_mark
> 0)
7325 CHECKSUM_ULEB128 ('R');
7326 CHECKSUM_ULEB128 (at
->dw_attr
);
7327 CHECKSUM_ULEB128 (target_die
->die_mark
);
7331 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
7335 target_die
->die_mark
= ++(*mark
);
7336 CHECKSUM_ULEB128 ('T');
7337 CHECKSUM_ULEB128 (at
->dw_attr
);
7338 if (decl
->die_parent
!= NULL
)
7339 checksum_die_context (decl
->die_parent
, ctx
);
7340 die_checksum_ordered (target_die
, ctx
, mark
);
7345 CHECKSUM_ULEB128 ('A');
7346 CHECKSUM_ULEB128 (at
->dw_attr
);
7348 switch (AT_class (at
))
7350 case dw_val_class_const
:
7351 case dw_val_class_const_implicit
:
7352 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7353 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
7356 case dw_val_class_unsigned_const
:
7357 case dw_val_class_unsigned_const_implicit
:
7358 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7359 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
7362 case dw_val_class_const_double
:
7363 CHECKSUM_ULEB128 (DW_FORM_block
);
7364 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
7365 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
7368 case dw_val_class_wide_int
:
7369 CHECKSUM_ULEB128 (DW_FORM_block
);
7370 CHECKSUM_ULEB128 (get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7371 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
7372 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
7373 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7374 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
7377 case dw_val_class_vec
:
7378 CHECKSUM_ULEB128 (DW_FORM_block
);
7379 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_vec
.length
7380 * at
->dw_attr_val
.v
.val_vec
.elt_size
);
7381 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
7382 (at
->dw_attr_val
.v
.val_vec
.length
7383 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
7386 case dw_val_class_flag
:
7387 CHECKSUM_ULEB128 (DW_FORM_flag
);
7388 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
7391 case dw_val_class_str
:
7392 CHECKSUM_ULEB128 (DW_FORM_string
);
7393 CHECKSUM_STRING (AT_string (at
));
7396 case dw_val_class_addr
:
7398 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
7399 CHECKSUM_ULEB128 (DW_FORM_string
);
7400 CHECKSUM_STRING (XSTR (r
, 0));
7403 case dw_val_class_offset
:
7404 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7405 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
7408 case dw_val_class_loc
:
7409 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
7410 loc_checksum_ordered (loc
, ctx
);
7413 case dw_val_class_fde_ref
:
7414 case dw_val_class_symview
:
7415 case dw_val_class_lbl_id
:
7416 case dw_val_class_lineptr
:
7417 case dw_val_class_macptr
:
7418 case dw_val_class_loclistsptr
:
7419 case dw_val_class_high_pc
:
7422 case dw_val_class_file
:
7423 case dw_val_class_file_implicit
:
7424 CHECKSUM_ULEB128 (DW_FORM_string
);
7425 CHECKSUM_STRING (AT_file (at
)->filename
);
7428 case dw_val_class_data8
:
7429 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
7437 struct checksum_attributes
7439 dw_attr_node
*at_name
;
7440 dw_attr_node
*at_type
;
7441 dw_attr_node
*at_friend
;
7442 dw_attr_node
*at_accessibility
;
7443 dw_attr_node
*at_address_class
;
7444 dw_attr_node
*at_alignment
;
7445 dw_attr_node
*at_allocated
;
7446 dw_attr_node
*at_artificial
;
7447 dw_attr_node
*at_associated
;
7448 dw_attr_node
*at_binary_scale
;
7449 dw_attr_node
*at_bit_offset
;
7450 dw_attr_node
*at_bit_size
;
7451 dw_attr_node
*at_bit_stride
;
7452 dw_attr_node
*at_byte_size
;
7453 dw_attr_node
*at_byte_stride
;
7454 dw_attr_node
*at_const_value
;
7455 dw_attr_node
*at_containing_type
;
7456 dw_attr_node
*at_count
;
7457 dw_attr_node
*at_data_location
;
7458 dw_attr_node
*at_data_member_location
;
7459 dw_attr_node
*at_decimal_scale
;
7460 dw_attr_node
*at_decimal_sign
;
7461 dw_attr_node
*at_default_value
;
7462 dw_attr_node
*at_digit_count
;
7463 dw_attr_node
*at_discr
;
7464 dw_attr_node
*at_discr_list
;
7465 dw_attr_node
*at_discr_value
;
7466 dw_attr_node
*at_encoding
;
7467 dw_attr_node
*at_endianity
;
7468 dw_attr_node
*at_explicit
;
7469 dw_attr_node
*at_is_optional
;
7470 dw_attr_node
*at_location
;
7471 dw_attr_node
*at_lower_bound
;
7472 dw_attr_node
*at_mutable
;
7473 dw_attr_node
*at_ordering
;
7474 dw_attr_node
*at_picture_string
;
7475 dw_attr_node
*at_prototyped
;
7476 dw_attr_node
*at_small
;
7477 dw_attr_node
*at_segment
;
7478 dw_attr_node
*at_string_length
;
7479 dw_attr_node
*at_string_length_bit_size
;
7480 dw_attr_node
*at_string_length_byte_size
;
7481 dw_attr_node
*at_threads_scaled
;
7482 dw_attr_node
*at_upper_bound
;
7483 dw_attr_node
*at_use_location
;
7484 dw_attr_node
*at_use_UTF8
;
7485 dw_attr_node
*at_variable_parameter
;
7486 dw_attr_node
*at_virtuality
;
7487 dw_attr_node
*at_visibility
;
7488 dw_attr_node
*at_vtable_elem_location
;
7491 /* Collect the attributes that we will want to use for the checksum. */
7494 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
7499 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7510 attrs
->at_friend
= a
;
7512 case DW_AT_accessibility
:
7513 attrs
->at_accessibility
= a
;
7515 case DW_AT_address_class
:
7516 attrs
->at_address_class
= a
;
7518 case DW_AT_alignment
:
7519 attrs
->at_alignment
= a
;
7521 case DW_AT_allocated
:
7522 attrs
->at_allocated
= a
;
7524 case DW_AT_artificial
:
7525 attrs
->at_artificial
= a
;
7527 case DW_AT_associated
:
7528 attrs
->at_associated
= a
;
7530 case DW_AT_binary_scale
:
7531 attrs
->at_binary_scale
= a
;
7533 case DW_AT_bit_offset
:
7534 attrs
->at_bit_offset
= a
;
7536 case DW_AT_bit_size
:
7537 attrs
->at_bit_size
= a
;
7539 case DW_AT_bit_stride
:
7540 attrs
->at_bit_stride
= a
;
7542 case DW_AT_byte_size
:
7543 attrs
->at_byte_size
= a
;
7545 case DW_AT_byte_stride
:
7546 attrs
->at_byte_stride
= a
;
7548 case DW_AT_const_value
:
7549 attrs
->at_const_value
= a
;
7551 case DW_AT_containing_type
:
7552 attrs
->at_containing_type
= a
;
7555 attrs
->at_count
= a
;
7557 case DW_AT_data_location
:
7558 attrs
->at_data_location
= a
;
7560 case DW_AT_data_member_location
:
7561 attrs
->at_data_member_location
= a
;
7563 case DW_AT_decimal_scale
:
7564 attrs
->at_decimal_scale
= a
;
7566 case DW_AT_decimal_sign
:
7567 attrs
->at_decimal_sign
= a
;
7569 case DW_AT_default_value
:
7570 attrs
->at_default_value
= a
;
7572 case DW_AT_digit_count
:
7573 attrs
->at_digit_count
= a
;
7576 attrs
->at_discr
= a
;
7578 case DW_AT_discr_list
:
7579 attrs
->at_discr_list
= a
;
7581 case DW_AT_discr_value
:
7582 attrs
->at_discr_value
= a
;
7584 case DW_AT_encoding
:
7585 attrs
->at_encoding
= a
;
7587 case DW_AT_endianity
:
7588 attrs
->at_endianity
= a
;
7590 case DW_AT_explicit
:
7591 attrs
->at_explicit
= a
;
7593 case DW_AT_is_optional
:
7594 attrs
->at_is_optional
= a
;
7596 case DW_AT_location
:
7597 attrs
->at_location
= a
;
7599 case DW_AT_lower_bound
:
7600 attrs
->at_lower_bound
= a
;
7603 attrs
->at_mutable
= a
;
7605 case DW_AT_ordering
:
7606 attrs
->at_ordering
= a
;
7608 case DW_AT_picture_string
:
7609 attrs
->at_picture_string
= a
;
7611 case DW_AT_prototyped
:
7612 attrs
->at_prototyped
= a
;
7615 attrs
->at_small
= a
;
7618 attrs
->at_segment
= a
;
7620 case DW_AT_string_length
:
7621 attrs
->at_string_length
= a
;
7623 case DW_AT_string_length_bit_size
:
7624 attrs
->at_string_length_bit_size
= a
;
7626 case DW_AT_string_length_byte_size
:
7627 attrs
->at_string_length_byte_size
= a
;
7629 case DW_AT_threads_scaled
:
7630 attrs
->at_threads_scaled
= a
;
7632 case DW_AT_upper_bound
:
7633 attrs
->at_upper_bound
= a
;
7635 case DW_AT_use_location
:
7636 attrs
->at_use_location
= a
;
7638 case DW_AT_use_UTF8
:
7639 attrs
->at_use_UTF8
= a
;
7641 case DW_AT_variable_parameter
:
7642 attrs
->at_variable_parameter
= a
;
7644 case DW_AT_virtuality
:
7645 attrs
->at_virtuality
= a
;
7647 case DW_AT_visibility
:
7648 attrs
->at_visibility
= a
;
7650 case DW_AT_vtable_elem_location
:
7651 attrs
->at_vtable_elem_location
= a
;
7659 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
7662 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
7666 struct checksum_attributes attrs
;
7668 CHECKSUM_ULEB128 ('D');
7669 CHECKSUM_ULEB128 (die
->die_tag
);
7671 memset (&attrs
, 0, sizeof (attrs
));
7673 decl
= get_AT_ref (die
, DW_AT_specification
);
7675 collect_checksum_attributes (&attrs
, decl
);
7676 collect_checksum_attributes (&attrs
, die
);
7678 CHECKSUM_ATTR (attrs
.at_name
);
7679 CHECKSUM_ATTR (attrs
.at_accessibility
);
7680 CHECKSUM_ATTR (attrs
.at_address_class
);
7681 CHECKSUM_ATTR (attrs
.at_allocated
);
7682 CHECKSUM_ATTR (attrs
.at_artificial
);
7683 CHECKSUM_ATTR (attrs
.at_associated
);
7684 CHECKSUM_ATTR (attrs
.at_binary_scale
);
7685 CHECKSUM_ATTR (attrs
.at_bit_offset
);
7686 CHECKSUM_ATTR (attrs
.at_bit_size
);
7687 CHECKSUM_ATTR (attrs
.at_bit_stride
);
7688 CHECKSUM_ATTR (attrs
.at_byte_size
);
7689 CHECKSUM_ATTR (attrs
.at_byte_stride
);
7690 CHECKSUM_ATTR (attrs
.at_const_value
);
7691 CHECKSUM_ATTR (attrs
.at_containing_type
);
7692 CHECKSUM_ATTR (attrs
.at_count
);
7693 CHECKSUM_ATTR (attrs
.at_data_location
);
7694 CHECKSUM_ATTR (attrs
.at_data_member_location
);
7695 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
7696 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
7697 CHECKSUM_ATTR (attrs
.at_default_value
);
7698 CHECKSUM_ATTR (attrs
.at_digit_count
);
7699 CHECKSUM_ATTR (attrs
.at_discr
);
7700 CHECKSUM_ATTR (attrs
.at_discr_list
);
7701 CHECKSUM_ATTR (attrs
.at_discr_value
);
7702 CHECKSUM_ATTR (attrs
.at_encoding
);
7703 CHECKSUM_ATTR (attrs
.at_endianity
);
7704 CHECKSUM_ATTR (attrs
.at_explicit
);
7705 CHECKSUM_ATTR (attrs
.at_is_optional
);
7706 CHECKSUM_ATTR (attrs
.at_location
);
7707 CHECKSUM_ATTR (attrs
.at_lower_bound
);
7708 CHECKSUM_ATTR (attrs
.at_mutable
);
7709 CHECKSUM_ATTR (attrs
.at_ordering
);
7710 CHECKSUM_ATTR (attrs
.at_picture_string
);
7711 CHECKSUM_ATTR (attrs
.at_prototyped
);
7712 CHECKSUM_ATTR (attrs
.at_small
);
7713 CHECKSUM_ATTR (attrs
.at_segment
);
7714 CHECKSUM_ATTR (attrs
.at_string_length
);
7715 CHECKSUM_ATTR (attrs
.at_string_length_bit_size
);
7716 CHECKSUM_ATTR (attrs
.at_string_length_byte_size
);
7717 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
7718 CHECKSUM_ATTR (attrs
.at_upper_bound
);
7719 CHECKSUM_ATTR (attrs
.at_use_location
);
7720 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
7721 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
7722 CHECKSUM_ATTR (attrs
.at_virtuality
);
7723 CHECKSUM_ATTR (attrs
.at_visibility
);
7724 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
7725 CHECKSUM_ATTR (attrs
.at_type
);
7726 CHECKSUM_ATTR (attrs
.at_friend
);
7727 CHECKSUM_ATTR (attrs
.at_alignment
);
7729 /* Checksum the child DIEs. */
7732 dw_attr_node
*name_attr
;
7735 name_attr
= get_AT (c
, DW_AT_name
);
7736 if (is_template_instantiation (c
))
7738 /* Ignore instantiations of member type and function templates. */
7740 else if (name_attr
!= NULL
7741 && (is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
))
7743 /* Use a shallow checksum for named nested types and member
7745 CHECKSUM_ULEB128 ('S');
7746 CHECKSUM_ULEB128 (c
->die_tag
);
7747 CHECKSUM_STRING (AT_string (name_attr
));
7751 /* Use a deep checksum for other children. */
7752 /* Mark this DIE so it gets processed when unmarking. */
7753 if (c
->die_mark
== 0)
7755 die_checksum_ordered (c
, ctx
, mark
);
7757 } while (c
!= die
->die_child
);
7759 CHECKSUM_ULEB128 (0);
7762 /* Add a type name and tag to a hash. */
7764 die_odr_checksum (int tag
, const char *name
, md5_ctx
*ctx
)
7766 CHECKSUM_ULEB128 (tag
);
7767 CHECKSUM_STRING (name
);
7771 #undef CHECKSUM_STRING
7772 #undef CHECKSUM_ATTR
7773 #undef CHECKSUM_LEB128
7774 #undef CHECKSUM_ULEB128
7776 /* Generate the type signature for DIE. This is computed by generating an
7777 MD5 checksum over the DIE's tag, its relevant attributes, and its
7778 children. Attributes that are references to other DIEs are processed
7779 by recursion, using the MARK field to prevent infinite recursion.
7780 If the DIE is nested inside a namespace or another type, we also
7781 need to include that context in the signature. The lower 64 bits
7782 of the resulting MD5 checksum comprise the signature. */
7785 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
7789 unsigned char checksum
[16];
7794 name
= get_AT_string (die
, DW_AT_name
);
7795 decl
= get_AT_ref (die
, DW_AT_specification
);
7796 parent
= get_die_parent (die
);
7798 /* First, compute a signature for just the type name (and its surrounding
7799 context, if any. This is stored in the type unit DIE for link-time
7800 ODR (one-definition rule) checking. */
7802 if (is_cxx () && name
!= NULL
)
7804 md5_init_ctx (&ctx
);
7806 /* Checksum the names of surrounding namespaces and structures. */
7808 checksum_die_context (parent
, &ctx
);
7810 /* Checksum the current DIE. */
7811 die_odr_checksum (die
->die_tag
, name
, &ctx
);
7812 md5_finish_ctx (&ctx
, checksum
);
7814 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
7817 /* Next, compute the complete type signature. */
7819 md5_init_ctx (&ctx
);
7821 die
->die_mark
= mark
;
7823 /* Checksum the names of surrounding namespaces and structures. */
7825 checksum_die_context (parent
, &ctx
);
7827 /* Checksum the DIE and its children. */
7828 die_checksum_ordered (die
, &ctx
, &mark
);
7829 unmark_all_dies (die
);
7830 md5_finish_ctx (&ctx
, checksum
);
7832 /* Store the signature in the type node and link the type DIE and the
7833 type node together. */
7834 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
7835 DWARF_TYPE_SIGNATURE_SIZE
);
7836 die
->comdat_type_p
= true;
7837 die
->die_id
.die_type_node
= type_node
;
7838 type_node
->type_die
= die
;
7840 /* If the DIE is a specification, link its declaration to the type node
7844 decl
->comdat_type_p
= true;
7845 decl
->die_id
.die_type_node
= type_node
;
7849 /* Do the location expressions look same? */
7851 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
7853 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
7854 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
7855 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
7858 /* Do the values look the same? */
7860 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
7862 dw_loc_descr_ref loc1
, loc2
;
7865 if (v1
->val_class
!= v2
->val_class
)
7868 switch (v1
->val_class
)
7870 case dw_val_class_const
:
7871 case dw_val_class_const_implicit
:
7872 return v1
->v
.val_int
== v2
->v
.val_int
;
7873 case dw_val_class_unsigned_const
:
7874 case dw_val_class_unsigned_const_implicit
:
7875 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
7876 case dw_val_class_const_double
:
7877 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
7878 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
7879 case dw_val_class_wide_int
:
7880 return *v1
->v
.val_wide
== *v2
->v
.val_wide
;
7881 case dw_val_class_vec
:
7882 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
7883 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
7885 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
7886 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
7889 case dw_val_class_flag
:
7890 return v1
->v
.val_flag
== v2
->v
.val_flag
;
7891 case dw_val_class_str
:
7892 return !strcmp (v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
7894 case dw_val_class_addr
:
7895 r1
= v1
->v
.val_addr
;
7896 r2
= v2
->v
.val_addr
;
7897 if (GET_CODE (r1
) != GET_CODE (r2
))
7899 return !rtx_equal_p (r1
, r2
);
7901 case dw_val_class_offset
:
7902 return v1
->v
.val_offset
== v2
->v
.val_offset
;
7904 case dw_val_class_loc
:
7905 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
7907 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
7908 if (!same_loc_p (loc1
, loc2
, mark
))
7910 return !loc1
&& !loc2
;
7912 case dw_val_class_die_ref
:
7913 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
7915 case dw_val_class_symview
:
7916 return strcmp (v1
->v
.val_symbolic_view
, v2
->v
.val_symbolic_view
) == 0;
7918 case dw_val_class_fde_ref
:
7919 case dw_val_class_vms_delta
:
7920 case dw_val_class_lbl_id
:
7921 case dw_val_class_lineptr
:
7922 case dw_val_class_macptr
:
7923 case dw_val_class_loclistsptr
:
7924 case dw_val_class_high_pc
:
7927 case dw_val_class_file
:
7928 case dw_val_class_file_implicit
:
7929 return v1
->v
.val_file
== v2
->v
.val_file
;
7931 case dw_val_class_data8
:
7932 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
7939 /* Do the attributes look the same? */
7942 same_attr_p (dw_attr_node
*at1
, dw_attr_node
*at2
, int *mark
)
7944 if (at1
->dw_attr
!= at2
->dw_attr
)
7947 /* We don't care that this was compiled with a different compiler
7948 snapshot; if the output is the same, that's what matters. */
7949 if (at1
->dw_attr
== DW_AT_producer
)
7952 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
7955 /* Do the dies look the same? */
7958 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
7964 /* To avoid infinite recursion. */
7966 return die1
->die_mark
== die2
->die_mark
;
7967 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
7969 if (die1
->die_tag
!= die2
->die_tag
)
7972 if (vec_safe_length (die1
->die_attr
) != vec_safe_length (die2
->die_attr
))
7975 FOR_EACH_VEC_SAFE_ELT (die1
->die_attr
, ix
, a1
)
7976 if (!same_attr_p (a1
, &(*die2
->die_attr
)[ix
], mark
))
7979 c1
= die1
->die_child
;
7980 c2
= die2
->die_child
;
7989 if (!same_die_p (c1
, c2
, mark
))
7993 if (c1
== die1
->die_child
)
7995 if (c2
== die2
->die_child
)
8005 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
8006 children, and set die_symbol. */
8009 compute_comp_unit_symbol (dw_die_ref unit_die
)
8011 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
8012 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
8013 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
8016 unsigned char checksum
[16];
8019 /* Compute the checksum of the DIE, then append part of it as hex digits to
8020 the name filename of the unit. */
8022 md5_init_ctx (&ctx
);
8024 die_checksum (unit_die
, &ctx
, &mark
);
8025 unmark_all_dies (unit_die
);
8026 md5_finish_ctx (&ctx
, checksum
);
8028 /* When we this for comp_unit_die () we have a DW_AT_name that might
8029 not start with a letter but with anything valid for filenames and
8030 clean_symbol_name doesn't fix that up. Prepend 'g' if the first
8031 character is not a letter. */
8032 sprintf (name
, "%s%s.", ISALPHA (*base
) ? "" : "g", base
);
8033 clean_symbol_name (name
);
8035 p
= name
+ strlen (name
);
8036 for (i
= 0; i
< 4; i
++)
8038 sprintf (p
, "%.2x", checksum
[i
]);
8042 unit_die
->die_id
.die_symbol
= xstrdup (name
);
8045 /* Returns true if DIE represents a type, in the sense of TYPE_P. */
8048 is_type_die (dw_die_ref die
)
8050 switch (die
->die_tag
)
8052 case DW_TAG_array_type
:
8053 case DW_TAG_class_type
:
8054 case DW_TAG_interface_type
:
8055 case DW_TAG_enumeration_type
:
8056 case DW_TAG_pointer_type
:
8057 case DW_TAG_reference_type
:
8058 case DW_TAG_rvalue_reference_type
:
8059 case DW_TAG_string_type
:
8060 case DW_TAG_structure_type
:
8061 case DW_TAG_subroutine_type
:
8062 case DW_TAG_union_type
:
8063 case DW_TAG_ptr_to_member_type
:
8064 case DW_TAG_set_type
:
8065 case DW_TAG_subrange_type
:
8066 case DW_TAG_base_type
:
8067 case DW_TAG_const_type
:
8068 case DW_TAG_file_type
:
8069 case DW_TAG_packed_type
:
8070 case DW_TAG_volatile_type
:
8071 case DW_TAG_typedef
:
8078 /* Returns true iff C is a compile-unit DIE. */
8081 is_cu_die (dw_die_ref c
)
8083 return c
&& (c
->die_tag
== DW_TAG_compile_unit
8084 || c
->die_tag
== DW_TAG_skeleton_unit
);
8087 /* Returns true iff C is a unit DIE of some sort. */
8090 is_unit_die (dw_die_ref c
)
8092 return c
&& (c
->die_tag
== DW_TAG_compile_unit
8093 || c
->die_tag
== DW_TAG_partial_unit
8094 || c
->die_tag
== DW_TAG_type_unit
8095 || c
->die_tag
== DW_TAG_skeleton_unit
);
8098 /* Returns true iff C is a namespace DIE. */
8101 is_namespace_die (dw_die_ref c
)
8103 return c
&& c
->die_tag
== DW_TAG_namespace
;
8106 /* Return true if this DIE is a template parameter. */
8109 is_template_parameter (dw_die_ref die
)
8111 switch (die
->die_tag
)
8113 case DW_TAG_template_type_param
:
8114 case DW_TAG_template_value_param
:
8115 case DW_TAG_GNU_template_template_param
:
8116 case DW_TAG_GNU_template_parameter_pack
:
8123 /* Return true if this DIE represents a template instantiation. */
8126 is_template_instantiation (dw_die_ref die
)
8130 if (!is_type_die (die
) && die
->die_tag
!= DW_TAG_subprogram
)
8132 FOR_EACH_CHILD (die
, c
, if (is_template_parameter (c
)) return true);
8137 gen_internal_sym (const char *prefix
)
8139 char buf
[MAX_ARTIFICIAL_LABEL_BYTES
];
8141 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
8142 return xstrdup (buf
);
8145 /* Return true if this DIE is a declaration. */
8148 is_declaration_die (dw_die_ref die
)
8153 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8154 if (a
->dw_attr
== DW_AT_declaration
)
8160 /* Return true if this DIE is nested inside a subprogram. */
8163 is_nested_in_subprogram (dw_die_ref die
)
8165 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
8169 return local_scope_p (decl
);
8172 /* Return true if this DIE contains a defining declaration of a
8176 contains_subprogram_definition (dw_die_ref die
)
8180 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
8182 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
8186 /* Return true if this is a type DIE that should be moved to a
8187 COMDAT .debug_types section or .debug_info section with DW_UT_*type
8191 should_move_die_to_comdat (dw_die_ref die
)
8193 switch (die
->die_tag
)
8195 case DW_TAG_class_type
:
8196 case DW_TAG_structure_type
:
8197 case DW_TAG_enumeration_type
:
8198 case DW_TAG_union_type
:
8199 /* Don't move declarations, inlined instances, types nested in a
8200 subprogram, or types that contain subprogram definitions. */
8201 if (is_declaration_die (die
)
8202 || get_AT (die
, DW_AT_abstract_origin
)
8203 || is_nested_in_subprogram (die
)
8204 || contains_subprogram_definition (die
))
8207 case DW_TAG_array_type
:
8208 case DW_TAG_interface_type
:
8209 case DW_TAG_pointer_type
:
8210 case DW_TAG_reference_type
:
8211 case DW_TAG_rvalue_reference_type
:
8212 case DW_TAG_string_type
:
8213 case DW_TAG_subroutine_type
:
8214 case DW_TAG_ptr_to_member_type
:
8215 case DW_TAG_set_type
:
8216 case DW_TAG_subrange_type
:
8217 case DW_TAG_base_type
:
8218 case DW_TAG_const_type
:
8219 case DW_TAG_file_type
:
8220 case DW_TAG_packed_type
:
8221 case DW_TAG_volatile_type
:
8222 case DW_TAG_typedef
:
8228 /* Make a clone of DIE. */
8231 clone_die (dw_die_ref die
)
8233 dw_die_ref clone
= new_die_raw (die
->die_tag
);
8237 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8238 add_dwarf_attr (clone
, a
);
8243 /* Make a clone of the tree rooted at DIE. */
8246 clone_tree (dw_die_ref die
)
8249 dw_die_ref clone
= clone_die (die
);
8251 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
8256 /* Make a clone of DIE as a declaration. */
8259 clone_as_declaration (dw_die_ref die
)
8266 /* If the DIE is already a declaration, just clone it. */
8267 if (is_declaration_die (die
))
8268 return clone_die (die
);
8270 /* If the DIE is a specification, just clone its declaration DIE. */
8271 decl
= get_AT_ref (die
, DW_AT_specification
);
8274 clone
= clone_die (decl
);
8275 if (die
->comdat_type_p
)
8276 add_AT_die_ref (clone
, DW_AT_signature
, die
);
8280 clone
= new_die_raw (die
->die_tag
);
8282 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8284 /* We don't want to copy over all attributes.
8285 For example we don't want DW_AT_byte_size because otherwise we will no
8286 longer have a declaration and GDB will treat it as a definition. */
8290 case DW_AT_abstract_origin
:
8291 case DW_AT_artificial
:
8292 case DW_AT_containing_type
:
8293 case DW_AT_external
:
8296 case DW_AT_virtuality
:
8297 case DW_AT_linkage_name
:
8298 case DW_AT_MIPS_linkage_name
:
8299 add_dwarf_attr (clone
, a
);
8301 case DW_AT_byte_size
:
8302 case DW_AT_alignment
:
8308 if (die
->comdat_type_p
)
8309 add_AT_die_ref (clone
, DW_AT_signature
, die
);
8311 add_AT_flag (clone
, DW_AT_declaration
, 1);
8316 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
8318 struct decl_table_entry
8324 /* Helpers to manipulate hash table of copied declarations. */
8326 /* Hashtable helpers. */
8328 struct decl_table_entry_hasher
: free_ptr_hash
<decl_table_entry
>
8330 typedef die_struct
*compare_type
;
8331 static inline hashval_t
hash (const decl_table_entry
*);
8332 static inline bool equal (const decl_table_entry
*, const die_struct
*);
8336 decl_table_entry_hasher::hash (const decl_table_entry
*entry
)
8338 return htab_hash_pointer (entry
->orig
);
8342 decl_table_entry_hasher::equal (const decl_table_entry
*entry1
,
8343 const die_struct
*entry2
)
8345 return entry1
->orig
== entry2
;
8348 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
8350 /* Copy DIE and its ancestors, up to, but not including, the compile unit
8351 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
8352 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
8353 to check if the ancestor has already been copied into UNIT. */
8356 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
,
8357 decl_hash_type
*decl_table
)
8359 dw_die_ref parent
= die
->die_parent
;
8360 dw_die_ref new_parent
= unit
;
8362 decl_table_entry
**slot
= NULL
;
8363 struct decl_table_entry
*entry
= NULL
;
8365 /* If DIE refers to a stub unfold that so we get the appropriate
8366 DIE registered as orig in decl_table. */
8367 if (dw_die_ref c
= get_AT_ref (die
, DW_AT_signature
))
8372 /* Check if the entry has already been copied to UNIT. */
8373 slot
= decl_table
->find_slot_with_hash (die
, htab_hash_pointer (die
),
8375 if (*slot
!= HTAB_EMPTY_ENTRY
)
8381 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
8382 entry
= XCNEW (struct decl_table_entry
);
8390 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
8393 if (!is_unit_die (parent
))
8394 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
8397 copy
= clone_as_declaration (die
);
8398 add_child_die (new_parent
, copy
);
8402 /* Record the pointer to the copy. */
8408 /* Copy the declaration context to the new type unit DIE. This includes
8409 any surrounding namespace or type declarations. If the DIE has an
8410 AT_specification attribute, it also includes attributes and children
8411 attached to the specification, and returns a pointer to the original
8412 parent of the declaration DIE. Returns NULL otherwise. */
8415 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
8418 dw_die_ref new_decl
;
8419 dw_die_ref orig_parent
= NULL
;
8421 decl
= get_AT_ref (die
, DW_AT_specification
);
8430 /* The original DIE will be changed to a declaration, and must
8431 be moved to be a child of the original declaration DIE. */
8432 orig_parent
= decl
->die_parent
;
8434 /* Copy the type node pointer from the new DIE to the original
8435 declaration DIE so we can forward references later. */
8436 decl
->comdat_type_p
= true;
8437 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
8439 remove_AT (die
, DW_AT_specification
);
8441 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
8443 if (a
->dw_attr
!= DW_AT_name
8444 && a
->dw_attr
!= DW_AT_declaration
8445 && a
->dw_attr
!= DW_AT_external
)
8446 add_dwarf_attr (die
, a
);
8449 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
8452 if (decl
->die_parent
!= NULL
8453 && !is_unit_die (decl
->die_parent
))
8455 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
8456 if (new_decl
!= NULL
)
8458 remove_AT (new_decl
, DW_AT_signature
);
8459 add_AT_specification (die
, new_decl
);
8466 /* Generate the skeleton ancestor tree for the given NODE, then clone
8467 the DIE and add the clone into the tree. */
8470 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
8472 if (node
->new_die
!= NULL
)
8475 node
->new_die
= clone_as_declaration (node
->old_die
);
8477 if (node
->parent
!= NULL
)
8479 generate_skeleton_ancestor_tree (node
->parent
);
8480 add_child_die (node
->parent
->new_die
, node
->new_die
);
8484 /* Generate a skeleton tree of DIEs containing any declarations that are
8485 found in the original tree. We traverse the tree looking for declaration
8486 DIEs, and construct the skeleton from the bottom up whenever we find one. */
8489 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
8491 skeleton_chain_node node
;
8494 dw_die_ref prev
= NULL
;
8495 dw_die_ref next
= NULL
;
8497 node
.parent
= parent
;
8499 first
= c
= parent
->old_die
->die_child
;
8503 if (prev
== NULL
|| prev
->die_sib
== c
)
8506 next
= (c
== first
? NULL
: c
->die_sib
);
8508 node
.new_die
= NULL
;
8509 if (is_declaration_die (c
))
8511 if (is_template_instantiation (c
))
8513 /* Instantiated templates do not need to be cloned into the
8514 type unit. Just move the DIE and its children back to
8515 the skeleton tree (in the main CU). */
8516 remove_child_with_prev (c
, prev
);
8517 add_child_die (parent
->new_die
, c
);
8520 else if (c
->comdat_type_p
)
8522 /* This is the skeleton of earlier break_out_comdat_types
8523 type. Clone the existing DIE, but keep the children
8524 under the original (which is in the main CU). */
8525 dw_die_ref clone
= clone_die (c
);
8527 replace_child (c
, clone
, prev
);
8528 generate_skeleton_ancestor_tree (parent
);
8529 add_child_die (parent
->new_die
, c
);
8535 /* Clone the existing DIE, move the original to the skeleton
8536 tree (which is in the main CU), and put the clone, with
8537 all the original's children, where the original came from
8538 (which is about to be moved to the type unit). */
8539 dw_die_ref clone
= clone_die (c
);
8540 move_all_children (c
, clone
);
8542 /* If the original has a DW_AT_object_pointer attribute,
8543 it would now point to a child DIE just moved to the
8544 cloned tree, so we need to remove that attribute from
8546 remove_AT (c
, DW_AT_object_pointer
);
8548 replace_child (c
, clone
, prev
);
8549 generate_skeleton_ancestor_tree (parent
);
8550 add_child_die (parent
->new_die
, c
);
8551 node
.old_die
= clone
;
8556 generate_skeleton_bottom_up (&node
);
8557 } while (next
!= NULL
);
8560 /* Wrapper function for generate_skeleton_bottom_up. */
8563 generate_skeleton (dw_die_ref die
)
8565 skeleton_chain_node node
;
8568 node
.new_die
= NULL
;
8571 /* If this type definition is nested inside another type,
8572 and is not an instantiation of a template, always leave
8573 at least a declaration in its place. */
8574 if (die
->die_parent
!= NULL
8575 && is_type_die (die
->die_parent
)
8576 && !is_template_instantiation (die
))
8577 node
.new_die
= clone_as_declaration (die
);
8579 generate_skeleton_bottom_up (&node
);
8580 return node
.new_die
;
8583 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
8584 declaration. The original DIE is moved to a new compile unit so that
8585 existing references to it follow it to the new location. If any of the
8586 original DIE's descendants is a declaration, we need to replace the
8587 original DIE with a skeleton tree and move the declarations back into the
8591 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
8594 dw_die_ref skeleton
, orig_parent
;
8596 /* Copy the declaration context to the type unit DIE. If the returned
8597 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
8599 orig_parent
= copy_declaration_context (unit
, child
);
8601 skeleton
= generate_skeleton (child
);
8602 if (skeleton
== NULL
)
8603 remove_child_with_prev (child
, prev
);
8606 skeleton
->comdat_type_p
= true;
8607 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
8609 /* If the original DIE was a specification, we need to put
8610 the skeleton under the parent DIE of the declaration.
8611 This leaves the original declaration in the tree, but
8612 it will be pruned later since there are no longer any
8613 references to it. */
8614 if (orig_parent
!= NULL
)
8616 remove_child_with_prev (child
, prev
);
8617 add_child_die (orig_parent
, skeleton
);
8620 replace_child (child
, skeleton
, prev
);
8627 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8628 comdat_type_node
*type_node
,
8629 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
);
8631 /* Helper for copy_dwarf_procs_ref_in_dies. Make a copy of the DIE DWARF
8632 procedure, put it under TYPE_NODE and return the copy. Continue looking for
8633 DWARF procedure references in the DW_AT_location attribute. */
8636 copy_dwarf_procedure (dw_die_ref die
,
8637 comdat_type_node
*type_node
,
8638 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8640 gcc_assert (die
->die_tag
== DW_TAG_dwarf_procedure
);
8642 /* DWARF procedures are not supposed to have children... */
8643 gcc_assert (die
->die_child
== NULL
);
8645 /* ... and they are supposed to have only one attribute: DW_AT_location. */
8646 gcc_assert (vec_safe_length (die
->die_attr
) == 1
8647 && ((*die
->die_attr
)[0].dw_attr
== DW_AT_location
));
8649 /* Do not copy more than once DWARF procedures. */
8651 dw_die_ref
&die_copy
= copied_dwarf_procs
.get_or_insert (die
, &existed
);
8655 die_copy
= clone_die (die
);
8656 add_child_die (type_node
->root_die
, die_copy
);
8657 copy_dwarf_procs_ref_in_attrs (die_copy
, type_node
, copied_dwarf_procs
);
8661 /* Helper for copy_dwarf_procs_ref_in_dies. Look for references to DWARF
8662 procedures in DIE's attributes. */
8665 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8666 comdat_type_node
*type_node
,
8667 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8672 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, i
, a
)
8674 dw_loc_descr_ref loc
;
8676 if (a
->dw_attr_val
.val_class
!= dw_val_class_loc
)
8679 for (loc
= a
->dw_attr_val
.v
.val_loc
; loc
!= NULL
; loc
= loc
->dw_loc_next
)
8681 switch (loc
->dw_loc_opc
)
8685 case DW_OP_call_ref
:
8686 gcc_assert (loc
->dw_loc_oprnd1
.val_class
8687 == dw_val_class_die_ref
);
8688 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
8689 = copy_dwarf_procedure (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
,
8691 copied_dwarf_procs
);
8700 /* Copy DWARF procedures that are referenced by the DIE tree to TREE_NODE and
8701 rewrite references to point to the copies.
8703 References are looked for in DIE's attributes and recursively in all its
8704 children attributes that are location descriptions. COPIED_DWARF_PROCS is a
8705 mapping from old DWARF procedures to their copy. It is used not to copy
8706 twice the same DWARF procedure under TYPE_NODE. */
8709 copy_dwarf_procs_ref_in_dies (dw_die_ref die
,
8710 comdat_type_node
*type_node
,
8711 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8715 copy_dwarf_procs_ref_in_attrs (die
, type_node
, copied_dwarf_procs
);
8716 FOR_EACH_CHILD (die
, c
, copy_dwarf_procs_ref_in_dies (c
,
8718 copied_dwarf_procs
));
8721 /* Traverse the DIE and set up additional .debug_types or .debug_info
8722 DW_UT_*type sections for each type worthy of being placed in a COMDAT
8726 break_out_comdat_types (dw_die_ref die
)
8730 dw_die_ref prev
= NULL
;
8731 dw_die_ref next
= NULL
;
8732 dw_die_ref unit
= NULL
;
8734 first
= c
= die
->die_child
;
8738 if (prev
== NULL
|| prev
->die_sib
== c
)
8741 next
= (c
== first
? NULL
: c
->die_sib
);
8742 if (should_move_die_to_comdat (c
))
8744 dw_die_ref replacement
;
8745 comdat_type_node
*type_node
;
8747 /* Break out nested types into their own type units. */
8748 break_out_comdat_types (c
);
8750 /* Create a new type unit DIE as the root for the new tree. */
8751 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
8752 add_AT_unsigned (unit
, DW_AT_language
,
8753 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
8755 /* Add the new unit's type DIE into the comdat type list. */
8756 type_node
= ggc_cleared_alloc
<comdat_type_node
> ();
8757 type_node
->root_die
= unit
;
8758 type_node
->next
= comdat_type_list
;
8759 comdat_type_list
= type_node
;
8761 /* Generate the type signature. */
8762 generate_type_signature (c
, type_node
);
8764 /* Copy the declaration context, attributes, and children of the
8765 declaration into the new type unit DIE, then remove this DIE
8766 from the main CU (or replace it with a skeleton if necessary). */
8767 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
8768 type_node
->skeleton_die
= replacement
;
8770 /* Add the DIE to the new compunit. */
8771 add_child_die (unit
, c
);
8773 /* Types can reference DWARF procedures for type size or data location
8774 expressions. Calls in DWARF expressions cannot target procedures
8775 that are not in the same section. So we must copy DWARF procedures
8776 along with this type and then rewrite references to them. */
8777 hash_map
<dw_die_ref
, dw_die_ref
> copied_dwarf_procs
;
8778 copy_dwarf_procs_ref_in_dies (c
, type_node
, copied_dwarf_procs
);
8780 if (replacement
!= NULL
)
8783 else if (c
->die_tag
== DW_TAG_namespace
8784 || c
->die_tag
== DW_TAG_class_type
8785 || c
->die_tag
== DW_TAG_structure_type
8786 || c
->die_tag
== DW_TAG_union_type
)
8788 /* Look for nested types that can be broken out. */
8789 break_out_comdat_types (c
);
8791 } while (next
!= NULL
);
8794 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
8795 Enter all the cloned children into the hash table decl_table. */
8798 clone_tree_partial (dw_die_ref die
, decl_hash_type
*decl_table
)
8802 struct decl_table_entry
*entry
;
8803 decl_table_entry
**slot
;
8805 if (die
->die_tag
== DW_TAG_subprogram
)
8806 clone
= clone_as_declaration (die
);
8808 clone
= clone_die (die
);
8810 slot
= decl_table
->find_slot_with_hash (die
,
8811 htab_hash_pointer (die
), INSERT
);
8813 /* Assert that DIE isn't in the hash table yet. If it would be there
8814 before, the ancestors would be necessarily there as well, therefore
8815 clone_tree_partial wouldn't be called. */
8816 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
8818 entry
= XCNEW (struct decl_table_entry
);
8820 entry
->copy
= clone
;
8823 if (die
->die_tag
!= DW_TAG_subprogram
)
8824 FOR_EACH_CHILD (die
, c
,
8825 add_child_die (clone
, clone_tree_partial (c
, decl_table
)));
8830 /* Walk the DIE and its children, looking for references to incomplete
8831 or trivial types that are unmarked (i.e., that are not in the current
8835 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type
*decl_table
)
8841 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8843 if (AT_class (a
) == dw_val_class_die_ref
)
8845 dw_die_ref targ
= AT_ref (a
);
8846 decl_table_entry
**slot
;
8847 struct decl_table_entry
*entry
;
8849 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
8852 slot
= decl_table
->find_slot_with_hash (targ
,
8853 htab_hash_pointer (targ
),
8856 if (*slot
!= HTAB_EMPTY_ENTRY
)
8858 /* TARG has already been copied, so we just need to
8859 modify the reference to point to the copy. */
8861 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
8865 dw_die_ref parent
= unit
;
8866 dw_die_ref copy
= clone_die (targ
);
8868 /* Record in DECL_TABLE that TARG has been copied.
8869 Need to do this now, before the recursive call,
8870 because DECL_TABLE may be expanded and SLOT
8871 would no longer be a valid pointer. */
8872 entry
= XCNEW (struct decl_table_entry
);
8877 /* If TARG is not a declaration DIE, we need to copy its
8879 if (!is_declaration_die (targ
))
8883 add_child_die (copy
,
8884 clone_tree_partial (c
, decl_table
)));
8887 /* Make sure the cloned tree is marked as part of the
8891 /* If TARG has surrounding context, copy its ancestor tree
8892 into the new type unit. */
8893 if (targ
->die_parent
!= NULL
8894 && !is_unit_die (targ
->die_parent
))
8895 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
8898 add_child_die (parent
, copy
);
8899 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
8901 /* Make sure the newly-copied DIE is walked. If it was
8902 installed in a previously-added context, it won't
8903 get visited otherwise. */
8906 /* Find the highest point of the newly-added tree,
8907 mark each node along the way, and walk from there. */
8908 parent
->die_mark
= 1;
8909 while (parent
->die_parent
8910 && parent
->die_parent
->die_mark
== 0)
8912 parent
= parent
->die_parent
;
8913 parent
->die_mark
= 1;
8915 copy_decls_walk (unit
, parent
, decl_table
);
8921 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
8924 /* Collect skeleton dies in DIE created by break_out_comdat_types already
8925 and record them in DECL_TABLE. */
8928 collect_skeleton_dies (dw_die_ref die
, decl_hash_type
*decl_table
)
8932 if (dw_attr_node
*a
= get_AT (die
, DW_AT_signature
))
8934 dw_die_ref targ
= AT_ref (a
);
8935 gcc_assert (targ
->die_mark
== 0 && targ
->comdat_type_p
);
8936 decl_table_entry
**slot
8937 = decl_table
->find_slot_with_hash (targ
,
8938 htab_hash_pointer (targ
),
8940 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
8941 /* Record in DECL_TABLE that TARG has been already copied
8942 by remove_child_or_replace_with_skeleton. */
8943 decl_table_entry
*entry
= XCNEW (struct decl_table_entry
);
8948 FOR_EACH_CHILD (die
, c
, collect_skeleton_dies (c
, decl_table
));
8951 /* Copy declarations for "unworthy" types into the new comdat section.
8952 Incomplete types, modified types, and certain other types aren't broken
8953 out into comdat sections of their own, so they don't have a signature,
8954 and we need to copy the declaration into the same section so that we
8955 don't have an external reference. */
8958 copy_decls_for_unworthy_types (dw_die_ref unit
)
8961 decl_hash_type
decl_table (10);
8962 collect_skeleton_dies (unit
, &decl_table
);
8963 copy_decls_walk (unit
, unit
, &decl_table
);
8967 /* Traverse the DIE and add a sibling attribute if it may have the
8968 effect of speeding up access to siblings. To save some space,
8969 avoid generating sibling attributes for DIE's without children. */
8972 add_sibling_attributes (dw_die_ref die
)
8976 if (! die
->die_child
)
8979 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
8980 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
8982 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
8985 /* Output all location lists for the DIE and its children. */
8988 output_location_lists (dw_die_ref die
)
8994 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8995 if (AT_class (a
) == dw_val_class_loc_list
)
8996 output_loc_list (AT_loc_list (a
));
8998 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
9001 /* During assign_location_list_indexes and output_loclists_offset the
9002 current index, after it the number of assigned indexes (i.e. how
9003 large the .debug_loclists* offset table should be). */
9004 static unsigned int loc_list_idx
;
9006 /* Output all location list offsets for the DIE and its children. */
9009 output_loclists_offsets (dw_die_ref die
)
9015 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9016 if (AT_class (a
) == dw_val_class_loc_list
)
9018 dw_loc_list_ref l
= AT_loc_list (a
);
9019 if (l
->offset_emitted
)
9021 dw2_asm_output_delta (dwarf_offset_size
, l
->ll_symbol
,
9022 loc_section_label
, NULL
);
9023 gcc_assert (l
->hash
== loc_list_idx
);
9025 l
->offset_emitted
= true;
9028 FOR_EACH_CHILD (die
, c
, output_loclists_offsets (c
));
9031 /* Recursively set indexes of location lists. */
9034 assign_location_list_indexes (dw_die_ref die
)
9040 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9041 if (AT_class (a
) == dw_val_class_loc_list
)
9043 dw_loc_list_ref list
= AT_loc_list (a
);
9044 if (!list
->num_assigned
)
9046 list
->num_assigned
= true;
9047 list
->hash
= loc_list_idx
++;
9051 FOR_EACH_CHILD (die
, c
, assign_location_list_indexes (c
));
9054 /* We want to limit the number of external references, because they are
9055 larger than local references: a relocation takes multiple words, and
9056 even a sig8 reference is always eight bytes, whereas a local reference
9057 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
9058 So if we encounter multiple external references to the same type DIE, we
9059 make a local typedef stub for it and redirect all references there.
9061 This is the element of the hash table for keeping track of these
9071 /* Hashtable helpers. */
9073 struct external_ref_hasher
: free_ptr_hash
<external_ref
>
9075 static inline hashval_t
hash (const external_ref
*);
9076 static inline bool equal (const external_ref
*, const external_ref
*);
9080 external_ref_hasher::hash (const external_ref
*r
)
9082 dw_die_ref die
= r
->type
;
9085 /* We can't use the address of the DIE for hashing, because
9086 that will make the order of the stub DIEs non-deterministic. */
9087 if (! die
->comdat_type_p
)
9088 /* We have a symbol; use it to compute a hash. */
9089 h
= htab_hash_string (die
->die_id
.die_symbol
);
9092 /* We have a type signature; use a subset of the bits as the hash.
9093 The 8-byte signature is at least as large as hashval_t. */
9094 comdat_type_node
*type_node
= die
->die_id
.die_type_node
;
9095 memcpy (&h
, type_node
->signature
, sizeof (h
));
9101 external_ref_hasher::equal (const external_ref
*r1
, const external_ref
*r2
)
9103 return r1
->type
== r2
->type
;
9106 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
9108 /* Return a pointer to the external_ref for references to DIE. */
9110 static struct external_ref
*
9111 lookup_external_ref (external_ref_hash_type
*map
, dw_die_ref die
)
9113 struct external_ref ref
, *ref_p
;
9114 external_ref
**slot
;
9117 slot
= map
->find_slot (&ref
, INSERT
);
9118 if (*slot
!= HTAB_EMPTY_ENTRY
)
9121 ref_p
= XCNEW (struct external_ref
);
9127 /* Subroutine of optimize_external_refs, below.
9129 If we see a type skeleton, record it as our stub. If we see external
9130 references, remember how many we've seen. */
9133 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type
*map
)
9138 struct external_ref
*ref_p
;
9140 if (is_type_die (die
)
9141 && (c
= get_AT_ref (die
, DW_AT_signature
)))
9143 /* This is a local skeleton; use it for local references. */
9144 ref_p
= lookup_external_ref (map
, c
);
9148 /* Scan the DIE references, and remember any that refer to DIEs from
9149 other CUs (i.e. those which are not marked). */
9150 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9151 if (AT_class (a
) == dw_val_class_die_ref
9152 && (c
= AT_ref (a
))->die_mark
== 0
9155 ref_p
= lookup_external_ref (map
, c
);
9159 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
9162 /* htab_traverse callback function for optimize_external_refs, below. SLOT
9163 points to an external_ref, DATA is the CU we're processing. If we don't
9164 already have a local stub, and we have multiple refs, build a stub. */
9167 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
9169 struct external_ref
*ref_p
= *slot
;
9171 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
9173 /* We have multiple references to this type, so build a small stub.
9174 Both of these forms are a bit dodgy from the perspective of the
9175 DWARF standard, since technically they should have names. */
9176 dw_die_ref cu
= data
;
9177 dw_die_ref type
= ref_p
->type
;
9178 dw_die_ref stub
= NULL
;
9180 if (type
->comdat_type_p
)
9182 /* If we refer to this type via sig8, use AT_signature. */
9183 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
9184 add_AT_die_ref (stub
, DW_AT_signature
, type
);
9188 /* Otherwise, use a typedef with no name. */
9189 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
9190 add_AT_die_ref (stub
, DW_AT_type
, type
);
9199 /* DIE is a unit; look through all the DIE references to see if there are
9200 any external references to types, and if so, create local stubs for
9201 them which will be applied in build_abbrev_table. This is useful because
9202 references to local DIEs are smaller. */
9204 static external_ref_hash_type
*
9205 optimize_external_refs (dw_die_ref die
)
9207 external_ref_hash_type
*map
= new external_ref_hash_type (10);
9208 optimize_external_refs_1 (die
, map
);
9209 map
->traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
9213 /* The following 3 variables are temporaries that are computed only during the
9214 build_abbrev_table call and used and released during the following
9215 optimize_abbrev_table call. */
9217 /* First abbrev_id that can be optimized based on usage. */
9218 static unsigned int abbrev_opt_start
;
9220 /* Maximum abbrev_id of a base type plus one (we can't optimize DIEs with
9221 abbrev_id smaller than this, because they must be already sized
9222 during build_abbrev_table). */
9223 static unsigned int abbrev_opt_base_type_end
;
9225 /* Vector of usage counts during build_abbrev_table. Indexed by
9226 abbrev_id - abbrev_opt_start. */
9227 static vec
<unsigned int> abbrev_usage_count
;
9229 /* Vector of all DIEs added with die_abbrev >= abbrev_opt_start. */
9230 static vec
<dw_die_ref
> sorted_abbrev_dies
;
9232 /* The format of each DIE (and its attribute value pairs) is encoded in an
9233 abbreviation table. This routine builds the abbreviation table and assigns
9234 a unique abbreviation id for each abbreviation entry. The children of each
9235 die are visited recursively. */
9238 build_abbrev_table (dw_die_ref die
, external_ref_hash_type
*extern_map
)
9240 unsigned int abbrev_id
= 0;
9246 /* Scan the DIE references, and replace any that refer to
9247 DIEs from other CUs (i.e. those which are not marked) with
9248 the local stubs we built in optimize_external_refs. */
9249 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9250 if (AT_class (a
) == dw_val_class_die_ref
9251 && (c
= AT_ref (a
))->die_mark
== 0)
9253 struct external_ref
*ref_p
;
9254 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
9257 && (ref_p
= lookup_external_ref (extern_map
, c
))
9258 && ref_p
->stub
&& ref_p
->stub
!= die
)
9260 gcc_assert (a
->dw_attr
!= DW_AT_signature
);
9261 change_AT_die_ref (a
, ref_p
->stub
);
9264 /* We aren't changing this reference, so mark it external. */
9265 set_AT_ref_external (a
, 1);
9268 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
9270 dw_attr_node
*die_a
, *abbrev_a
;
9276 if (abbrev
->die_tag
!= die
->die_tag
)
9278 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
9281 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
9284 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
9286 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
9287 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
9288 || (value_format (abbrev_a
) != value_format (die_a
)))
9298 if (abbrev_id
>= vec_safe_length (abbrev_die_table
))
9300 vec_safe_push (abbrev_die_table
, die
);
9301 if (abbrev_opt_start
)
9302 abbrev_usage_count
.safe_push (0);
9304 if (abbrev_opt_start
&& abbrev_id
>= abbrev_opt_start
)
9306 abbrev_usage_count
[abbrev_id
- abbrev_opt_start
]++;
9307 sorted_abbrev_dies
.safe_push (die
);
9310 die
->die_abbrev
= abbrev_id
;
9311 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
9314 /* Callback function for sorted_abbrev_dies vector sorting. We sort
9315 by die_abbrev's usage count, from the most commonly used
9316 abbreviation to the least. */
9319 die_abbrev_cmp (const void *p1
, const void *p2
)
9321 dw_die_ref die1
= *(const dw_die_ref
*) p1
;
9322 dw_die_ref die2
= *(const dw_die_ref
*) p2
;
9324 gcc_checking_assert (die1
->die_abbrev
>= abbrev_opt_start
);
9325 gcc_checking_assert (die2
->die_abbrev
>= abbrev_opt_start
);
9327 if (die1
->die_abbrev
>= abbrev_opt_base_type_end
9328 && die2
->die_abbrev
>= abbrev_opt_base_type_end
)
9330 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
9331 > abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
9333 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
9334 < abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
9338 /* Stabilize the sort. */
9339 if (die1
->die_abbrev
< die2
->die_abbrev
)
9341 if (die1
->die_abbrev
> die2
->die_abbrev
)
9347 /* Convert dw_val_class_const and dw_val_class_unsigned_const class attributes
9348 of DIEs in between sorted_abbrev_dies[first_id] and abbrev_dies[end_id - 1]
9349 into dw_val_class_const_implicit or
9350 dw_val_class_unsigned_const_implicit. */
9353 optimize_implicit_const (unsigned int first_id
, unsigned int end
,
9354 vec
<bool> &implicit_consts
)
9356 /* It never makes sense if there is just one DIE using the abbreviation. */
9357 if (end
< first_id
+ 2)
9362 dw_die_ref die
= sorted_abbrev_dies
[first_id
];
9363 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9364 if (implicit_consts
[ix
])
9366 enum dw_val_class new_class
= dw_val_class_none
;
9367 switch (AT_class (a
))
9369 case dw_val_class_unsigned_const
:
9370 if ((HOST_WIDE_INT
) AT_unsigned (a
) < 0)
9373 /* The .debug_abbrev section will grow by
9374 size_of_sleb128 (AT_unsigned (a)) and we avoid the constants
9375 in all the DIEs using that abbreviation. */
9376 if (constant_size (AT_unsigned (a
)) * (end
- first_id
)
9377 <= (unsigned) size_of_sleb128 (AT_unsigned (a
)))
9380 new_class
= dw_val_class_unsigned_const_implicit
;
9383 case dw_val_class_const
:
9384 new_class
= dw_val_class_const_implicit
;
9387 case dw_val_class_file
:
9388 new_class
= dw_val_class_file_implicit
;
9394 for (i
= first_id
; i
< end
; i
++)
9395 (*sorted_abbrev_dies
[i
]->die_attr
)[ix
].dw_attr_val
.val_class
9400 /* Attempt to optimize abbreviation table from abbrev_opt_start
9401 abbreviation above. */
9404 optimize_abbrev_table (void)
9406 if (abbrev_opt_start
9407 && vec_safe_length (abbrev_die_table
) > abbrev_opt_start
9408 && (dwarf_version
>= 5 || vec_safe_length (abbrev_die_table
) > 127))
9410 auto_vec
<bool, 32> implicit_consts
;
9411 sorted_abbrev_dies
.qsort (die_abbrev_cmp
);
9413 unsigned int abbrev_id
= abbrev_opt_start
- 1;
9414 unsigned int first_id
= ~0U;
9415 unsigned int last_abbrev_id
= 0;
9418 if (abbrev_opt_base_type_end
> abbrev_opt_start
)
9419 abbrev_id
= abbrev_opt_base_type_end
- 1;
9420 /* Reassign abbreviation ids from abbrev_opt_start above, so that
9421 most commonly used abbreviations come first. */
9422 FOR_EACH_VEC_ELT (sorted_abbrev_dies
, i
, die
)
9427 /* If calc_base_type_die_sizes has been called, the CU and
9428 base types after it can't be optimized, because we've already
9429 calculated their DIE offsets. We've sorted them first. */
9430 if (die
->die_abbrev
< abbrev_opt_base_type_end
)
9432 if (die
->die_abbrev
!= last_abbrev_id
)
9434 last_abbrev_id
= die
->die_abbrev
;
9435 if (dwarf_version
>= 5 && first_id
!= ~0U)
9436 optimize_implicit_const (first_id
, i
, implicit_consts
);
9438 (*abbrev_die_table
)[abbrev_id
] = die
;
9439 if (dwarf_version
>= 5)
9442 implicit_consts
.truncate (0);
9444 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9445 switch (AT_class (a
))
9447 case dw_val_class_const
:
9448 case dw_val_class_unsigned_const
:
9449 case dw_val_class_file
:
9450 implicit_consts
.safe_push (true);
9453 implicit_consts
.safe_push (false);
9458 else if (dwarf_version
>= 5)
9460 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9461 if (!implicit_consts
[ix
])
9465 dw_attr_node
*other_a
9466 = &(*(*abbrev_die_table
)[abbrev_id
]->die_attr
)[ix
];
9467 if (!dw_val_equal_p (&a
->dw_attr_val
,
9468 &other_a
->dw_attr_val
))
9469 implicit_consts
[ix
] = false;
9472 die
->die_abbrev
= abbrev_id
;
9474 gcc_assert (abbrev_id
== vec_safe_length (abbrev_die_table
) - 1);
9475 if (dwarf_version
>= 5 && first_id
!= ~0U)
9476 optimize_implicit_const (first_id
, i
, implicit_consts
);
9479 abbrev_opt_start
= 0;
9480 abbrev_opt_base_type_end
= 0;
9481 abbrev_usage_count
.release ();
9482 sorted_abbrev_dies
.release ();
9485 /* Return the power-of-two number of bytes necessary to represent VALUE. */
9488 constant_size (unsigned HOST_WIDE_INT value
)
9495 log
= floor_log2 (value
);
9498 log
= 1 << (floor_log2 (log
) + 1);
9503 /* Return the size of a DIE as it is represented in the
9504 .debug_info section. */
9506 static unsigned long
9507 size_of_die (dw_die_ref die
)
9509 unsigned long size
= 0;
9512 enum dwarf_form form
;
9514 size
+= size_of_uleb128 (die
->die_abbrev
);
9515 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9517 switch (AT_class (a
))
9519 case dw_val_class_addr
:
9520 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9522 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9523 size
+= size_of_uleb128 (AT_index (a
));
9526 size
+= DWARF2_ADDR_SIZE
;
9528 case dw_val_class_offset
:
9529 size
+= dwarf_offset_size
;
9531 case dw_val_class_loc
:
9533 unsigned long lsize
= size_of_locs (AT_loc (a
));
9536 if (dwarf_version
>= 4)
9537 size
+= size_of_uleb128 (lsize
);
9539 size
+= constant_size (lsize
);
9543 case dw_val_class_loc_list
:
9544 if (dwarf_split_debug_info
&& dwarf_version
>= 5)
9546 gcc_assert (AT_loc_list (a
)->num_assigned
);
9547 size
+= size_of_uleb128 (AT_loc_list (a
)->hash
);
9550 size
+= dwarf_offset_size
;
9552 case dw_val_class_view_list
:
9553 size
+= dwarf_offset_size
;
9555 case dw_val_class_range_list
:
9556 if (value_format (a
) == DW_FORM_rnglistx
)
9558 gcc_assert (rnglist_idx
);
9559 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
9560 size
+= size_of_uleb128 (r
->idx
);
9563 size
+= dwarf_offset_size
;
9565 case dw_val_class_const
:
9566 size
+= size_of_sleb128 (AT_int (a
));
9568 case dw_val_class_unsigned_const
:
9570 int csize
= constant_size (AT_unsigned (a
));
9571 if (dwarf_version
== 3
9572 && a
->dw_attr
== DW_AT_data_member_location
9574 size
+= size_of_uleb128 (AT_unsigned (a
));
9579 case dw_val_class_symview
:
9580 if (symview_upper_bound
<= 0xff)
9582 else if (symview_upper_bound
<= 0xffff)
9584 else if (symview_upper_bound
<= 0xffffffff)
9589 case dw_val_class_const_implicit
:
9590 case dw_val_class_unsigned_const_implicit
:
9591 case dw_val_class_file_implicit
:
9592 /* These occupy no size in the DIE, just an extra sleb128 in
9595 case dw_val_class_const_double
:
9596 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
9597 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
9600 case dw_val_class_wide_int
:
9601 size
+= (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9602 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
9603 if (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9604 * HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
9607 case dw_val_class_vec
:
9608 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
9609 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
9610 + a
->dw_attr_val
.v
.val_vec
.length
9611 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
9613 case dw_val_class_flag
:
9614 if (dwarf_version
>= 4)
9615 /* Currently all add_AT_flag calls pass in 1 as last argument,
9616 so DW_FORM_flag_present can be used. If that ever changes,
9617 we'll need to use DW_FORM_flag and have some optimization
9618 in build_abbrev_table that will change those to
9619 DW_FORM_flag_present if it is set to 1 in all DIEs using
9620 the same abbrev entry. */
9621 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9625 case dw_val_class_die_ref
:
9626 if (AT_ref_external (a
))
9628 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
9629 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
9630 is sized by target address length, whereas in DWARF3
9631 it's always sized as an offset. */
9632 if (AT_ref (a
)->comdat_type_p
)
9633 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
9634 else if (dwarf_version
== 2)
9635 size
+= DWARF2_ADDR_SIZE
;
9637 size
+= dwarf_offset_size
;
9640 size
+= dwarf_offset_size
;
9642 case dw_val_class_fde_ref
:
9643 size
+= dwarf_offset_size
;
9645 case dw_val_class_lbl_id
:
9646 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9648 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9649 size
+= size_of_uleb128 (AT_index (a
));
9652 size
+= DWARF2_ADDR_SIZE
;
9654 case dw_val_class_lineptr
:
9655 case dw_val_class_macptr
:
9656 case dw_val_class_loclistsptr
:
9657 size
+= dwarf_offset_size
;
9659 case dw_val_class_str
:
9660 form
= AT_string_form (a
);
9661 if (form
== DW_FORM_strp
|| form
== DW_FORM_line_strp
)
9662 size
+= dwarf_offset_size
;
9663 else if (form
== dwarf_FORM (DW_FORM_strx
))
9664 size
+= size_of_uleb128 (AT_index (a
));
9666 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
9668 case dw_val_class_file
:
9669 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
9671 case dw_val_class_data8
:
9674 case dw_val_class_vms_delta
:
9675 size
+= dwarf_offset_size
;
9677 case dw_val_class_high_pc
:
9678 size
+= DWARF2_ADDR_SIZE
;
9680 case dw_val_class_discr_value
:
9681 size
+= size_of_discr_value (&a
->dw_attr_val
.v
.val_discr_value
);
9683 case dw_val_class_discr_list
:
9685 unsigned block_size
= size_of_discr_list (AT_discr_list (a
));
9687 /* This is a block, so we have the block length and then its
9689 size
+= constant_size (block_size
) + block_size
;
9700 /* Size the debugging information associated with a given DIE. Visits the
9701 DIE's children recursively. Updates the global variable next_die_offset, on
9702 each time through. Uses the current value of next_die_offset to update the
9703 die_offset field in each DIE. */
9706 calc_die_sizes (dw_die_ref die
)
9710 gcc_assert (die
->die_offset
== 0
9711 || (unsigned long int) die
->die_offset
== next_die_offset
);
9712 die
->die_offset
= next_die_offset
;
9713 next_die_offset
+= size_of_die (die
);
9715 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
9717 if (die
->die_child
!= NULL
)
9718 /* Count the null byte used to terminate sibling lists. */
9719 next_die_offset
+= 1;
9722 /* Size just the base type children at the start of the CU.
9723 This is needed because build_abbrev needs to size locs
9724 and sizing of type based stack ops needs to know die_offset
9725 values for the base types. */
9728 calc_base_type_die_sizes (void)
9730 unsigned long die_offset
= (dwarf_split_debug_info
9731 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
9732 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
9734 dw_die_ref base_type
;
9735 #if ENABLE_ASSERT_CHECKING
9736 dw_die_ref prev
= comp_unit_die ()->die_child
;
9739 die_offset
+= size_of_die (comp_unit_die ());
9740 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
9742 #if ENABLE_ASSERT_CHECKING
9743 gcc_assert (base_type
->die_offset
== 0
9744 && prev
->die_sib
== base_type
9745 && base_type
->die_child
== NULL
9746 && base_type
->die_abbrev
);
9749 if (abbrev_opt_start
9750 && base_type
->die_abbrev
>= abbrev_opt_base_type_end
)
9751 abbrev_opt_base_type_end
= base_type
->die_abbrev
+ 1;
9752 base_type
->die_offset
= die_offset
;
9753 die_offset
+= size_of_die (base_type
);
9757 /* Set the marks for a die and its children. We do this so
9758 that we know whether or not a reference needs to use FORM_ref_addr; only
9759 DIEs in the same CU will be marked. We used to clear out the offset
9760 and use that as the flag, but ran into ordering problems. */
9763 mark_dies (dw_die_ref die
)
9767 gcc_assert (!die
->die_mark
);
9770 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
9773 /* Clear the marks for a die and its children. */
9776 unmark_dies (dw_die_ref die
)
9780 if (! use_debug_types
)
9781 gcc_assert (die
->die_mark
);
9784 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
9787 /* Clear the marks for a die, its children and referred dies. */
9790 unmark_all_dies (dw_die_ref die
)
9800 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
9802 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9803 if (AT_class (a
) == dw_val_class_die_ref
)
9804 unmark_all_dies (AT_ref (a
));
9807 /* Calculate if the entry should appear in the final output file. It may be
9808 from a pruned a type. */
9811 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
9813 /* By limiting gnu pubnames to definitions only, gold can generate a
9814 gdb index without entries for declarations, which don't include
9815 enough information to be useful. */
9816 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
9819 if (table
== pubname_table
)
9821 /* Enumerator names are part of the pubname table, but the
9822 parent DW_TAG_enumeration_type die may have been pruned.
9823 Don't output them if that is the case. */
9824 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
9825 (p
->die
->die_parent
== NULL
9826 || !p
->die
->die_parent
->die_perennial_p
))
9829 /* Everything else in the pubname table is included. */
9833 /* The pubtypes table shouldn't include types that have been
9835 return (p
->die
->die_offset
!= 0
9836 || !flag_eliminate_unused_debug_types
);
9839 /* Return the size of the .debug_pubnames or .debug_pubtypes table
9840 generated for the compilation unit. */
9842 static unsigned long
9843 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9848 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
9850 size
= DWARF_PUBNAMES_HEADER_SIZE
;
9851 FOR_EACH_VEC_ELT (*names
, i
, p
)
9852 if (include_pubname_in_output (names
, p
))
9853 size
+= strlen (p
->name
) + dwarf_offset_size
+ 1 + space_for_flags
;
9855 size
+= dwarf_offset_size
;
9859 /* Return the size of the information in the .debug_aranges section. */
9861 static unsigned long
9862 size_of_aranges (void)
9866 size
= DWARF_ARANGES_HEADER_SIZE
;
9868 /* Count the address/length pair for this compilation unit. */
9869 if (switch_text_ranges
)
9870 size
+= 2 * DWARF2_ADDR_SIZE
9871 * (vec_safe_length (switch_text_ranges
) / 2 + 1);
9872 if (switch_cold_ranges
)
9873 size
+= 2 * DWARF2_ADDR_SIZE
9874 * (vec_safe_length (switch_cold_ranges
) / 2 + 1);
9875 if (have_multiple_function_sections
)
9880 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
9882 if (fde
->ignored_debug
)
9884 if (!fde
->in_std_section
)
9885 size
+= 2 * DWARF2_ADDR_SIZE
;
9886 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
9887 size
+= 2 * DWARF2_ADDR_SIZE
;
9891 /* Count the two zero words used to terminated the address range table. */
9892 size
+= 2 * DWARF2_ADDR_SIZE
;
9896 /* Select the encoding of an attribute value. */
9898 static enum dwarf_form
9899 value_format (dw_attr_node
*a
)
9901 switch (AT_class (a
))
9903 case dw_val_class_addr
:
9904 /* Only very few attributes allow DW_FORM_addr. */
9909 case DW_AT_entry_pc
:
9910 case DW_AT_trampoline
:
9911 return (AT_index (a
) == NOT_INDEXED
9912 ? DW_FORM_addr
: dwarf_FORM (DW_FORM_addrx
));
9916 switch (DWARF2_ADDR_SIZE
)
9919 return DW_FORM_data1
;
9921 return DW_FORM_data2
;
9923 return DW_FORM_data4
;
9925 return DW_FORM_data8
;
9929 case dw_val_class_loc_list
:
9930 if (dwarf_split_debug_info
9931 && dwarf_version
>= 5
9932 && AT_loc_list (a
)->num_assigned
)
9933 return DW_FORM_loclistx
;
9935 case dw_val_class_view_list
:
9936 case dw_val_class_range_list
:
9937 /* For range lists in DWARF 5, use DW_FORM_rnglistx from .debug_info.dwo
9938 but in .debug_info use DW_FORM_sec_offset, which is shorter if we
9939 care about sizes of .debug* sections in shared libraries and
9940 executables and don't take into account relocations that affect just
9941 relocatable objects - for DW_FORM_rnglistx we'd have to emit offset
9942 table in the .debug_rnglists section. */
9943 if (dwarf_split_debug_info
9944 && dwarf_version
>= 5
9945 && AT_class (a
) == dw_val_class_range_list
9947 && a
->dw_attr_val
.val_entry
!= RELOCATED_OFFSET
)
9948 return DW_FORM_rnglistx
;
9949 if (dwarf_version
>= 4)
9950 return DW_FORM_sec_offset
;
9952 case dw_val_class_vms_delta
:
9953 case dw_val_class_offset
:
9954 switch (dwarf_offset_size
)
9957 return DW_FORM_data4
;
9959 return DW_FORM_data8
;
9963 case dw_val_class_loc
:
9964 if (dwarf_version
>= 4)
9965 return DW_FORM_exprloc
;
9966 switch (constant_size (size_of_locs (AT_loc (a
))))
9969 return DW_FORM_block1
;
9971 return DW_FORM_block2
;
9973 return DW_FORM_block4
;
9977 case dw_val_class_const
:
9978 return DW_FORM_sdata
;
9979 case dw_val_class_unsigned_const
:
9980 switch (constant_size (AT_unsigned (a
)))
9983 return DW_FORM_data1
;
9985 return DW_FORM_data2
;
9987 /* In DWARF3 DW_AT_data_member_location with
9988 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
9989 constant, so we need to use DW_FORM_udata if we need
9990 a large constant. */
9991 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9992 return DW_FORM_udata
;
9993 return DW_FORM_data4
;
9995 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9996 return DW_FORM_udata
;
9997 return DW_FORM_data8
;
10001 case dw_val_class_const_implicit
:
10002 case dw_val_class_unsigned_const_implicit
:
10003 case dw_val_class_file_implicit
:
10004 return DW_FORM_implicit_const
;
10005 case dw_val_class_const_double
:
10006 switch (HOST_BITS_PER_WIDE_INT
)
10009 return DW_FORM_data2
;
10011 return DW_FORM_data4
;
10013 return DW_FORM_data8
;
10015 if (dwarf_version
>= 5)
10016 return DW_FORM_data16
;
10019 return DW_FORM_block1
;
10021 case dw_val_class_wide_int
:
10022 switch (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
)
10025 return DW_FORM_data1
;
10027 return DW_FORM_data2
;
10029 return DW_FORM_data4
;
10031 return DW_FORM_data8
;
10033 if (dwarf_version
>= 5)
10034 return DW_FORM_data16
;
10037 return DW_FORM_block1
;
10039 case dw_val_class_symview
:
10040 /* ??? We might use uleb128, but then we'd have to compute
10041 .debug_info offsets in the assembler. */
10042 if (symview_upper_bound
<= 0xff)
10043 return DW_FORM_data1
;
10044 else if (symview_upper_bound
<= 0xffff)
10045 return DW_FORM_data2
;
10046 else if (symview_upper_bound
<= 0xffffffff)
10047 return DW_FORM_data4
;
10049 return DW_FORM_data8
;
10050 case dw_val_class_vec
:
10051 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
10052 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
10055 return DW_FORM_block1
;
10057 return DW_FORM_block2
;
10059 return DW_FORM_block4
;
10061 gcc_unreachable ();
10063 case dw_val_class_flag
:
10064 if (dwarf_version
>= 4)
10066 /* Currently all add_AT_flag calls pass in 1 as last argument,
10067 so DW_FORM_flag_present can be used. If that ever changes,
10068 we'll need to use DW_FORM_flag and have some optimization
10069 in build_abbrev_table that will change those to
10070 DW_FORM_flag_present if it is set to 1 in all DIEs using
10071 the same abbrev entry. */
10072 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
10073 return DW_FORM_flag_present
;
10075 return DW_FORM_flag
;
10076 case dw_val_class_die_ref
:
10077 if (AT_ref_external (a
))
10079 if (AT_ref (a
)->comdat_type_p
)
10080 return DW_FORM_ref_sig8
;
10082 return DW_FORM_ref_addr
;
10085 return DW_FORM_ref
;
10086 case dw_val_class_fde_ref
:
10087 return DW_FORM_data
;
10088 case dw_val_class_lbl_id
:
10089 return (AT_index (a
) == NOT_INDEXED
10090 ? DW_FORM_addr
: dwarf_FORM (DW_FORM_addrx
));
10091 case dw_val_class_lineptr
:
10092 case dw_val_class_macptr
:
10093 case dw_val_class_loclistsptr
:
10094 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
10095 case dw_val_class_str
:
10096 return AT_string_form (a
);
10097 case dw_val_class_file
:
10098 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
10101 return DW_FORM_data1
;
10103 return DW_FORM_data2
;
10105 return DW_FORM_data4
;
10107 gcc_unreachable ();
10110 case dw_val_class_data8
:
10111 return DW_FORM_data8
;
10113 case dw_val_class_high_pc
:
10114 switch (DWARF2_ADDR_SIZE
)
10117 return DW_FORM_data1
;
10119 return DW_FORM_data2
;
10121 return DW_FORM_data4
;
10123 return DW_FORM_data8
;
10125 gcc_unreachable ();
10128 case dw_val_class_discr_value
:
10129 return (a
->dw_attr_val
.v
.val_discr_value
.pos
10132 case dw_val_class_discr_list
:
10133 switch (constant_size (size_of_discr_list (AT_discr_list (a
))))
10136 return DW_FORM_block1
;
10138 return DW_FORM_block2
;
10140 return DW_FORM_block4
;
10142 gcc_unreachable ();
10146 gcc_unreachable ();
10150 /* Output the encoding of an attribute value. */
10153 output_value_format (dw_attr_node
*a
)
10155 enum dwarf_form form
= value_format (a
);
10157 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
10160 /* Given a die and id, produce the appropriate abbreviations. */
10163 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
10166 dw_attr_node
*a_attr
;
10168 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
10169 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
10170 dwarf_tag_name (abbrev
->die_tag
));
10172 if (abbrev
->die_child
!= NULL
)
10173 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
10175 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
10177 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
10179 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
10180 dwarf_attr_name (a_attr
->dw_attr
));
10181 output_value_format (a_attr
);
10182 if (value_format (a_attr
) == DW_FORM_implicit_const
)
10184 if (AT_class (a_attr
) == dw_val_class_file_implicit
)
10186 int f
= maybe_emit_file (a_attr
->dw_attr_val
.v
.val_file
);
10187 const char *filename
= a_attr
->dw_attr_val
.v
.val_file
->filename
;
10188 dw2_asm_output_data_sleb128 (f
, "(%s)", filename
);
10191 dw2_asm_output_data_sleb128 (a_attr
->dw_attr_val
.v
.val_int
, NULL
);
10195 dw2_asm_output_data (1, 0, NULL
);
10196 dw2_asm_output_data (1, 0, NULL
);
10200 /* Output the .debug_abbrev section which defines the DIE abbreviation
10204 output_abbrev_section (void)
10206 unsigned int abbrev_id
;
10209 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
10210 if (abbrev_id
!= 0)
10211 output_die_abbrevs (abbrev_id
, abbrev
);
10213 /* Terminate the table. */
10214 dw2_asm_output_data (1, 0, NULL
);
10217 /* Return a new location list, given the begin and end range, and the
10220 static inline dw_loc_list_ref
10221 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, var_loc_view vbegin
,
10222 const char *end
, var_loc_view vend
,
10223 const char *section
)
10225 dw_loc_list_ref retlist
= ggc_cleared_alloc
<dw_loc_list_node
> ();
10227 retlist
->begin
= begin
;
10228 retlist
->begin_entry
= NULL
;
10229 retlist
->end
= end
;
10230 retlist
->end_entry
= NULL
;
10231 retlist
->expr
= expr
;
10232 retlist
->section
= section
;
10233 retlist
->vbegin
= vbegin
;
10234 retlist
->vend
= vend
;
10239 /* Return true iff there's any nonzero view number in the loc list.
10241 ??? When views are not enabled, we'll often extend a single range
10242 to the entire function, so that we emit a single location
10243 expression rather than a location list. With views, even with a
10244 single range, we'll output a list if start or end have a nonzero
10245 view. If we change this, we may want to stop splitting a single
10246 range in dw_loc_list just because of a nonzero view, even if it
10247 straddles across hot/cold partitions. */
10250 loc_list_has_views (dw_loc_list_ref list
)
10252 if (!debug_variable_location_views
)
10255 for (dw_loc_list_ref loc
= list
;
10256 loc
!= NULL
; loc
= loc
->dw_loc_next
)
10257 if (!ZERO_VIEW_P (loc
->vbegin
) || !ZERO_VIEW_P (loc
->vend
))
10263 /* Generate a new internal symbol for this location list node, if it
10264 hasn't got one yet. */
10267 gen_llsym (dw_loc_list_ref list
)
10269 gcc_assert (!list
->ll_symbol
);
10270 list
->ll_symbol
= gen_internal_sym ("LLST");
10272 if (!loc_list_has_views (list
))
10275 if (dwarf2out_locviews_in_attribute ())
10277 /* Use the same label_num for the view list. */
10279 list
->vl_symbol
= gen_internal_sym ("LVUS");
10282 list
->vl_symbol
= list
->ll_symbol
;
10285 /* Generate a symbol for the list, but only if we really want to emit
10289 maybe_gen_llsym (dw_loc_list_ref list
)
10291 if (!list
|| (!list
->dw_loc_next
&& !loc_list_has_views (list
)))
10297 /* Determine whether or not to skip loc_list entry CURR. If SIZEP is
10298 NULL, don't consider size of the location expression. If we're not
10299 to skip it, and SIZEP is non-null, store the size of CURR->expr's
10300 representation in *SIZEP. */
10303 skip_loc_list_entry (dw_loc_list_ref curr
, unsigned long *sizep
= NULL
)
10305 /* Don't output an entry that starts and ends at the same address. */
10306 if (strcmp (curr
->begin
, curr
->end
) == 0
10307 && curr
->vbegin
== curr
->vend
&& !curr
->force
)
10313 unsigned long size
= size_of_locs (curr
->expr
);
10315 /* If the expression is too large, drop it on the floor. We could
10316 perhaps put it into DW_TAG_dwarf_procedure and refer to that
10317 in the expression, but >= 64KB expressions for a single value
10318 in a single range are unlikely very useful. */
10319 if (dwarf_version
< 5 && size
> 0xffff)
10327 /* Output a view pair loclist entry for CURR, if it requires one. */
10330 dwarf2out_maybe_output_loclist_view_pair (dw_loc_list_ref curr
)
10332 if (!dwarf2out_locviews_in_loclist ())
10335 if (ZERO_VIEW_P (curr
->vbegin
) && ZERO_VIEW_P (curr
->vend
))
10338 #ifdef DW_LLE_view_pair
10339 dw2_asm_output_data (1, DW_LLE_view_pair
, "DW_LLE_view_pair");
10341 if (dwarf2out_as_locview_support
)
10343 if (ZERO_VIEW_P (curr
->vbegin
))
10344 dw2_asm_output_data_uleb128 (0, "Location view begin");
10347 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10348 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vbegin
);
10349 dw2_asm_output_symname_uleb128 (label
, "Location view begin");
10352 if (ZERO_VIEW_P (curr
->vend
))
10353 dw2_asm_output_data_uleb128 (0, "Location view end");
10356 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10357 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vend
);
10358 dw2_asm_output_symname_uleb128 (label
, "Location view end");
10363 dw2_asm_output_data_uleb128 (curr
->vbegin
, "Location view begin");
10364 dw2_asm_output_data_uleb128 (curr
->vend
, "Location view end");
10366 #endif /* DW_LLE_view_pair */
10371 /* Output the location list given to us. */
10374 output_loc_list (dw_loc_list_ref list_head
)
10376 int vcount
= 0, lcount
= 0;
10378 if (list_head
->emitted
)
10380 list_head
->emitted
= true;
10382 if (list_head
->vl_symbol
&& dwarf2out_locviews_in_attribute ())
10384 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->vl_symbol
);
10386 for (dw_loc_list_ref curr
= list_head
; curr
!= NULL
;
10387 curr
= curr
->dw_loc_next
)
10389 unsigned long size
;
10391 if (skip_loc_list_entry (curr
, &size
))
10396 /* ?? dwarf_split_debug_info? */
10397 if (dwarf2out_as_locview_support
)
10399 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10401 if (!ZERO_VIEW_P (curr
->vbegin
))
10403 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vbegin
);
10404 dw2_asm_output_symname_uleb128 (label
,
10405 "View list begin (%s)",
10406 list_head
->vl_symbol
);
10409 dw2_asm_output_data_uleb128 (0,
10410 "View list begin (%s)",
10411 list_head
->vl_symbol
);
10413 if (!ZERO_VIEW_P (curr
->vend
))
10415 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vend
);
10416 dw2_asm_output_symname_uleb128 (label
,
10417 "View list end (%s)",
10418 list_head
->vl_symbol
);
10421 dw2_asm_output_data_uleb128 (0,
10422 "View list end (%s)",
10423 list_head
->vl_symbol
);
10427 dw2_asm_output_data_uleb128 (curr
->vbegin
,
10428 "View list begin (%s)",
10429 list_head
->vl_symbol
);
10430 dw2_asm_output_data_uleb128 (curr
->vend
,
10431 "View list end (%s)",
10432 list_head
->vl_symbol
);
10437 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
10439 const char *last_section
= NULL
;
10440 const char *base_label
= NULL
;
10442 /* Walk the location list, and output each range + expression. */
10443 for (dw_loc_list_ref curr
= list_head
; curr
!= NULL
;
10444 curr
= curr
->dw_loc_next
)
10446 unsigned long size
;
10448 /* Skip this entry? If we skip it here, we must skip it in the
10449 view list above as well. */
10450 if (skip_loc_list_entry (curr
, &size
))
10455 if (dwarf_version
>= 5)
10457 if (dwarf_split_debug_info
&& HAVE_AS_LEB128
)
10459 dwarf2out_maybe_output_loclist_view_pair (curr
);
10460 /* For -gsplit-dwarf, emit DW_LLE_startx_length, which has
10461 uleb128 index into .debug_addr and uleb128 length. */
10462 dw2_asm_output_data (1, DW_LLE_startx_length
,
10463 "DW_LLE_startx_length (%s)",
10464 list_head
->ll_symbol
);
10465 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10466 "Location list range start index "
10467 "(%s)", curr
->begin
);
10468 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
10469 "Location list length (%s)",
10470 list_head
->ll_symbol
);
10472 else if (dwarf_split_debug_info
)
10474 dwarf2out_maybe_output_loclist_view_pair (curr
);
10475 /* For -gsplit-dwarf without usable .uleb128 support, emit
10476 DW_LLE_startx_endx, which has two uleb128 indexes into
10478 dw2_asm_output_data (1, DW_LLE_startx_endx
,
10479 "DW_LLE_startx_endx (%s)",
10480 list_head
->ll_symbol
);
10481 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10482 "Location list range start index "
10483 "(%s)", curr
->begin
);
10484 dw2_asm_output_data_uleb128 (curr
->end_entry
->index
,
10485 "Location list range end index "
10486 "(%s)", curr
->end
);
10488 else if (!have_multiple_function_sections
&& HAVE_AS_LEB128
)
10490 dwarf2out_maybe_output_loclist_view_pair (curr
);
10491 /* If all code is in .text section, the base address is
10492 already provided by the CU attributes. Use
10493 DW_LLE_offset_pair where both addresses are uleb128 encoded
10494 offsets against that base. */
10495 dw2_asm_output_data (1, DW_LLE_offset_pair
,
10496 "DW_LLE_offset_pair (%s)",
10497 list_head
->ll_symbol
);
10498 dw2_asm_output_delta_uleb128 (curr
->begin
, curr
->section
,
10499 "Location list begin address (%s)",
10500 list_head
->ll_symbol
);
10501 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->section
,
10502 "Location list end address (%s)",
10503 list_head
->ll_symbol
);
10505 else if (HAVE_AS_LEB128
)
10507 /* Otherwise, find out how many consecutive entries could share
10508 the same base entry. If just one, emit DW_LLE_start_length,
10509 otherwise emit DW_LLE_base_address for the base address
10510 followed by a series of DW_LLE_offset_pair. */
10511 if (last_section
== NULL
|| curr
->section
!= last_section
)
10513 dw_loc_list_ref curr2
;
10514 for (curr2
= curr
->dw_loc_next
; curr2
!= NULL
;
10515 curr2
= curr2
->dw_loc_next
)
10517 if (strcmp (curr2
->begin
, curr2
->end
) == 0
10522 if (curr2
== NULL
|| curr
->section
!= curr2
->section
)
10523 last_section
= NULL
;
10526 last_section
= curr
->section
;
10527 base_label
= curr
->begin
;
10528 dw2_asm_output_data (1, DW_LLE_base_address
,
10529 "DW_LLE_base_address (%s)",
10530 list_head
->ll_symbol
);
10531 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, base_label
,
10532 "Base address (%s)",
10533 list_head
->ll_symbol
);
10536 /* Only one entry with the same base address. Use
10537 DW_LLE_start_length with absolute address and uleb128
10539 if (last_section
== NULL
)
10541 dwarf2out_maybe_output_loclist_view_pair (curr
);
10542 dw2_asm_output_data (1, DW_LLE_start_length
,
10543 "DW_LLE_start_length (%s)",
10544 list_head
->ll_symbol
);
10545 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10546 "Location list begin address (%s)",
10547 list_head
->ll_symbol
);
10548 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
10549 "Location list length "
10550 "(%s)", list_head
->ll_symbol
);
10552 /* Otherwise emit DW_LLE_offset_pair, relative to above emitted
10553 DW_LLE_base_address. */
10556 dwarf2out_maybe_output_loclist_view_pair (curr
);
10557 dw2_asm_output_data (1, DW_LLE_offset_pair
,
10558 "DW_LLE_offset_pair (%s)",
10559 list_head
->ll_symbol
);
10560 dw2_asm_output_delta_uleb128 (curr
->begin
, base_label
,
10561 "Location list begin address "
10562 "(%s)", list_head
->ll_symbol
);
10563 dw2_asm_output_delta_uleb128 (curr
->end
, base_label
,
10564 "Location list end address "
10565 "(%s)", list_head
->ll_symbol
);
10568 /* The assembler does not support .uleb128 directive. Emit
10569 DW_LLE_start_end with a pair of absolute addresses. */
10572 dwarf2out_maybe_output_loclist_view_pair (curr
);
10573 dw2_asm_output_data (1, DW_LLE_start_end
,
10574 "DW_LLE_start_end (%s)",
10575 list_head
->ll_symbol
);
10576 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10577 "Location list begin address (%s)",
10578 list_head
->ll_symbol
);
10579 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10580 "Location list end address (%s)",
10581 list_head
->ll_symbol
);
10584 else if (dwarf_split_debug_info
)
10586 /* For -gsplit-dwarf -gdwarf-{2,3,4} emit index into .debug_addr
10587 and 4 byte length. */
10588 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
10589 "Location list start/length entry (%s)",
10590 list_head
->ll_symbol
);
10591 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10592 "Location list range start index (%s)",
10594 /* The length field is 4 bytes. If we ever need to support
10595 an 8-byte length, we can add a new DW_LLE code or fall back
10596 to DW_LLE_GNU_start_end_entry. */
10597 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
10598 "Location list range length (%s)",
10599 list_head
->ll_symbol
);
10601 else if (!have_multiple_function_sections
)
10603 /* Pair of relative addresses against start of text section. */
10604 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
10605 "Location list begin address (%s)",
10606 list_head
->ll_symbol
);
10607 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
10608 "Location list end address (%s)",
10609 list_head
->ll_symbol
);
10613 /* Pair of absolute addresses. */
10614 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10615 "Location list begin address (%s)",
10616 list_head
->ll_symbol
);
10617 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10618 "Location list end address (%s)",
10619 list_head
->ll_symbol
);
10622 /* Output the block length for this list of location operations. */
10623 if (dwarf_version
>= 5)
10624 dw2_asm_output_data_uleb128 (size
, "Location expression size");
10627 gcc_assert (size
<= 0xffff);
10628 dw2_asm_output_data (2, size
, "Location expression size");
10631 output_loc_sequence (curr
->expr
, -1);
10634 /* And finally list termination. */
10635 if (dwarf_version
>= 5)
10636 dw2_asm_output_data (1, DW_LLE_end_of_list
,
10637 "DW_LLE_end_of_list (%s)", list_head
->ll_symbol
);
10638 else if (dwarf_split_debug_info
)
10639 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
10640 "Location list terminator (%s)",
10641 list_head
->ll_symbol
);
10644 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10645 "Location list terminator begin (%s)",
10646 list_head
->ll_symbol
);
10647 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10648 "Location list terminator end (%s)",
10649 list_head
->ll_symbol
);
10652 gcc_assert (!list_head
->vl_symbol
10653 || vcount
== lcount
* (dwarf2out_locviews_in_attribute () ? 1 : 0));
10656 /* Output a range_list offset into the .debug_ranges or .debug_rnglists
10657 section. Emit a relocated reference if val_entry is NULL, otherwise,
10658 emit an indirect reference. */
10661 output_range_list_offset (dw_attr_node
*a
)
10663 const char *name
= dwarf_attr_name (a
->dw_attr
);
10665 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
10667 if (dwarf_version
>= 5)
10669 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
10670 dw2_asm_output_offset (dwarf_offset_size
, r
->label
,
10671 debug_ranges_section
, "%s", name
);
10675 char *p
= strchr (ranges_section_label
, '\0');
10676 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
10677 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
);
10678 dw2_asm_output_offset (dwarf_offset_size
, ranges_section_label
,
10679 debug_ranges_section
, "%s", name
);
10683 else if (dwarf_version
>= 5)
10685 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
10686 gcc_assert (rnglist_idx
);
10687 dw2_asm_output_data_uleb128 (r
->idx
, "%s", name
);
10690 dw2_asm_output_data (dwarf_offset_size
,
10691 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
,
10692 "%s (offset from %s)", name
, ranges_section_label
);
10695 /* Output the offset into the debug_loc section. */
10698 output_loc_list_offset (dw_attr_node
*a
)
10700 char *sym
= AT_loc_list (a
)->ll_symbol
;
10703 if (!dwarf_split_debug_info
)
10704 dw2_asm_output_offset (dwarf_offset_size
, sym
, debug_loc_section
,
10705 "%s", dwarf_attr_name (a
->dw_attr
));
10706 else if (dwarf_version
>= 5)
10708 gcc_assert (AT_loc_list (a
)->num_assigned
);
10709 dw2_asm_output_data_uleb128 (AT_loc_list (a
)->hash
, "%s (%s)",
10710 dwarf_attr_name (a
->dw_attr
),
10714 dw2_asm_output_delta (dwarf_offset_size
, sym
, loc_section_label
,
10715 "%s", dwarf_attr_name (a
->dw_attr
));
10718 /* Output the offset into the debug_loc section. */
10721 output_view_list_offset (dw_attr_node
*a
)
10723 char *sym
= (*AT_loc_list_ptr (a
))->vl_symbol
;
10726 if (dwarf_split_debug_info
)
10727 dw2_asm_output_delta (dwarf_offset_size
, sym
, loc_section_label
,
10728 "%s", dwarf_attr_name (a
->dw_attr
));
10730 dw2_asm_output_offset (dwarf_offset_size
, sym
, debug_loc_section
,
10731 "%s", dwarf_attr_name (a
->dw_attr
));
10734 /* Output an attribute's index or value appropriately. */
10737 output_attr_index_or_value (dw_attr_node
*a
)
10739 const char *name
= dwarf_attr_name (a
->dw_attr
);
10741 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
10743 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
10746 switch (AT_class (a
))
10748 case dw_val_class_addr
:
10749 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
10751 case dw_val_class_high_pc
:
10752 case dw_val_class_lbl_id
:
10753 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
10756 gcc_unreachable ();
10760 /* Output a type signature. */
10763 output_signature (const char *sig
, const char *name
)
10767 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
10768 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
10771 /* Output a discriminant value. */
10774 output_discr_value (dw_discr_value
*discr_value
, const char *name
)
10776 if (discr_value
->pos
)
10777 dw2_asm_output_data_uleb128 (discr_value
->v
.uval
, "%s", name
);
10779 dw2_asm_output_data_sleb128 (discr_value
->v
.sval
, "%s", name
);
10782 /* Output the DIE and its attributes. Called recursively to generate
10783 the definitions of each child DIE. */
10786 output_die (dw_die_ref die
)
10790 unsigned long size
;
10793 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
10794 (unsigned long)die
->die_offset
,
10795 dwarf_tag_name (die
->die_tag
));
10797 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
10799 const char *name
= dwarf_attr_name (a
->dw_attr
);
10801 switch (AT_class (a
))
10803 case dw_val_class_addr
:
10804 output_attr_index_or_value (a
);
10807 case dw_val_class_offset
:
10808 dw2_asm_output_data (dwarf_offset_size
, a
->dw_attr_val
.v
.val_offset
,
10812 case dw_val_class_range_list
:
10813 output_range_list_offset (a
);
10816 case dw_val_class_loc
:
10817 size
= size_of_locs (AT_loc (a
));
10819 /* Output the block length for this list of location operations. */
10820 if (dwarf_version
>= 4)
10821 dw2_asm_output_data_uleb128 (size
, "%s", name
);
10823 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
10825 output_loc_sequence (AT_loc (a
), -1);
10828 case dw_val_class_const
:
10829 /* ??? It would be slightly more efficient to use a scheme like is
10830 used for unsigned constants below, but gdb 4.x does not sign
10831 extend. Gdb 5.x does sign extend. */
10832 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
10835 case dw_val_class_unsigned_const
:
10837 int csize
= constant_size (AT_unsigned (a
));
10838 if (dwarf_version
== 3
10839 && a
->dw_attr
== DW_AT_data_member_location
10841 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
10843 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
10847 case dw_val_class_symview
:
10850 if (symview_upper_bound
<= 0xff)
10852 else if (symview_upper_bound
<= 0xffff)
10854 else if (symview_upper_bound
<= 0xffffffff)
10858 dw2_asm_output_addr (vsize
, a
->dw_attr_val
.v
.val_symbolic_view
,
10863 case dw_val_class_const_implicit
:
10864 if (flag_debug_asm
)
10865 fprintf (asm_out_file
, "\t\t\t%s %s ("
10866 HOST_WIDE_INT_PRINT_DEC
")\n",
10867 ASM_COMMENT_START
, name
, AT_int (a
));
10870 case dw_val_class_unsigned_const_implicit
:
10871 if (flag_debug_asm
)
10872 fprintf (asm_out_file
, "\t\t\t%s %s ("
10873 HOST_WIDE_INT_PRINT_HEX
")\n",
10874 ASM_COMMENT_START
, name
, AT_unsigned (a
));
10877 case dw_val_class_const_double
:
10879 unsigned HOST_WIDE_INT first
, second
;
10881 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
10882 dw2_asm_output_data (1,
10883 HOST_BITS_PER_DOUBLE_INT
10884 / HOST_BITS_PER_CHAR
,
10887 if (WORDS_BIG_ENDIAN
)
10889 first
= a
->dw_attr_val
.v
.val_double
.high
;
10890 second
= a
->dw_attr_val
.v
.val_double
.low
;
10894 first
= a
->dw_attr_val
.v
.val_double
.low
;
10895 second
= a
->dw_attr_val
.v
.val_double
.high
;
10898 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10899 first
, "%s", name
);
10900 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10905 case dw_val_class_wide_int
:
10908 int len
= get_full_len (*a
->dw_attr_val
.v
.val_wide
);
10909 int l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
10910 if (len
* HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
10911 dw2_asm_output_data (1, get_full_len (*a
->dw_attr_val
.v
.val_wide
)
10914 if (WORDS_BIG_ENDIAN
)
10915 for (i
= len
- 1; i
>= 0; --i
)
10917 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10922 for (i
= 0; i
< len
; ++i
)
10924 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10931 case dw_val_class_vec
:
10933 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
10934 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
10938 dw2_asm_output_data (constant_size (len
* elt_size
),
10939 len
* elt_size
, "%s", name
);
10940 if (elt_size
> sizeof (HOST_WIDE_INT
))
10945 for (i
= 0, p
= (unsigned char *) a
->dw_attr_val
.v
.val_vec
.array
;
10947 i
++, p
+= elt_size
)
10948 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
10949 "fp or vector constant word %u", i
);
10953 case dw_val_class_flag
:
10954 if (dwarf_version
>= 4)
10956 /* Currently all add_AT_flag calls pass in 1 as last argument,
10957 so DW_FORM_flag_present can be used. If that ever changes,
10958 we'll need to use DW_FORM_flag and have some optimization
10959 in build_abbrev_table that will change those to
10960 DW_FORM_flag_present if it is set to 1 in all DIEs using
10961 the same abbrev entry. */
10962 gcc_assert (AT_flag (a
) == 1);
10963 if (flag_debug_asm
)
10964 fprintf (asm_out_file
, "\t\t\t%s %s\n",
10965 ASM_COMMENT_START
, name
);
10968 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
10971 case dw_val_class_loc_list
:
10972 output_loc_list_offset (a
);
10975 case dw_val_class_view_list
:
10976 output_view_list_offset (a
);
10979 case dw_val_class_die_ref
:
10980 if (AT_ref_external (a
))
10982 if (AT_ref (a
)->comdat_type_p
)
10984 comdat_type_node
*type_node
10985 = AT_ref (a
)->die_id
.die_type_node
;
10987 gcc_assert (type_node
);
10988 output_signature (type_node
->signature
, name
);
10992 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
10996 /* In DWARF2, DW_FORM_ref_addr is sized by target address
10997 length, whereas in DWARF3 it's always sized as an
10999 if (dwarf_version
== 2)
11000 size
= DWARF2_ADDR_SIZE
;
11002 size
= dwarf_offset_size
;
11003 /* ??? We cannot unconditionally output die_offset if
11004 non-zero - others might create references to those
11006 And we do not clear its DIE offset after outputting it
11007 (and the label refers to the actual DIEs, not the
11008 DWARF CU unit header which is when using label + offset
11009 would be the correct thing to do).
11010 ??? This is the reason for the with_offset flag. */
11011 if (AT_ref (a
)->with_offset
)
11012 dw2_asm_output_offset (size
, sym
, AT_ref (a
)->die_offset
,
11013 debug_info_section
, "%s", name
);
11015 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
11021 gcc_assert (AT_ref (a
)->die_offset
);
11022 dw2_asm_output_data (dwarf_offset_size
, AT_ref (a
)->die_offset
,
11027 case dw_val_class_fde_ref
:
11029 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
11031 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
11032 a
->dw_attr_val
.v
.val_fde_index
* 2);
11033 dw2_asm_output_offset (dwarf_offset_size
, l1
, debug_frame_section
,
11038 case dw_val_class_vms_delta
:
11039 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
11040 dw2_asm_output_vms_delta (dwarf_offset_size
,
11041 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
11044 dw2_asm_output_delta (dwarf_offset_size
,
11045 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
11050 case dw_val_class_lbl_id
:
11051 output_attr_index_or_value (a
);
11054 case dw_val_class_lineptr
:
11055 dw2_asm_output_offset (dwarf_offset_size
, AT_lbl (a
),
11056 debug_line_section
, "%s", name
);
11059 case dw_val_class_macptr
:
11060 dw2_asm_output_offset (dwarf_offset_size
, AT_lbl (a
),
11061 debug_macinfo_section
, "%s", name
);
11064 case dw_val_class_loclistsptr
:
11065 dw2_asm_output_offset (dwarf_offset_size
, AT_lbl (a
),
11066 debug_loc_section
, "%s", name
);
11069 case dw_val_class_str
:
11070 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
11071 dw2_asm_output_offset (dwarf_offset_size
,
11072 a
->dw_attr_val
.v
.val_str
->label
,
11074 "%s: \"%s\"", name
, AT_string (a
));
11075 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_line_strp
)
11076 dw2_asm_output_offset (dwarf_offset_size
,
11077 a
->dw_attr_val
.v
.val_str
->label
,
11078 debug_line_str_section
,
11079 "%s: \"%s\"", name
, AT_string (a
));
11080 else if (a
->dw_attr_val
.v
.val_str
->form
== dwarf_FORM (DW_FORM_strx
))
11081 dw2_asm_output_data_uleb128 (AT_index (a
),
11082 "%s: \"%s\"", name
, AT_string (a
));
11084 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
11087 case dw_val_class_file
:
11089 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
11091 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
11092 a
->dw_attr_val
.v
.val_file
->filename
);
11096 case dw_val_class_file_implicit
:
11097 if (flag_debug_asm
)
11098 fprintf (asm_out_file
, "\t\t\t%s %s (%d, %s)\n",
11099 ASM_COMMENT_START
, name
,
11100 maybe_emit_file (a
->dw_attr_val
.v
.val_file
),
11101 a
->dw_attr_val
.v
.val_file
->filename
);
11104 case dw_val_class_data8
:
11108 for (i
= 0; i
< 8; i
++)
11109 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
11110 i
== 0 ? "%s" : NULL
, name
);
11114 case dw_val_class_high_pc
:
11115 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
11116 get_AT_low_pc (die
), "DW_AT_high_pc");
11119 case dw_val_class_discr_value
:
11120 output_discr_value (&a
->dw_attr_val
.v
.val_discr_value
, name
);
11123 case dw_val_class_discr_list
:
11125 dw_discr_list_ref list
= AT_discr_list (a
);
11126 const int size
= size_of_discr_list (list
);
11128 /* This is a block, so output its length first. */
11129 dw2_asm_output_data (constant_size (size
), size
,
11130 "%s: block size", name
);
11132 for (; list
!= NULL
; list
= list
->dw_discr_next
)
11134 /* One byte for the discriminant value descriptor, and then as
11135 many LEB128 numbers as required. */
11136 if (list
->dw_discr_range
)
11137 dw2_asm_output_data (1, DW_DSC_range
,
11138 "%s: DW_DSC_range", name
);
11140 dw2_asm_output_data (1, DW_DSC_label
,
11141 "%s: DW_DSC_label", name
);
11143 output_discr_value (&list
->dw_discr_lower_bound
, name
);
11144 if (list
->dw_discr_range
)
11145 output_discr_value (&list
->dw_discr_upper_bound
, name
);
11151 gcc_unreachable ();
11155 FOR_EACH_CHILD (die
, c
, output_die (c
));
11157 /* Add null byte to terminate sibling list. */
11158 if (die
->die_child
!= NULL
)
11159 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
11160 (unsigned long) die
->die_offset
);
11163 /* Output the dwarf version number. */
11166 output_dwarf_version ()
11168 /* ??? For now, if -gdwarf-6 is specified, we output version 5 with
11169 views in loclist. That will change eventually. */
11170 if (dwarf_version
== 6)
11175 warning (0, "%<-gdwarf-6%> is output as version 5 with "
11176 "incompatibilities");
11179 dw2_asm_output_data (2, 5, "DWARF version number");
11182 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
11185 /* Output the compilation unit that appears at the beginning of the
11186 .debug_info section, and precedes the DIE descriptions. */
11189 output_compilation_unit_header (enum dwarf_unit_type ut
)
11191 if (!XCOFF_DEBUGGING_INFO
)
11193 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
11194 dw2_asm_output_data (4, 0xffffffff,
11195 "Initial length escape value indicating 64-bit DWARF extension");
11196 dw2_asm_output_data (dwarf_offset_size
,
11197 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
11198 "Length of Compilation Unit Info");
11201 output_dwarf_version ();
11202 if (dwarf_version
>= 5)
11207 case DW_UT_compile
: name
= "DW_UT_compile"; break;
11208 case DW_UT_type
: name
= "DW_UT_type"; break;
11209 case DW_UT_split_compile
: name
= "DW_UT_split_compile"; break;
11210 case DW_UT_split_type
: name
= "DW_UT_split_type"; break;
11211 default: gcc_unreachable ();
11213 dw2_asm_output_data (1, ut
, "%s", name
);
11214 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11216 dw2_asm_output_offset (dwarf_offset_size
, abbrev_section_label
,
11217 debug_abbrev_section
,
11218 "Offset Into Abbrev. Section");
11219 if (dwarf_version
< 5)
11220 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11223 /* Output the compilation unit DIE and its children. */
11226 output_comp_unit (dw_die_ref die
, int output_if_empty
,
11227 const unsigned char *dwo_id
)
11229 const char *secname
, *oldsym
;
11232 /* Unless we are outputting main CU, we may throw away empty ones. */
11233 if (!output_if_empty
&& die
->die_child
== NULL
)
11236 /* Even if there are no children of this DIE, we must output the information
11237 about the compilation unit. Otherwise, on an empty translation unit, we
11238 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
11239 will then complain when examining the file. First mark all the DIEs in
11240 this CU so we know which get local refs. */
11243 external_ref_hash_type
*extern_map
= optimize_external_refs (die
);
11245 /* For now, optimize only the main CU, in order to optimize the rest
11246 we'd need to see all of them earlier. Leave the rest for post-linking
11248 if (die
== comp_unit_die ())
11249 abbrev_opt_start
= vec_safe_length (abbrev_die_table
);
11251 build_abbrev_table (die
, extern_map
);
11253 optimize_abbrev_table ();
11257 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11258 next_die_offset
= (dwo_id
11259 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11260 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
11261 calc_die_sizes (die
);
11263 oldsym
= die
->die_id
.die_symbol
;
11264 if (oldsym
&& die
->comdat_type_p
)
11266 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
11268 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
11270 die
->die_id
.die_symbol
= NULL
;
11271 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11275 switch_to_section (debug_info_section
);
11276 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
11277 info_section_emitted
= true;
11280 /* For LTO cross unit DIE refs we want a symbol on the start of the
11281 debuginfo section, not on the CU DIE. */
11282 if ((flag_generate_lto
|| flag_generate_offload
) && oldsym
)
11284 /* ??? No way to get visibility assembled without a decl. */
11285 tree decl
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
11286 get_identifier (oldsym
), char_type_node
);
11287 TREE_PUBLIC (decl
) = true;
11288 TREE_STATIC (decl
) = true;
11289 DECL_ARTIFICIAL (decl
) = true;
11290 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
11291 DECL_VISIBILITY_SPECIFIED (decl
) = true;
11292 targetm
.asm_out
.assemble_visibility (decl
, VISIBILITY_HIDDEN
);
11293 #ifdef ASM_WEAKEN_LABEL
11294 /* We prefer a .weak because that handles duplicates from duplicate
11295 archive members in a graceful way. */
11296 ASM_WEAKEN_LABEL (asm_out_file
, oldsym
);
11298 targetm
.asm_out
.globalize_label (asm_out_file
, oldsym
);
11300 ASM_OUTPUT_LABEL (asm_out_file
, oldsym
);
11303 /* Output debugging information. */
11304 output_compilation_unit_header (dwo_id
11305 ? DW_UT_split_compile
: DW_UT_compile
);
11306 if (dwarf_version
>= 5)
11308 if (dwo_id
!= NULL
)
11309 for (int i
= 0; i
< 8; i
++)
11310 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
11314 /* Leave the marks on the main CU, so we can check them in
11315 output_pubnames. */
11319 die
->die_id
.die_symbol
= oldsym
;
11323 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
11324 and .debug_pubtypes. This is configured per-target, but can be
11325 overridden by the -gpubnames or -gno-pubnames options. */
11328 want_pubnames (void)
11330 if (debug_info_level
<= DINFO_LEVEL_TERSE
11331 /* Names and types go to the early debug part only. */
11334 if (debug_generate_pub_sections
!= -1)
11335 return debug_generate_pub_sections
;
11336 return targetm
.want_debug_pub_sections
;
11339 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
11342 add_AT_pubnames (dw_die_ref die
)
11344 if (want_pubnames ())
11345 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
11348 /* Add a string attribute value to a skeleton DIE. */
11351 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
11355 struct indirect_string_node
*node
;
11357 if (! skeleton_debug_str_hash
)
11358 skeleton_debug_str_hash
11359 = hash_table
<indirect_string_hasher
>::create_ggc (10);
11361 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
11362 find_string_form (node
);
11363 if (node
->form
== dwarf_FORM (DW_FORM_strx
))
11364 node
->form
= DW_FORM_strp
;
11366 attr
.dw_attr
= attr_kind
;
11367 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
11368 attr
.dw_attr_val
.val_entry
= NULL
;
11369 attr
.dw_attr_val
.v
.val_str
= node
;
11370 add_dwarf_attr (die
, &attr
);
11373 /* Helper function to generate top-level dies for skeleton debug_info and
11377 add_top_level_skeleton_die_attrs (dw_die_ref die
)
11379 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
11380 const char *comp_dir
= comp_dir_string ();
11382 add_skeleton_AT_string (die
, dwarf_AT (DW_AT_dwo_name
), dwo_file_name
);
11383 if (comp_dir
!= NULL
)
11384 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
11385 add_AT_pubnames (die
);
11386 if (addr_index_table
!= NULL
&& addr_index_table
->size () > 0)
11387 add_AT_lineptr (die
, dwarf_AT (DW_AT_addr_base
), debug_addr_section_label
);
11390 /* Output skeleton debug sections that point to the dwo file. */
11393 output_skeleton_debug_sections (dw_die_ref comp_unit
,
11394 const unsigned char *dwo_id
)
11396 /* These attributes will be found in the full debug_info section. */
11397 remove_AT (comp_unit
, DW_AT_producer
);
11398 remove_AT (comp_unit
, DW_AT_language
);
11400 switch_to_section (debug_skeleton_info_section
);
11401 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
11403 /* Produce the skeleton compilation-unit header. This one differs enough from
11404 a normal CU header that it's better not to call output_compilation_unit
11406 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
11407 dw2_asm_output_data (4, 0xffffffff,
11408 "Initial length escape value indicating 64-bit "
11409 "DWARF extension");
11411 dw2_asm_output_data (dwarf_offset_size
,
11412 DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11413 - DWARF_INITIAL_LENGTH_SIZE
11414 + size_of_die (comp_unit
),
11415 "Length of Compilation Unit Info");
11416 output_dwarf_version ();
11417 if (dwarf_version
>= 5)
11419 dw2_asm_output_data (1, DW_UT_skeleton
, "DW_UT_skeleton");
11420 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11422 dw2_asm_output_offset (dwarf_offset_size
, debug_skeleton_abbrev_section_label
,
11423 debug_skeleton_abbrev_section
,
11424 "Offset Into Abbrev. Section");
11425 if (dwarf_version
< 5)
11426 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11428 for (int i
= 0; i
< 8; i
++)
11429 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
11431 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
11432 output_die (comp_unit
);
11434 /* Build the skeleton debug_abbrev section. */
11435 switch_to_section (debug_skeleton_abbrev_section
);
11436 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
11438 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
11440 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
11443 /* Output a comdat type unit DIE and its children. */
11446 output_comdat_type_unit (comdat_type_node
*node
,
11447 bool early_lto_debug ATTRIBUTE_UNUSED
)
11449 const char *secname
;
11452 #if defined (OBJECT_FORMAT_ELF)
11456 /* First mark all the DIEs in this CU so we know which get local refs. */
11457 mark_dies (node
->root_die
);
11459 external_ref_hash_type
*extern_map
= optimize_external_refs (node
->root_die
);
11461 build_abbrev_table (node
->root_die
, extern_map
);
11466 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11467 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
11468 calc_die_sizes (node
->root_die
);
11470 #if defined (OBJECT_FORMAT_ELF)
11471 if (dwarf_version
>= 5)
11473 if (!dwarf_split_debug_info
)
11474 secname
= early_lto_debug
? DEBUG_LTO_INFO_SECTION
: DEBUG_INFO_SECTION
;
11476 secname
= (early_lto_debug
11477 ? DEBUG_LTO_DWO_INFO_SECTION
: DEBUG_DWO_INFO_SECTION
);
11479 else if (!dwarf_split_debug_info
)
11480 secname
= early_lto_debug
? ".gnu.debuglto_.debug_types" : ".debug_types";
11482 secname
= (early_lto_debug
11483 ? ".gnu.debuglto_.debug_types.dwo" : ".debug_types.dwo");
11485 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11486 sprintf (tmp
, dwarf_version
>= 5 ? "wi." : "wt.");
11487 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11488 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11489 comdat_key
= get_identifier (tmp
);
11490 targetm
.asm_out
.named_section (secname
,
11491 SECTION_DEBUG
| SECTION_LINKONCE
,
11494 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11495 sprintf (tmp
, (dwarf_version
>= 5
11496 ? ".gnu.linkonce.wi." : ".gnu.linkonce.wt."));
11497 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11498 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11500 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11503 /* Output debugging information. */
11504 output_compilation_unit_header (dwarf_split_debug_info
11505 ? DW_UT_split_type
: DW_UT_type
);
11506 output_signature (node
->signature
, "Type Signature");
11507 dw2_asm_output_data (dwarf_offset_size
, node
->type_die
->die_offset
,
11508 "Offset to Type DIE");
11509 output_die (node
->root_die
);
11511 unmark_dies (node
->root_die
);
11514 /* Return the DWARF2/3 pubname associated with a decl. */
11516 static const char *
11517 dwarf2_name (tree decl
, int scope
)
11519 if (DECL_NAMELESS (decl
))
11521 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
11524 /* Add a new entry to .debug_pubnames if appropriate. */
11527 add_pubname_string (const char *str
, dw_die_ref die
)
11532 e
.name
= xstrdup (str
);
11533 vec_safe_push (pubname_table
, e
);
11537 add_pubname (tree decl
, dw_die_ref die
)
11539 if (!want_pubnames ())
11542 /* Don't add items to the table when we expect that the consumer will have
11543 just read the enclosing die. For example, if the consumer is looking at a
11544 class_member, it will either be inside the class already, or will have just
11545 looked up the class to find the member. Either way, searching the class is
11546 faster than searching the index. */
11547 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
11548 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
11550 const char *name
= dwarf2_name (decl
, 1);
11553 add_pubname_string (name
, die
);
11557 /* Add an enumerator to the pubnames section. */
11560 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
11564 gcc_assert (scope_name
);
11565 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
11567 vec_safe_push (pubname_table
, e
);
11570 /* Add a new entry to .debug_pubtypes if appropriate. */
11573 add_pubtype (tree decl
, dw_die_ref die
)
11577 if (!want_pubnames ())
11580 if ((TREE_PUBLIC (decl
)
11581 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
11582 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
11585 const char *scope_name
= "";
11586 const char *sep
= is_cxx () ? "::" : ".";
11589 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
11590 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
11592 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
11593 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
11594 scope_name
= concat (scope_name
, sep
, NULL
);
11600 name
= type_tag (decl
);
11602 name
= lang_hooks
.dwarf_name (decl
, 1);
11604 /* If we don't have a name for the type, there's no point in adding
11605 it to the table. */
11606 if (name
!= NULL
&& name
[0] != '\0')
11609 e
.name
= concat (scope_name
, name
, NULL
);
11610 vec_safe_push (pubtype_table
, e
);
11613 /* Although it might be more consistent to add the pubinfo for the
11614 enumerators as their dies are created, they should only be added if the
11615 enum type meets the criteria above. So rather than re-check the parent
11616 enum type whenever an enumerator die is created, just output them all
11617 here. This isn't protected by the name conditional because anonymous
11618 enums don't have names. */
11619 if (die
->die_tag
== DW_TAG_enumeration_type
)
11623 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
11628 /* Output a single entry in the pubnames table. */
11631 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
11633 dw_die_ref die
= entry
->die
;
11634 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
11636 dw2_asm_output_data (dwarf_offset_size
, die_offset
, "DIE offset");
11638 if (debug_generate_pub_sections
== 2)
11640 /* This logic follows gdb's method for determining the value of the flag
11642 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
11643 switch (die
->die_tag
)
11645 case DW_TAG_typedef
:
11646 case DW_TAG_base_type
:
11647 case DW_TAG_subrange_type
:
11648 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11649 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11651 case DW_TAG_enumerator
:
11652 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11653 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11655 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11657 case DW_TAG_subprogram
:
11658 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11659 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
11661 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11663 case DW_TAG_constant
:
11664 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11665 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11666 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11668 case DW_TAG_variable
:
11669 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11670 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11671 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11673 case DW_TAG_namespace
:
11674 case DW_TAG_imported_declaration
:
11675 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11677 case DW_TAG_class_type
:
11678 case DW_TAG_interface_type
:
11679 case DW_TAG_structure_type
:
11680 case DW_TAG_union_type
:
11681 case DW_TAG_enumeration_type
:
11682 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11684 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11687 /* An unusual tag. Leave the flag-byte empty. */
11690 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
11691 "GDB-index flags");
11694 dw2_asm_output_nstring (entry
->name
, -1, "external name");
11698 /* Output the public names table used to speed up access to externally
11699 visible names; or the public types table used to find type definitions. */
11702 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
11705 unsigned long pubnames_length
= size_of_pubnames (names
);
11706 pubname_entry
*pub
;
11708 if (!XCOFF_DEBUGGING_INFO
)
11710 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
11711 dw2_asm_output_data (4, 0xffffffff,
11712 "Initial length escape value indicating 64-bit DWARF extension");
11713 dw2_asm_output_data (dwarf_offset_size
, pubnames_length
,
11714 "Pub Info Length");
11717 /* Version number for pubnames/pubtypes is independent of dwarf version. */
11718 dw2_asm_output_data (2, 2, "DWARF pubnames/pubtypes version");
11720 if (dwarf_split_debug_info
)
11721 dw2_asm_output_offset (dwarf_offset_size
, debug_skeleton_info_section_label
,
11722 debug_skeleton_info_section
,
11723 "Offset of Compilation Unit Info");
11725 dw2_asm_output_offset (dwarf_offset_size
, debug_info_section_label
,
11726 debug_info_section
,
11727 "Offset of Compilation Unit Info");
11728 dw2_asm_output_data (dwarf_offset_size
, next_die_offset
,
11729 "Compilation Unit Length");
11731 FOR_EACH_VEC_ELT (*names
, i
, pub
)
11733 if (include_pubname_in_output (names
, pub
))
11735 dw_offset die_offset
= pub
->die
->die_offset
;
11737 /* We shouldn't see pubnames for DIEs outside of the main CU. */
11738 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
11739 gcc_assert (pub
->die
->die_mark
);
11741 /* If we're putting types in their own .debug_types sections,
11742 the .debug_pubtypes table will still point to the compile
11743 unit (not the type unit), so we want to use the offset of
11744 the skeleton DIE (if there is one). */
11745 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
11747 comdat_type_node
*type_node
= pub
->die
->die_id
.die_type_node
;
11749 if (type_node
!= NULL
)
11750 die_offset
= (type_node
->skeleton_die
!= NULL
11751 ? type_node
->skeleton_die
->die_offset
11752 : comp_unit_die ()->die_offset
);
11755 output_pubname (die_offset
, pub
);
11759 dw2_asm_output_data (dwarf_offset_size
, 0, NULL
);
11762 /* Output public names and types tables if necessary. */
11765 output_pubtables (void)
11767 if (!want_pubnames () || !info_section_emitted
)
11770 switch_to_section (debug_pubnames_section
);
11771 output_pubnames (pubname_table
);
11772 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
11773 It shouldn't hurt to emit it always, since pure DWARF2 consumers
11774 simply won't look for the section. */
11775 switch_to_section (debug_pubtypes_section
);
11776 output_pubnames (pubtype_table
);
11780 /* Output the information that goes into the .debug_aranges table.
11781 Namely, define the beginning and ending address range of the
11782 text section generated for this compilation unit. */
11785 output_aranges (void)
11788 unsigned long aranges_length
= size_of_aranges ();
11790 if (!XCOFF_DEBUGGING_INFO
)
11792 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
11793 dw2_asm_output_data (4, 0xffffffff,
11794 "Initial length escape value indicating 64-bit DWARF extension");
11795 dw2_asm_output_data (dwarf_offset_size
, aranges_length
,
11796 "Length of Address Ranges Info");
11799 /* Version number for aranges is still 2, even up to DWARF5. */
11800 dw2_asm_output_data (2, 2, "DWARF aranges version");
11801 if (dwarf_split_debug_info
)
11802 dw2_asm_output_offset (dwarf_offset_size
, debug_skeleton_info_section_label
,
11803 debug_skeleton_info_section
,
11804 "Offset of Compilation Unit Info");
11806 dw2_asm_output_offset (dwarf_offset_size
, debug_info_section_label
,
11807 debug_info_section
,
11808 "Offset of Compilation Unit Info");
11809 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
11810 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
11812 /* We need to align to twice the pointer size here. */
11813 if (DWARF_ARANGES_PAD_SIZE
)
11815 /* Pad using a 2 byte words so that padding is correct for any
11817 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
11818 2 * DWARF2_ADDR_SIZE
);
11819 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
11820 dw2_asm_output_data (2, 0, NULL
);
11823 /* It is necessary not to output these entries if the sections were
11824 not used; if the sections were not used, the length will be 0 and
11825 the address may end up as 0 if the section is discarded by ld
11826 --gc-sections, leaving an invalid (0, 0) entry that can be
11827 confused with the terminator. */
11828 if (switch_text_ranges
)
11830 const char *prev_loc
= text_section_label
;
11834 FOR_EACH_VEC_ELT (*switch_text_ranges
, idx
, loc
)
11837 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, prev_loc
, "Address");
11838 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, loc
, prev_loc
, "Length");
11846 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, prev_loc
, "Address");
11847 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
11848 prev_loc
, "Length");
11852 if (switch_cold_ranges
)
11854 const char *prev_loc
= cold_text_section_label
;
11858 FOR_EACH_VEC_ELT (*switch_cold_ranges
, idx
, loc
)
11861 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, prev_loc
, "Address");
11862 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, loc
, prev_loc
, "Length");
11870 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, prev_loc
, "Address");
11871 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
11872 prev_loc
, "Length");
11876 if (have_multiple_function_sections
)
11881 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
11883 if (fde
->ignored_debug
)
11885 if (!fde
->in_std_section
)
11887 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
11889 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
11890 fde
->dw_fde_begin
, "Length");
11892 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
11894 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
11896 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
11897 fde
->dw_fde_second_begin
, "Length");
11902 /* Output the terminator words. */
11903 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11904 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11907 /* Add a new entry to .debug_ranges. Return its index into
11908 ranges_table vector. */
11910 static unsigned int
11911 add_ranges_num (int num
, bool maybe_new_sec
)
11913 dw_ranges r
= { NULL
, num
, 0, maybe_new_sec
, NULL
, NULL
};
11914 vec_safe_push (ranges_table
, r
);
11915 return vec_safe_length (ranges_table
) - 1;
11918 /* Add a new entry to .debug_ranges corresponding to a block, or a
11919 range terminator if BLOCK is NULL. MAYBE_NEW_SEC is true if
11920 this entry might be in a different section from previous range. */
11922 static unsigned int
11923 add_ranges (const_tree block
, bool maybe_new_sec
)
11925 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0, maybe_new_sec
);
11928 /* Note that (*rnglist_table)[offset] is either a head of a rnglist
11929 chain, or middle entry of a chain that will be directly referred to. */
11932 note_rnglist_head (unsigned int offset
)
11934 if (dwarf_version
< 5 || (*ranges_table
)[offset
].label
)
11936 (*ranges_table
)[offset
].label
= gen_internal_sym ("LLRL");
11939 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
11940 When using dwarf_split_debug_info, address attributes in dies destined
11941 for the final executable should be direct references--setting the
11942 parameter force_direct ensures this behavior. */
11945 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
11946 bool *added
, bool force_direct
)
11948 unsigned int in_use
= vec_safe_length (ranges_by_label
);
11949 unsigned int offset
;
11950 dw_ranges_by_label rbl
= { begin
, end
};
11951 vec_safe_push (ranges_by_label
, rbl
);
11952 offset
= add_ranges_num (-(int)in_use
- 1, true);
11955 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
11957 note_rnglist_head (offset
);
11958 if (dwarf_split_debug_info
&& force_direct
)
11959 (*ranges_table
)[offset
].idx
= DW_RANGES_IDX_SKELETON
;
11963 /* Emit .debug_ranges section. */
11966 output_ranges (void)
11969 static const char *const start_fmt
= "Offset %#x";
11970 const char *fmt
= start_fmt
;
11973 switch_to_section (debug_ranges_section
);
11974 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11975 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11977 int block_num
= r
->num
;
11981 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11982 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11984 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11985 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11987 /* If all code is in the text section, then the compilation
11988 unit base address defaults to DW_AT_low_pc, which is the
11989 base of the text section. */
11990 if (!have_multiple_function_sections
)
11992 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
11993 text_section_label
,
11994 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11995 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
11996 text_section_label
, NULL
);
11999 /* Otherwise, the compilation unit base address is zero,
12000 which allows us to use absolute addresses, and not worry
12001 about whether the target supports cross-section
12005 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
12006 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
12007 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
12013 /* Negative block_num stands for an index into ranges_by_label. */
12014 else if (block_num
< 0)
12016 int lab_idx
= - block_num
- 1;
12018 if (!have_multiple_function_sections
)
12020 gcc_unreachable ();
12022 /* If we ever use add_ranges_by_labels () for a single
12023 function section, all we have to do is to take out
12024 the #if 0 above. */
12025 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
12026 (*ranges_by_label
)[lab_idx
].begin
,
12027 text_section_label
,
12028 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
12029 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
12030 (*ranges_by_label
)[lab_idx
].end
,
12031 text_section_label
, NULL
);
12036 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
12037 (*ranges_by_label
)[lab_idx
].begin
,
12038 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
12039 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
12040 (*ranges_by_label
)[lab_idx
].end
,
12046 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
12047 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
12053 /* Non-zero if .debug_line_str should be used for .debug_line section
12054 strings or strings that are likely shareable with those. */
12055 #define DWARF5_USE_DEBUG_LINE_STR \
12056 (!DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET \
12057 && (DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) != 0 \
12058 /* FIXME: there is no .debug_line_str.dwo section, \
12059 for -gsplit-dwarf we should use DW_FORM_strx instead. */ \
12060 && !dwarf_split_debug_info)
12063 /* Returns TRUE if we are outputting DWARF5 and the assembler supports
12064 DWARF5 .debug_line tables using .debug_line_str or we generate
12065 it ourselves, except for split-dwarf which doesn't have a
12066 .debug_line_str. */
12068 asm_outputs_debug_line_str (void)
12070 if (dwarf_version
>= 5
12071 && ! output_asm_line_debug_info ()
12072 && DWARF5_USE_DEBUG_LINE_STR
)
12076 #if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
12077 return !dwarf_split_debug_info
&& dwarf_version
>= 5;
12084 /* Return true if it is beneficial to use DW_RLE_base_address{,x}.
12085 I is index of the following range. */
12088 use_distinct_base_address_for_range (unsigned int i
)
12090 if (i
>= vec_safe_length (ranges_table
))
12093 dw_ranges
*r2
= &(*ranges_table
)[i
];
12094 /* Use DW_RLE_base_address{,x} if there is a next range in the
12095 range list and is guaranteed to be in the same section. */
12096 return r2
->num
!= 0 && r2
->label
== NULL
&& !r2
->maybe_new_sec
;
12099 /* Assign .debug_rnglists indexes and unique indexes into the debug_addr
12100 section when needed. */
12103 index_rnglists (void)
12109 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
12111 if (r
->label
&& r
->idx
!= DW_RANGES_IDX_SKELETON
)
12112 r
->idx
= rnglist_idx
++;
12114 int block_num
= r
->num
;
12115 if ((HAVE_AS_LEB128
|| block_num
< 0)
12116 && !have_multiple_function_sections
)
12118 if (HAVE_AS_LEB128
&& (r
->label
|| r
->maybe_new_sec
))
12122 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
12123 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
12125 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
12126 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
12128 if (HAVE_AS_LEB128
)
12130 if (!base
&& use_distinct_base_address_for_range (i
+ 1))
12132 r
->begin_entry
= add_addr_table_entry (xstrdup (blabel
),
12137 /* If we have a base, no need for further
12138 begin_entry/end_entry, as DW_RLE_offset_pair will be
12142 = add_addr_table_entry (xstrdup (blabel
), ate_kind_label
);
12143 /* No need for end_entry, DW_RLE_start{,x}_length will use
12144 length as opposed to a pair of addresses. */
12149 = add_addr_table_entry (xstrdup (blabel
), ate_kind_label
);
12151 = add_addr_table_entry (xstrdup (elabel
), ate_kind_label
);
12155 /* Negative block_num stands for an index into ranges_by_label. */
12156 else if (block_num
< 0)
12158 int lab_idx
= - block_num
- 1;
12159 const char *blabel
= (*ranges_by_label
)[lab_idx
].begin
;
12160 const char *elabel
= (*ranges_by_label
)[lab_idx
].end
;
12163 = add_addr_table_entry (xstrdup (blabel
), ate_kind_label
);
12164 if (!HAVE_AS_LEB128
)
12166 = add_addr_table_entry (xstrdup (elabel
), ate_kind_label
);
12171 /* Emit .debug_rnglists or (when DWO is true) .debug_rnglists.dwo section. */
12174 output_rnglists (unsigned generation
, bool dwo
)
12178 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
12179 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
12180 char basebuf
[MAX_ARTIFICIAL_LABEL_BYTES
];
12183 switch_to_section (debug_ranges_dwo_section
);
12186 switch_to_section (debug_ranges_section
);
12187 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
12189 /* There are up to 4 unique ranges labels per generation.
12190 See also init_sections_and_labels. */
12191 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_RANGES_SECTION_LABEL
,
12192 2 + 2 * dwo
+ generation
* 6);
12193 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_RANGES_SECTION_LABEL
,
12194 3 + 2 * dwo
+ generation
* 6);
12195 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
12196 dw2_asm_output_data (4, 0xffffffff,
12197 "Initial length escape value indicating "
12198 "64-bit DWARF extension");
12199 dw2_asm_output_delta (dwarf_offset_size
, l2
, l1
,
12200 "Length of Range Lists");
12201 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
12202 output_dwarf_version ();
12203 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
12204 dw2_asm_output_data (1, 0, "Segment Size");
12205 /* Emit the offset table only for -gsplit-dwarf. If we don't care
12206 about relocation sizes and primarily care about the size of .debug*
12207 sections in linked shared libraries and executables, then
12208 the offset table plus corresponding DW_FORM_rnglistx uleb128 indexes
12209 into it are usually larger than just DW_FORM_sec_offset offsets
12210 into the .debug_rnglists section. */
12211 dw2_asm_output_data (4, dwo
? rnglist_idx
: 0,
12212 "Offset Entry Count");
12215 ASM_OUTPUT_LABEL (asm_out_file
, ranges_base_label
);
12216 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
12217 if (r
->label
&& r
->idx
!= DW_RANGES_IDX_SKELETON
)
12218 dw2_asm_output_delta (dwarf_offset_size
, r
->label
,
12219 ranges_base_label
, NULL
);
12222 const char *lab
= "";
12223 const char *base
= NULL
;
12224 bool skipping
= false;
12226 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
12228 int block_num
= r
->num
;
12232 if (dwarf_split_debug_info
12233 && (r
->idx
== DW_RANGES_IDX_SKELETON
) == dwo
)
12239 ASM_OUTPUT_LABEL (asm_out_file
, r
->label
);
12244 if (block_num
== 0)
12248 if (HAVE_AS_LEB128
&& (r
->label
|| r
->maybe_new_sec
))
12252 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
12253 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
12255 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
12256 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
12258 if (HAVE_AS_LEB128
)
12260 /* If all code is in the text section, then the compilation
12261 unit base address defaults to DW_AT_low_pc, which is the
12262 base of the text section. */
12263 if (!have_multiple_function_sections
)
12265 dw2_asm_output_data (1, DW_RLE_offset_pair
,
12266 "DW_RLE_offset_pair (%s)", lab
);
12267 dw2_asm_output_delta_uleb128 (blabel
, text_section_label
,
12268 "Range begin address (%s)", lab
);
12269 dw2_asm_output_delta_uleb128 (elabel
, text_section_label
,
12270 "Range end address (%s)", lab
);
12273 if (base
== NULL
&& use_distinct_base_address_for_range (i
+ 1))
12275 if (dwarf_split_debug_info
)
12277 dw2_asm_output_data (1, DW_RLE_base_addressx
,
12278 "DW_RLE_base_addressx (%s)", lab
);
12279 dw2_asm_output_data_uleb128 (r
->begin_entry
->index
,
12280 "Base address index (%s)",
12285 dw2_asm_output_data (1, DW_RLE_base_address
,
12286 "DW_RLE_base_address (%s)", lab
);
12287 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
12288 "Base address (%s)", lab
);
12290 strcpy (basebuf
, blabel
);
12295 dw2_asm_output_data (1, DW_RLE_offset_pair
,
12296 "DW_RLE_offset_pair (%s)", lab
);
12297 dw2_asm_output_delta_uleb128 (blabel
, base
,
12298 "Range begin address (%s)", lab
);
12299 dw2_asm_output_delta_uleb128 (elabel
, base
,
12300 "Range end address (%s)", lab
);
12303 if (dwarf_split_debug_info
)
12305 dw2_asm_output_data (1, DW_RLE_startx_length
,
12306 "DW_RLE_startx_length (%s)", lab
);
12307 dw2_asm_output_data_uleb128 (r
->begin_entry
->index
,
12308 "Range begin address index "
12313 dw2_asm_output_data (1, DW_RLE_start_length
,
12314 "DW_RLE_start_length (%s)", lab
);
12315 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
12316 "Range begin address (%s)", lab
);
12318 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
12319 "Range length (%s)", lab
);
12321 else if (dwarf_split_debug_info
)
12323 dw2_asm_output_data (1, DW_RLE_startx_endx
,
12324 "DW_RLE_startx_endx (%s)", lab
);
12325 dw2_asm_output_data_uleb128 (r
->begin_entry
->index
,
12326 "Range begin address index "
12328 dw2_asm_output_data_uleb128 (r
->end_entry
->index
,
12329 "Range end address index "
12334 dw2_asm_output_data (1, DW_RLE_start_end
,
12335 "DW_RLE_start_end (%s)", lab
);
12336 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
12337 "Range begin address (%s)", lab
);
12338 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
12339 "Range end address (%s)", lab
);
12343 /* Negative block_num stands for an index into ranges_by_label. */
12344 else if (block_num
< 0)
12346 int lab_idx
= - block_num
- 1;
12347 const char *blabel
= (*ranges_by_label
)[lab_idx
].begin
;
12348 const char *elabel
= (*ranges_by_label
)[lab_idx
].end
;
12350 if (!have_multiple_function_sections
)
12351 gcc_unreachable ();
12352 if (HAVE_AS_LEB128
)
12354 if (dwarf_split_debug_info
)
12356 dw2_asm_output_data (1, DW_RLE_startx_length
,
12357 "DW_RLE_startx_length (%s)", lab
);
12358 dw2_asm_output_data_uleb128 (r
->begin_entry
->index
,
12359 "Range begin address index "
12364 dw2_asm_output_data (1, DW_RLE_start_length
,
12365 "DW_RLE_start_length (%s)", lab
);
12366 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
12367 "Range begin address (%s)", lab
);
12369 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
12370 "Range length (%s)", lab
);
12372 else if (dwarf_split_debug_info
)
12374 dw2_asm_output_data (1, DW_RLE_startx_endx
,
12375 "DW_RLE_startx_endx (%s)", lab
);
12376 dw2_asm_output_data_uleb128 (r
->begin_entry
->index
,
12377 "Range begin address index "
12379 dw2_asm_output_data_uleb128 (r
->end_entry
->index
,
12380 "Range end address index "
12385 dw2_asm_output_data (1, DW_RLE_start_end
,
12386 "DW_RLE_start_end (%s)", lab
);
12387 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
12388 "Range begin address (%s)", lab
);
12389 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
12390 "Range end address (%s)", lab
);
12394 dw2_asm_output_data (1, DW_RLE_end_of_list
,
12395 "DW_RLE_end_of_list (%s)", lab
);
12397 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12401 /* Data structure containing information about input files. */
12404 const char *path
; /* Complete file name. */
12405 const char *fname
; /* File name part. */
12406 int length
; /* Length of entire string. */
12407 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
12408 int dir_idx
; /* Index in directory table. */
12411 /* Data structure containing information about directories with source
12415 const char *path
; /* Path including directory name. */
12416 int length
; /* Path length. */
12417 int prefix
; /* Index of directory entry which is a prefix. */
12418 int count
; /* Number of files in this directory. */
12419 int dir_idx
; /* Index of directory used as base. */
12422 /* Callback function for file_info comparison. We sort by looking at
12423 the directories in the path. */
12426 file_info_cmp (const void *p1
, const void *p2
)
12428 const struct file_info
*const s1
= (const struct file_info
*) p1
;
12429 const struct file_info
*const s2
= (const struct file_info
*) p2
;
12430 const unsigned char *cp1
;
12431 const unsigned char *cp2
;
12433 /* Take care of file names without directories. We need to make sure that
12434 we return consistent values to qsort since some will get confused if
12435 we return the same value when identical operands are passed in opposite
12436 orders. So if neither has a directory, return 0 and otherwise return
12437 1 or -1 depending on which one has the directory. We want the one with
12438 the directory to sort after the one without, so all no directory files
12439 are at the start (normally only the compilation unit file). */
12440 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
12441 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
12443 cp1
= (const unsigned char *) s1
->path
;
12444 cp2
= (const unsigned char *) s2
->path
;
12450 /* Reached the end of the first path? If so, handle like above,
12451 but now we want longer directory prefixes before shorter ones. */
12452 if ((cp1
== (const unsigned char *) s1
->fname
)
12453 || (cp2
== (const unsigned char *) s2
->fname
))
12454 return ((cp1
== (const unsigned char *) s1
->fname
)
12455 - (cp2
== (const unsigned char *) s2
->fname
));
12457 /* Character of current path component the same? */
12458 else if (*cp1
!= *cp2
)
12459 return *cp1
- *cp2
;
12463 struct file_name_acquire_data
12465 struct file_info
*files
;
12470 /* Traversal function for the hash table. */
12473 file_name_acquire (dwarf_file_data
**slot
, file_name_acquire_data
*fnad
)
12475 struct dwarf_file_data
*d
= *slot
;
12476 struct file_info
*fi
;
12479 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
12481 if (! d
->emitted_number
)
12484 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
12486 fi
= fnad
->files
+ fnad
->used_files
++;
12490 /* Skip all leading "./". */
12491 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
12494 /* Create a new array entry. */
12496 fi
->length
= strlen (f
);
12499 /* Search for the file name part. */
12500 f
= strrchr (f
, DIR_SEPARATOR
);
12501 #if defined (DIR_SEPARATOR_2)
12503 const char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
12507 if (f
== NULL
|| f
< g
)
12513 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
12517 /* Helper function for output_file_names. Emit a FORM encoded
12518 string STR, with assembly comment start ENTRY_KIND and
12522 output_line_string (enum dwarf_form form
, const char *str
,
12523 const char *entry_kind
, unsigned int idx
)
12527 case DW_FORM_string
:
12528 dw2_asm_output_nstring (str
, -1, "%s: %#x", entry_kind
, idx
);
12530 case DW_FORM_line_strp
:
12531 if (!debug_line_str_hash
)
12532 debug_line_str_hash
12533 = hash_table
<indirect_string_hasher
>::create_ggc (10);
12535 struct indirect_string_node
*node
;
12536 node
= find_AT_string_in_table (str
, debug_line_str_hash
);
12537 set_indirect_string (node
);
12539 dw2_asm_output_offset (dwarf_offset_size
, node
->label
,
12540 debug_line_str_section
, "%s: %#x: \"%s\"",
12541 entry_kind
, 0, node
->str
);
12544 gcc_unreachable ();
12548 /* Output the directory table and the file name table. We try to minimize
12549 the total amount of memory needed. A heuristic is used to avoid large
12550 slowdowns with many input files. */
12553 output_file_names (void)
12555 struct file_name_acquire_data fnad
;
12557 struct file_info
*files
;
12558 struct dir_info
*dirs
;
12566 if (!last_emitted_file
)
12568 if (dwarf_version
>= 5)
12570 const char *comp_dir
= comp_dir_string ();
12571 if (comp_dir
== NULL
)
12573 dw2_asm_output_data (1, 1, "Directory entry format count");
12574 enum dwarf_form str_form
= DW_FORM_string
;
12575 if (DWARF5_USE_DEBUG_LINE_STR
)
12576 str_form
= DW_FORM_line_strp
;
12577 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12578 dw2_asm_output_data_uleb128 (str_form
, "%s",
12579 get_DW_FORM_name (str_form
));
12580 dw2_asm_output_data_uleb128 (1, "Directories count");
12581 if (str_form
== DW_FORM_string
)
12582 dw2_asm_output_nstring (comp_dir
, -1, "Directory Entry: %#x", 0);
12584 output_line_string (str_form
, comp_dir
, "Directory Entry", 0);
12585 const char *filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
12586 if (filename0
== NULL
)
12588 #ifdef VMS_DEBUGGING_INFO
12589 dw2_asm_output_data (1, 4, "File name entry format count");
12591 dw2_asm_output_data (1, 2, "File name entry format count");
12593 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12594 dw2_asm_output_data_uleb128 (str_form
, "%s",
12595 get_DW_FORM_name (str_form
));
12596 dw2_asm_output_data_uleb128 (DW_LNCT_directory_index
,
12597 "DW_LNCT_directory_index");
12598 dw2_asm_output_data_uleb128 (DW_FORM_data1
, "%s",
12599 get_DW_FORM_name (DW_FORM_data1
));
12600 #ifdef VMS_DEBUGGING_INFO
12601 dw2_asm_output_data_uleb128 (DW_LNCT_timestamp
, "DW_LNCT_timestamp");
12602 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12603 dw2_asm_output_data_uleb128 (DW_LNCT_size
, "DW_LNCT_size");
12604 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12606 dw2_asm_output_data_uleb128 (1, "File names count");
12608 output_line_string (str_form
, filename0
, "File Entry", 0);
12609 dw2_asm_output_data (1, 0, NULL
);
12610 #ifdef VMS_DEBUGGING_INFO
12611 dw2_asm_output_data_uleb128 (0, NULL
);
12612 dw2_asm_output_data_uleb128 (0, NULL
);
12617 dw2_asm_output_data (1, 0, "End directory table");
12618 dw2_asm_output_data (1, 0, "End file name table");
12623 numfiles
= last_emitted_file
->emitted_number
;
12625 /* Allocate the various arrays we need. */
12626 files
= XALLOCAVEC (struct file_info
, numfiles
);
12627 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
12629 fnad
.files
= files
;
12630 fnad
.used_files
= 0;
12631 fnad
.max_files
= numfiles
;
12632 file_table
->traverse
<file_name_acquire_data
*, file_name_acquire
> (&fnad
);
12633 gcc_assert (fnad
.used_files
== fnad
.max_files
);
12635 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
12637 /* Find all the different directories used. */
12638 dirs
[0].path
= files
[0].path
;
12639 dirs
[0].length
= files
[0].fname
- files
[0].path
;
12640 dirs
[0].prefix
= -1;
12642 dirs
[0].dir_idx
= 0;
12643 files
[0].dir_idx
= 0;
12646 for (i
= 1; i
< numfiles
; i
++)
12647 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
12648 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
12649 dirs
[ndirs
- 1].length
) == 0)
12651 /* Same directory as last entry. */
12652 files
[i
].dir_idx
= ndirs
- 1;
12653 ++dirs
[ndirs
- 1].count
;
12659 /* This is a new directory. */
12660 dirs
[ndirs
].path
= files
[i
].path
;
12661 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
12662 dirs
[ndirs
].count
= 1;
12663 dirs
[ndirs
].dir_idx
= ndirs
;
12664 files
[i
].dir_idx
= ndirs
;
12666 /* Search for a prefix. */
12667 dirs
[ndirs
].prefix
= -1;
12668 for (j
= 0; j
< ndirs
; j
++)
12669 if (dirs
[j
].length
< dirs
[ndirs
].length
12670 && dirs
[j
].length
> 1
12671 && (dirs
[ndirs
].prefix
== -1
12672 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
12673 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
12674 dirs
[ndirs
].prefix
= j
;
12679 /* Now to the actual work. We have to find a subset of the directories which
12680 allow expressing the file name using references to the directory table
12681 with the least amount of characters. We do not do an exhaustive search
12682 where we would have to check out every combination of every single
12683 possible prefix. Instead we use a heuristic which provides nearly optimal
12684 results in most cases and never is much off. */
12685 saved
= XALLOCAVEC (int, ndirs
);
12686 savehere
= XALLOCAVEC (int, ndirs
);
12688 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
12689 for (i
= 0; i
< ndirs
; i
++)
12694 /* We can always save some space for the current directory. But this
12695 does not mean it will be enough to justify adding the directory. */
12696 savehere
[i
] = dirs
[i
].length
;
12697 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
12699 for (j
= i
+ 1; j
< ndirs
; j
++)
12702 if (saved
[j
] < dirs
[i
].length
)
12704 /* Determine whether the dirs[i] path is a prefix of the
12708 k
= dirs
[j
].prefix
;
12709 while (k
!= -1 && k
!= (int) i
)
12710 k
= dirs
[k
].prefix
;
12714 /* Yes it is. We can possibly save some memory by
12715 writing the filenames in dirs[j] relative to
12717 savehere
[j
] = dirs
[i
].length
;
12718 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
12723 /* Check whether we can save enough to justify adding the dirs[i]
12725 if (total
> dirs
[i
].length
+ 1)
12727 /* It's worthwhile adding. */
12728 for (j
= i
; j
< ndirs
; j
++)
12729 if (savehere
[j
] > 0)
12731 /* Remember how much we saved for this directory so far. */
12732 saved
[j
] = savehere
[j
];
12734 /* Remember the prefix directory. */
12735 dirs
[j
].dir_idx
= i
;
12740 /* Emit the directory name table. */
12741 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
12742 enum dwarf_form str_form
= DW_FORM_string
;
12743 enum dwarf_form idx_form
= DW_FORM_udata
;
12744 if (dwarf_version
>= 5)
12746 const char *comp_dir
= comp_dir_string ();
12747 if (comp_dir
== NULL
)
12749 dw2_asm_output_data (1, 1, "Directory entry format count");
12750 if (DWARF5_USE_DEBUG_LINE_STR
)
12751 str_form
= DW_FORM_line_strp
;
12752 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12753 dw2_asm_output_data_uleb128 (str_form
, "%s",
12754 get_DW_FORM_name (str_form
));
12755 dw2_asm_output_data_uleb128 (ndirs
+ idx_offset
, "Directories count");
12756 if (str_form
== DW_FORM_string
)
12758 dw2_asm_output_nstring (comp_dir
, -1, "Directory Entry: %#x", 0);
12759 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12760 dw2_asm_output_nstring (dirs
[i
].path
,
12762 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
12763 "Directory Entry: %#x", i
+ idx_offset
);
12767 output_line_string (str_form
, comp_dir
, "Directory Entry", 0);
12768 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12771 = ggc_alloc_string (dirs
[i
].path
,
12773 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
);
12774 output_line_string (str_form
, str
, "Directory Entry",
12775 (unsigned) i
+ idx_offset
);
12781 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12782 dw2_asm_output_nstring (dirs
[i
].path
,
12784 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
12785 "Directory Entry: %#x", i
+ idx_offset
);
12787 dw2_asm_output_data (1, 0, "End directory table");
12790 /* We have to emit them in the order of emitted_number since that's
12791 used in the debug info generation. To do this efficiently we
12792 generate a back-mapping of the indices first. */
12793 backmap
= XALLOCAVEC (int, numfiles
);
12794 for (i
= 0; i
< numfiles
; i
++)
12795 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
12797 if (dwarf_version
>= 5)
12799 const char *filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
12800 if (filename0
== NULL
)
12802 /* DW_LNCT_directory_index can use DW_FORM_udata, DW_FORM_data1 and
12803 DW_FORM_data2. Choose one based on the number of directories
12804 and how much space would they occupy in each encoding.
12805 If we have at most 256 directories, all indexes fit into
12806 a single byte, so DW_FORM_data1 is most compact (if there
12807 are at most 128 directories, DW_FORM_udata would be as
12808 compact as that, but not shorter and slower to decode). */
12809 if (ndirs
+ idx_offset
<= 256)
12810 idx_form
= DW_FORM_data1
;
12811 /* If there are more than 65536 directories, we have to use
12812 DW_FORM_udata, DW_FORM_data2 can't refer to them.
12813 Otherwise, compute what space would occupy if all the indexes
12814 used DW_FORM_udata - sum - and compare that to how large would
12815 be DW_FORM_data2 encoding, and pick the more efficient one. */
12816 else if (ndirs
+ idx_offset
<= 65536)
12818 unsigned HOST_WIDE_INT sum
= 1;
12819 for (i
= 0; i
< numfiles
; i
++)
12821 int file_idx
= backmap
[i
];
12822 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
12823 sum
+= size_of_uleb128 (dir_idx
);
12825 if (sum
>= HOST_WIDE_INT_UC (2) * (numfiles
+ 1))
12826 idx_form
= DW_FORM_data2
;
12828 #ifdef VMS_DEBUGGING_INFO
12829 dw2_asm_output_data (1, 4, "File name entry format count");
12831 dw2_asm_output_data (1, 2, "File name entry format count");
12833 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12834 dw2_asm_output_data_uleb128 (str_form
, "%s",
12835 get_DW_FORM_name (str_form
));
12836 dw2_asm_output_data_uleb128 (DW_LNCT_directory_index
,
12837 "DW_LNCT_directory_index");
12838 dw2_asm_output_data_uleb128 (idx_form
, "%s",
12839 get_DW_FORM_name (idx_form
));
12840 #ifdef VMS_DEBUGGING_INFO
12841 dw2_asm_output_data_uleb128 (DW_LNCT_timestamp
, "DW_LNCT_timestamp");
12842 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12843 dw2_asm_output_data_uleb128 (DW_LNCT_size
, "DW_LNCT_size");
12844 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12846 dw2_asm_output_data_uleb128 (numfiles
+ 1, "File names count");
12848 output_line_string (str_form
, filename0
, "File Entry", 0);
12850 /* Include directory index. */
12851 if (idx_form
!= DW_FORM_udata
)
12852 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12855 dw2_asm_output_data_uleb128 (0, NULL
);
12857 #ifdef VMS_DEBUGGING_INFO
12858 dw2_asm_output_data_uleb128 (0, NULL
);
12859 dw2_asm_output_data_uleb128 (0, NULL
);
12863 /* Now write all the file names. */
12864 for (i
= 0; i
< numfiles
; i
++)
12866 int file_idx
= backmap
[i
];
12867 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
12869 #ifdef VMS_DEBUGGING_INFO
12870 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
12872 /* Setting these fields can lead to debugger miscomparisons,
12873 but VMS Debug requires them to be set correctly. */
12878 int maxfilelen
= (strlen (files
[file_idx
].path
)
12879 + dirs
[dir_idx
].length
12880 + MAX_VMS_VERSION_LEN
+ 1);
12881 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
12883 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
12884 snprintf (filebuf
, maxfilelen
, "%s;%d",
12885 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
12887 output_line_string (str_form
, filebuf
, "File Entry", (unsigned) i
+ 1);
12889 /* Include directory index. */
12890 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
12891 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12892 dir_idx
+ idx_offset
, NULL
);
12894 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
12896 /* Modification time. */
12897 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
12898 &cdt
, 0, 0, 0) == 0)
12901 /* File length in bytes. */
12902 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
12903 0, &siz
, 0, 0) == 0)
12906 output_line_string (str_form
,
12907 files
[file_idx
].path
+ dirs
[dir_idx
].length
,
12908 "File Entry", (unsigned) i
+ 1);
12910 /* Include directory index. */
12911 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
12912 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12913 dir_idx
+ idx_offset
, NULL
);
12915 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
12917 if (dwarf_version
>= 5)
12920 /* Modification time. */
12921 dw2_asm_output_data_uleb128 (0, NULL
);
12923 /* File length in bytes. */
12924 dw2_asm_output_data_uleb128 (0, NULL
);
12925 #endif /* VMS_DEBUGGING_INFO */
12928 if (dwarf_version
< 5)
12929 dw2_asm_output_data (1, 0, "End file name table");
12933 /* Output one line number table into the .debug_line section. */
12936 output_one_line_info_table (dw_line_info_table
*table
)
12938 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12939 unsigned int current_line
= 1;
12940 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
12941 dw_line_info_entry
*ent
, *prev_addr
= NULL
;
12947 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
12949 switch (ent
->opcode
)
12951 case LI_set_address
:
12952 /* ??? Unfortunately, we have little choice here currently, and
12953 must always use the most general form. GCC does not know the
12954 address delta itself, so we can't use DW_LNS_advance_pc. Many
12955 ports do have length attributes which will give an upper bound
12956 on the address range. We could perhaps use length attributes
12957 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
12958 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
12962 /* This can handle any delta. This takes
12963 4+DWARF2_ADDR_SIZE bytes. */
12964 dw2_asm_output_data (1, 0, "set address %s%s", line_label
,
12965 debug_variable_location_views
12966 ? ", reset view to 0" : "");
12967 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12968 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12969 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
12974 case LI_adv_address
:
12976 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
12977 char prev_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12978 ASM_GENERATE_INTERNAL_LABEL (prev_label
, LINE_CODE_LABEL
, prev_addr
->val
);
12982 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
, "fixed advance PC, increment view to %i", view
);
12983 dw2_asm_output_delta (2, line_label
, prev_label
,
12984 "from %s to %s", prev_label
, line_label
);
12991 if (ent
->val
== current_line
)
12993 /* We still need to start a new row, so output a copy insn. */
12994 dw2_asm_output_data (1, DW_LNS_copy
,
12995 "copy line %u", current_line
);
12999 int line_offset
= ent
->val
- current_line
;
13000 int line_delta
= line_offset
- DWARF_LINE_BASE
;
13002 current_line
= ent
->val
;
13003 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
13005 /* This can handle deltas from -10 to 234, using the current
13006 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
13007 This takes 1 byte. */
13008 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
13009 "line %u", current_line
);
13013 /* This can handle any delta. This takes at least 4 bytes,
13014 depending on the value being encoded. */
13015 dw2_asm_output_data (1, DW_LNS_advance_line
,
13016 "advance to line %u", current_line
);
13017 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
13018 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
13024 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
13025 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
13028 case LI_set_column
:
13029 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
13030 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
13033 case LI_negate_stmt
:
13034 current_is_stmt
= !current_is_stmt
;
13035 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
13036 "is_stmt %d", current_is_stmt
);
13039 case LI_set_prologue_end
:
13040 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
13041 "set prologue end");
13044 case LI_set_epilogue_begin
:
13045 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
13046 "set epilogue begin");
13049 case LI_set_discriminator
:
13050 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
13051 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
13052 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
13053 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
13058 /* Emit debug info for the address of the end of the table. */
13059 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
13060 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
13061 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
13062 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
13064 dw2_asm_output_data (1, 0, "end sequence");
13065 dw2_asm_output_data_uleb128 (1, NULL
);
13066 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
13069 static unsigned int output_line_info_generation
;
13071 /* Output the source line number correspondence information. This
13072 information goes into the .debug_line section. */
13075 output_line_info (bool prologue_only
)
13077 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
13078 char p1
[MAX_ARTIFICIAL_LABEL_BYTES
], p2
[MAX_ARTIFICIAL_LABEL_BYTES
];
13079 bool saw_one
= false;
13082 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
,
13083 output_line_info_generation
);
13084 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
,
13085 output_line_info_generation
);
13086 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
,
13087 output_line_info_generation
);
13088 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
,
13089 output_line_info_generation
++);
13091 if (!XCOFF_DEBUGGING_INFO
)
13093 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
13094 dw2_asm_output_data (4, 0xffffffff,
13095 "Initial length escape value indicating 64-bit DWARF extension");
13096 dw2_asm_output_delta (dwarf_offset_size
, l2
, l1
,
13097 "Length of Source Line Info");
13100 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
13102 output_dwarf_version ();
13103 if (dwarf_version
>= 5)
13105 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
13106 dw2_asm_output_data (1, 0, "Segment Size");
13108 dw2_asm_output_delta (dwarf_offset_size
, p2
, p1
, "Prolog Length");
13109 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
13111 /* Define the architecture-dependent minimum instruction length (in bytes).
13112 In this implementation of DWARF, this field is used for information
13113 purposes only. Since GCC generates assembly language, we have no
13114 a priori knowledge of how many instruction bytes are generated for each
13115 source line, and therefore can use only the DW_LNE_set_address and
13116 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
13117 this as '1', which is "correct enough" for all architectures,
13118 and don't let the target override. */
13119 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
13121 if (dwarf_version
>= 4)
13122 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
13123 "Maximum Operations Per Instruction");
13124 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
13125 "Default is_stmt_start flag");
13126 dw2_asm_output_data (1, DWARF_LINE_BASE
,
13127 "Line Base Value (Special Opcodes)");
13128 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
13129 "Line Range Value (Special Opcodes)");
13130 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
13131 "Special Opcode Base");
13133 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
13138 case DW_LNS_advance_pc
:
13139 case DW_LNS_advance_line
:
13140 case DW_LNS_set_file
:
13141 case DW_LNS_set_column
:
13142 case DW_LNS_fixed_advance_pc
:
13143 case DW_LNS_set_isa
:
13151 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
13155 /* Write out the information about the files we use. */
13156 output_file_names ();
13157 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
13160 /* Output the marker for the end of the line number info. */
13161 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
13165 if (separate_line_info
)
13167 dw_line_info_table
*table
;
13170 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
13173 output_one_line_info_table (table
);
13177 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
13179 output_one_line_info_table (cold_text_section_line_info
);
13183 /* ??? Some Darwin linkers crash on a .debug_line section with no
13184 sequences. Further, merely a DW_LNE_end_sequence entry is not
13185 sufficient -- the address column must also be initialized.
13186 Make sure to output at least one set_address/end_sequence pair,
13187 choosing .text since that section is always present. */
13188 if (text_section_line_info
->in_use
|| !saw_one
)
13189 output_one_line_info_table (text_section_line_info
);
13191 /* Output the marker for the end of the line number info. */
13192 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
13195 /* Return true if DW_AT_endianity should be emitted according to REVERSE. */
13198 need_endianity_attribute_p (bool reverse
)
13200 return reverse
&& (dwarf_version
>= 3 || !dwarf_strict
);
13203 /* Given a pointer to a tree node for some base type, return a pointer to
13204 a DIE that describes the given type. REVERSE is true if the type is
13205 to be interpreted in the reverse storage order wrt the target order.
13207 This routine must only be called for GCC type nodes that correspond to
13208 Dwarf base (fundamental) types. */
13211 base_type_die (tree type
, bool reverse
)
13213 dw_die_ref base_type_result
;
13214 enum dwarf_type encoding
;
13215 bool fpt_used
= false;
13216 struct fixed_point_type_info fpt_info
;
13217 tree type_bias
= NULL_TREE
;
13219 /* If this is a subtype that should not be emitted as a subrange type,
13220 use the base type. See subrange_type_for_debug_p. */
13221 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
13222 type
= TREE_TYPE (type
);
13224 switch (TREE_CODE (type
))
13227 if ((dwarf_version
>= 4 || !dwarf_strict
)
13228 && TYPE_NAME (type
)
13229 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
13230 && DECL_IS_UNDECLARED_BUILTIN (TYPE_NAME (type
))
13231 && DECL_NAME (TYPE_NAME (type
)))
13233 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
13234 if (strcmp (name
, "char16_t") == 0
13235 || strcmp (name
, "char8_t") == 0
13236 || strcmp (name
, "char32_t") == 0)
13238 encoding
= DW_ATE_UTF
;
13242 if ((dwarf_version
>= 3 || !dwarf_strict
)
13243 && lang_hooks
.types
.get_fixed_point_type_info
)
13245 memset (&fpt_info
, 0, sizeof (fpt_info
));
13246 if (lang_hooks
.types
.get_fixed_point_type_info (type
, &fpt_info
))
13249 encoding
= ((TYPE_UNSIGNED (type
))
13250 ? DW_ATE_unsigned_fixed
13251 : DW_ATE_signed_fixed
);
13255 if (TYPE_STRING_FLAG (type
))
13257 if ((dwarf_version
>= 4 || !dwarf_strict
)
13259 && int_size_in_bytes (type
) == 4)
13260 encoding
= DW_ATE_UTF
;
13261 else if (TYPE_UNSIGNED (type
))
13262 encoding
= DW_ATE_unsigned_char
;
13264 encoding
= DW_ATE_signed_char
;
13266 else if (TYPE_UNSIGNED (type
))
13267 encoding
= DW_ATE_unsigned
;
13269 encoding
= DW_ATE_signed
;
13272 && lang_hooks
.types
.get_type_bias
)
13273 type_bias
= lang_hooks
.types
.get_type_bias (type
);
13277 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
13279 if (dwarf_version
>= 3 || !dwarf_strict
)
13280 encoding
= DW_ATE_decimal_float
;
13282 encoding
= DW_ATE_lo_user
;
13285 encoding
= DW_ATE_float
;
13288 case FIXED_POINT_TYPE
:
13289 if (!(dwarf_version
>= 3 || !dwarf_strict
))
13290 encoding
= DW_ATE_lo_user
;
13291 else if (TYPE_UNSIGNED (type
))
13292 encoding
= DW_ATE_unsigned_fixed
;
13294 encoding
= DW_ATE_signed_fixed
;
13297 /* Dwarf2 doesn't know anything about complex ints, so use
13298 a user defined type for it. */
13300 if (SCALAR_FLOAT_TYPE_P (TREE_TYPE (type
)))
13301 encoding
= DW_ATE_complex_float
;
13303 encoding
= DW_ATE_lo_user
;
13307 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
13308 encoding
= DW_ATE_boolean
;
13312 /* C23 _BitInt(N). */
13313 if (TYPE_UNSIGNED (type
))
13314 encoding
= DW_ATE_unsigned
;
13316 encoding
= DW_ATE_signed
;
13320 /* No other TREE_CODEs are Dwarf fundamental types. */
13321 gcc_unreachable ();
13324 base_type_result
= new_die_raw (DW_TAG_base_type
);
13326 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
13327 int_size_in_bytes (type
));
13328 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
13329 if (TREE_CODE (type
) == BITINT_TYPE
)
13330 add_AT_unsigned (base_type_result
, DW_AT_bit_size
, TYPE_PRECISION (type
));
13332 if (need_endianity_attribute_p (reverse
))
13333 add_AT_unsigned (base_type_result
, DW_AT_endianity
,
13334 BYTES_BIG_ENDIAN
? DW_END_little
: DW_END_big
);
13336 add_alignment_attribute (base_type_result
, type
);
13340 switch (fpt_info
.scale_factor_kind
)
13342 case fixed_point_scale_factor_binary
:
13343 add_AT_int (base_type_result
, DW_AT_binary_scale
,
13344 fpt_info
.scale_factor
.binary
);
13347 case fixed_point_scale_factor_decimal
:
13348 add_AT_int (base_type_result
, DW_AT_decimal_scale
,
13349 fpt_info
.scale_factor
.decimal
);
13352 case fixed_point_scale_factor_arbitrary
:
13353 /* Arbitrary scale factors cannot be described in standard DWARF. */
13356 /* Describe the scale factor as a rational constant. */
13357 const dw_die_ref scale_factor
13358 = new_die (DW_TAG_constant
, comp_unit_die (), type
);
13360 add_scalar_info (scale_factor
, DW_AT_GNU_numerator
,
13361 fpt_info
.scale_factor
.arbitrary
.numerator
,
13362 dw_scalar_form_constant
, NULL
);
13363 add_scalar_info (scale_factor
, DW_AT_GNU_denominator
,
13364 fpt_info
.scale_factor
.arbitrary
.denominator
,
13365 dw_scalar_form_constant
, NULL
);
13367 add_AT_die_ref (base_type_result
, DW_AT_small
, scale_factor
);
13372 gcc_unreachable ();
13377 add_scalar_info (base_type_result
, DW_AT_GNU_bias
, type_bias
,
13378 dw_scalar_form_constant
13379 | dw_scalar_form_exprloc
13380 | dw_scalar_form_reference
,
13383 return base_type_result
;
13386 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
13387 named 'auto' in its type: return true for it, false otherwise. */
13390 is_cxx_auto (tree type
)
13394 tree name
= TYPE_IDENTIFIER (type
);
13395 if (name
== get_identifier ("auto")
13396 || name
== get_identifier ("decltype(auto)"))
13402 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if the
13403 given input type is a Dwarf "fundamental" type. Otherwise return null. */
13406 is_base_type (tree type
)
13408 switch (TREE_CODE (type
))
13412 case FIXED_POINT_TYPE
:
13423 case QUAL_UNION_TYPE
:
13424 case ENUMERAL_TYPE
:
13425 case FUNCTION_TYPE
:
13428 case REFERENCE_TYPE
:
13436 if (is_cxx_auto (type
))
13438 gcc_unreachable ();
13442 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
13443 node, return the size in bits for the type if it is a constant, or else
13444 return the alignment for the type if the type's size is not constant, or
13445 else return BITS_PER_WORD if the type actually turns out to be an
13446 ERROR_MARK node. */
13448 static inline unsigned HOST_WIDE_INT
13449 simple_type_size_in_bits (const_tree type
)
13451 if (TREE_CODE (type
) == ERROR_MARK
)
13452 return BITS_PER_WORD
;
13453 else if (TYPE_SIZE (type
) == NULL_TREE
)
13455 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
13456 return tree_to_uhwi (TYPE_SIZE (type
));
13458 return TYPE_ALIGN (type
);
13461 /* Similarly, but return an offset_int instead of UHWI. */
13463 static inline offset_int
13464 offset_int_type_size_in_bits (const_tree type
)
13466 if (TREE_CODE (type
) == ERROR_MARK
)
13467 return BITS_PER_WORD
;
13468 else if (TYPE_SIZE (type
) == NULL_TREE
)
13470 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
13471 return wi::to_offset (TYPE_SIZE (type
));
13473 return TYPE_ALIGN (type
);
13476 /* Given a pointer to a tree node for a subrange type, return a pointer
13477 to a DIE that describes the given type. */
13480 subrange_type_die (tree type
, tree low
, tree high
, tree bias
,
13481 dw_die_ref context_die
)
13483 dw_die_ref subrange_die
;
13484 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
13486 if (context_die
== NULL
)
13487 context_die
= comp_unit_die ();
13489 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
13491 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
13493 /* The size of the subrange type and its base type do not match,
13494 so we need to generate a size attribute for the subrange type. */
13495 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
13498 add_alignment_attribute (subrange_die
, type
);
13501 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
, NULL
);
13503 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
, NULL
);
13504 if (bias
&& !dwarf_strict
)
13505 add_scalar_info (subrange_die
, DW_AT_GNU_bias
, bias
,
13506 dw_scalar_form_constant
13507 | dw_scalar_form_exprloc
13508 | dw_scalar_form_reference
,
13511 return subrange_die
;
13514 /* Returns the (const and/or volatile) cv_qualifiers associated with
13515 the decl node. This will normally be augmented with the
13516 cv_qualifiers of the underlying type in add_type_attribute. */
13519 decl_quals (const_tree decl
)
13521 return ((TREE_READONLY (decl
)
13522 /* The C++ front-end correctly marks reference-typed
13523 variables as readonly, but from a language (and debug
13524 info) standpoint they are not const-qualified. */
13525 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
13526 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
)
13527 | (TREE_THIS_VOLATILE (decl
)
13528 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
));
13531 /* Determine the TYPE whose qualifiers match the largest strict subset
13532 of the given TYPE_QUALS, and return its qualifiers. Ignore all
13533 qualifiers outside QUAL_MASK. */
13536 get_nearest_type_subqualifiers (tree type
, int type_quals
, int qual_mask
)
13539 int best_rank
= 0, best_qual
= 0, max_rank
;
13541 type_quals
&= qual_mask
;
13542 max_rank
= popcount_hwi (type_quals
) - 1;
13544 for (t
= TYPE_MAIN_VARIANT (type
); t
&& best_rank
< max_rank
;
13545 t
= TYPE_NEXT_VARIANT (t
))
13547 int q
= TYPE_QUALS (t
) & qual_mask
;
13549 if ((q
& type_quals
) == q
&& q
!= type_quals
13550 && check_base_type (t
, type
))
13552 int rank
= popcount_hwi (q
);
13554 if (rank
> best_rank
)
13565 struct dwarf_qual_info_t
{ int q
; enum dwarf_tag t
; };
13566 static const dwarf_qual_info_t dwarf_qual_info
[] =
13568 { TYPE_QUAL_CONST
, DW_TAG_const_type
},
13569 { TYPE_QUAL_VOLATILE
, DW_TAG_volatile_type
},
13570 { TYPE_QUAL_RESTRICT
, DW_TAG_restrict_type
},
13571 { TYPE_QUAL_ATOMIC
, DW_TAG_atomic_type
}
13573 static const unsigned int dwarf_qual_info_size
= ARRAY_SIZE (dwarf_qual_info
);
13575 /* If DIE is a qualified DIE of some base DIE with the same parent,
13576 return the base DIE, otherwise return NULL. Set MASK to the
13577 qualifiers added compared to the returned DIE. */
13580 qualified_die_p (dw_die_ref die
, int *mask
, unsigned int depth
)
13583 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13584 if (die
->die_tag
== dwarf_qual_info
[i
].t
)
13586 if (i
== dwarf_qual_info_size
)
13588 if (vec_safe_length (die
->die_attr
) != 1)
13590 dw_die_ref type
= get_AT_ref (die
, DW_AT_type
);
13591 if (type
== NULL
|| type
->die_parent
!= die
->die_parent
)
13593 *mask
|= dwarf_qual_info
[i
].q
;
13596 dw_die_ref ret
= qualified_die_p (type
, mask
, depth
- 1);
13603 /* If TYPE is long double or complex long double that
13604 should be emitted as artificial typedef to _Float128 or
13605 complex _Float128, return the type it should be emitted as.
13606 This is done in case the target already supports 16-byte
13607 composite floating point type (ibm_extended_format). */
13610 long_double_as_float128 (tree type
)
13612 if (type
!= long_double_type_node
13613 && type
!= complex_long_double_type_node
)
13616 machine_mode mode
, fmode
;
13617 if (TREE_CODE (type
) == COMPLEX_TYPE
)
13618 mode
= TYPE_MODE (TREE_TYPE (type
));
13620 mode
= TYPE_MODE (type
);
13621 if (known_eq (GET_MODE_SIZE (mode
), 16) && !MODE_COMPOSITE_P (mode
))
13622 FOR_EACH_MODE_IN_CLASS (fmode
, MODE_FLOAT
)
13623 if (known_eq (GET_MODE_SIZE (fmode
), 16)
13624 && MODE_COMPOSITE_P (fmode
))
13626 if (type
== long_double_type_node
)
13628 if (float128_type_node
13629 && (TYPE_MODE (float128_type_node
)
13630 == TYPE_MODE (type
)))
13631 return float128_type_node
;
13634 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
13635 if (COMPLEX_FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
13636 && (TYPE_MODE (COMPLEX_FLOATN_NX_TYPE_NODE (i
))
13637 == TYPE_MODE (type
)))
13638 return COMPLEX_FLOATN_NX_TYPE_NODE (i
);
13644 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
13645 entry that chains the modifiers specified by CV_QUALS in front of the
13646 given type. REVERSE is true if the type is to be interpreted in the
13647 reverse storage order wrt the target order. */
13650 modified_type_die (tree type
, int cv_quals
, bool reverse
,
13651 dw_die_ref context_die
)
13653 enum tree_code code
= TREE_CODE (type
);
13654 dw_die_ref mod_type_die
;
13655 dw_die_ref sub_die
= NULL
;
13656 tree item_type
= NULL
;
13657 tree qualified_type
;
13658 tree name
, low
, high
;
13659 dw_die_ref mod_scope
;
13660 struct array_descr_info info
;
13661 /* Only these cv-qualifiers are currently handled. */
13662 const int cv_qual_mask
= (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
13663 | TYPE_QUAL_RESTRICT
| TYPE_QUAL_ATOMIC
|
13664 ENCODE_QUAL_ADDR_SPACE(~0U));
13665 const bool reverse_base_type
13666 = need_endianity_attribute_p (reverse
) && is_base_type (type
);
13668 if (code
== ERROR_MARK
)
13671 if (lang_hooks
.types
.get_debug_type
)
13673 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
13675 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
13676 return modified_type_die (debug_type
, cv_quals
, reverse
, context_die
);
13679 cv_quals
&= cv_qual_mask
;
13681 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
13682 tag modifier (and not an attribute) old consumers won't be able
13684 if (dwarf_version
< 3)
13685 cv_quals
&= ~TYPE_QUAL_RESTRICT
;
13687 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
13688 if (dwarf_version
< 5)
13689 cv_quals
&= ~TYPE_QUAL_ATOMIC
;
13691 /* See if we already have the appropriately qualified variant of
13693 qualified_type
= get_qualified_type (type
, cv_quals
);
13695 if (qualified_type
== sizetype
)
13697 /* Try not to expose the internal sizetype type's name. */
13698 if (TYPE_NAME (qualified_type
)
13699 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
13701 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
13703 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
13704 && (TYPE_PRECISION (t
)
13705 == TYPE_PRECISION (qualified_type
))
13706 && (TYPE_UNSIGNED (t
)
13707 == TYPE_UNSIGNED (qualified_type
)));
13708 qualified_type
= t
;
13710 else if (qualified_type
== sizetype
13711 && TREE_CODE (sizetype
) == TREE_CODE (size_type_node
)
13712 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (size_type_node
)
13713 && TYPE_UNSIGNED (sizetype
) == TYPE_UNSIGNED (size_type_node
))
13714 qualified_type
= size_type_node
;
13715 if (type
== sizetype
)
13716 type
= qualified_type
;
13719 /* If we do, then we can just use its DIE, if it exists. */
13720 if (qualified_type
)
13722 mod_type_die
= lookup_type_die (qualified_type
);
13724 /* DW_AT_endianity doesn't come from a qualifier on the type, so it is
13725 dealt with specially: the DIE with the attribute, if it exists, is
13726 placed immediately after the regular DIE for the same base type. */
13728 && (!reverse_base_type
13729 || ((mod_type_die
= mod_type_die
->die_sib
) != NULL
13730 && get_AT_unsigned (mod_type_die
, DW_AT_endianity
))))
13731 return mod_type_die
;
13734 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
13736 /* Handle C typedef types. */
13738 && TREE_CODE (name
) == TYPE_DECL
13739 && DECL_ORIGINAL_TYPE (name
)
13740 && !DECL_ARTIFICIAL (name
))
13742 tree dtype
= TREE_TYPE (name
);
13744 /* Skip the typedef for base types with DW_AT_endianity, no big deal. */
13745 if (qualified_type
== dtype
&& !reverse_base_type
)
13747 tree origin
= decl_ultimate_origin (name
);
13749 /* Typedef variants that have an abstract origin don't get their own
13750 type DIE (see gen_typedef_die), so fall back on the ultimate
13751 abstract origin instead. */
13752 if (origin
!= NULL
&& origin
!= name
)
13753 return modified_type_die (TREE_TYPE (origin
), cv_quals
, reverse
,
13756 /* For a named type, use the typedef. */
13757 gen_type_die (qualified_type
, context_die
);
13758 return lookup_type_die (qualified_type
);
13762 int dquals
= TYPE_QUALS_NO_ADDR_SPACE (dtype
);
13763 dquals
&= cv_qual_mask
;
13764 if ((dquals
& ~cv_quals
) != TYPE_UNQUALIFIED
13765 || (cv_quals
== dquals
&& DECL_ORIGINAL_TYPE (name
) != type
))
13766 /* cv-unqualified version of named type. Just use
13767 the unnamed type to which it refers. */
13768 return modified_type_die (DECL_ORIGINAL_TYPE (name
), cv_quals
,
13769 reverse
, context_die
);
13770 /* Else cv-qualified version of named type; fall through. */
13774 mod_scope
= scope_die_for (type
, context_die
);
13778 int sub_quals
= 0, first_quals
= 0;
13780 dw_die_ref first
= NULL
, last
= NULL
;
13782 /* Determine a lesser qualified type that most closely matches
13783 this one. Then generate DW_TAG_* entries for the remaining
13785 sub_quals
= get_nearest_type_subqualifiers (type
, cv_quals
,
13787 if (sub_quals
&& use_debug_types
)
13789 bool needed
= false;
13790 /* If emitting type units, make sure the order of qualifiers
13791 is canonical. Thus, start from unqualified type if
13792 an earlier qualifier is missing in sub_quals, but some later
13793 one is present there. */
13794 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13795 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
13797 else if (needed
&& (dwarf_qual_info
[i
].q
& cv_quals
))
13803 mod_type_die
= modified_type_die (type
, sub_quals
, reverse
, context_die
);
13804 if (mod_scope
&& mod_type_die
&& mod_type_die
->die_parent
== mod_scope
)
13806 /* As not all intermediate qualified DIEs have corresponding
13807 tree types, ensure that qualified DIEs in the same scope
13808 as their DW_AT_type are emitted after their DW_AT_type,
13809 only with other qualified DIEs for the same type possibly
13810 in between them. Determine the range of such qualified
13811 DIEs now (first being the base type, last being corresponding
13812 last qualified DIE for it). */
13813 unsigned int count
= 0;
13814 first
= qualified_die_p (mod_type_die
, &first_quals
,
13815 dwarf_qual_info_size
);
13817 first
= mod_type_die
;
13818 gcc_assert ((first_quals
& ~sub_quals
) == 0);
13819 for (count
= 0, last
= first
;
13820 count
< (1U << dwarf_qual_info_size
);
13821 count
++, last
= last
->die_sib
)
13824 if (last
== mod_scope
->die_child
)
13826 if (qualified_die_p (last
->die_sib
, &quals
, dwarf_qual_info_size
)
13832 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13833 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
13836 if (first
&& first
!= last
)
13838 for (d
= first
->die_sib
; ; d
= d
->die_sib
)
13841 qualified_die_p (d
, &quals
, dwarf_qual_info_size
);
13842 if (quals
== (first_quals
| dwarf_qual_info
[i
].q
))
13858 d
= new_die_raw (dwarf_qual_info
[i
].t
);
13859 add_child_die_after (mod_scope
, d
, last
);
13863 d
= new_die (dwarf_qual_info
[i
].t
, mod_scope
, type
);
13865 add_AT_die_ref (d
, DW_AT_type
, mod_type_die
);
13867 first_quals
|= dwarf_qual_info
[i
].q
;
13870 else if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
)
13872 dwarf_tag tag
= DW_TAG_pointer_type
;
13873 if (code
== REFERENCE_TYPE
)
13875 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
13876 tag
= DW_TAG_rvalue_reference_type
;
13878 tag
= DW_TAG_reference_type
;
13880 mod_type_die
= new_die (tag
, mod_scope
, type
);
13882 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
13883 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
13884 add_alignment_attribute (mod_type_die
, type
);
13885 item_type
= TREE_TYPE (type
);
13887 addr_space_t as
= TYPE_ADDR_SPACE (item_type
);
13888 if (!ADDR_SPACE_GENERIC_P (as
))
13890 int action
= targetm
.addr_space
.debug (as
);
13893 /* Positive values indicate an address_class. */
13894 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, action
);
13898 /* Negative values indicate an (inverted) segment base reg. */
13900 = one_reg_loc_descriptor (~action
, VAR_INIT_STATUS_INITIALIZED
);
13901 add_AT_loc (mod_type_die
, DW_AT_segment
, d
);
13905 else if (code
== ARRAY_TYPE
13906 || (lang_hooks
.types
.get_array_descr_info
13907 && lang_hooks
.types
.get_array_descr_info (type
, &info
)))
13909 gen_type_die (type
, context_die
);
13910 return lookup_type_die (type
);
13912 else if (code
== INTEGER_TYPE
13913 && TREE_TYPE (type
) != NULL_TREE
13914 && subrange_type_for_debug_p (type
, &low
, &high
))
13916 tree bias
= NULL_TREE
;
13917 if (lang_hooks
.types
.get_type_bias
)
13918 bias
= lang_hooks
.types
.get_type_bias (type
);
13919 mod_type_die
= subrange_type_die (type
, low
, high
, bias
, context_die
);
13920 item_type
= TREE_TYPE (type
);
13922 else if (is_base_type (type
))
13924 /* If a target supports long double as different floating point
13925 modes with the same 16-byte size, use normal DW_TAG_base_type
13926 only for the composite (ibm_extended_real_format) type and
13927 for the other for the time being emit instead a "_Float128"
13928 or "complex _Float128" DW_TAG_base_type and a "long double"
13929 or "complex long double" typedef to it. */
13930 if (tree other_type
= long_double_as_float128 (type
))
13932 dw_die_ref other_die
;
13933 if (TYPE_NAME (other_type
))
13935 = modified_type_die (other_type
, TYPE_UNQUALIFIED
, reverse
,
13939 other_die
= base_type_die (type
, reverse
);
13940 add_child_die (comp_unit_die (), other_die
);
13941 add_name_attribute (other_die
,
13942 TREE_CODE (type
) == COMPLEX_TYPE
13943 ? "complex _Float128" : "_Float128");
13945 mod_type_die
= new_die_raw (DW_TAG_typedef
);
13946 add_AT_die_ref (mod_type_die
, DW_AT_type
, other_die
);
13949 mod_type_die
= base_type_die (type
, reverse
);
13951 /* The DIE with DW_AT_endianity is placed right after the naked DIE. */
13952 if (reverse_base_type
)
13954 dw_die_ref after_die
13955 = modified_type_die (type
, cv_quals
, false, context_die
);
13956 add_child_die_after (comp_unit_die (), mod_type_die
, after_die
);
13959 add_child_die (comp_unit_die (), mod_type_die
);
13961 add_pubtype (type
, mod_type_die
);
13965 gen_type_die (type
, context_die
);
13967 /* We have to get the type_main_variant here (and pass that to the
13968 `lookup_type_die' routine) because the ..._TYPE node we have
13969 might simply be a *copy* of some original type node (where the
13970 copy was created to help us keep track of typedef names) and
13971 that copy might have a different TYPE_UID from the original
13973 if (code
== FUNCTION_TYPE
|| code
== METHOD_TYPE
)
13975 /* For function/method types, can't just use type_main_variant here,
13976 because that can have different ref-qualifiers for C++,
13977 but try to canonicalize. */
13978 tree main
= TYPE_MAIN_VARIANT (type
);
13979 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
13980 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
13981 && check_base_type (t
, main
)
13982 && check_lang_type (t
, type
))
13983 return lookup_type_die (t
);
13984 return lookup_type_die (type
);
13986 /* Vectors have the debugging information in the type,
13987 not the main variant. */
13988 else if (code
== VECTOR_TYPE
)
13989 return lookup_type_die (type
);
13991 return lookup_type_die (type_main_variant (type
));
13994 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
13995 don't output a DW_TAG_typedef, since there isn't one in the
13996 user's program; just attach a DW_AT_name to the type.
13997 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
13998 if the base type already has the same name. */
14000 && ((TREE_CODE (name
) != TYPE_DECL
14001 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
14002 || (cv_quals
== TYPE_UNQUALIFIED
)))
14003 || (TREE_CODE (name
) == TYPE_DECL
14004 && TREE_TYPE (name
) == qualified_type
14005 && DECL_NAME (name
))))
14007 if (TREE_CODE (name
) == TYPE_DECL
)
14008 /* Could just call add_name_and_src_coords_attributes here,
14009 but since this is a builtin type it doesn't have any
14010 useful source coordinates anyway. */
14011 name
= DECL_NAME (name
);
14012 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
14014 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
14016 if (TREE_CODE (type
) == BITINT_TYPE
)
14018 char name_buf
[sizeof ("unsigned _BitInt(2147483647)")];
14019 snprintf (name_buf
, sizeof (name_buf
),
14020 "%s_BitInt(%d)", TYPE_UNSIGNED (type
) ? "unsigned " : "",
14021 TYPE_PRECISION (type
));
14022 add_name_attribute (mod_type_die
, name_buf
);
14026 /* This probably indicates a bug. */
14027 name
= TYPE_IDENTIFIER (type
);
14028 add_name_attribute (mod_type_die
,
14030 ? IDENTIFIER_POINTER (name
) : "__unknown__");
14034 if (qualified_type
&& !reverse_base_type
)
14035 equate_type_number_to_die (qualified_type
, mod_type_die
);
14038 /* We must do this after the equate_type_number_to_die call, in case
14039 this is a recursive type. This ensures that the modified_type_die
14040 recursion will terminate even if the type is recursive. Recursive
14041 types are possible in Ada. */
14042 sub_die
= modified_type_die (item_type
,
14043 TYPE_QUALS_NO_ADDR_SPACE (item_type
),
14047 if (sub_die
!= NULL
)
14048 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
14050 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
14051 if (TYPE_ARTIFICIAL (type
))
14052 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
14054 return mod_type_die
;
14057 /* Generate DIEs for the generic parameters of T.
14058 T must be either a generic type or a generic function.
14059 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
14062 gen_generic_params_dies (tree t
)
14066 dw_die_ref die
= NULL
;
14069 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
14073 die
= lookup_type_die (t
);
14074 else if (DECL_P (t
))
14075 die
= lookup_decl_die (t
);
14079 parms
= lang_hooks
.get_innermost_generic_parms (t
);
14081 /* T has no generic parameter. It means T is neither a generic type
14082 or function. End of story. */
14085 parms_num
= TREE_VEC_LENGTH (parms
);
14086 args
= lang_hooks
.get_innermost_generic_args (t
);
14087 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
14088 non_default
= int_cst_value (TREE_CHAIN (args
));
14090 non_default
= TREE_VEC_LENGTH (args
);
14091 for (i
= 0; i
< parms_num
; i
++)
14093 tree parm
, arg
, arg_pack_elems
;
14094 dw_die_ref parm_die
;
14096 parm
= TREE_VEC_ELT (parms
, i
);
14097 arg
= TREE_VEC_ELT (args
, i
);
14098 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
14099 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
14101 if (parm
&& TREE_VALUE (parm
) && arg
)
14103 /* If PARM represents a template parameter pack,
14104 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
14105 by DW_TAG_template_*_parameter DIEs for the argument
14106 pack elements of ARG. Note that ARG would then be
14107 an argument pack. */
14108 if (arg_pack_elems
)
14109 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
14113 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
14114 true /* emit name */, die
);
14115 if (i
>= non_default
)
14116 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
14121 /* Create and return a DIE for PARM which should be
14122 the representation of a generic type parameter.
14123 For instance, in the C++ front end, PARM would be a template parameter.
14124 ARG is the argument to PARM.
14125 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
14127 PARENT_DIE is the parent DIE which the new created DIE should be added to,
14128 as a child node. */
14131 generic_parameter_die (tree parm
, tree arg
,
14133 dw_die_ref parent_die
)
14135 dw_die_ref tmpl_die
= NULL
;
14136 const char *name
= NULL
;
14138 /* C++20 accepts class literals as template parameters, and var
14139 decls with initializers represent them. The VAR_DECLs would be
14140 rejected, but we can take the DECL_INITIAL constructor and
14141 attempt to expand it. */
14142 if (arg
&& VAR_P (arg
))
14143 arg
= DECL_INITIAL (arg
);
14145 if (!parm
|| !DECL_NAME (parm
) || !arg
)
14148 /* We support non-type generic parameters and arguments,
14149 type generic parameters and arguments, as well as
14150 generic generic parameters (a.k.a. template template parameters in C++)
14152 if (TREE_CODE (parm
) == PARM_DECL
)
14153 /* PARM is a nontype generic parameter */
14154 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
14155 else if (TREE_CODE (parm
) == TYPE_DECL
)
14156 /* PARM is a type generic parameter. */
14157 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
14158 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
14159 /* PARM is a generic generic parameter.
14160 Its DIE is a GNU extension. It shall have a
14161 DW_AT_name attribute to represent the name of the template template
14162 parameter, and a DW_AT_GNU_template_name attribute to represent the
14163 name of the template template argument. */
14164 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
14167 gcc_unreachable ();
14173 /* If PARM is a generic parameter pack, it means we are
14174 emitting debug info for a template argument pack element.
14175 In other terms, ARG is a template argument pack element.
14176 In that case, we don't emit any DW_AT_name attribute for
14180 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
14182 add_AT_string (tmpl_die
, DW_AT_name
, name
);
14185 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
14187 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
14188 TMPL_DIE should have a child DW_AT_type attribute that is set
14189 to the type of the argument to PARM, which is ARG.
14190 If PARM is a type generic parameter, TMPL_DIE should have a
14191 child DW_AT_type that is set to ARG. */
14192 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
14193 add_type_attribute (tmpl_die
, tmpl_type
,
14194 (TREE_THIS_VOLATILE (tmpl_type
)
14195 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
),
14196 false, parent_die
);
14200 /* So TMPL_DIE is a DIE representing a
14201 a generic generic template parameter, a.k.a template template
14202 parameter in C++ and arg is a template. */
14204 /* The DW_AT_GNU_template_name attribute of the DIE must be set
14205 to the name of the argument. */
14206 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
14208 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
14211 if (TREE_CODE (parm
) == PARM_DECL
)
14212 /* So PARM is a non-type generic parameter.
14213 DWARF3 5.6.8 says we must set a DW_AT_const_value child
14214 attribute of TMPL_DIE which value represents the value
14216 We must be careful here:
14217 The value of ARG might reference some function decls.
14218 We might currently be emitting debug info for a generic
14219 type and types are emitted before function decls, we don't
14220 know if the function decls referenced by ARG will actually be
14221 emitted after cgraph computations.
14222 So must defer the generation of the DW_AT_const_value to
14223 after cgraph is ready. */
14224 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
14230 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
14231 PARM_PACK must be a template parameter pack. The returned DIE
14232 will be child DIE of PARENT_DIE. */
14235 template_parameter_pack_die (tree parm_pack
,
14236 tree parm_pack_args
,
14237 dw_die_ref parent_die
)
14242 gcc_assert (parent_die
&& parm_pack
);
14244 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
14245 add_name_and_src_coords_attributes (die
, parm_pack
);
14246 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
14247 generic_parameter_die (parm_pack
,
14248 TREE_VEC_ELT (parm_pack_args
, j
),
14249 false /* Don't emit DW_AT_name */,
14254 /* Return the debugger register number described by a given RTL node. */
14256 static unsigned int
14257 debugger_reg_number (const_rtx rtl
)
14259 unsigned regno
= REGNO (rtl
);
14261 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
14263 #ifdef LEAF_REG_REMAP
14264 if (crtl
->uses_only_leaf_regs
)
14266 int leaf_reg
= LEAF_REG_REMAP (regno
);
14267 if (leaf_reg
!= -1)
14268 regno
= (unsigned) leaf_reg
;
14272 regno
= DEBUGGER_REGNO (regno
);
14273 gcc_assert (regno
!= INVALID_REGNUM
);
14277 /* Optionally add a DW_OP_piece term to a location description expression.
14278 DW_OP_piece is only added if the location description expression already
14279 doesn't end with DW_OP_piece. */
14282 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
14284 dw_loc_descr_ref loc
;
14286 if (*list_head
!= NULL
)
14288 /* Find the end of the chain. */
14289 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
14292 if (loc
->dw_loc_opc
!= DW_OP_piece
)
14293 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
14297 /* Return a location descriptor that designates a machine register or
14298 zero if there is none. */
14300 static dw_loc_descr_ref
14301 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
14305 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
14308 /* We only use "frame base" when we're sure we're talking about the
14309 post-prologue local stack frame. We do this by *not* running
14310 register elimination until this point, and recognizing the special
14311 argument pointer and soft frame pointer rtx's.
14312 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
14313 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
14315 ? lra_eliminate_regs (rtl
, VOIDmode
, NULL_RTX
)
14316 : eliminate_regs (rtl
, VOIDmode
, NULL_RTX
)) != rtl
)
14318 dw_loc_descr_ref result
= NULL
;
14320 if (dwarf_version
>= 4 || !dwarf_strict
)
14322 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
14325 add_loc_descr (&result
,
14326 new_loc_descr (DW_OP_stack_value
, 0, 0));
14331 regs
= targetm
.dwarf_register_span (rtl
);
14333 if (REG_NREGS (rtl
) > 1 || regs
)
14334 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
14337 unsigned int debugger_regnum
= debugger_reg_number (rtl
);
14338 if (debugger_regnum
== IGNORED_DWARF_REGNUM
)
14340 return one_reg_loc_descriptor (debugger_regnum
, initialized
);
14344 /* Return a location descriptor that designates a machine register for
14345 a given hard register number. */
14347 static dw_loc_descr_ref
14348 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
14350 dw_loc_descr_ref reg_loc_descr
;
14354 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
14356 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
14358 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14359 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14361 return reg_loc_descr
;
14364 /* Given an RTL of a register, return a location descriptor that
14365 designates a value that spans more than one register. */
14367 static dw_loc_descr_ref
14368 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
14369 enum var_init_status initialized
)
14372 dw_loc_descr_ref loc_result
= NULL
;
14374 /* Simple, contiguous registers. */
14375 if (regs
== NULL_RTX
)
14377 unsigned reg
= REGNO (rtl
);
14380 #ifdef LEAF_REG_REMAP
14381 if (crtl
->uses_only_leaf_regs
)
14383 int leaf_reg
= LEAF_REG_REMAP (reg
);
14384 if (leaf_reg
!= -1)
14385 reg
= (unsigned) leaf_reg
;
14389 gcc_assert ((unsigned) DEBUGGER_REGNO (reg
) == debugger_reg_number (rtl
));
14390 nregs
= REG_NREGS (rtl
);
14392 /* At present we only track constant-sized pieces. */
14393 if (!GET_MODE_SIZE (GET_MODE (rtl
)).is_constant (&size
))
14400 dw_loc_descr_ref t
;
14402 t
= one_reg_loc_descriptor (DEBUGGER_REGNO (reg
),
14403 VAR_INIT_STATUS_INITIALIZED
);
14404 add_loc_descr (&loc_result
, t
);
14405 add_loc_descr_op_piece (&loc_result
, size
);
14411 /* Now onto stupid register sets in non contiguous locations. */
14413 gcc_assert (GET_CODE (regs
) == PARALLEL
);
14415 /* At present we only track constant-sized pieces. */
14416 if (!GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0))).is_constant (&size
))
14420 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
14422 dw_loc_descr_ref t
;
14424 t
= one_reg_loc_descriptor (debugger_reg_number (XVECEXP (regs
, 0, i
)),
14425 VAR_INIT_STATUS_INITIALIZED
);
14426 add_loc_descr (&loc_result
, t
);
14427 add_loc_descr_op_piece (&loc_result
, size
);
14430 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14431 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14435 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
14437 /* Return a location descriptor that designates a constant i,
14438 as a compound operation from constant (i >> shift), constant shift
14441 static dw_loc_descr_ref
14442 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
14444 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
14445 add_loc_descr (&ret
, int_loc_descriptor (shift
));
14446 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
14450 /* Return a location descriptor that designates constant POLY_I. */
14452 static dw_loc_descr_ref
14453 int_loc_descriptor (poly_int64 poly_i
)
14455 enum dwarf_location_atom op
;
14458 if (!poly_i
.is_constant (&i
))
14460 /* Create location descriptions for the non-constant part and
14461 add any constant offset at the end. */
14462 dw_loc_descr_ref ret
= NULL
;
14463 HOST_WIDE_INT constant
= poly_i
.coeffs
[0];
14464 for (unsigned int j
= 1; j
< NUM_POLY_INT_COEFFS
; ++j
)
14466 HOST_WIDE_INT coeff
= poly_i
.coeffs
[j
];
14469 dw_loc_descr_ref start
= ret
;
14470 unsigned int factor
;
14472 unsigned int regno
= targetm
.dwarf_poly_indeterminate_value
14473 (j
, &factor
, &bias
);
14475 /* Add COEFF * ((REGNO / FACTOR) - BIAS) to the value:
14476 add COEFF * (REGNO / FACTOR) now and subtract
14477 COEFF * BIAS from the final constant part. */
14478 constant
-= coeff
* bias
;
14479 add_loc_descr (&ret
, new_reg_loc_descr (regno
, 0));
14480 if (coeff
% factor
== 0)
14484 int amount
= exact_log2 (factor
);
14485 gcc_assert (amount
>= 0);
14486 add_loc_descr (&ret
, int_loc_descriptor (amount
));
14487 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
14491 add_loc_descr (&ret
, int_loc_descriptor (coeff
));
14492 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
14495 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
14498 loc_descr_plus_const (&ret
, constant
);
14502 /* Pick the smallest representation of a constant, rather than just
14503 defaulting to the LEB encoding. */
14506 int clz
= clz_hwi (i
);
14507 int ctz
= ctz_hwi (i
);
14509 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
14510 else if (i
<= 0xff)
14511 op
= DW_OP_const1u
;
14512 else if (i
<= 0xffff)
14513 op
= DW_OP_const2u
;
14514 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
14515 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
14516 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
14517 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
14518 while DW_OP_const4u is 5 bytes. */
14519 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
14520 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14521 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
14522 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
14523 while DW_OP_const4u is 5 bytes. */
14524 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
14526 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
14527 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
14530 /* As i >= 2**31, the double cast above will yield a negative number.
14531 Since wrapping is defined in DWARF expressions we can output big
14532 positive integers as small negative ones, regardless of the size
14535 Here, since the evaluator will handle 32-bit values and since i >=
14536 2**31, we know it's going to be interpreted as a negative literal:
14537 store it this way if we can do better than 5 bytes this way. */
14538 return int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
14540 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14541 op
= DW_OP_const4u
;
14543 /* Past this point, i >= 0x100000000 and thus DW_OP_constu will take at
14544 least 6 bytes: see if we can do better before falling back to it. */
14545 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14546 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
14547 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes. */
14548 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
14549 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
14550 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
14551 >= HOST_BITS_PER_WIDE_INT
)
14552 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
14553 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes. */
14554 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
14555 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
14556 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
14557 && size_of_uleb128 (i
) > 6)
14558 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
14559 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
14566 op
= DW_OP_const1s
;
14567 else if (i
>= -0x8000)
14568 op
= DW_OP_const2s
;
14569 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
14571 if (size_of_int_loc_descriptor (i
) < 5)
14573 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
14574 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14577 op
= DW_OP_const4s
;
14581 if (size_of_int_loc_descriptor (i
)
14582 < (unsigned long) 1 + size_of_sleb128 (i
))
14584 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
14585 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14592 return new_loc_descr (op
, i
, 0);
14595 /* Likewise, for unsigned constants. */
14597 static dw_loc_descr_ref
14598 uint_loc_descriptor (unsigned HOST_WIDE_INT i
)
14600 const unsigned HOST_WIDE_INT max_int
= INTTYPE_MAXIMUM (HOST_WIDE_INT
);
14601 const unsigned HOST_WIDE_INT max_uint
14602 = INTTYPE_MAXIMUM (unsigned HOST_WIDE_INT
);
14604 /* If possible, use the clever signed constants handling. */
14606 return int_loc_descriptor ((HOST_WIDE_INT
) i
);
14608 /* Here, we are left with positive numbers that cannot be represented as
14609 HOST_WIDE_INT, i.e.:
14610 max (HOST_WIDE_INT) < i <= max (unsigned HOST_WIDE_INT)
14612 Using DW_OP_const4/8/./u operation to encode them consumes a lot of bytes
14613 whereas may be better to output a negative integer: thanks to integer
14614 wrapping, we know that:
14615 x = x - 2 ** DWARF2_ADDR_SIZE
14616 = x - 2 * (max (HOST_WIDE_INT) + 1)
14617 So numbers close to max (unsigned HOST_WIDE_INT) could be represented as
14618 small negative integers. Let's try that in cases it will clearly improve
14619 the encoding: there is no gain turning DW_OP_const4u into
14621 if (DWARF2_ADDR_SIZE
* 8 == HOST_BITS_PER_WIDE_INT
14622 && ((DWARF2_ADDR_SIZE
== 4 && i
> max_uint
- 0x8000)
14623 || (DWARF2_ADDR_SIZE
== 8 && i
> max_uint
- 0x80000000)))
14625 const unsigned HOST_WIDE_INT first_shift
= i
- max_int
- 1;
14627 /* Now, -1 < first_shift <= max (HOST_WIDE_INT)
14628 i.e. 0 <= first_shift <= max (HOST_WIDE_INT). */
14629 const HOST_WIDE_INT second_shift
14630 = (HOST_WIDE_INT
) first_shift
- (HOST_WIDE_INT
) max_int
- 1;
14632 /* So we finally have:
14633 -max (HOST_WIDE_INT) - 1 <= second_shift <= -1.
14634 i.e. min (HOST_WIDE_INT) <= second_shift < 0. */
14635 return int_loc_descriptor (second_shift
);
14638 /* Last chance: fallback to a simple constant operation. */
14639 return new_loc_descr
14640 ((HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14646 /* Generate and return a location description that computes the unsigned
14647 comparison of the two stack top entries (a OP b where b is the top-most
14648 entry and a is the second one). The KIND of comparison can be LT_EXPR,
14649 LE_EXPR, GT_EXPR or GE_EXPR. */
14651 static dw_loc_descr_ref
14652 uint_comparison_loc_list (enum tree_code kind
)
14654 enum dwarf_location_atom op
, flip_op
;
14655 dw_loc_descr_ref ret
, bra_node
, jmp_node
, tmp
;
14672 gcc_unreachable ();
14675 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14676 jmp_node
= new_loc_descr (DW_OP_skip
, 0, 0);
14678 /* Until DWARFv4, operations all work on signed integers. It is nevertheless
14679 possible to perform unsigned comparisons: we just have to distinguish
14682 1. when a and b have the same sign (as signed integers); then we should
14683 return: a OP(signed) b;
14685 2. when a is a negative signed integer while b is a positive one, then a
14686 is a greater unsigned integer than b; likewise when a and b's roles
14689 So first, compare the sign of the two operands. */
14690 ret
= new_loc_descr (DW_OP_over
, 0, 0);
14691 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
14692 add_loc_descr (&ret
, new_loc_descr (DW_OP_xor
, 0, 0));
14693 /* If they have different signs (i.e. they have different sign bits), then
14694 the stack top value has now the sign bit set and thus it's smaller than
14696 add_loc_descr (&ret
, new_loc_descr (DW_OP_lit0
, 0, 0));
14697 add_loc_descr (&ret
, new_loc_descr (DW_OP_lt
, 0, 0));
14698 add_loc_descr (&ret
, bra_node
);
14700 /* We are in case 1. At this point, we know both operands have the same
14701 sign, to it's safe to use the built-in signed comparison. */
14702 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14703 add_loc_descr (&ret
, jmp_node
);
14705 /* We are in case 2. Here, we know both operands do not have the same sign,
14706 so we have to flip the signed comparison. */
14707 flip_op
= (kind
== LT_EXPR
|| kind
== LE_EXPR
) ? DW_OP_gt
: DW_OP_lt
;
14708 tmp
= new_loc_descr (flip_op
, 0, 0);
14709 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14710 bra_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14711 add_loc_descr (&ret
, tmp
);
14713 /* This dummy operation is necessary to make the two branches join. */
14714 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
14715 jmp_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14716 jmp_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14717 add_loc_descr (&ret
, tmp
);
14722 /* Likewise, but takes the location description lists (might be destructive on
14723 them). Return NULL if either is NULL or if concatenation fails. */
14725 static dw_loc_list_ref
14726 loc_list_from_uint_comparison (dw_loc_list_ref left
, dw_loc_list_ref right
,
14727 enum tree_code kind
)
14729 if (left
== NULL
|| right
== NULL
)
14732 add_loc_list (&left
, right
);
14736 add_loc_descr_to_each (left
, uint_comparison_loc_list (kind
));
14740 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
14741 without actually allocating it. */
14743 static unsigned long
14744 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
14746 return size_of_int_loc_descriptor (i
>> shift
)
14747 + size_of_int_loc_descriptor (shift
)
14751 /* Return size_of_locs (int_loc_descriptor (i)) without
14752 actually allocating it. */
14754 static unsigned long
14755 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
14764 else if (i
<= 0xff)
14766 else if (i
<= 0xffff)
14770 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
14771 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
14772 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14774 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14775 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
14776 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14778 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
14779 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
14781 return size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
14782 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14784 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
14785 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14786 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
14787 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14789 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
14790 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
14791 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14793 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
14794 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
14796 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14805 else if (i
>= -0x8000)
14807 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
14809 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
14811 s
= size_of_int_loc_descriptor (-i
) + 1;
14819 unsigned long r
= 1 + size_of_sleb128 (i
);
14820 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
14822 s
= size_of_int_loc_descriptor (-i
) + 1;
14831 /* Return loc description representing "address" of integer value.
14832 This can appear only as toplevel expression. */
14834 static dw_loc_descr_ref
14835 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
14838 dw_loc_descr_ref loc_result
= NULL
;
14840 if (!(dwarf_version
>= 4 || !dwarf_strict
))
14843 litsize
= size_of_int_loc_descriptor (i
);
14844 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
14845 is more compact. For DW_OP_stack_value we need:
14846 litsize + 1 (DW_OP_stack_value)
14847 and for DW_OP_implicit_value:
14848 1 (DW_OP_implicit_value) + 1 (length) + size. */
14849 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
14851 loc_result
= int_loc_descriptor (i
);
14852 add_loc_descr (&loc_result
,
14853 new_loc_descr (DW_OP_stack_value
, 0, 0));
14857 loc_result
= new_loc_descr (DW_OP_implicit_value
,
14859 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
14860 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
14864 /* Return a location descriptor that designates a base+offset location. */
14866 static dw_loc_descr_ref
14867 based_loc_descr (rtx reg
, poly_int64 offset
,
14868 enum var_init_status initialized
)
14870 unsigned int regno
;
14871 dw_loc_descr_ref result
;
14872 dw_fde_ref fde
= cfun
->fde
;
14874 /* We only use "frame base" when we're sure we're talking about the
14875 post-prologue local stack frame. We do this by *not* running
14876 register elimination until this point, and recognizing the special
14877 argument pointer and soft frame pointer rtx's. */
14878 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
14880 rtx elim
= (ira_use_lra_p
14881 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
14882 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
14886 /* Allow hard frame pointer here even if frame pointer
14887 isn't used since hard frame pointer is encoded with
14888 DW_OP_fbreg which uses the DW_AT_frame_base attribute,
14889 not hard frame pointer directly. */
14890 elim
= strip_offset_and_add (elim
, &offset
);
14891 gcc_assert (elim
== hard_frame_pointer_rtx
14892 || elim
== stack_pointer_rtx
);
14894 /* If drap register is used to align stack, use frame
14895 pointer + offset to access stack variables. If stack
14896 is aligned without drap, use stack pointer + offset to
14897 access stack variables. */
14898 if (crtl
->stack_realign_tried
14899 && reg
== frame_pointer_rtx
)
14902 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
14903 ? HARD_FRAME_POINTER_REGNUM
14905 return new_reg_loc_descr (base_reg
, offset
);
14908 gcc_assert (frame_pointer_fb_offset_valid
);
14909 offset
+= frame_pointer_fb_offset
;
14910 HOST_WIDE_INT const_offset
;
14911 if (offset
.is_constant (&const_offset
))
14912 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
14915 dw_loc_descr_ref ret
= new_loc_descr (DW_OP_fbreg
, 0, 0);
14916 loc_descr_plus_const (&ret
, offset
);
14922 regno
= REGNO (reg
);
14923 #ifdef LEAF_REG_REMAP
14924 if (crtl
->uses_only_leaf_regs
)
14926 int leaf_reg
= LEAF_REG_REMAP (regno
);
14927 if (leaf_reg
!= -1)
14928 regno
= (unsigned) leaf_reg
;
14931 regno
= DWARF_FRAME_REGNUM (regno
);
14933 HOST_WIDE_INT const_offset
;
14934 if (!optimize
&& fde
14935 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
)
14936 && offset
.is_constant (&const_offset
))
14938 /* Use cfa+offset to represent the location of arguments passed
14939 on the stack when drap is used to align stack.
14940 Only do this when not optimizing, for optimized code var-tracking
14941 is supposed to track where the arguments live and the register
14942 used as vdrap or drap in some spot might be used for something
14943 else in other part of the routine. */
14944 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
14947 result
= new_reg_loc_descr (regno
, offset
);
14949 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14950 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14955 /* Return true if this RTL expression describes a base+offset calculation. */
14958 is_based_loc (const_rtx rtl
)
14960 return (GET_CODE (rtl
) == PLUS
14961 && ((REG_P (XEXP (rtl
, 0))
14962 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
14963 && CONST_INT_P (XEXP (rtl
, 1)))));
14966 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
14969 static dw_loc_descr_ref
14970 tls_mem_loc_descriptor (rtx mem
)
14973 dw_loc_descr_ref loc_result
;
14975 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
14978 base
= get_base_address (MEM_EXPR (mem
));
14981 || !DECL_THREAD_LOCAL_P (base
))
14984 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1, NULL
);
14985 if (loc_result
== NULL
)
14988 if (maybe_ne (MEM_OFFSET (mem
), 0))
14989 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
14994 /* Output debug info about reason why we failed to expand expression as dwarf
14998 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
15000 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
15002 fprintf (dump_file
, "Failed to expand as dwarf: ");
15004 print_generic_expr (dump_file
, expr
, dump_flags
);
15007 fprintf (dump_file
, "\n");
15008 print_rtl (dump_file
, rtl
);
15010 fprintf (dump_file
, "\nReason: %s\n", reason
);
15014 /* Helper function for const_ok_for_output. */
15017 const_ok_for_output_1 (rtx rtl
)
15019 if (targetm
.const_not_ok_for_debug_p (rtl
))
15021 if (GET_CODE (rtl
) != UNSPEC
)
15023 expansion_failed (NULL_TREE
, rtl
,
15024 "Expression rejected for debug by the backend.\n");
15028 /* If delegitimize_address couldn't do anything with the UNSPEC, and
15029 the target hook doesn't explicitly allow it in debug info, assume
15030 we can't express it in the debug info. */
15031 /* Don't complain about TLS UNSPECs, those are just too hard to
15032 delegitimize. Note this could be a non-decl SYMBOL_REF such as
15033 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
15034 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
15036 && (XVECLEN (rtl
, 0) == 0
15037 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
15038 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
))
15039 inform (current_function_decl
15040 ? DECL_SOURCE_LOCATION (current_function_decl
)
15041 : UNKNOWN_LOCATION
,
15042 #if NUM_UNSPEC_VALUES > 0
15043 "non-delegitimized UNSPEC %s (%d) found in variable location",
15044 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
15045 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
15047 "non-delegitimized UNSPEC %d found in variable location",
15050 expansion_failed (NULL_TREE
, rtl
,
15051 "UNSPEC hasn't been delegitimized.\n");
15055 if (CONST_POLY_INT_P (rtl
))
15058 /* FIXME: Refer to PR60655. It is possible for simplification
15059 of rtl expressions in var tracking to produce such expressions.
15060 We should really identify / validate expressions
15061 enclosed in CONST that can be handled by assemblers on various
15062 targets and only handle legitimate cases here. */
15063 switch (GET_CODE (rtl
))
15072 /* Make sure SYMBOL_REFs/UNSPECs are at most in one of the
15074 subrtx_var_iterator::array_type array
;
15075 bool first
= false;
15076 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
15077 if (SYMBOL_REF_P (*iter
)
15079 || GET_CODE (*iter
) == UNSPEC
)
15086 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 1), ALL
)
15087 if (SYMBOL_REF_P (*iter
)
15089 || GET_CODE (*iter
) == UNSPEC
)
15095 /* Disallow negation of SYMBOL_REFs or UNSPECs when they
15096 appear in the second operand of MINUS. */
15097 subrtx_var_iterator::array_type array
;
15098 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 1), ALL
)
15099 if (SYMBOL_REF_P (*iter
)
15101 || GET_CODE (*iter
) == UNSPEC
)
15109 if (CONSTANT_POOL_ADDRESS_P (rtl
))
15112 get_pool_constant_mark (rtl
, &marked
);
15113 /* If all references to this pool constant were optimized away,
15114 it was not output and thus we can't represent it. */
15117 expansion_failed (NULL_TREE
, rtl
,
15118 "Constant was removed from constant pool.\n");
15123 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
15126 /* Avoid references to external symbols in debug info, on several targets
15127 the linker might even refuse to link when linking a shared library,
15128 and in many other cases the relocations for .debug_info/.debug_loc are
15129 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
15130 to be defined within the same shared library or executable are fine. */
15131 if (SYMBOL_REF_EXTERNAL_P (rtl
))
15133 tree decl
= SYMBOL_REF_DECL (rtl
);
15135 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
15137 expansion_failed (NULL_TREE
, rtl
,
15138 "Symbol not defined in current TU.\n");
15146 /* Return true if constant RTL can be emitted in DW_OP_addr or
15147 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
15148 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
15151 const_ok_for_output (rtx rtl
)
15153 if (GET_CODE (rtl
) == SYMBOL_REF
)
15154 return const_ok_for_output_1 (rtl
);
15156 if (GET_CODE (rtl
) == CONST
)
15158 subrtx_var_iterator::array_type array
;
15159 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
15160 if (!const_ok_for_output_1 (*iter
))
15168 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
15169 if possible, NULL otherwise. */
15172 base_type_for_mode (machine_mode mode
, bool unsignedp
)
15174 dw_die_ref type_die
;
15175 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
15179 switch (TREE_CODE (type
))
15187 type_die
= lookup_type_die (type
);
15189 type_die
= modified_type_die (type
, TYPE_UNQUALIFIED
, false,
15191 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
15196 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
15197 type matching MODE, or, if MODE is narrower than or as wide as
15198 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
15201 static dw_loc_descr_ref
15202 convert_descriptor_to_mode (scalar_int_mode mode
, dw_loc_descr_ref op
)
15204 machine_mode outer_mode
= mode
;
15205 dw_die_ref type_die
;
15206 dw_loc_descr_ref cvt
;
15208 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
15210 add_loc_descr (&op
, new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0));
15213 type_die
= base_type_for_mode (outer_mode
, 1);
15214 if (type_die
== NULL
)
15216 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15217 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15218 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15219 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15220 add_loc_descr (&op
, cvt
);
15224 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
15226 static dw_loc_descr_ref
15227 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
15228 dw_loc_descr_ref op1
)
15230 dw_loc_descr_ref ret
= op0
;
15231 add_loc_descr (&ret
, op1
);
15232 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
15233 if (STORE_FLAG_VALUE
!= 1)
15235 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
15236 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
15241 /* Subroutine of scompare_loc_descriptor for the case in which we're
15242 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
15243 and in which OP_MODE is bigger than DWARF2_ADDR_SIZE. */
15245 static dw_loc_descr_ref
15246 scompare_loc_descriptor_wide (enum dwarf_location_atom op
,
15247 scalar_int_mode op_mode
,
15248 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
15250 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
15251 dw_loc_descr_ref cvt
;
15253 if (type_die
== NULL
)
15255 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15256 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15257 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15258 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15259 add_loc_descr (&op0
, cvt
);
15260 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15261 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15262 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15263 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15264 add_loc_descr (&op1
, cvt
);
15265 return compare_loc_descriptor (op
, op0
, op1
);
15268 /* Subroutine of scompare_loc_descriptor for the case in which we're
15269 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
15270 and in which OP_MODE is smaller than DWARF2_ADDR_SIZE. */
15272 static dw_loc_descr_ref
15273 scompare_loc_descriptor_narrow (enum dwarf_location_atom op
, rtx rtl
,
15274 scalar_int_mode op_mode
,
15275 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
15277 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
15278 /* For eq/ne, if the operands are known to be zero-extended,
15279 there is no need to do the fancy shifting up. */
15280 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
15282 dw_loc_descr_ref last0
, last1
;
15283 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
15285 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
15287 /* deref_size zero extends, and for constants we can check
15288 whether they are zero extended or not. */
15289 if (((last0
->dw_loc_opc
== DW_OP_deref_size
15290 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
15291 || (CONST_INT_P (XEXP (rtl
, 0))
15292 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
15293 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
15294 && ((last1
->dw_loc_opc
== DW_OP_deref_size
15295 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
15296 || (CONST_INT_P (XEXP (rtl
, 1))
15297 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
15298 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
15299 return compare_loc_descriptor (op
, op0
, op1
);
15301 /* EQ/NE comparison against constant in narrower type than
15302 DWARF2_ADDR_SIZE can be performed either as
15303 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
15306 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
15307 DW_OP_{eq,ne}. Pick whatever is shorter. */
15308 if (CONST_INT_P (XEXP (rtl
, 1))
15309 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
15310 && (size_of_int_loc_descriptor (shift
) + 1
15311 + size_of_int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
)
15312 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
15313 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
15314 & GET_MODE_MASK (op_mode
))))
15316 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
15317 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
15318 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
15319 & GET_MODE_MASK (op_mode
));
15320 return compare_loc_descriptor (op
, op0
, op1
);
15323 add_loc_descr (&op0
, int_loc_descriptor (shift
));
15324 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
15325 if (CONST_INT_P (XEXP (rtl
, 1)))
15326 op1
= int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
);
15329 add_loc_descr (&op1
, int_loc_descriptor (shift
));
15330 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
15332 return compare_loc_descriptor (op
, op0
, op1
);
15335 /* Return location descriptor for signed comparison OP RTL. */
15337 static dw_loc_descr_ref
15338 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
15339 machine_mode mem_mode
)
15341 machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
15342 dw_loc_descr_ref op0
, op1
;
15344 if (op_mode
== VOIDmode
)
15345 op_mode
= GET_MODE (XEXP (rtl
, 1));
15346 if (op_mode
== VOIDmode
)
15349 scalar_int_mode int_op_mode
;
15351 && dwarf_version
< 5
15352 && (!is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
)
15353 || GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
))
15356 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
15357 VAR_INIT_STATUS_INITIALIZED
);
15358 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
15359 VAR_INIT_STATUS_INITIALIZED
);
15361 if (op0
== NULL
|| op1
== NULL
)
15364 if (is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
))
15366 if (GET_MODE_SIZE (int_op_mode
) < DWARF2_ADDR_SIZE
)
15367 return scompare_loc_descriptor_narrow (op
, rtl
, int_op_mode
, op0
, op1
);
15369 if (GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
)
15370 return scompare_loc_descriptor_wide (op
, int_op_mode
, op0
, op1
);
15372 return compare_loc_descriptor (op
, op0
, op1
);
15375 /* Return location descriptor for unsigned comparison OP RTL. */
15377 static dw_loc_descr_ref
15378 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
15379 machine_mode mem_mode
)
15381 dw_loc_descr_ref op0
, op1
;
15383 machine_mode test_op_mode
= GET_MODE (XEXP (rtl
, 0));
15384 if (test_op_mode
== VOIDmode
)
15385 test_op_mode
= GET_MODE (XEXP (rtl
, 1));
15387 scalar_int_mode op_mode
;
15388 if (!is_a
<scalar_int_mode
> (test_op_mode
, &op_mode
))
15392 && dwarf_version
< 5
15393 && GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
15396 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
15397 VAR_INIT_STATUS_INITIALIZED
);
15398 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
15399 VAR_INIT_STATUS_INITIALIZED
);
15401 if (op0
== NULL
|| op1
== NULL
)
15404 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
15406 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
15407 dw_loc_descr_ref last0
, last1
;
15408 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
15410 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
15412 if (CONST_INT_P (XEXP (rtl
, 0)))
15413 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
15414 /* deref_size zero extends, so no need to mask it again. */
15415 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
15416 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
15418 add_loc_descr (&op0
, int_loc_descriptor (mask
));
15419 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
15421 if (CONST_INT_P (XEXP (rtl
, 1)))
15422 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
15423 /* deref_size zero extends, so no need to mask it again. */
15424 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
15425 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
15427 add_loc_descr (&op1
, int_loc_descriptor (mask
));
15428 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
15431 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
15433 HOST_WIDE_INT bias
= 1;
15434 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
15435 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
15436 if (CONST_INT_P (XEXP (rtl
, 1)))
15437 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
15438 + INTVAL (XEXP (rtl
, 1)));
15440 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
15443 return compare_loc_descriptor (op
, op0
, op1
);
15446 /* Return location descriptor for {U,S}{MIN,MAX}. */
15448 static dw_loc_descr_ref
15449 minmax_loc_descriptor (rtx rtl
, machine_mode mode
,
15450 machine_mode mem_mode
)
15452 enum dwarf_location_atom op
;
15453 dw_loc_descr_ref op0
, op1
, ret
;
15454 dw_loc_descr_ref bra_node
, drop_node
;
15456 scalar_int_mode int_mode
;
15458 && dwarf_version
< 5
15459 && (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15460 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
))
15463 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15464 VAR_INIT_STATUS_INITIALIZED
);
15465 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15466 VAR_INIT_STATUS_INITIALIZED
);
15468 if (op0
== NULL
|| op1
== NULL
)
15471 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
15472 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
15473 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
15474 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
15476 /* Checked by the caller. */
15477 int_mode
= as_a
<scalar_int_mode
> (mode
);
15478 if (GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
15480 HOST_WIDE_INT mask
= GET_MODE_MASK (int_mode
);
15481 add_loc_descr (&op0
, int_loc_descriptor (mask
));
15482 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
15483 add_loc_descr (&op1
, int_loc_descriptor (mask
));
15484 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
15486 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
15488 HOST_WIDE_INT bias
= 1;
15489 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
15490 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
15491 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
15494 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15495 && GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
15497 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (int_mode
)) * BITS_PER_UNIT
;
15498 add_loc_descr (&op0
, int_loc_descriptor (shift
));
15499 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
15500 add_loc_descr (&op1
, int_loc_descriptor (shift
));
15501 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
15503 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15504 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15506 dw_die_ref type_die
= base_type_for_mode (int_mode
, 0);
15507 dw_loc_descr_ref cvt
;
15508 if (type_die
== NULL
)
15510 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15511 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15512 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15513 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15514 add_loc_descr (&op0
, cvt
);
15515 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15516 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15517 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15518 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15519 add_loc_descr (&op1
, cvt
);
15522 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
15527 add_loc_descr (&ret
, op1
);
15528 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
15529 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
15530 add_loc_descr (&ret
, bra_node
);
15531 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15532 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
15533 add_loc_descr (&ret
, drop_node
);
15534 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15535 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
15536 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
15537 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15538 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15539 ret
= convert_descriptor_to_mode (int_mode
, ret
);
15543 /* Helper function for mem_loc_descriptor. Perform OP binary op,
15544 but after converting arguments to type_die, afterwards
15545 convert back to unsigned. */
15547 static dw_loc_descr_ref
15548 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
15549 scalar_int_mode mode
, machine_mode mem_mode
)
15551 dw_loc_descr_ref cvt
, op0
, op1
;
15553 if (type_die
== NULL
)
15555 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15556 VAR_INIT_STATUS_INITIALIZED
);
15557 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15558 VAR_INIT_STATUS_INITIALIZED
);
15559 if (op0
== NULL
|| op1
== NULL
)
15561 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15562 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15563 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15564 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15565 add_loc_descr (&op0
, cvt
);
15566 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15567 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15568 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15569 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15570 add_loc_descr (&op1
, cvt
);
15571 add_loc_descr (&op0
, op1
);
15572 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
15573 return convert_descriptor_to_mode (mode
, op0
);
15576 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
15577 const0 is DW_OP_lit0 or corresponding typed constant,
15578 const1 is DW_OP_lit1 or corresponding typed constant
15579 and constMSB is constant with just the MSB bit set
15581 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
15582 L1: const0 DW_OP_swap
15583 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
15584 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15589 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
15590 L1: const0 DW_OP_swap
15591 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
15592 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15597 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
15598 L1: const1 DW_OP_swap
15599 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
15600 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15604 static dw_loc_descr_ref
15605 clz_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15606 machine_mode mem_mode
)
15608 dw_loc_descr_ref op0
, ret
, tmp
;
15609 HOST_WIDE_INT valv
;
15610 dw_loc_descr_ref l1jump
, l1label
;
15611 dw_loc_descr_ref l2jump
, l2label
;
15612 dw_loc_descr_ref l3jump
, l3label
;
15613 dw_loc_descr_ref l4jump
, l4label
;
15616 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
15619 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15620 VAR_INIT_STATUS_INITIALIZED
);
15624 if (GET_CODE (rtl
) == CLZ
)
15626 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
15627 valv
= GET_MODE_BITSIZE (mode
);
15629 else if (GET_CODE (rtl
) == FFS
)
15631 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
15632 valv
= GET_MODE_BITSIZE (mode
);
15633 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15634 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15635 add_loc_descr (&ret
, l1jump
);
15636 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
15637 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
15638 VAR_INIT_STATUS_INITIALIZED
);
15641 add_loc_descr (&ret
, tmp
);
15642 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15643 add_loc_descr (&ret
, l4jump
);
15644 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
15645 ? const1_rtx
: const0_rtx
,
15647 VAR_INIT_STATUS_INITIALIZED
);
15648 if (l1label
== NULL
)
15650 add_loc_descr (&ret
, l1label
);
15651 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15652 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
15653 add_loc_descr (&ret
, l2label
);
15654 if (GET_CODE (rtl
) != CLZ
)
15656 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
15657 msb
= GEN_INT (HOST_WIDE_INT_1U
15658 << (GET_MODE_BITSIZE (mode
) - 1));
15660 msb
= immed_wide_int_const
15661 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode
) - 1,
15662 GET_MODE_PRECISION (mode
)), mode
);
15663 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
15664 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
15665 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
15666 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
15668 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
15669 VAR_INIT_STATUS_INITIALIZED
);
15672 add_loc_descr (&ret
, tmp
);
15673 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15674 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15675 add_loc_descr (&ret
, l3jump
);
15676 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15677 VAR_INIT_STATUS_INITIALIZED
);
15680 add_loc_descr (&ret
, tmp
);
15681 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
15682 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
15683 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15684 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
15685 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15686 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15687 add_loc_descr (&ret
, l2jump
);
15688 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
15689 add_loc_descr (&ret
, l3label
);
15690 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
15691 add_loc_descr (&ret
, l4label
);
15692 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15693 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15694 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15695 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15696 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15697 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
15698 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15699 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
15703 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
15704 const1 is DW_OP_lit1 or corresponding typed constant):
15706 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15707 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15711 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15712 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15715 static dw_loc_descr_ref
15716 popcount_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15717 machine_mode mem_mode
)
15719 dw_loc_descr_ref op0
, ret
, tmp
;
15720 dw_loc_descr_ref l1jump
, l1label
;
15721 dw_loc_descr_ref l2jump
, l2label
;
15723 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
15726 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15727 VAR_INIT_STATUS_INITIALIZED
);
15731 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15732 VAR_INIT_STATUS_INITIALIZED
);
15735 add_loc_descr (&ret
, tmp
);
15736 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15737 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
15738 add_loc_descr (&ret
, l1label
);
15739 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15740 add_loc_descr (&ret
, l2jump
);
15741 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15742 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
15743 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15744 VAR_INIT_STATUS_INITIALIZED
);
15747 add_loc_descr (&ret
, tmp
);
15748 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15749 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
15750 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
15751 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15752 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15753 VAR_INIT_STATUS_INITIALIZED
);
15754 add_loc_descr (&ret
, tmp
);
15755 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15756 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15757 add_loc_descr (&ret
, l1jump
);
15758 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
15759 add_loc_descr (&ret
, l2label
);
15760 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15761 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15762 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15763 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15767 /* BSWAP (constS is initial shift count, either 56 or 24):
15769 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
15770 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
15771 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
15772 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
15773 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
15775 static dw_loc_descr_ref
15776 bswap_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15777 machine_mode mem_mode
)
15779 dw_loc_descr_ref op0
, ret
, tmp
;
15780 dw_loc_descr_ref l1jump
, l1label
;
15781 dw_loc_descr_ref l2jump
, l2label
;
15783 if (BITS_PER_UNIT
!= 8
15784 || (GET_MODE_BITSIZE (mode
) != 32
15785 && GET_MODE_BITSIZE (mode
) != 64))
15788 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15789 VAR_INIT_STATUS_INITIALIZED
);
15794 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
15796 VAR_INIT_STATUS_INITIALIZED
);
15799 add_loc_descr (&ret
, tmp
);
15800 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15801 VAR_INIT_STATUS_INITIALIZED
);
15804 add_loc_descr (&ret
, tmp
);
15805 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
15806 add_loc_descr (&ret
, l1label
);
15807 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
15809 VAR_INIT_STATUS_INITIALIZED
);
15810 add_loc_descr (&ret
, tmp
);
15811 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
15812 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15813 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15814 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
15815 VAR_INIT_STATUS_INITIALIZED
);
15818 add_loc_descr (&ret
, tmp
);
15819 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15820 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
15821 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
15822 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
15823 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15824 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15825 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15826 VAR_INIT_STATUS_INITIALIZED
);
15827 add_loc_descr (&ret
, tmp
);
15828 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
15829 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15830 add_loc_descr (&ret
, l2jump
);
15831 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
15832 VAR_INIT_STATUS_INITIALIZED
);
15833 add_loc_descr (&ret
, tmp
);
15834 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15835 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15836 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15837 add_loc_descr (&ret
, l1jump
);
15838 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
15839 add_loc_descr (&ret
, l2label
);
15840 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15841 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
15842 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15843 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15844 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15845 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15849 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
15850 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15851 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
15852 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
15854 ROTATERT is similar:
15855 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
15856 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15857 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
15859 static dw_loc_descr_ref
15860 rotate_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15861 machine_mode mem_mode
)
15863 rtx rtlop1
= XEXP (rtl
, 1);
15864 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
15867 if (is_narrower_int_mode (GET_MODE (rtlop1
), mode
))
15868 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
15869 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15870 VAR_INIT_STATUS_INITIALIZED
);
15871 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
15872 VAR_INIT_STATUS_INITIALIZED
);
15873 if (op0
== NULL
|| op1
== NULL
)
15875 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
15876 for (i
= 0; i
< 2; i
++)
15878 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
15879 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
15881 VAR_INIT_STATUS_INITIALIZED
);
15882 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
15883 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
15885 : HOST_BITS_PER_WIDE_INT
== 64
15886 ? DW_OP_const8u
: DW_OP_constu
,
15887 GET_MODE_MASK (mode
), 0);
15890 if (mask
[i
] == NULL
)
15892 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
15895 add_loc_descr (&ret
, op1
);
15896 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
15897 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
15898 if (GET_CODE (rtl
) == ROTATERT
)
15900 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
15901 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
15902 GET_MODE_BITSIZE (mode
), 0));
15904 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
15905 if (mask
[0] != NULL
)
15906 add_loc_descr (&ret
, mask
[0]);
15907 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
15908 if (mask
[1] != NULL
)
15910 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15911 add_loc_descr (&ret
, mask
[1]);
15912 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15914 if (GET_CODE (rtl
) == ROTATE
)
15916 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
15917 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
15918 GET_MODE_BITSIZE (mode
), 0));
15920 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15921 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
15925 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
15926 for DEBUG_PARAMETER_REF RTL. */
15928 static dw_loc_descr_ref
15929 parameter_ref_descriptor (rtx rtl
)
15931 dw_loc_descr_ref ret
;
15936 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
15937 /* With LTO during LTRANS we get the late DIE that refers to the early
15938 DIE, thus we add another indirection here. This seems to confuse
15939 gdb enough to make gcc.dg/guality/pr68860-1.c FAIL with LTO. */
15940 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
15941 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
15944 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15945 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
15946 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15950 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
15951 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
15956 /* The following routine converts the RTL for a variable or parameter
15957 (resident in memory) into an equivalent Dwarf representation of a
15958 mechanism for getting the address of that same variable onto the top of a
15959 hypothetical "address evaluation" stack.
15961 When creating memory location descriptors, we are effectively transforming
15962 the RTL for a memory-resident object into its Dwarf postfix expression
15963 equivalent. This routine recursively descends an RTL tree, turning
15964 it into Dwarf postfix code as it goes.
15966 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
15968 MEM_MODE is the mode of the memory reference, needed to handle some
15969 autoincrement addressing modes.
15971 Return 0 if we can't represent the location. */
15974 mem_loc_descriptor (rtx rtl
, machine_mode mode
,
15975 machine_mode mem_mode
,
15976 enum var_init_status initialized
)
15978 dw_loc_descr_ref mem_loc_result
= NULL
;
15979 enum dwarf_location_atom op
;
15980 dw_loc_descr_ref op0
, op1
;
15981 rtx inner
= NULL_RTX
;
15983 if (mode
== VOIDmode
)
15984 mode
= GET_MODE (rtl
);
15986 /* Note that for a dynamically sized array, the location we will generate a
15987 description of here will be the lowest numbered location which is
15988 actually within the array. That's *not* necessarily the same as the
15989 zeroth element of the array. */
15991 rtl
= targetm
.delegitimize_address (rtl
);
15993 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
15996 scalar_int_mode int_mode
= BImode
, inner_mode
, op1_mode
;
15997 switch (GET_CODE (rtl
))
16002 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
16005 /* The case of a subreg may arise when we have a local (register)
16006 variable or a formal (register) parameter which doesn't quite fill
16007 up an entire register. For now, just assume that it is
16008 legitimate to make the Dwarf info refer to the whole register which
16009 contains the given subreg. */
16010 if (!subreg_lowpart_p (rtl
))
16012 inner
= SUBREG_REG (rtl
);
16015 if (inner
== NULL_RTX
)
16016 inner
= XEXP (rtl
, 0);
16017 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16018 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
16019 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16020 #ifdef POINTERS_EXTEND_UNSIGNED
16021 || (int_mode
== Pmode
&& mem_mode
!= VOIDmode
)
16024 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
)
16026 mem_loc_result
= mem_loc_descriptor (inner
,
16028 mem_mode
, initialized
);
16031 if (dwarf_strict
&& dwarf_version
< 5)
16033 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16034 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
16035 ? GET_MODE_SIZE (int_mode
) <= GET_MODE_SIZE (inner_mode
)
16036 : known_eq (GET_MODE_SIZE (mode
), GET_MODE_SIZE (GET_MODE (inner
))))
16038 dw_die_ref type_die
;
16039 dw_loc_descr_ref cvt
;
16041 mem_loc_result
= mem_loc_descriptor (inner
,
16043 mem_mode
, initialized
);
16044 if (mem_loc_result
== NULL
)
16046 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16047 if (type_die
== NULL
)
16049 mem_loc_result
= NULL
;
16052 if (maybe_ne (GET_MODE_SIZE (mode
), GET_MODE_SIZE (GET_MODE (inner
))))
16053 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16055 cvt
= new_loc_descr (dwarf_OP (DW_OP_reinterpret
), 0, 0);
16056 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16057 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16058 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16059 add_loc_descr (&mem_loc_result
, cvt
);
16060 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16061 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
16063 /* Convert it to untyped afterwards. */
16064 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16065 add_loc_descr (&mem_loc_result
, cvt
);
16071 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16072 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
16073 && rtl
!= arg_pointer_rtx
16074 && rtl
!= frame_pointer_rtx
16075 #ifdef POINTERS_EXTEND_UNSIGNED
16076 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
16080 dw_die_ref type_die
;
16081 unsigned int debugger_regnum
;
16083 if (dwarf_strict
&& dwarf_version
< 5)
16085 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
16087 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16088 if (type_die
== NULL
)
16091 debugger_regnum
= debugger_reg_number (rtl
);
16092 if (debugger_regnum
== IGNORED_DWARF_REGNUM
)
16094 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_regval_type
),
16095 debugger_regnum
, 0);
16096 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
16097 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
16098 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
16101 /* Whenever a register number forms a part of the description of the
16102 method for calculating the (dynamic) address of a memory resident
16103 object, DWARF rules require the register number be referred to as
16104 a "base register". This distinction is not based in any way upon
16105 what category of register the hardware believes the given register
16106 belongs to. This is strictly DWARF terminology we're dealing with
16107 here. Note that in cases where the location of a memory-resident
16108 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
16109 OP_CONST (0)) the actual DWARF location descriptor that we generate
16110 may just be OP_BASEREG (basereg). This may look deceptively like
16111 the object in question was allocated to a register (rather than in
16112 memory) so DWARF consumers need to be aware of the subtle
16113 distinction between OP_REG and OP_BASEREG. */
16114 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
16115 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
16116 else if (stack_realign_drap
16118 && crtl
->args
.internal_arg_pointer
== rtl
16119 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
16121 /* If RTL is internal_arg_pointer, which has been optimized
16122 out, use DRAP instead. */
16123 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
16124 VAR_INIT_STATUS_INITIALIZED
);
16130 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16131 || !is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
))
16133 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
16134 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16137 else if (GET_CODE (rtl
) == ZERO_EXTEND
16138 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16139 && GET_MODE_BITSIZE (inner_mode
) < HOST_BITS_PER_WIDE_INT
16140 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
16141 to expand zero extend as two shifts instead of
16143 && GET_MODE_SIZE (inner_mode
) <= 4)
16145 mem_loc_result
= op0
;
16146 add_loc_descr (&mem_loc_result
,
16147 int_loc_descriptor (GET_MODE_MASK (inner_mode
)));
16148 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
16150 else if (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
16152 int shift
= DWARF2_ADDR_SIZE
- GET_MODE_SIZE (inner_mode
);
16153 shift
*= BITS_PER_UNIT
;
16154 if (GET_CODE (rtl
) == SIGN_EXTEND
)
16158 mem_loc_result
= op0
;
16159 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
16160 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
16161 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
16162 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16164 else if (!dwarf_strict
|| dwarf_version
>= 5)
16166 dw_die_ref type_die1
, type_die2
;
16167 dw_loc_descr_ref cvt
;
16169 type_die1
= base_type_for_mode (inner_mode
,
16170 GET_CODE (rtl
) == ZERO_EXTEND
);
16171 if (type_die1
== NULL
)
16173 type_die2
= base_type_for_mode (int_mode
, 1);
16174 if (type_die2
== NULL
)
16176 mem_loc_result
= op0
;
16177 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16178 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16179 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
16180 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16181 add_loc_descr (&mem_loc_result
, cvt
);
16182 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16183 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16184 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
16185 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16186 add_loc_descr (&mem_loc_result
, cvt
);
16192 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
16193 if (new_rtl
!= rtl
)
16195 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
16197 if (mem_loc_result
!= NULL
)
16198 return mem_loc_result
;
16201 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
16202 get_address_mode (rtl
), mode
,
16203 VAR_INIT_STATUS_INITIALIZED
);
16204 if (mem_loc_result
== NULL
)
16205 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
16206 if (mem_loc_result
!= NULL
)
16208 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16209 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
16211 dw_die_ref type_die
;
16212 dw_loc_descr_ref deref
;
16213 HOST_WIDE_INT size
;
16215 if (dwarf_strict
&& dwarf_version
< 5)
16217 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
16220 = base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16221 if (type_die
== NULL
)
16223 deref
= new_loc_descr (dwarf_OP (DW_OP_deref_type
), size
, 0);
16224 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
16225 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
16226 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
16227 add_loc_descr (&mem_loc_result
, deref
);
16229 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
16230 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
16232 add_loc_descr (&mem_loc_result
,
16233 new_loc_descr (DW_OP_deref_size
,
16234 GET_MODE_SIZE (int_mode
), 0));
16239 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
16242 /* Some ports can transform a symbol ref into a label ref, because
16243 the symbol ref is too far away and has to be dumped into a constant
16248 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16249 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
16250 #ifdef POINTERS_EXTEND_UNSIGNED
16251 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
16256 if (GET_CODE (rtl
) == UNSPEC
)
16258 /* If delegitimize_address couldn't do anything with the UNSPEC, we
16259 can't express it in the debug info. This can happen e.g. with some
16260 TLS UNSPECs. Allow UNSPECs formerly from CONST that the backend
16262 bool not_ok
= false;
16263 subrtx_var_iterator::array_type array
;
16264 FOR_EACH_SUBRTX_VAR (iter
, array
, rtl
, ALL
)
16265 if (*iter
!= rtl
&& !CONSTANT_P (*iter
))
16274 FOR_EACH_SUBRTX_VAR (iter
, array
, rtl
, ALL
)
16275 if (!const_ok_for_output_1 (*iter
))
16284 rtl
= gen_rtx_CONST (GET_MODE (rtl
), rtl
);
16288 if (GET_CODE (rtl
) == SYMBOL_REF
16289 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
16291 dw_loc_descr_ref temp
;
16293 /* If this is not defined, we have no way to emit the data. */
16294 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
16297 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
16299 /* We check for DWARF 5 here because gdb did not implement
16300 DW_OP_form_tls_address until after 7.12. */
16301 mem_loc_result
= new_loc_descr ((dwarf_version
>= 5
16302 ? DW_OP_form_tls_address
16303 : DW_OP_GNU_push_tls_address
),
16305 add_loc_descr (&mem_loc_result
, temp
);
16310 if (!const_ok_for_output (rtl
))
16312 if (GET_CODE (rtl
) == CONST
)
16313 switch (GET_CODE (XEXP (rtl
, 0)))
16317 goto try_const_unop
;
16320 goto try_const_unop
;
16323 arg
= XEXP (XEXP (rtl
, 0), 0);
16324 if (!CONSTANT_P (arg
))
16325 arg
= gen_rtx_CONST (int_mode
, arg
);
16326 op0
= mem_loc_descriptor (arg
, int_mode
, mem_mode
,
16330 mem_loc_result
= op0
;
16331 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16335 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
,
16336 mem_mode
, initialized
);
16343 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
16344 vec_safe_push (used_rtx_array
, rtl
);
16350 case DEBUG_IMPLICIT_PTR
:
16351 expansion_failed (NULL_TREE
, rtl
,
16352 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
16356 if (dwarf_strict
&& dwarf_version
< 5)
16358 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
16360 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16361 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
16362 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
16363 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16366 unsigned int debugger_regnum
= debugger_reg_number (ENTRY_VALUE_EXP (rtl
));
16367 if (debugger_regnum
== IGNORED_DWARF_REGNUM
)
16369 op0
= one_reg_loc_descriptor (debugger_regnum
,
16370 VAR_INIT_STATUS_INITIALIZED
);
16373 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
16374 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
16376 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
16377 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16378 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
16382 gcc_unreachable ();
16385 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_entry_value
), 0, 0);
16386 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
16387 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
16390 case DEBUG_PARAMETER_REF
:
16391 mem_loc_result
= parameter_ref_descriptor (rtl
);
16395 /* Extract the PLUS expression nested inside and fall into
16396 PLUS code below. */
16397 rtl
= XEXP (rtl
, 1);
16402 /* Turn these into a PLUS expression and fall into the PLUS code
16404 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
16405 gen_int_mode (GET_CODE (rtl
) == PRE_INC
16406 ? GET_MODE_UNIT_SIZE (mem_mode
)
16407 : -GET_MODE_UNIT_SIZE (mem_mode
),
16414 if (is_based_loc (rtl
)
16415 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16416 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16417 || XEXP (rtl
, 0) == arg_pointer_rtx
16418 || XEXP (rtl
, 0) == frame_pointer_rtx
))
16419 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
16420 INTVAL (XEXP (rtl
, 1)),
16421 VAR_INIT_STATUS_INITIALIZED
);
16424 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
16425 VAR_INIT_STATUS_INITIALIZED
);
16426 if (mem_loc_result
== 0)
16429 if (CONST_INT_P (XEXP (rtl
, 1))
16430 && (GET_MODE_SIZE (as_a
<scalar_int_mode
> (mode
))
16431 <= DWARF2_ADDR_SIZE
))
16432 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
16435 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16436 VAR_INIT_STATUS_INITIALIZED
);
16439 add_loc_descr (&mem_loc_result
, op1
);
16440 add_loc_descr (&mem_loc_result
,
16441 new_loc_descr (DW_OP_plus
, 0, 0));
16446 /* If a pseudo-reg is optimized away, it is possible for it to
16447 be replaced with a MEM containing a multiply or shift. */
16457 if ((!dwarf_strict
|| dwarf_version
>= 5)
16458 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16459 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
16461 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
16462 base_type_for_mode (mode
, 0),
16463 int_mode
, mem_mode
);
16486 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
))
16488 op0
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
, mem_mode
,
16489 VAR_INIT_STATUS_INITIALIZED
);
16491 rtx rtlop1
= XEXP (rtl
, 1);
16492 if (is_a
<scalar_int_mode
> (GET_MODE (rtlop1
), &op1_mode
)
16493 && GET_MODE_BITSIZE (op1_mode
) < GET_MODE_BITSIZE (int_mode
))
16494 rtlop1
= gen_rtx_ZERO_EXTEND (int_mode
, rtlop1
);
16495 op1
= mem_loc_descriptor (rtlop1
, int_mode
, mem_mode
,
16496 VAR_INIT_STATUS_INITIALIZED
);
16499 if (op0
== 0 || op1
== 0)
16502 mem_loc_result
= op0
;
16503 add_loc_descr (&mem_loc_result
, op1
);
16504 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16520 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
16521 VAR_INIT_STATUS_INITIALIZED
);
16522 if (XEXP (rtl
, 0) == XEXP (rtl
, 1))
16526 mem_loc_result
= op0
;
16527 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_dup
, 0, 0));
16528 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16531 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16532 VAR_INIT_STATUS_INITIALIZED
);
16534 if (op0
== 0 || op1
== 0)
16537 mem_loc_result
= op0
;
16538 add_loc_descr (&mem_loc_result
, op1
);
16539 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16543 if ((!dwarf_strict
|| dwarf_version
>= 5)
16544 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16545 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
16547 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
16548 base_type_for_mode (mode
, 0),
16549 int_mode
, mem_mode
);
16553 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
16554 VAR_INIT_STATUS_INITIALIZED
);
16555 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16556 VAR_INIT_STATUS_INITIALIZED
);
16558 if (op0
== 0 || op1
== 0)
16561 mem_loc_result
= op0
;
16562 add_loc_descr (&mem_loc_result
, op1
);
16563 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
16564 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
16565 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
16566 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
16567 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
16571 if ((!dwarf_strict
|| dwarf_version
>= 5)
16572 && is_a
<scalar_int_mode
> (mode
, &int_mode
))
16574 /* We can use a signed divide if the sign bit is not set. */
16575 if (GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
16581 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
16582 base_type_for_mode (int_mode
, 1),
16583 int_mode
, mem_mode
);
16600 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
16601 VAR_INIT_STATUS_INITIALIZED
);
16606 mem_loc_result
= op0
;
16607 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16611 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16612 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16613 #ifdef POINTERS_EXTEND_UNSIGNED
16614 || (int_mode
== Pmode
16615 && mem_mode
!= VOIDmode
16616 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
16620 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
16623 if ((!dwarf_strict
|| dwarf_version
>= 5)
16624 && (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
16625 || GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_DOUBLE_INT
))
16627 dw_die_ref type_die
= base_type_for_mode (int_mode
, 1);
16628 scalar_int_mode amode
;
16629 if (type_die
== NULL
)
16631 if (INTVAL (rtl
) >= 0
16632 && (int_mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
, 0)
16634 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
16635 /* const DW_OP_convert <XXX> vs.
16636 DW_OP_const_type <XXX, 1, const>. */
16637 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
16638 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (int_mode
))
16640 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
16641 op0
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16642 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16643 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16644 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16645 add_loc_descr (&mem_loc_result
, op0
);
16646 return mem_loc_result
;
16648 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0,
16650 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16651 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16652 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16653 if (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
)
16654 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
16657 mem_loc_result
->dw_loc_oprnd2
.val_class
16658 = dw_val_class_const_double
;
16659 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
16660 = double_int::from_shwi (INTVAL (rtl
));
16666 if (!dwarf_strict
|| dwarf_version
>= 5)
16668 dw_die_ref type_die
;
16670 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
16671 CONST_DOUBLE rtx could represent either a large integer
16672 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
16673 the value is always a floating point constant.
16675 When it is an integer, a CONST_DOUBLE is used whenever
16676 the constant requires 2 HWIs to be adequately represented.
16677 We output CONST_DOUBLEs as blocks. */
16678 if (mode
== VOIDmode
16679 || (GET_MODE (rtl
) == VOIDmode
16680 && maybe_ne (GET_MODE_BITSIZE (mode
),
16681 HOST_BITS_PER_DOUBLE_INT
)))
16683 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16684 if (type_die
== NULL
)
16686 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
16687 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16688 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16689 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16690 #if TARGET_SUPPORTS_WIDE_INT == 0
16691 if (!SCALAR_FLOAT_MODE_P (mode
))
16693 mem_loc_result
->dw_loc_oprnd2
.val_class
16694 = dw_val_class_const_double
;
16695 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
16696 = rtx_to_double_int (rtl
);
16701 scalar_float_mode float_mode
= as_a
<scalar_float_mode
> (mode
);
16702 unsigned int length
= GET_MODE_SIZE (float_mode
);
16703 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
16704 unsigned int elt_size
= insert_float (rtl
, array
);
16706 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16707 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
16708 = length
/ elt_size
;
16709 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
16710 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16715 case CONST_WIDE_INT
:
16716 if (!dwarf_strict
|| dwarf_version
>= 5)
16718 dw_die_ref type_die
;
16720 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16721 if (type_die
== NULL
)
16723 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
16724 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16725 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16726 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16727 mem_loc_result
->dw_loc_oprnd2
.val_class
16728 = dw_val_class_wide_int
;
16729 mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
16730 = alloc_dw_wide_int (rtx_mode_t (rtl
, mode
));
16734 case CONST_POLY_INT
:
16735 mem_loc_result
= int_loc_descriptor (rtx_to_poly_int64 (rtl
));
16739 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
16743 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
16747 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
16751 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
16755 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
16759 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
16763 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
16767 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
16771 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
16775 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
16780 if (!SCALAR_INT_MODE_P (mode
))
16785 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
16790 if (CONST_INT_P (XEXP (rtl
, 1))
16791 && CONST_INT_P (XEXP (rtl
, 2))
16792 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16793 && is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
)
16794 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16795 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
16796 && ((unsigned) INTVAL (XEXP (rtl
, 1))
16797 + (unsigned) INTVAL (XEXP (rtl
, 2))
16798 <= GET_MODE_BITSIZE (int_mode
)))
16801 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
16802 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16805 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
16809 mem_loc_result
= op0
;
16810 size
= INTVAL (XEXP (rtl
, 1));
16811 shift
= INTVAL (XEXP (rtl
, 2));
16812 if (BITS_BIG_ENDIAN
)
16813 shift
= GET_MODE_BITSIZE (inner_mode
) - shift
- size
;
16814 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
16816 add_loc_descr (&mem_loc_result
,
16817 int_loc_descriptor (DWARF2_ADDR_SIZE
16819 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
16821 if (size
!= (int) DWARF2_ADDR_SIZE
)
16823 add_loc_descr (&mem_loc_result
,
16824 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
16825 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16832 dw_loc_descr_ref op2
, bra_node
, drop_node
;
16833 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
16834 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
16835 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
16836 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16837 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16838 VAR_INIT_STATUS_INITIALIZED
);
16839 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
16840 VAR_INIT_STATUS_INITIALIZED
);
16841 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
16844 mem_loc_result
= op1
;
16845 add_loc_descr (&mem_loc_result
, op2
);
16846 add_loc_descr (&mem_loc_result
, op0
);
16847 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
16848 add_loc_descr (&mem_loc_result
, bra_node
);
16849 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
16850 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
16851 add_loc_descr (&mem_loc_result
, drop_node
);
16852 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
16853 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
16858 case FLOAT_TRUNCATE
:
16860 case UNSIGNED_FLOAT
:
16863 if (!dwarf_strict
|| dwarf_version
>= 5)
16865 dw_die_ref type_die
;
16866 dw_loc_descr_ref cvt
;
16868 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
16869 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16872 if (is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &int_mode
)
16873 && (GET_CODE (rtl
) == FLOAT
16874 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
))
16876 type_die
= base_type_for_mode (int_mode
,
16877 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
16878 if (type_die
== NULL
)
16880 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16881 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16882 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16883 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16884 add_loc_descr (&op0
, cvt
);
16886 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
16887 if (type_die
== NULL
)
16889 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16890 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16891 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16892 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16893 add_loc_descr (&op0
, cvt
);
16894 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16895 && (GET_CODE (rtl
) == FIX
16896 || GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
))
16898 op0
= convert_descriptor_to_mode (int_mode
, op0
);
16902 mem_loc_result
= op0
;
16909 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16910 mem_loc_result
= clz_loc_descriptor (rtl
, int_mode
, mem_mode
);
16915 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16916 mem_loc_result
= popcount_loc_descriptor (rtl
, int_mode
, mem_mode
);
16920 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16921 mem_loc_result
= bswap_loc_descriptor (rtl
, int_mode
, mem_mode
);
16926 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16927 mem_loc_result
= rotate_loc_descriptor (rtl
, int_mode
, mem_mode
);
16931 /* In theory, we could implement the above. */
16932 /* DWARF cannot represent the unsigned compare operations
16957 case FRACT_CONVERT
:
16958 case UNSIGNED_FRACT_CONVERT
:
16960 case UNSIGNED_SAT_FRACT
:
16966 case VEC_DUPLICATE
:
16970 case STRICT_LOW_PART
:
16975 case SMUL_HIGHPART
:
16976 case UMUL_HIGHPART
:
16982 resolve_one_addr (&rtl
);
16985 /* RTL sequences inside PARALLEL record a series of DWARF operations for
16986 the expression. An UNSPEC rtx represents a raw DWARF operation,
16987 new_loc_descr is called for it to build the operation directly.
16988 Otherwise mem_loc_descriptor is called recursively. */
16992 dw_loc_descr_ref exp_result
= NULL
;
16994 for (; index
< XVECLEN (rtl
, 0); index
++)
16996 rtx elem
= XVECEXP (rtl
, 0, index
);
16997 if (GET_CODE (elem
) == UNSPEC
)
16999 /* Each DWARF operation UNSPEC contain two operands, if
17000 one operand is not used for the operation, const0_rtx is
17002 gcc_assert (XVECLEN (elem
, 0) == 2);
17004 HOST_WIDE_INT dw_op
= XINT (elem
, 1);
17005 HOST_WIDE_INT oprnd1
= INTVAL (XVECEXP (elem
, 0, 0));
17006 HOST_WIDE_INT oprnd2
= INTVAL (XVECEXP (elem
, 0, 1));
17008 = new_loc_descr ((enum dwarf_location_atom
) dw_op
, oprnd1
,
17013 = mem_loc_descriptor (elem
, mode
, mem_mode
,
17014 VAR_INIT_STATUS_INITIALIZED
);
17016 if (!mem_loc_result
)
17017 mem_loc_result
= exp_result
;
17019 add_loc_descr (&mem_loc_result
, exp_result
);
17028 print_rtl (stderr
, rtl
);
17029 gcc_unreachable ();
17034 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
17035 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
17037 return mem_loc_result
;
17040 /* Return a descriptor that describes the concatenation of two locations.
17041 This is typically a complex variable. */
17043 static dw_loc_descr_ref
17044 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
17046 /* At present we only track constant-sized pieces. */
17047 unsigned int size0
, size1
;
17048 if (!GET_MODE_SIZE (GET_MODE (x0
)).is_constant (&size0
)
17049 || !GET_MODE_SIZE (GET_MODE (x1
)).is_constant (&size1
))
17052 dw_loc_descr_ref cc_loc_result
= NULL
;
17053 dw_loc_descr_ref x0_ref
17054 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
17055 dw_loc_descr_ref x1_ref
17056 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
17058 if (x0_ref
== 0 || x1_ref
== 0)
17061 cc_loc_result
= x0_ref
;
17062 add_loc_descr_op_piece (&cc_loc_result
, size0
);
17064 add_loc_descr (&cc_loc_result
, x1_ref
);
17065 add_loc_descr_op_piece (&cc_loc_result
, size1
);
17067 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
17068 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
17070 return cc_loc_result
;
17073 /* Return a descriptor that describes the concatenation of N
17076 static dw_loc_descr_ref
17077 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
17080 dw_loc_descr_ref cc_loc_result
= NULL
;
17081 unsigned int n
= XVECLEN (concatn
, 0);
17084 for (i
= 0; i
< n
; ++i
)
17086 dw_loc_descr_ref ref
;
17087 rtx x
= XVECEXP (concatn
, 0, i
);
17089 /* At present we only track constant-sized pieces. */
17090 if (!GET_MODE_SIZE (GET_MODE (x
)).is_constant (&size
))
17093 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
17097 add_loc_descr (&cc_loc_result
, ref
);
17098 add_loc_descr_op_piece (&cc_loc_result
, size
);
17101 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
17102 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
17104 return cc_loc_result
;
17107 /* Helper function for loc_descriptor. Return DW_OP_implicit_pointer
17108 for DEBUG_IMPLICIT_PTR RTL. */
17110 static dw_loc_descr_ref
17111 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
17113 dw_loc_descr_ref ret
;
17116 if (dwarf_strict
&& dwarf_version
< 5)
17118 gcc_assert (VAR_P (DEBUG_IMPLICIT_PTR_DECL (rtl
))
17119 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
17120 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
17121 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
17122 ret
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
17123 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
17126 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
17127 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
17128 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
17132 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
17133 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
17138 /* Output a proper Dwarf location descriptor for a variable or parameter
17139 which is either allocated in a register or in a memory location. For a
17140 register, we just generate an OP_REG and the register number. For a
17141 memory location we provide a Dwarf postfix expression describing how to
17142 generate the (dynamic) address of the object onto the address stack.
17144 MODE is mode of the decl if this loc_descriptor is going to be used in
17145 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
17146 allowed, VOIDmode otherwise.
17148 If we don't know how to describe it, return 0. */
17150 static dw_loc_descr_ref
17151 loc_descriptor (rtx rtl
, machine_mode mode
,
17152 enum var_init_status initialized
)
17154 dw_loc_descr_ref loc_result
= NULL
;
17155 scalar_int_mode int_mode
;
17157 switch (GET_CODE (rtl
))
17160 /* The case of a subreg may arise when we have a local (register)
17161 variable or a formal (register) parameter which doesn't quite fill
17162 up an entire register. For now, just assume that it is
17163 legitimate to make the Dwarf info refer to the whole register which
17164 contains the given subreg. */
17165 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
17166 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
17167 GET_MODE (SUBREG_REG (rtl
)), initialized
);
17173 loc_result
= reg_loc_descriptor (rtl
, initialized
);
17177 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
17178 GET_MODE (rtl
), initialized
);
17179 if (loc_result
== NULL
)
17180 loc_result
= tls_mem_loc_descriptor (rtl
);
17181 if (loc_result
== NULL
)
17183 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
17184 if (new_rtl
!= rtl
)
17185 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
17190 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
17195 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
17200 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
17202 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
17203 if (GET_CODE (loc
) == EXPR_LIST
)
17204 loc
= XEXP (loc
, 0);
17205 loc_result
= loc_descriptor (loc
, mode
, initialized
);
17209 rtl
= XEXP (rtl
, 1);
17214 rtvec par_elems
= XVEC (rtl
, 0);
17215 int num_elem
= GET_NUM_ELEM (par_elems
);
17219 /* Create the first one, so we have something to add to. */
17220 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
17221 VOIDmode
, initialized
);
17222 if (loc_result
== NULL
)
17224 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
17225 /* At present we only track constant-sized pieces. */
17226 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
17228 add_loc_descr_op_piece (&loc_result
, size
);
17229 for (i
= 1; i
< num_elem
; i
++)
17231 dw_loc_descr_ref temp
;
17233 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
17234 VOIDmode
, initialized
);
17237 add_loc_descr (&loc_result
, temp
);
17238 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
17239 /* At present we only track constant-sized pieces. */
17240 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
17242 add_loc_descr_op_piece (&loc_result
, size
);
17248 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
17250 int_mode
= as_a
<scalar_int_mode
> (mode
);
17251 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (int_mode
),
17257 if (mode
== VOIDmode
)
17258 mode
= GET_MODE (rtl
);
17260 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
17262 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
17264 /* Note that a CONST_DOUBLE rtx could represent either an integer
17265 or a floating-point constant. A CONST_DOUBLE is used whenever
17266 the constant requires more than one word in order to be
17267 adequately represented. We output CONST_DOUBLEs as blocks. */
17268 scalar_mode smode
= as_a
<scalar_mode
> (mode
);
17269 loc_result
= new_loc_descr (DW_OP_implicit_value
,
17270 GET_MODE_SIZE (smode
), 0);
17271 #if TARGET_SUPPORTS_WIDE_INT == 0
17272 if (!SCALAR_FLOAT_MODE_P (smode
))
17274 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
17275 loc_result
->dw_loc_oprnd2
.v
.val_double
17276 = rtx_to_double_int (rtl
);
17281 unsigned int length
= GET_MODE_SIZE (smode
);
17282 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
17283 unsigned int elt_size
= insert_float (rtl
, array
);
17285 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
17286 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ elt_size
;
17287 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
17288 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
17293 case CONST_WIDE_INT
:
17294 if (mode
== VOIDmode
)
17295 mode
= GET_MODE (rtl
);
17297 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
17299 int_mode
= as_a
<scalar_int_mode
> (mode
);
17300 loc_result
= new_loc_descr (DW_OP_implicit_value
,
17301 GET_MODE_SIZE (int_mode
), 0);
17302 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_wide_int
;
17303 loc_result
->dw_loc_oprnd2
.v
.val_wide
17304 = alloc_dw_wide_int (rtx_mode_t (rtl
, int_mode
));
17309 if (mode
== VOIDmode
)
17310 mode
= GET_MODE (rtl
);
17312 if (mode
!= VOIDmode
17313 /* The combination of a length and byte elt_size doesn't extend
17314 naturally to boolean vectors, where several elements are packed
17315 into the same byte. */
17316 && GET_MODE_CLASS (mode
) != MODE_VECTOR_BOOL
17317 && (dwarf_version
>= 4 || !dwarf_strict
))
17319 unsigned int length
;
17320 if (!CONST_VECTOR_NUNITS (rtl
).is_constant (&length
))
17323 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
17324 unsigned char *array
17325 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
17328 machine_mode imode
= GET_MODE_INNER (mode
);
17330 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
17331 switch (GET_MODE_CLASS (mode
))
17333 case MODE_VECTOR_INT
:
17334 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
17336 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
17337 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
17341 case MODE_VECTOR_FLOAT
:
17342 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
17344 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
17345 insert_float (elt
, p
);
17350 gcc_unreachable ();
17353 loc_result
= new_loc_descr (DW_OP_implicit_value
,
17354 length
* elt_size
, 0);
17355 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
17356 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
17357 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
17358 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
17363 if (mode
== VOIDmode
17364 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
17365 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
17366 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
17368 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
17373 if (!const_ok_for_output (rtl
))
17377 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
17378 && GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
17379 && (dwarf_version
>= 4 || !dwarf_strict
))
17381 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
17382 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
17383 vec_safe_push (used_rtx_array
, rtl
);
17387 case DEBUG_IMPLICIT_PTR
:
17388 loc_result
= implicit_ptr_descriptor (rtl
, 0);
17392 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
17393 && CONST_INT_P (XEXP (rtl
, 1)))
17396 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
17402 if ((is_a
<scalar_int_mode
> (mode
, &int_mode
)
17403 && GET_MODE (rtl
) == int_mode
17404 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
17405 && dwarf_version
>= 4)
17406 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
17408 /* Value expression. */
17409 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
17411 add_loc_descr (&loc_result
,
17412 new_loc_descr (DW_OP_stack_value
, 0, 0));
17420 /* We need to figure out what section we should use as the base for the
17421 address ranges where a given location is valid.
17422 1. If this particular DECL has a section associated with it, use that.
17423 2. If this function has a section associated with it, use that.
17424 3. Otherwise, use the text section.
17425 XXX: If you split a variable across multiple sections, we won't notice. */
17427 static const char *
17428 secname_for_decl (const_tree decl
)
17430 const char *secname
;
17432 if (VAR_OR_FUNCTION_DECL_P (decl
)
17433 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
) || TREE_STATIC (decl
))
17434 && DECL_SECTION_NAME (decl
))
17435 secname
= DECL_SECTION_NAME (decl
);
17436 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
17438 if (in_cold_section_p
)
17440 section
*sec
= current_function_section ();
17441 if (sec
->common
.flags
& SECTION_NAMED
)
17442 return sec
->named
.name
;
17444 secname
= DECL_SECTION_NAME (current_function_decl
);
17446 else if (cfun
&& in_cold_section_p
)
17447 secname
= crtl
->subsections
.cold_section_label
;
17449 secname
= text_section_label
;
17454 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
17457 decl_by_reference_p (tree decl
)
17459 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
17461 && DECL_BY_REFERENCE (decl
));
17464 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
17467 static dw_loc_descr_ref
17468 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
17469 enum var_init_status initialized
)
17471 int have_address
= 0;
17472 dw_loc_descr_ref descr
;
17475 if (want_address
!= 2)
17477 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
17479 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
17481 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
17482 if (GET_CODE (varloc
) == EXPR_LIST
)
17483 varloc
= XEXP (varloc
, 0);
17484 mode
= GET_MODE (varloc
);
17485 if (MEM_P (varloc
))
17487 rtx addr
= XEXP (varloc
, 0);
17488 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
17489 mode
, initialized
);
17494 rtx x
= avoid_constant_pool_reference (varloc
);
17496 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
17501 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
17508 if (GET_CODE (varloc
) == VAR_LOCATION
)
17509 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
17511 mode
= DECL_MODE (loc
);
17512 descr
= loc_descriptor (varloc
, mode
, initialized
);
17519 if (want_address
== 2 && !have_address
17520 && (dwarf_version
>= 4 || !dwarf_strict
))
17522 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
17524 expansion_failed (loc
, NULL_RTX
,
17525 "DWARF address size mismatch");
17528 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
17531 /* Show if we can't fill the request for an address. */
17532 if (want_address
&& !have_address
)
17534 expansion_failed (loc
, NULL_RTX
,
17535 "Want address and only have value");
17539 /* If we've got an address and don't want one, dereference. */
17540 if (!want_address
&& have_address
)
17542 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
17543 enum dwarf_location_atom op
;
17545 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
17547 expansion_failed (loc
, NULL_RTX
,
17548 "DWARF address size mismatch");
17551 else if (size
== DWARF2_ADDR_SIZE
)
17554 op
= DW_OP_deref_size
;
17556 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
17562 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
17563 if it is not possible. */
17565 static dw_loc_descr_ref
17566 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
17568 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
17569 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
17570 else if (dwarf_version
>= 3 || !dwarf_strict
)
17571 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
17576 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
17577 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
17579 static dw_loc_descr_ref
17580 dw_sra_loc_expr (tree decl
, rtx loc
)
17583 unsigned HOST_WIDE_INT padsize
= 0;
17584 dw_loc_descr_ref descr
, *descr_tail
;
17585 unsigned HOST_WIDE_INT decl_size
;
17587 enum var_init_status initialized
;
17589 if (DECL_SIZE (decl
) == NULL
17590 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
17593 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
17595 descr_tail
= &descr
;
17597 for (p
= loc
; p
; p
= XEXP (p
, 1))
17599 unsigned HOST_WIDE_INT bitsize
= decl_piece_bitsize (p
);
17600 rtx loc_note
= *decl_piece_varloc_ptr (p
);
17601 dw_loc_descr_ref cur_descr
;
17602 dw_loc_descr_ref
*tail
, last
= NULL
;
17603 unsigned HOST_WIDE_INT opsize
= 0;
17605 if (loc_note
== NULL_RTX
17606 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
17608 padsize
+= bitsize
;
17611 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
17612 varloc
= NOTE_VAR_LOCATION (loc_note
);
17613 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
17614 if (cur_descr
== NULL
)
17616 padsize
+= bitsize
;
17620 /* Check that cur_descr either doesn't use
17621 DW_OP_*piece operations, or their sum is equal
17622 to bitsize. Otherwise we can't embed it. */
17623 for (tail
= &cur_descr
; *tail
!= NULL
;
17624 tail
= &(*tail
)->dw_loc_next
)
17625 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
17627 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
17631 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
17633 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
17637 if (last
!= NULL
&& opsize
!= bitsize
)
17639 padsize
+= bitsize
;
17640 /* Discard the current piece of the descriptor and release any
17641 addr_table entries it uses. */
17642 remove_loc_list_addr_table_entries (cur_descr
);
17646 /* If there is a hole, add DW_OP_*piece after empty DWARF
17647 expression, which means that those bits are optimized out. */
17650 if (padsize
> decl_size
)
17652 remove_loc_list_addr_table_entries (cur_descr
);
17653 goto discard_descr
;
17655 decl_size
-= padsize
;
17656 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
17657 if (*descr_tail
== NULL
)
17659 remove_loc_list_addr_table_entries (cur_descr
);
17660 goto discard_descr
;
17662 descr_tail
= &(*descr_tail
)->dw_loc_next
;
17665 *descr_tail
= cur_descr
;
17667 if (bitsize
> decl_size
)
17668 goto discard_descr
;
17669 decl_size
-= bitsize
;
17672 HOST_WIDE_INT offset
= 0;
17673 if (GET_CODE (varloc
) == VAR_LOCATION
17674 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
17676 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
17677 if (GET_CODE (varloc
) == EXPR_LIST
)
17678 varloc
= XEXP (varloc
, 0);
17682 if (GET_CODE (varloc
) == CONST
17683 || GET_CODE (varloc
) == SIGN_EXTEND
17684 || GET_CODE (varloc
) == ZERO_EXTEND
)
17685 varloc
= XEXP (varloc
, 0);
17686 else if (GET_CODE (varloc
) == SUBREG
)
17687 varloc
= SUBREG_REG (varloc
);
17692 /* DW_OP_bit_size offset should be zero for register
17693 or implicit location descriptions and empty location
17694 descriptions, but for memory addresses needs big endian
17696 if (MEM_P (varloc
))
17698 unsigned HOST_WIDE_INT memsize
;
17699 if (!poly_uint64 (MEM_SIZE (varloc
)).is_constant (&memsize
))
17700 goto discard_descr
;
17701 memsize
*= BITS_PER_UNIT
;
17702 if (memsize
!= bitsize
)
17704 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
17705 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
17706 goto discard_descr
;
17707 if (memsize
< bitsize
)
17708 goto discard_descr
;
17709 if (BITS_BIG_ENDIAN
)
17710 offset
= memsize
- bitsize
;
17714 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
17715 if (*descr_tail
== NULL
)
17716 goto discard_descr
;
17717 descr_tail
= &(*descr_tail
)->dw_loc_next
;
17721 /* If there were any non-empty expressions, add padding till the end of
17723 if (descr
!= NULL
&& decl_size
!= 0)
17725 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
17726 if (*descr_tail
== NULL
)
17727 goto discard_descr
;
17732 /* Discard the descriptor and release any addr_table entries it uses. */
17733 remove_loc_list_addr_table_entries (descr
);
17737 /* Return the dwarf representation of the location list LOC_LIST of
17738 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
17741 static dw_loc_list_ref
17742 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
17744 const char *endname
, *secname
;
17745 var_loc_view endview
;
17747 enum var_init_status initialized
;
17748 struct var_loc_node
*node
;
17749 dw_loc_descr_ref descr
;
17750 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
17751 dw_loc_list_ref list
= NULL
;
17752 dw_loc_list_ref
*listp
= &list
;
17754 /* Now that we know what section we are using for a base,
17755 actually construct the list of locations.
17756 The first location information is what is passed to the
17757 function that creates the location list, and the remaining
17758 locations just get added on to that list.
17759 Note that we only know the start address for a location
17760 (IE location changes), so to build the range, we use
17761 the range [current location start, next location start].
17762 This means we have to special case the last node, and generate
17763 a range of [last location start, end of function label]. */
17765 if (cfun
&& crtl
->has_bb_partition
)
17767 bool save_in_cold_section_p
= in_cold_section_p
;
17768 in_cold_section_p
= first_function_block_is_cold
;
17769 if (loc_list
->last_before_switch
== NULL
)
17770 in_cold_section_p
= !in_cold_section_p
;
17771 secname
= secname_for_decl (decl
);
17772 in_cold_section_p
= save_in_cold_section_p
;
17775 secname
= secname_for_decl (decl
);
17777 for (node
= loc_list
->first
; node
; node
= node
->next
)
17779 bool range_across_switch
= false;
17780 if (GET_CODE (node
->loc
) == EXPR_LIST
17781 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
17783 if (GET_CODE (node
->loc
) == EXPR_LIST
)
17786 /* This requires DW_OP_{,bit_}piece, which is not usable
17787 inside DWARF expressions. */
17788 if (want_address
== 2)
17789 descr
= dw_sra_loc_expr (decl
, node
->loc
);
17793 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
17794 varloc
= NOTE_VAR_LOCATION (node
->loc
);
17795 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
17799 /* If section switch happens in between node->label
17800 and node->next->label (or end of function) and
17801 we can't emit it as a single entry list,
17802 emit two ranges, first one ending at the end
17803 of first partition and second one starting at the
17804 beginning of second partition. */
17805 if (node
== loc_list
->last_before_switch
17806 && (node
!= loc_list
->first
|| loc_list
->first
->next
17807 /* If we are to emit a view number, we will emit
17808 a loclist rather than a single location
17809 expression for the entire function (see
17810 loc_list_has_views), so we have to split the
17811 range that straddles across partitions. */
17812 || !ZERO_VIEW_P (node
->view
))
17813 && current_function_decl
)
17815 endname
= cfun
->fde
->dw_fde_end
;
17817 range_across_switch
= true;
17819 /* The variable has a location between NODE->LABEL and
17820 NODE->NEXT->LABEL. */
17821 else if (node
->next
)
17822 endname
= node
->next
->label
, endview
= node
->next
->view
;
17823 /* If the variable has a location at the last label
17824 it keeps its location until the end of function. */
17825 else if (!current_function_decl
)
17826 endname
= text_end_label
, endview
= 0;
17829 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
17830 current_function_funcdef_no
);
17831 endname
= ggc_strdup (label_id
);
17835 *listp
= new_loc_list (descr
, node
->label
, node
->view
,
17836 endname
, endview
, secname
);
17837 if (TREE_CODE (decl
) == PARM_DECL
17838 && node
== loc_list
->first
17839 && NOTE_P (node
->loc
)
17840 && strcmp (node
->label
, endname
) == 0)
17841 (*listp
)->force
= true;
17842 listp
= &(*listp
)->dw_loc_next
;
17847 && crtl
->has_bb_partition
17848 && node
== loc_list
->last_before_switch
)
17850 bool save_in_cold_section_p
= in_cold_section_p
;
17851 in_cold_section_p
= !first_function_block_is_cold
;
17852 secname
= secname_for_decl (decl
);
17853 in_cold_section_p
= save_in_cold_section_p
;
17856 if (range_across_switch
)
17858 if (GET_CODE (node
->loc
) == EXPR_LIST
)
17859 descr
= dw_sra_loc_expr (decl
, node
->loc
);
17862 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
17863 varloc
= NOTE_VAR_LOCATION (node
->loc
);
17864 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
17867 gcc_assert (descr
);
17868 /* The variable has a location between NODE->LABEL and
17869 NODE->NEXT->LABEL. */
17871 endname
= node
->next
->label
, endview
= node
->next
->view
;
17873 endname
= cfun
->fde
->dw_fde_second_end
, endview
= 0;
17874 *listp
= new_loc_list (descr
, cfun
->fde
->dw_fde_second_begin
, 0,
17875 endname
, endview
, secname
);
17876 listp
= &(*listp
)->dw_loc_next
;
17880 /* Try to avoid the overhead of a location list emitting a location
17881 expression instead, but only if we didn't have more than one
17882 location entry in the first place. If some entries were not
17883 representable, we don't want to pretend a single entry that was
17884 applies to the entire scope in which the variable is
17886 if (list
&& loc_list
->first
->next
)
17889 maybe_gen_llsym (list
);
17894 /* Return true if the loc_list has only single element and thus
17895 can be represented as location description. */
17898 single_element_loc_list_p (dw_loc_list_ref list
)
17900 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
17901 return !list
->ll_symbol
;
17904 /* Duplicate a single element of location list. */
17906 static inline dw_loc_descr_ref
17907 copy_loc_descr (dw_loc_descr_ref ref
)
17909 dw_loc_descr_ref copy
= ggc_alloc
<dw_loc_descr_node
> ();
17910 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
17914 /* To each location in list LIST append loc descr REF. */
17917 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
17919 dw_loc_descr_ref copy
;
17920 add_loc_descr (&list
->expr
, ref
);
17921 list
= list
->dw_loc_next
;
17924 copy
= copy_loc_descr (ref
);
17925 add_loc_descr (&list
->expr
, copy
);
17926 while (copy
->dw_loc_next
)
17927 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
17928 list
= list
->dw_loc_next
;
17932 /* To each location in list LIST prepend loc descr REF. */
17935 prepend_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
17937 dw_loc_descr_ref copy
;
17938 dw_loc_descr_ref ref_end
= list
->expr
;
17939 add_loc_descr (&ref
, list
->expr
);
17941 list
= list
->dw_loc_next
;
17944 dw_loc_descr_ref end
= list
->expr
;
17945 list
->expr
= copy
= copy_loc_descr (ref
);
17946 while (copy
->dw_loc_next
!= ref_end
)
17947 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
17948 copy
->dw_loc_next
= end
;
17949 list
= list
->dw_loc_next
;
17953 /* Given two lists RET and LIST
17954 produce location list that is result of adding expression in LIST
17955 to expression in RET on each position in program.
17956 Might be destructive on both RET and LIST.
17958 TODO: We handle only simple cases of RET or LIST having at most one
17959 element. General case would involve sorting the lists in program order
17960 and merging them that will need some additional work.
17961 Adding that will improve quality of debug info especially for SRA-ed
17965 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
17974 if (!list
->dw_loc_next
)
17976 add_loc_descr_to_each (*ret
, list
->expr
);
17979 if (!(*ret
)->dw_loc_next
)
17981 prepend_loc_descr_to_each (list
, (*ret
)->expr
);
17985 expansion_failed (NULL_TREE
, NULL_RTX
,
17986 "Don't know how to merge two non-trivial"
17987 " location lists.\n");
17992 /* LOC is constant expression. Try a luck, look it up in constant
17993 pool and return its loc_descr of its address. */
17995 static dw_loc_descr_ref
17996 cst_pool_loc_descr (tree loc
)
17998 /* Get an RTL for this, if something has been emitted. */
17999 rtx rtl
= lookup_constant_def (loc
);
18001 if (!rtl
|| !MEM_P (rtl
))
18006 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
18008 /* TODO: We might get more coverage if we was actually delaying expansion
18009 of all expressions till end of compilation when constant pools are fully
18011 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
18013 expansion_failed (loc
, NULL_RTX
,
18014 "CST value in contant pool but not marked.");
18017 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
18018 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
18021 /* Return dw_loc_list representing address of addr_expr LOC
18022 by looking for inner INDIRECT_REF expression and turning
18023 it into simple arithmetics.
18025 See loc_list_from_tree for the meaning of CONTEXT. */
18027 static dw_loc_list_ref
18028 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
,
18029 loc_descr_context
*context
)
18032 poly_int64 bitsize
, bitpos
, bytepos
;
18034 int unsignedp
, reversep
, volatilep
= 0;
18035 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
18037 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
18038 &bitsize
, &bitpos
, &offset
, &mode
,
18039 &unsignedp
, &reversep
, &volatilep
);
18041 if (!multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
))
18043 expansion_failed (loc
, NULL_RTX
, "bitfield access");
18046 if (!INDIRECT_REF_P (obj
))
18048 expansion_failed (obj
,
18049 NULL_RTX
, "no indirect ref in inner refrence");
18052 if (!offset
&& known_eq (bitpos
, 0))
18053 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1,
18056 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
18057 && (dwarf_version
>= 4 || !dwarf_strict
))
18059 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0, context
);
18064 /* Variable offset. */
18065 list_ret1
= loc_list_from_tree (offset
, 0, context
);
18066 if (list_ret1
== 0)
18068 add_loc_list (&list_ret
, list_ret1
);
18071 add_loc_descr_to_each (list_ret
,
18072 new_loc_descr (DW_OP_plus
, 0, 0));
18074 HOST_WIDE_INT value
;
18075 if (bytepos
.is_constant (&value
) && value
> 0)
18076 add_loc_descr_to_each (list_ret
,
18077 new_loc_descr (DW_OP_plus_uconst
, value
, 0));
18078 else if (maybe_ne (bytepos
, 0))
18079 loc_list_plus_const (list_ret
, bytepos
);
18080 add_loc_descr_to_each (list_ret
,
18081 new_loc_descr (DW_OP_stack_value
, 0, 0));
18086 /* Set LOC to the next operation that is not a DW_OP_nop operation. In the case
18087 all operations from LOC are nops, move to the last one. Insert in NOPS all
18088 operations that are skipped. */
18091 loc_descr_to_next_no_nop (dw_loc_descr_ref
&loc
,
18092 hash_set
<dw_loc_descr_ref
> &nops
)
18094 while (loc
->dw_loc_next
!= NULL
&& loc
->dw_loc_opc
== DW_OP_nop
)
18097 loc
= loc
->dw_loc_next
;
18101 /* Helper for loc_descr_without_nops: free the location description operation
18105 free_loc_descr (const dw_loc_descr_ref
&loc
, void *data ATTRIBUTE_UNUSED
)
18111 /* Remove all DW_OP_nop operations from LOC except, if it exists, the one that
18115 loc_descr_without_nops (dw_loc_descr_ref
&loc
)
18117 if (loc
->dw_loc_opc
== DW_OP_nop
&& loc
->dw_loc_next
== NULL
)
18120 /* Set of all DW_OP_nop operations we remove. */
18121 hash_set
<dw_loc_descr_ref
> nops
;
18123 /* First, strip all prefix NOP operations in order to keep the head of the
18124 operations list. */
18125 loc_descr_to_next_no_nop (loc
, nops
);
18127 for (dw_loc_descr_ref cur
= loc
; cur
!= NULL
;)
18129 /* For control flow operations: strip "prefix" nops in destination
18131 if (cur
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
)
18132 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd1
.v
.val_loc
, nops
);
18133 if (cur
->dw_loc_oprnd2
.val_class
== dw_val_class_loc
)
18134 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd2
.v
.val_loc
, nops
);
18136 /* Do the same for the operations that follow, then move to the next
18138 if (cur
->dw_loc_next
!= NULL
)
18139 loc_descr_to_next_no_nop (cur
->dw_loc_next
, nops
);
18140 cur
= cur
->dw_loc_next
;
18143 nops
.traverse
<void *, free_loc_descr
> (NULL
);
18147 struct dwarf_procedure_info
;
18149 /* Helper structure for location descriptions generation. */
18150 struct loc_descr_context
18152 /* The type that is implicitly referenced by DW_OP_push_object_address, or
18153 NULL_TREE if DW_OP_push_object_address in invalid for this location
18154 description. This is used when processing PLACEHOLDER_EXPR nodes. */
18156 /* The ..._DECL node that should be translated as a
18157 DW_OP_push_object_address operation. */
18159 /* Information about the DWARF procedure we are currently generating. NULL if
18160 we are not generating a DWARF procedure. */
18161 struct dwarf_procedure_info
*dpi
;
18162 /* True if integral PLACEHOLDER_EXPR stands for the first argument passed
18163 by consumer. Used for DW_TAG_generic_subrange attributes. */
18164 bool placeholder_arg
;
18165 /* True if PLACEHOLDER_EXPR has been seen. */
18166 bool placeholder_seen
;
18167 /* True if strict preservation of signedness has been requested. */
18168 bool strict_signedness
;
18171 /* DWARF procedures generation
18173 DWARF expressions (aka. location descriptions) are used to encode variable
18174 things such as sizes or offsets. Such computations can have redundant parts
18175 that can be factorized in order to reduce the size of the output debug
18176 information. This is the whole point of DWARF procedures.
18178 Thanks to stor-layout.cc, size and offset expressions in GENERIC trees are
18179 already factorized into functions ("size functions") in order to handle very
18180 big and complex types. Such functions are quite simple: they have integral
18181 arguments, they return an integral result and their body contains only a
18182 return statement with arithmetic expressions. This is the only kind of
18183 function we are interested in translating into DWARF procedures, here.
18185 DWARF expressions and DWARF procedure are executed using a stack, so we have
18186 to define some calling convention for them to interact. Let's say that:
18188 - Before calling a DWARF procedure, DWARF expressions must push on the stack
18189 all arguments in reverse order (right-to-left) so that when the DWARF
18190 procedure execution starts, the first argument is the top of the stack.
18192 - Then, when returning, the DWARF procedure must have consumed all arguments
18193 on the stack, must have pushed the result and touched nothing else.
18195 - Each integral argument and the result are integral types can be hold in a
18198 - We call "frame offset" the number of stack slots that are "under DWARF
18199 procedure control": it includes the arguments slots, the temporaries and
18200 the result slot. Thus, it is equal to the number of arguments when the
18201 procedure execution starts and must be equal to one (the result) when it
18204 /* Helper structure used when generating operations for a DWARF procedure. */
18205 struct dwarf_procedure_info
18207 /* The FUNCTION_DECL node corresponding to the DWARF procedure that is
18208 currently translated. */
18210 /* The number of arguments FNDECL takes. */
18211 unsigned args_count
;
18214 /* Return a pointer to a newly created DIE node for a DWARF procedure. Add
18215 LOCATION as its DW_AT_location attribute. If FNDECL is not NULL_TREE,
18216 equate it to this DIE. */
18219 new_dwarf_proc_die (dw_loc_descr_ref location
, tree fndecl
,
18220 dw_die_ref parent_die
)
18222 dw_die_ref dwarf_proc_die
;
18224 if ((dwarf_version
< 3 && dwarf_strict
)
18225 || location
== NULL
)
18228 dwarf_proc_die
= new_die (DW_TAG_dwarf_procedure
, parent_die
, fndecl
);
18230 equate_decl_number_to_die (fndecl
, dwarf_proc_die
);
18231 add_AT_loc (dwarf_proc_die
, DW_AT_location
, location
);
18232 return dwarf_proc_die
;
18235 /* Return whether TYPE is a supported type as a DWARF procedure argument
18236 type or return type (we handle only scalar types and pointer types that
18237 aren't wider than the DWARF expression evaluation stack). */
18240 is_handled_procedure_type (tree type
)
18242 return ((INTEGRAL_TYPE_P (type
)
18243 || TREE_CODE (type
) == OFFSET_TYPE
18244 || TREE_CODE (type
) == POINTER_TYPE
)
18245 && int_size_in_bytes (type
) <= DWARF2_ADDR_SIZE
);
18248 /* Helper for resolve_args_picking: do the same but stop when coming across
18249 visited nodes. For each node we visit, register in FRAME_OFFSETS the frame
18250 offset *before* evaluating the corresponding operation. */
18253 resolve_args_picking_1 (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
18254 struct dwarf_procedure_info
*dpi
,
18255 hash_map
<dw_loc_descr_ref
, unsigned> &frame_offsets
)
18257 /* The "frame_offset" identifier is already used to name a macro... */
18258 unsigned frame_offset_
= initial_frame_offset
;
18259 dw_loc_descr_ref l
;
18261 for (l
= loc
; l
!= NULL
;)
18264 unsigned &l_frame_offset
= frame_offsets
.get_or_insert (l
, &existed
);
18266 /* If we already met this node, there is nothing to compute anymore. */
18269 /* Make sure that the stack size is consistent wherever the execution
18270 flow comes from. */
18271 gcc_assert ((unsigned) l_frame_offset
== frame_offset_
);
18274 l_frame_offset
= frame_offset_
;
18276 /* If needed, relocate the picking offset with respect to the frame
18278 if (l
->frame_offset_rel
)
18280 unsigned HOST_WIDE_INT off
;
18281 switch (l
->dw_loc_opc
)
18284 off
= l
->dw_loc_oprnd1
.v
.val_unsigned
;
18293 gcc_unreachable ();
18295 /* frame_offset_ is the size of the current stack frame, including
18296 incoming arguments. Besides, the arguments are pushed
18297 right-to-left. Thus, in order to access the Nth argument from
18298 this operation node, the picking has to skip temporaries *plus*
18299 one stack slot per argument (0 for the first one, 1 for the second
18302 The targetted argument number (N) is already set as the operand,
18303 and the number of temporaries can be computed with:
18304 frame_offsets_ - dpi->args_count */
18305 off
+= frame_offset_
- dpi
->args_count
;
18307 /* DW_OP_pick handles only offsets from 0 to 255 (inclusive)... */
18313 l
->dw_loc_opc
= DW_OP_dup
;
18314 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
18318 l
->dw_loc_opc
= DW_OP_over
;
18319 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
18323 l
->dw_loc_opc
= DW_OP_pick
;
18324 l
->dw_loc_oprnd1
.v
.val_unsigned
= off
;
18328 /* Update frame_offset according to the effect the current operation has
18330 switch (l
->dw_loc_opc
)
18338 case DW_OP_plus_uconst
:
18374 case DW_OP_deref_size
:
18376 case DW_OP_bit_piece
:
18377 case DW_OP_implicit_value
:
18378 case DW_OP_stack_value
:
18379 case DW_OP_deref_type
:
18380 case DW_OP_convert
:
18381 case DW_OP_reinterpret
:
18382 case DW_OP_GNU_deref_type
:
18383 case DW_OP_GNU_convert
:
18384 case DW_OP_GNU_reinterpret
:
18388 case DW_OP_const1u
:
18389 case DW_OP_const1s
:
18390 case DW_OP_const2u
:
18391 case DW_OP_const2s
:
18392 case DW_OP_const4u
:
18393 case DW_OP_const4s
:
18394 case DW_OP_const8u
:
18395 case DW_OP_const8s
:
18466 case DW_OP_push_object_address
:
18467 case DW_OP_call_frame_cfa
:
18468 case DW_OP_GNU_variable_value
:
18469 case DW_OP_GNU_addr_index
:
18470 case DW_OP_GNU_const_index
:
18495 case DW_OP_xderef_size
:
18501 case DW_OP_call_ref
:
18503 dw_die_ref dwarf_proc
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
18504 int *stack_usage
= dwarf_proc_stack_usage_map
->get (dwarf_proc
);
18506 if (stack_usage
== NULL
)
18508 frame_offset_
+= *stack_usage
;
18512 case DW_OP_implicit_pointer
:
18513 case DW_OP_entry_value
:
18514 case DW_OP_const_type
:
18515 case DW_OP_regval_type
:
18516 case DW_OP_form_tls_address
:
18517 case DW_OP_GNU_push_tls_address
:
18518 case DW_OP_GNU_uninit
:
18519 case DW_OP_GNU_encoded_addr
:
18520 case DW_OP_GNU_implicit_pointer
:
18521 case DW_OP_GNU_entry_value
:
18522 case DW_OP_GNU_const_type
:
18523 case DW_OP_GNU_regval_type
:
18524 case DW_OP_GNU_parameter_ref
:
18525 /* loc_list_from_tree will probably not output these operations for
18526 size functions, so assume they will not appear here. */
18527 /* Fall through... */
18530 gcc_unreachable ();
18533 /* Now, follow the control flow (except subroutine calls). */
18534 switch (l
->dw_loc_opc
)
18537 if (!resolve_args_picking_1 (l
->dw_loc_next
, frame_offset_
, dpi
,
18540 /* Fall through. */
18543 l
= l
->dw_loc_oprnd1
.v
.val_loc
;
18546 case DW_OP_stack_value
:
18550 l
= l
->dw_loc_next
;
18558 /* Make a DFS over operations reachable through LOC (i.e. follow branch
18559 operations) in order to resolve the operand of DW_OP_pick operations that
18560 target DWARF procedure arguments (DPI). INITIAL_FRAME_OFFSET is the frame
18561 offset *before* LOC is executed. Return if all relocations were
18565 resolve_args_picking (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
18566 struct dwarf_procedure_info
*dpi
)
18568 /* Associate to all visited operations the frame offset *before* evaluating
18570 hash_map
<dw_loc_descr_ref
, unsigned> frame_offsets
;
18573 resolve_args_picking_1 (loc
, initial_frame_offset
, dpi
, frame_offsets
);
18576 /* Try to generate a DWARF procedure that computes the same result as FNDECL.
18577 Return NULL if it is not possible. */
18580 function_to_dwarf_procedure (tree fndecl
)
18582 struct dwarf_procedure_info dpi
;
18583 struct loc_descr_context ctx
= {
18584 NULL_TREE
, /* context_type */
18585 NULL_TREE
, /* base_decl */
18587 false, /* placeholder_arg */
18588 false, /* placeholder_seen */
18589 true /* strict_signedness */
18591 dw_die_ref dwarf_proc_die
;
18592 tree tree_body
= DECL_SAVED_TREE (fndecl
);
18593 dw_loc_descr_ref loc_body
, epilogue
;
18598 /* Do not generate multiple DWARF procedures for the same function
18600 dwarf_proc_die
= lookup_decl_die (fndecl
);
18601 if (dwarf_proc_die
!= NULL
)
18602 return dwarf_proc_die
;
18604 /* DWARF procedures are available starting with the DWARFv3 standard. */
18605 if (dwarf_version
< 3 && dwarf_strict
)
18608 /* We handle only functions for which we still have a body, that return a
18609 supported type and that takes arguments with supported types. Note that
18610 there is no point translating functions that return nothing. */
18611 if (tree_body
== NULL_TREE
18612 || DECL_RESULT (fndecl
) == NULL_TREE
18613 || !is_handled_procedure_type (TREE_TYPE (DECL_RESULT (fndecl
))))
18616 for (cursor
= DECL_ARGUMENTS (fndecl
);
18617 cursor
!= NULL_TREE
;
18618 cursor
= TREE_CHAIN (cursor
))
18619 if (!is_handled_procedure_type (TREE_TYPE (cursor
)))
18622 /* Match only "expr" in: RETURN_EXPR (MODIFY_EXPR (RESULT_DECL, expr)). */
18623 if (TREE_CODE (tree_body
) != RETURN_EXPR
)
18625 tree_body
= TREE_OPERAND (tree_body
, 0);
18626 if (TREE_CODE (tree_body
) != MODIFY_EXPR
18627 || TREE_OPERAND (tree_body
, 0) != DECL_RESULT (fndecl
))
18629 tree_body
= TREE_OPERAND (tree_body
, 1);
18631 /* Try to translate the body expression itself. Note that this will probably
18632 cause an infinite recursion if its call graph has a cycle. This is very
18633 unlikely for size functions, however, so don't bother with such things at
18635 dpi
.fndecl
= fndecl
;
18636 dpi
.args_count
= list_length (DECL_ARGUMENTS (fndecl
));
18637 loc_body
= loc_descriptor_from_tree (tree_body
, 0, &ctx
);
18641 /* After evaluating all operands in "loc_body", we should still have on the
18642 stack all arguments plus the desired function result (top of the stack).
18643 Generate code in order to keep only the result in our stack frame. */
18645 for (i
= 0; i
< dpi
.args_count
; ++i
)
18647 dw_loc_descr_ref op_couple
= new_loc_descr (DW_OP_swap
, 0, 0);
18648 op_couple
->dw_loc_next
= new_loc_descr (DW_OP_drop
, 0, 0);
18649 op_couple
->dw_loc_next
->dw_loc_next
= epilogue
;
18650 epilogue
= op_couple
;
18652 add_loc_descr (&loc_body
, epilogue
);
18653 if (!resolve_args_picking (loc_body
, dpi
.args_count
, &dpi
))
18656 /* Trailing nops from loc_descriptor_from_tree (if any) cannot be removed
18657 because they are considered useful. Now there is an epilogue, they are
18658 not anymore, so give it another try. */
18659 loc_descr_without_nops (loc_body
);
18661 /* fndecl may be used both as a regular DW_TAG_subprogram DIE and as
18662 a DW_TAG_dwarf_procedure, so we may have a conflict, here. It's unlikely,
18663 though, given that size functions do not come from source, so they should
18664 not have a dedicated DW_TAG_subprogram DIE. */
18666 = new_dwarf_proc_die (loc_body
, fndecl
,
18667 get_context_die (DECL_CONTEXT (fndecl
)));
18669 /* The called DWARF procedure consumes one stack slot per argument and
18670 returns one stack slot. */
18671 dwarf_proc_stack_usage_map
->put (dwarf_proc_die
, 1 - dpi
.args_count
);
18673 return dwarf_proc_die
;
18676 /* Helper function for loc_list_from_tree. Perform OP binary op,
18677 but after converting arguments to type_die, afterwards convert
18678 back to unsigned. */
18680 static dw_loc_list_ref
18681 typed_binop_from_tree (enum dwarf_location_atom op
, tree loc
,
18682 dw_die_ref type_die
, scalar_int_mode mode
,
18683 struct loc_descr_context
*context
)
18685 dw_loc_list_ref op0
, op1
;
18686 dw_loc_descr_ref cvt
, binop
;
18688 if (type_die
== NULL
)
18691 op0
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0, context
);
18692 op1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
18693 if (op0
== NULL
|| op1
== NULL
)
18696 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
18697 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18698 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
18699 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18700 add_loc_descr_to_each (op0
, cvt
);
18702 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
18703 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18704 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
18705 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18706 add_loc_descr_to_each (op1
, cvt
);
18708 add_loc_list (&op0
, op1
);
18712 binop
= new_loc_descr (op
, 0, 0);
18713 convert_descriptor_to_mode (mode
, binop
);
18714 add_loc_descr_to_each (op0
, binop
);
18719 /* Generate Dwarf location list representing LOC.
18720 If WANT_ADDRESS is false, expression computing LOC will be computed
18721 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
18722 if WANT_ADDRESS is 2, expression computing address useable in location
18723 will be returned (i.e. DW_OP_reg can be used
18724 to refer to register values).
18726 CONTEXT provides information to customize the location descriptions
18727 generation. Its context_type field specifies what type is implicitly
18728 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
18729 will not be generated.
18731 Its DPI field determines whether we are generating a DWARF expression for a
18732 DWARF procedure, so PARM_DECL references are processed specifically.
18734 If CONTEXT is NULL, the behavior is the same as if context_type, base_decl
18735 and dpi fields were null. */
18737 static dw_loc_list_ref
18738 loc_list_from_tree_1 (tree loc
, int want_address
,
18739 struct loc_descr_context
*context
)
18741 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
18742 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
18743 int have_address
= 0;
18744 enum dwarf_location_atom op
;
18746 /* ??? Most of the time we do not take proper care for sign/zero
18747 extending the values properly. Hopefully this won't be a real
18750 if (context
!= NULL
18751 && context
->base_decl
== loc
18752 && want_address
== 0)
18754 if (dwarf_version
>= 3 || !dwarf_strict
)
18755 return new_loc_list (new_loc_descr (DW_OP_push_object_address
, 0, 0),
18756 NULL
, 0, NULL
, 0, NULL
);
18761 switch (TREE_CODE (loc
))
18764 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
18767 case PLACEHOLDER_EXPR
:
18768 /* This case involves extracting fields from an object to determine the
18769 position of other fields. It is supposed to appear only as the first
18770 operand of COMPONENT_REF nodes and to reference precisely the type
18771 that the context allows or its enclosing type. */
18772 if (context
!= NULL
18773 && (TREE_TYPE (loc
) == context
->context_type
18774 || TREE_TYPE (loc
) == TYPE_CONTEXT (context
->context_type
))
18775 && want_address
>= 1)
18777 if (dwarf_version
>= 3 || !dwarf_strict
)
18779 ret
= new_loc_descr (DW_OP_push_object_address
, 0, 0);
18786 /* For DW_TAG_generic_subrange attributes, PLACEHOLDER_EXPR stands for
18787 the single argument passed by consumer. */
18788 else if (context
!= NULL
18789 && context
->placeholder_arg
18790 && INTEGRAL_TYPE_P (TREE_TYPE (loc
))
18791 && want_address
== 0)
18793 ret
= new_loc_descr (DW_OP_pick
, 0, 0);
18794 ret
->frame_offset_rel
= 1;
18795 context
->placeholder_seen
= true;
18799 expansion_failed (loc
, NULL_RTX
,
18800 "PLACEHOLDER_EXPR for an unexpected type");
18805 tree callee
= get_callee_fndecl (loc
);
18806 dw_die_ref dwarf_proc
;
18809 && is_handled_procedure_type (TREE_TYPE (TREE_TYPE (callee
)))
18810 && (dwarf_proc
= function_to_dwarf_procedure (callee
)))
18812 /* DWARF procedures are used for size functions, which are built
18813 when size expressions contain conditional constructs, so we
18814 request strict preservation of signedness for comparisons. */
18815 bool old_strict_signedness
;
18818 old_strict_signedness
= context
->strict_signedness
;
18819 context
->strict_signedness
= true;
18822 /* Evaluate arguments right-to-left so that the first argument
18823 will be the top-most one on the stack. */
18824 for (int i
= call_expr_nargs (loc
) - 1; i
>= 0; --i
)
18826 tree arg
= CALL_EXPR_ARG (loc
, i
);
18827 ret1
= loc_descriptor_from_tree (arg
, 0, context
);
18830 expansion_failed (arg
, NULL_RTX
, "CALL_EXPR argument");
18833 add_loc_descr (&ret
, ret1
);
18836 ret1
= new_loc_descr (DW_OP_call4
, 0, 0);
18837 ret1
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18838 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.die
= dwarf_proc
;
18839 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18840 add_loc_descr (&ret
, ret1
);
18842 context
->strict_signedness
= old_strict_signedness
;
18845 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR target");
18849 case PREINCREMENT_EXPR
:
18850 case PREDECREMENT_EXPR
:
18851 case POSTINCREMENT_EXPR
:
18852 case POSTDECREMENT_EXPR
:
18853 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
18854 /* There are no opcodes for these operations. */
18858 /* If we already want an address, see if there is INDIRECT_REF inside
18859 e.g. for &this->field. */
18862 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
18863 (loc
, want_address
== 2, context
);
18866 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
18867 && (ret
= cst_pool_loc_descr (loc
)))
18870 /* Otherwise, process the argument and look for the address. */
18871 if (!list_ret
&& !ret
)
18872 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 1, context
);
18876 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
18882 if (DECL_THREAD_LOCAL_P (loc
))
18885 enum dwarf_location_atom tls_op
;
18886 enum dtprel_bool dtprel
= dtprel_false
;
18888 if (targetm
.have_tls
)
18890 /* If this is not defined, we have no way to emit the
18892 if (!targetm
.asm_out
.output_dwarf_dtprel
)
18895 /* The way DW_OP_GNU_push_tls_address is specified, we
18896 can only look up addresses of objects in the current
18897 module. We used DW_OP_addr as first op, but that's
18898 wrong, because DW_OP_addr is relocated by the debug
18899 info consumer, while DW_OP_GNU_push_tls_address
18900 operand shouldn't be. */
18901 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
18903 dtprel
= dtprel_true
;
18904 /* We check for DWARF 5 here because gdb did not implement
18905 DW_OP_form_tls_address until after 7.12. */
18906 tls_op
= (dwarf_version
>= 5 ? DW_OP_form_tls_address
18907 : DW_OP_GNU_push_tls_address
);
18911 if (!targetm
.emutls
.debug_form_tls_address
18912 || !(dwarf_version
>= 3 || !dwarf_strict
))
18914 /* We stuffed the control variable into the DECL_VALUE_EXPR
18915 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
18916 no longer appear in gimple code. We used the control
18917 variable in specific so that we could pick it up here. */
18918 loc
= DECL_VALUE_EXPR (loc
);
18919 tls_op
= DW_OP_form_tls_address
;
18922 rtl
= rtl_for_decl_location (loc
);
18923 if (rtl
== NULL_RTX
)
18928 rtl
= XEXP (rtl
, 0);
18929 if (! CONSTANT_P (rtl
))
18932 ret
= new_addr_loc_descr (rtl
, dtprel
);
18933 ret1
= new_loc_descr (tls_op
, 0, 0);
18934 add_loc_descr (&ret
, ret1
);
18942 if (context
!= NULL
&& context
->dpi
!= NULL
18943 && DECL_CONTEXT (loc
) == context
->dpi
->fndecl
)
18945 /* We are generating code for a DWARF procedure and we want to access
18946 one of its arguments: find the appropriate argument offset and let
18947 the resolve_args_picking pass compute the offset that complies
18948 with the stack frame size. */
18952 for (cursor
= DECL_ARGUMENTS (context
->dpi
->fndecl
);
18953 cursor
!= NULL_TREE
&& cursor
!= loc
;
18954 cursor
= TREE_CHAIN (cursor
), ++i
)
18956 /* If we are translating a DWARF procedure, all referenced parameters
18957 must belong to the current function. */
18958 gcc_assert (cursor
!= NULL_TREE
);
18960 ret
= new_loc_descr (DW_OP_pick
, i
, 0);
18961 ret
->frame_offset_rel
= 1;
18967 if (DECL_HAS_VALUE_EXPR_P (loc
))
18969 tree value_expr
= DECL_VALUE_EXPR (loc
);
18971 /* Non-local frame structures are DECL_IGNORED_P variables so we need
18972 to wait until they get an RTX in order to reference them. */
18974 && TREE_CODE (value_expr
) == COMPONENT_REF
18975 && VAR_P (TREE_OPERAND (value_expr
, 0))
18976 && DECL_NONLOCAL_FRAME (TREE_OPERAND (value_expr
, 0)))
18979 return loc_list_from_tree_1 (value_expr
, want_address
, context
);
18984 case FUNCTION_DECL
:
18987 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
18989 if (loc_list
&& loc_list
->first
)
18991 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
18992 have_address
= want_address
!= 0;
18995 rtl
= rtl_for_decl_location (loc
);
18996 if (rtl
== NULL_RTX
)
18998 if (TREE_CODE (loc
) != FUNCTION_DECL
19000 && want_address
!= 1
19001 && ! DECL_IGNORED_P (loc
)
19002 && (INTEGRAL_TYPE_P (TREE_TYPE (loc
))
19003 || POINTER_TYPE_P (TREE_TYPE (loc
)))
19004 && (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (loc
)))
19005 <= DWARF2_ADDR_SIZE
))
19007 dw_die_ref ref
= lookup_decl_die (loc
);
19010 ret
= new_loc_descr (DW_OP_GNU_variable_value
, 0, 0);
19011 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
19012 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
19013 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
19015 else if (current_function_decl
19016 && DECL_CONTEXT (loc
) == current_function_decl
)
19018 ret
= new_loc_descr (DW_OP_GNU_variable_value
, 0, 0);
19019 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
19020 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= loc
;
19024 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
19027 else if (CONST_INT_P (rtl
))
19029 HOST_WIDE_INT val
= INTVAL (rtl
);
19030 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
19031 val
&= GET_MODE_MASK (DECL_MODE (loc
));
19032 ret
= int_loc_descriptor (val
);
19034 else if (GET_CODE (rtl
) == CONST_STRING
)
19036 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
19039 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
19040 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
19043 machine_mode mode
, mem_mode
;
19045 /* Certain constructs can only be represented at top-level. */
19046 if (want_address
== 2)
19048 ret
= loc_descriptor (rtl
, VOIDmode
,
19049 VAR_INIT_STATUS_INITIALIZED
);
19054 mode
= GET_MODE (rtl
);
19055 mem_mode
= VOIDmode
;
19059 mode
= get_address_mode (rtl
);
19060 rtl
= XEXP (rtl
, 0);
19063 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
19064 VAR_INIT_STATUS_INITIALIZED
);
19067 expansion_failed (loc
, rtl
,
19068 "failed to produce loc descriptor for rtl");
19074 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
19081 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19085 case TARGET_MEM_REF
:
19087 case DEBUG_EXPR_DECL
:
19090 case COMPOUND_EXPR
:
19091 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), want_address
,
19095 case VIEW_CONVERT_EXPR
:
19098 case NON_LVALUE_EXPR
:
19099 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), want_address
,
19102 case COMPONENT_REF
:
19103 case BIT_FIELD_REF
:
19105 case ARRAY_RANGE_REF
:
19106 case REALPART_EXPR
:
19107 case IMAGPART_EXPR
:
19110 poly_int64 bitsize
, bitpos
, bytepos
;
19112 int unsignedp
, reversep
, volatilep
= 0;
19114 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
19115 &unsignedp
, &reversep
, &volatilep
);
19117 gcc_assert (obj
!= loc
);
19119 list_ret
= loc_list_from_tree_1 (obj
,
19121 && known_eq (bitpos
, 0)
19122 && !offset
? 2 : 1,
19124 /* TODO: We can extract value of the small expression via shifting even
19125 for nonzero bitpos. */
19128 if (!multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
19129 || !multiple_p (bitsize
, BITS_PER_UNIT
))
19131 expansion_failed (loc
, NULL_RTX
,
19132 "bitfield access");
19136 if (offset
!= NULL_TREE
)
19138 /* Variable offset. */
19139 list_ret1
= loc_list_from_tree_1 (offset
, 0, context
);
19140 if (list_ret1
== 0)
19142 add_loc_list (&list_ret
, list_ret1
);
19145 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
19148 HOST_WIDE_INT value
;
19149 if (bytepos
.is_constant (&value
) && value
> 0)
19150 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
,
19152 else if (maybe_ne (bytepos
, 0))
19153 loc_list_plus_const (list_ret
, bytepos
);
19160 if ((want_address
|| !tree_fits_shwi_p (loc
))
19161 && (ret
= cst_pool_loc_descr (loc
)))
19163 else if (want_address
== 2
19164 && tree_fits_shwi_p (loc
)
19165 && (ret
= address_of_int_loc_descriptor
19166 (int_size_in_bytes (TREE_TYPE (loc
)),
19167 tree_to_shwi (loc
))))
19169 else if (tree_fits_shwi_p (loc
))
19170 ret
= int_loc_descriptor (tree_to_shwi (loc
));
19171 else if (tree_fits_uhwi_p (loc
))
19172 ret
= uint_loc_descriptor (tree_to_uhwi (loc
));
19175 expansion_failed (loc
, NULL_RTX
,
19176 "Integer operand is not host integer");
19185 expansion_failed (loc
, NULL_RTX
,
19186 "constant address with a runtime component");
19190 if (!poly_int_tree_p (loc
, &value
))
19192 expansion_failed (loc
, NULL_RTX
, "constant too big");
19195 ret
= int_loc_descriptor (value
);
19203 if ((ret
= cst_pool_loc_descr (loc
)))
19205 else if (TREE_CODE (loc
) == CONSTRUCTOR
)
19207 tree type
= TREE_TYPE (loc
);
19208 unsigned HOST_WIDE_INT size
= int_size_in_bytes (type
);
19209 unsigned HOST_WIDE_INT offset
= 0;
19210 unsigned HOST_WIDE_INT cnt
;
19211 constructor_elt
*ce
;
19213 if (TREE_CODE (type
) == RECORD_TYPE
)
19215 /* This is very limited, but it's enough to output
19216 pointers to member functions, as long as the
19217 referenced function is defined in the current
19218 translation unit. */
19219 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (loc
), cnt
, ce
)
19221 tree val
= ce
->value
;
19223 tree field
= ce
->index
;
19228 if (!field
|| DECL_BIT_FIELD (field
))
19230 expansion_failed (loc
, NULL_RTX
,
19231 "bitfield in record type constructor");
19232 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
19237 HOST_WIDE_INT fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
19238 unsigned HOST_WIDE_INT pos
= int_byte_position (field
);
19239 gcc_assert (pos
+ fieldsize
<= size
);
19242 expansion_failed (loc
, NULL_RTX
,
19243 "out-of-order fields in record constructor");
19244 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
19250 ret1
= new_loc_descr (DW_OP_piece
, pos
- offset
, 0);
19251 add_loc_descr (&ret
, ret1
);
19254 if (val
&& fieldsize
!= 0)
19256 ret1
= loc_descriptor_from_tree (val
, want_address
, context
);
19259 expansion_failed (loc
, NULL_RTX
,
19260 "unsupported expression in field");
19261 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
19265 add_loc_descr (&ret
, ret1
);
19269 ret1
= new_loc_descr (DW_OP_piece
, fieldsize
, 0);
19270 add_loc_descr (&ret
, ret1
);
19271 offset
= pos
+ fieldsize
;
19275 if (offset
!= size
)
19277 ret1
= new_loc_descr (DW_OP_piece
, size
- offset
, 0);
19278 add_loc_descr (&ret
, ret1
);
19282 have_address
= !!want_address
;
19285 expansion_failed (loc
, NULL_RTX
,
19286 "constructor of non-record type");
19289 /* We can construct small constants here using int_loc_descriptor. */
19290 expansion_failed (loc
, NULL_RTX
,
19291 "constructor or constant not in constant pool");
19294 case TRUTH_AND_EXPR
:
19295 case TRUTH_ANDIF_EXPR
:
19300 case TRUTH_XOR_EXPR
:
19305 case TRUTH_OR_EXPR
:
19306 case TRUTH_ORIF_EXPR
:
19311 case EXACT_DIV_EXPR
:
19312 case FLOOR_DIV_EXPR
:
19313 case TRUNC_DIV_EXPR
:
19314 /* Turn a divide by a power of 2 into a shift when possible. */
19315 if (TYPE_UNSIGNED (TREE_TYPE (loc
))
19316 && tree_fits_uhwi_p (TREE_OPERAND (loc
, 1)))
19318 const int log2
= exact_log2 (tree_to_uhwi (TREE_OPERAND (loc
, 1)));
19322 = loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19326 add_loc_descr_to_each (list_ret
, uint_loc_descriptor (log2
));
19327 add_loc_descr_to_each (list_ret
,
19328 new_loc_descr (DW_OP_shr
, 0, 0));
19335 case CEIL_DIV_EXPR
:
19336 case ROUND_DIV_EXPR
:
19337 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
19339 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (loc
));
19340 scalar_int_mode int_mode
;
19342 if ((dwarf_strict
&& dwarf_version
< 5)
19343 || !is_a
<scalar_int_mode
> (mode
, &int_mode
))
19346 /* We can use a signed divide if the sign bit is not set. */
19347 if (GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
19353 list_ret
= typed_binop_from_tree (DW_OP_div
, loc
,
19354 base_type_for_mode (int_mode
, 1),
19355 int_mode
, context
);
19365 case FLOOR_MOD_EXPR
:
19366 case CEIL_MOD_EXPR
:
19367 case ROUND_MOD_EXPR
:
19368 case TRUNC_MOD_EXPR
:
19369 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
19374 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19375 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
19376 if (list_ret
== 0 || list_ret1
== 0)
19379 add_loc_list (&list_ret
, list_ret1
);
19382 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
19383 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
19384 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
19385 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
19386 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
19398 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
19401 case POINTER_PLUS_EXPR
:
19404 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
19406 /* Big unsigned numbers can fit in HOST_WIDE_INT but it may be
19407 smarter to encode their opposite. The DW_OP_plus_uconst operation
19408 takes 1 + X bytes, X being the size of the ULEB128 addend. On the
19409 other hand, a "<push literal>; DW_OP_minus" pattern takes 1 + Y
19410 bytes, Y being the size of the operation that pushes the opposite
19411 of the addend. So let's choose the smallest representation. */
19412 const tree tree_addend
= TREE_OPERAND (loc
, 1);
19413 offset_int wi_addend
;
19414 HOST_WIDE_INT shwi_addend
;
19415 dw_loc_descr_ref loc_naddend
;
19417 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19421 /* Try to get the literal to push. It is the opposite of the addend,
19422 so as we rely on wrapping during DWARF evaluation, first decode
19423 the literal as a "DWARF-sized" signed number. */
19424 wi_addend
= wi::to_offset (tree_addend
);
19425 wi_addend
= wi::sext (wi_addend
, DWARF2_ADDR_SIZE
* 8);
19426 shwi_addend
= wi_addend
.to_shwi ();
19427 loc_naddend
= (shwi_addend
!= INTTYPE_MINIMUM (HOST_WIDE_INT
))
19428 ? int_loc_descriptor (-shwi_addend
)
19431 if (loc_naddend
!= NULL
19432 && ((unsigned) size_of_uleb128 (shwi_addend
)
19433 > size_of_loc_descr (loc_naddend
)))
19435 add_loc_descr_to_each (list_ret
, loc_naddend
);
19436 add_loc_descr_to_each (list_ret
,
19437 new_loc_descr (DW_OP_minus
, 0, 0));
19441 for (dw_loc_descr_ref loc_cur
= loc_naddend
; loc_cur
!= NULL
; )
19443 loc_naddend
= loc_cur
;
19444 loc_cur
= loc_cur
->dw_loc_next
;
19445 ggc_free (loc_naddend
);
19447 loc_list_plus_const (list_ret
, wi_addend
.to_shwi ());
19457 goto do_comp_binop
;
19461 goto do_comp_binop
;
19465 goto do_comp_binop
;
19469 goto do_comp_binop
;
19472 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
19474 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0, context
);
19475 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
19476 list_ret
= loc_list_from_uint_comparison (list_ret
, list_ret1
,
19492 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19493 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
19494 if (list_ret
== 0 || list_ret1
== 0)
19497 add_loc_list (&list_ret
, list_ret1
);
19500 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
19503 case TRUTH_NOT_EXPR
:
19504 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19508 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_lit0
, 0, 0));
19509 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_eq
, 0, 0));
19525 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19529 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
19535 const enum tree_code code
=
19536 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
19538 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
19539 build2 (code
, integer_type_node
,
19540 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
19541 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
19548 dw_loc_descr_ref lhs
19549 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
19550 dw_loc_list_ref rhs
19551 = loc_list_from_tree_1 (TREE_OPERAND (loc
, 2), 0, context
);
19552 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
19554 /* DW_OP_bra is branch-on-nonzero so avoid doing useless work. */
19555 if (TREE_CODE (TREE_OPERAND (loc
, 0)) == NE_EXPR
19556 && integer_zerop (TREE_OPERAND (TREE_OPERAND (loc
, 0), 1)))
19558 = loc_list_from_tree_1 (TREE_OPERAND (TREE_OPERAND (loc
, 0), 0),
19560 /* Likewise, swap the operands for a logically negated condition. */
19561 else if (TREE_CODE (TREE_OPERAND (loc
, 0)) == TRUTH_NOT_EXPR
)
19563 lhs
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 2), 0, context
);
19564 rhs
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
19566 = loc_list_from_tree_1 (TREE_OPERAND (TREE_OPERAND (loc
, 0), 0),
19570 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19571 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
19574 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
19575 add_loc_descr_to_each (list_ret
, bra_node
);
19577 add_loc_list (&list_ret
, rhs
);
19578 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
19579 add_loc_descr_to_each (list_ret
, jump_node
);
19581 add_loc_descr_to_each (list_ret
, lhs
);
19582 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
19583 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
19585 /* ??? Need a node to point the skip at. Use a nop. */
19586 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
19587 add_loc_descr_to_each (list_ret
, tmp
);
19588 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
19589 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
19593 case FIX_TRUNC_EXPR
:
19596 case COMPOUND_LITERAL_EXPR
:
19597 return loc_list_from_tree_1 (COMPOUND_LITERAL_EXPR_DECL (loc
),
19601 /* Leave front-end specific codes as simply unknown. This comes
19602 up, for instance, with the C STMT_EXPR. */
19603 if ((unsigned int) TREE_CODE (loc
)
19604 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
19606 expansion_failed (loc
, NULL_RTX
,
19607 "language specific tree node");
19611 /* Otherwise this is a generic code; we should just lists all of
19612 these explicitly. We forgot one. */
19614 gcc_unreachable ();
19616 /* In a release build, we want to degrade gracefully: better to
19617 generate incomplete debugging information than to crash. */
19621 if (!ret
&& !list_ret
)
19624 if (want_address
== 2 && !have_address
19625 && (dwarf_version
>= 4 || !dwarf_strict
))
19627 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
19629 expansion_failed (loc
, NULL_RTX
,
19630 "DWARF address size mismatch");
19634 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
19636 add_loc_descr_to_each (list_ret
,
19637 new_loc_descr (DW_OP_stack_value
, 0, 0));
19640 /* Show if we can't fill the request for an address. */
19641 if (want_address
&& !have_address
)
19643 expansion_failed (loc
, NULL_RTX
,
19644 "Want address and only have value");
19648 gcc_assert (!ret
|| !list_ret
);
19650 /* If we've got an address and don't want one, dereference. */
19651 if (!want_address
&& have_address
)
19653 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
19654 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (loc
));
19655 scalar_int_mode int_mode
;
19656 dw_die_ref type_die
;
19657 dw_loc_descr_ref deref
;
19659 /* If the size is greater than DWARF2_ADDR_SIZE, bail out. */
19660 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
19662 expansion_failed (loc
, NULL_RTX
,
19663 "DWARF address size mismatch");
19667 /* If it is equal to DWARF2_ADDR_SIZE, extension does not matter. */
19668 else if (size
== DWARF2_ADDR_SIZE
)
19669 deref
= new_loc_descr (DW_OP_deref
, size
, 0);
19671 /* If it is lower than DWARF2_ADDR_SIZE, DW_OP_deref_size will zero-
19672 extend the value, which is really OK for unsigned types only. */
19673 else if (!(context
&& context
->strict_signedness
)
19674 || TYPE_UNSIGNED (TREE_TYPE (loc
))
19675 || (dwarf_strict
&& dwarf_version
< 5)
19676 || !is_a
<scalar_int_mode
> (mode
, &int_mode
)
19677 || !(type_die
= base_type_for_mode (mode
, false)))
19678 deref
= new_loc_descr (DW_OP_deref_size
, size
, 0);
19680 /* Use DW_OP_deref_type for signed integral types if possible, but
19681 convert back to the generic type to avoid type mismatches later. */
19684 deref
= new_loc_descr (dwarf_OP (DW_OP_deref_type
), size
, 0);
19685 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
19686 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
19687 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
19688 add_loc_descr (&deref
,
19689 new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0));
19693 add_loc_descr (&ret
, deref
);
19695 add_loc_descr_to_each (list_ret
, deref
);
19699 list_ret
= new_loc_list (ret
, NULL
, 0, NULL
, 0, NULL
);
19704 /* Likewise, but strip useless DW_OP_nop operations in the resulting
19707 static dw_loc_list_ref
19708 loc_list_from_tree (tree loc
, int want_address
,
19709 struct loc_descr_context
*context
)
19711 dw_loc_list_ref result
= loc_list_from_tree_1 (loc
, want_address
, context
);
19713 for (dw_loc_list_ref loc_cur
= result
;
19714 loc_cur
!= NULL
; loc_cur
= loc_cur
->dw_loc_next
)
19715 loc_descr_without_nops (loc_cur
->expr
);
19719 /* Same as above but return only single location expression. */
19720 static dw_loc_descr_ref
19721 loc_descriptor_from_tree (tree loc
, int want_address
,
19722 struct loc_descr_context
*context
)
19724 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
, context
);
19727 if (ret
->dw_loc_next
)
19729 expansion_failed (loc
, NULL_RTX
,
19730 "Location list where only loc descriptor needed");
19736 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
19737 pointer to the declared type for the relevant field variable, or return
19738 `integer_type_node' if the given node turns out to be an
19739 ERROR_MARK node. */
19742 field_type (const_tree decl
)
19746 if (TREE_CODE (decl
) == ERROR_MARK
)
19747 return integer_type_node
;
19749 type
= DECL_BIT_FIELD_TYPE (decl
);
19750 if (type
== NULL_TREE
)
19751 type
= TREE_TYPE (decl
);
19756 /* Given a pointer to a tree node, return the alignment in bits for
19757 it, or else return BITS_PER_WORD if the node actually turns out to
19758 be an ERROR_MARK node. */
19760 static inline unsigned
19761 simple_type_align_in_bits (const_tree type
)
19763 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
19766 static inline unsigned
19767 simple_decl_align_in_bits (const_tree decl
)
19769 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
19772 /* Return the result of rounding T up to ALIGN. */
19774 static inline offset_int
19775 round_up_to_align (const offset_int
&t
, unsigned int align
)
19777 return wi::udiv_trunc (t
+ align
- 1, align
) * align
;
19780 /* Helper structure for RECORD_TYPE processing. */
19783 /* Root RECORD_TYPE. It is needed to generate data member location
19784 descriptions in variable-length records (VLR), but also to cope with
19785 variants, which are composed of nested structures multiplexed with
19786 QUAL_UNION_TYPE nodes. Each time such a structure is passed to a
19787 function processing a FIELD_DECL, it is required to be non null. */
19790 /* When generating a variant part in a RECORD_TYPE (i.e. a nested
19791 QUAL_UNION_TYPE), this holds an expression that computes the offset for
19792 this variant part as part of the root record (in storage units). For
19793 regular records, it must be NULL_TREE. */
19794 tree variant_part_offset
;
19797 /* Given a pointer to a FIELD_DECL, compute the byte offset of the lowest
19798 addressed byte of the "containing object" for the given FIELD_DECL. If
19799 possible, return a native constant through CST_OFFSET (in which case NULL is
19800 returned); otherwise return a DWARF expression that computes the offset.
19802 Set *CST_OFFSET to 0 and return NULL if we are unable to determine what
19803 that offset is, either because the argument turns out to be a pointer to an
19804 ERROR_MARK node, or because the offset expression is too complex for us.
19806 CTX is required: see the comment for VLR_CONTEXT. */
19808 static dw_loc_descr_ref
19809 field_byte_offset (const_tree decl
, struct vlr_context
*ctx
,
19810 HOST_WIDE_INT
*cst_offset
)
19813 dw_loc_list_ref loc_result
;
19817 if (TREE_CODE (decl
) == ERROR_MARK
)
19820 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
19822 /* We cannot handle variable bit offsets at the moment, so abort if it's the
19824 if (TREE_CODE (DECL_FIELD_BIT_OFFSET (decl
)) != INTEGER_CST
)
19827 /* We used to handle only constant offsets in all cases. Now, we handle
19828 properly dynamic byte offsets only when PCC bitfield type doesn't
19830 if (PCC_BITFIELD_TYPE_MATTERS
19831 && DECL_BIT_FIELD_TYPE (decl
)
19832 && TREE_CODE (DECL_FIELD_OFFSET (decl
)) == INTEGER_CST
)
19834 offset_int object_offset_in_bits
;
19835 offset_int object_offset_in_bytes
;
19836 offset_int bitpos_int
;
19838 tree field_size_tree
;
19839 offset_int deepest_bitpos
;
19840 offset_int field_size_in_bits
;
19841 unsigned int type_align_in_bits
;
19842 unsigned int decl_align_in_bits
;
19843 offset_int type_size_in_bits
;
19845 bitpos_int
= wi::to_offset (bit_position (decl
));
19846 type
= field_type (decl
);
19847 type_size_in_bits
= offset_int_type_size_in_bits (type
);
19848 type_align_in_bits
= simple_type_align_in_bits (type
);
19850 field_size_tree
= DECL_SIZE (decl
);
19852 /* The size could be unspecified if there was an error, or for
19853 a flexible array member. */
19854 if (!field_size_tree
)
19855 field_size_tree
= bitsize_zero_node
;
19857 /* If the size of the field is not constant, use the type size. */
19858 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
19859 field_size_in_bits
= wi::to_offset (field_size_tree
);
19861 field_size_in_bits
= type_size_in_bits
;
19863 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
19865 /* The GCC front-end doesn't make any attempt to keep track of the
19866 starting bit offset (relative to the start of the containing
19867 structure type) of the hypothetical "containing object" for a
19868 bit-field. Thus, when computing the byte offset value for the
19869 start of the "containing object" of a bit-field, we must deduce
19870 this information on our own. This can be rather tricky to do in
19871 some cases. For example, handling the following structure type
19872 definition when compiling for an i386/i486 target (which only
19873 aligns long long's to 32-bit boundaries) can be very tricky:
19875 struct S { int field1; long long field2:31; };
19877 Fortunately, there is a simple rule-of-thumb which can be used
19878 in such cases. When compiling for an i386/i486, GCC will
19879 allocate 8 bytes for the structure shown above. It decides to
19880 do this based upon one simple rule for bit-field allocation.
19881 GCC allocates each "containing object" for each bit-field at
19882 the first (i.e. lowest addressed) legitimate alignment boundary
19883 (based upon the required minimum alignment for the declared
19884 type of the field) which it can possibly use, subject to the
19885 condition that there is still enough available space remaining
19886 in the containing object (when allocated at the selected point)
19887 to fully accommodate all of the bits of the bit-field itself.
19889 This simple rule makes it obvious why GCC allocates 8 bytes for
19890 each object of the structure type shown above. When looking
19891 for a place to allocate the "containing object" for `field2',
19892 the compiler simply tries to allocate a 64-bit "containing
19893 object" at each successive 32-bit boundary (starting at zero)
19894 until it finds a place to allocate that 64- bit field such that
19895 at least 31 contiguous (and previously unallocated) bits remain
19896 within that selected 64 bit field. (As it turns out, for the
19897 example above, the compiler finds it is OK to allocate the
19898 "containing object" 64-bit field at bit-offset zero within the
19901 Here we attempt to work backwards from the limited set of facts
19902 we're given, and we try to deduce from those facts, where GCC
19903 must have believed that the containing object started (within
19904 the structure type). The value we deduce is then used (by the
19905 callers of this routine) to generate DW_AT_location and
19906 DW_AT_bit_offset attributes for fields (both bit-fields and, in
19907 the case of DW_AT_location, regular fields as well). */
19909 /* Figure out the bit-distance from the start of the structure to
19910 the "deepest" bit of the bit-field. */
19911 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
19913 /* This is the tricky part. Use some fancy footwork to deduce
19914 where the lowest addressed bit of the containing object must
19916 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
19918 /* Round up to type_align by default. This works best for
19920 object_offset_in_bits
19921 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
19923 if (wi::gtu_p (object_offset_in_bits
, bitpos_int
))
19925 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
19927 /* Round up to decl_align instead. */
19928 object_offset_in_bits
19929 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
19932 object_offset_in_bytes
19933 = wi::lrshift (object_offset_in_bits
, LOG2_BITS_PER_UNIT
);
19934 if (ctx
->variant_part_offset
== NULL_TREE
)
19936 *cst_offset
= object_offset_in_bytes
.to_shwi ();
19939 tree_result
= wide_int_to_tree (sizetype
, object_offset_in_bytes
);
19942 tree_result
= byte_position (decl
);
19944 if (ctx
->variant_part_offset
!= NULL_TREE
)
19945 tree_result
= fold_build2 (PLUS_EXPR
, TREE_TYPE (tree_result
),
19946 ctx
->variant_part_offset
, tree_result
);
19948 /* If the byte offset is a constant, it's simplier to handle a native
19949 constant rather than a DWARF expression. */
19950 if (TREE_CODE (tree_result
) == INTEGER_CST
)
19952 *cst_offset
= wi::to_offset (tree_result
).to_shwi ();
19956 struct loc_descr_context loc_ctx
= {
19957 ctx
->struct_type
, /* context_type */
19958 NULL_TREE
, /* base_decl */
19960 false, /* placeholder_arg */
19961 false, /* placeholder_seen */
19962 false /* strict_signedness */
19964 loc_result
= loc_list_from_tree (tree_result
, 0, &loc_ctx
);
19966 /* We want a DWARF expression: abort if we only have a location list with
19967 multiple elements. */
19968 if (!loc_result
|| !single_element_loc_list_p (loc_result
))
19971 return loc_result
->expr
;
19974 /* The following routines define various Dwarf attributes and any data
19975 associated with them. */
19977 /* Add a location description attribute value to a DIE.
19979 This emits location attributes suitable for whole variables and
19980 whole parameters. Note that the location attributes for struct fields are
19981 generated by the routine `data_member_location_attribute' below. */
19984 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
19985 dw_loc_list_ref descr
)
19987 bool check_no_locviews
= true;
19990 if (single_element_loc_list_p (descr
))
19991 add_AT_loc (die
, attr_kind
, descr
->expr
);
19994 add_AT_loc_list (die
, attr_kind
, descr
);
19995 gcc_assert (descr
->ll_symbol
);
19996 if (attr_kind
== DW_AT_location
&& descr
->vl_symbol
19997 && dwarf2out_locviews_in_attribute ())
19999 add_AT_view_list (die
, DW_AT_GNU_locviews
);
20000 check_no_locviews
= false;
20004 if (check_no_locviews
)
20005 gcc_assert (!get_AT (die
, DW_AT_GNU_locviews
));
20008 /* Add DW_AT_accessibility attribute to DIE if needed. */
20011 add_accessibility_attribute (dw_die_ref die
, tree decl
)
20013 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
20014 children, otherwise the default is DW_ACCESS_public. In DWARF2
20015 the default has always been DW_ACCESS_public. */
20016 if (TREE_PROTECTED (decl
))
20017 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
20018 else if (TREE_PRIVATE (decl
))
20020 if (dwarf_version
== 2
20021 || die
->die_parent
== NULL
20022 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
20023 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
20025 else if (dwarf_version
> 2
20027 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
20028 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
20031 /* Attach the specialized form of location attribute used for data members of
20032 struct and union types. In the special case of a FIELD_DECL node which
20033 represents a bit-field, the "offset" part of this special location
20034 descriptor must indicate the distance in bytes from the lowest-addressed
20035 byte of the containing struct or union type to the lowest-addressed byte of
20036 the "containing object" for the bit-field. (See the `field_byte_offset'
20039 For any given bit-field, the "containing object" is a hypothetical object
20040 (of some integral or enum type) within which the given bit-field lives. The
20041 type of this hypothetical "containing object" is always the same as the
20042 declared type of the individual bit-field itself (for GCC anyway... the
20043 DWARF spec doesn't actually mandate this). Note that it is the size (in
20044 bytes) of the hypothetical "containing object" which will be given in the
20045 DW_AT_byte_size attribute for this bit-field. (See the
20046 `byte_size_attribute' function below.) It is also used when calculating the
20047 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
20050 CTX is required: see the comment for VLR_CONTEXT. */
20053 add_data_member_location_attribute (dw_die_ref die
,
20055 struct vlr_context
*ctx
)
20057 HOST_WIDE_INT offset
;
20058 dw_loc_descr_ref loc_descr
= 0;
20060 if (TREE_CODE (decl
) == TREE_BINFO
)
20062 /* We're working on the TAG_inheritance for a base class. */
20063 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
20065 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
20066 aren't at a fixed offset from all (sub)objects of the same
20067 type. We need to extract the appropriate offset from our
20068 vtable. The following dwarf expression means
20070 BaseAddr = ObAddr + *((*ObAddr) - Offset)
20072 This is specific to the V3 ABI, of course. */
20074 dw_loc_descr_ref tmp
;
20076 /* Make a copy of the object address. */
20077 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
20078 add_loc_descr (&loc_descr
, tmp
);
20080 /* Extract the vtable address. */
20081 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
20082 add_loc_descr (&loc_descr
, tmp
);
20084 /* Calculate the address of the offset. */
20085 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
20086 gcc_assert (offset
< 0);
20088 tmp
= int_loc_descriptor (-offset
);
20089 add_loc_descr (&loc_descr
, tmp
);
20090 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
20091 add_loc_descr (&loc_descr
, tmp
);
20093 /* Extract the offset. */
20094 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
20095 add_loc_descr (&loc_descr
, tmp
);
20097 /* Add it to the object address. */
20098 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
20099 add_loc_descr (&loc_descr
, tmp
);
20102 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
20106 loc_descr
= field_byte_offset (decl
, ctx
, &offset
);
20111 /* If loc_descr is available, then we know the offset is dynamic. */
20112 else if (gnat_encodings
== DWARF_GNAT_ENCODINGS_ALL
)
20118 /* Data member location evaluation starts with the base address on the
20119 stack. Compute the field offset and add it to this base address. */
20121 add_loc_descr (&loc_descr
, new_loc_descr (DW_OP_plus
, 0, 0));
20126 /* While DW_AT_data_bit_offset has been added already in DWARF4,
20127 e.g. GDB only added support to it in November 2016. For DWARF5
20128 we need newer debug info consumers anyway. We might change this
20129 to dwarf_version >= 4 once most consumers catched up. */
20130 if (dwarf_version
>= 5
20131 && TREE_CODE (decl
) == FIELD_DECL
20132 && DECL_BIT_FIELD_TYPE (decl
)
20133 && (ctx
->variant_part_offset
== NULL_TREE
20134 || TREE_CODE (ctx
->variant_part_offset
) == INTEGER_CST
))
20136 tree off
= bit_position (decl
);
20137 if (ctx
->variant_part_offset
)
20138 off
= bit_from_pos (ctx
->variant_part_offset
, off
);
20139 if (tree_fits_uhwi_p (off
) && get_AT (die
, DW_AT_bit_size
))
20141 remove_AT (die
, DW_AT_byte_size
);
20142 remove_AT (die
, DW_AT_bit_offset
);
20143 add_AT_unsigned (die
, DW_AT_data_bit_offset
, tree_to_uhwi (off
));
20147 if (dwarf_version
> 2)
20149 /* Don't need to output a location expression, just the constant. */
20151 add_AT_int (die
, DW_AT_data_member_location
, offset
);
20153 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
20158 enum dwarf_location_atom op
;
20160 /* The DWARF2 standard says that we should assume that the structure
20161 address is already on the stack, so we can specify a structure
20162 field address by using DW_OP_plus_uconst. */
20163 op
= DW_OP_plus_uconst
;
20164 loc_descr
= new_loc_descr (op
, offset
, 0);
20168 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
20171 /* Writes integer values to dw_vec_const array. */
20174 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
20178 *dest
++ = val
& 0xff;
20184 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
20186 static HOST_WIDE_INT
20187 extract_int (const unsigned char *src
, unsigned int size
)
20189 HOST_WIDE_INT val
= 0;
20195 val
|= *--src
& 0xff;
20201 /* Writes wide_int values to dw_vec_const array. */
20204 insert_wide_int (const wide_int_ref
&val
, unsigned char *dest
, int elt_size
)
20208 if (elt_size
<= HOST_BITS_PER_WIDE_INT
/BITS_PER_UNIT
)
20210 insert_int ((HOST_WIDE_INT
) val
.elt (0), elt_size
, dest
);
20214 /* We'd have to extend this code to support odd sizes. */
20215 gcc_assert (elt_size
% (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
) == 0);
20217 int n
= elt_size
/ (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
20219 if (WORDS_BIG_ENDIAN
)
20220 for (i
= n
- 1; i
>= 0; i
--)
20222 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
20223 dest
+= sizeof (HOST_WIDE_INT
);
20226 for (i
= 0; i
< n
; i
++)
20228 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
20229 dest
+= sizeof (HOST_WIDE_INT
);
20233 /* Writes floating point values to dw_vec_const array. */
20236 insert_float (const_rtx rtl
, unsigned char *array
)
20240 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
20242 real_to_target (val
, CONST_DOUBLE_REAL_VALUE (rtl
), mode
);
20244 /* real_to_target puts 32-bit pieces in each long. Pack them. */
20245 if (GET_MODE_SIZE (mode
) < 4)
20247 gcc_assert (GET_MODE_SIZE (mode
) == 2);
20248 insert_int (val
[0], 2, array
);
20252 for (i
= 0; i
< GET_MODE_SIZE (mode
) / 4; i
++)
20254 insert_int (val
[i
], 4, array
);
20260 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
20261 does not have a "location" either in memory or in a register. These
20262 things can arise in GNU C when a constant is passed as an actual parameter
20263 to an inlined function. They can also arise in C++ where declared
20264 constants do not necessarily get memory "homes". */
20267 add_const_value_attribute (dw_die_ref die
, machine_mode mode
, rtx rtl
)
20269 scalar_mode int_mode
;
20271 switch (GET_CODE (rtl
))
20275 HOST_WIDE_INT val
= INTVAL (rtl
);
20278 add_AT_int (die
, DW_AT_const_value
, val
);
20280 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
20284 case CONST_WIDE_INT
:
20285 if (is_int_mode (mode
, &int_mode
)
20286 && (GET_MODE_PRECISION (int_mode
)
20287 & (HOST_BITS_PER_WIDE_INT
- 1)) == 0)
20289 add_AT_wide (die
, DW_AT_const_value
, rtx_mode_t (rtl
, int_mode
));
20295 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
20296 floating-point constant. A CONST_DOUBLE is used whenever the
20297 constant requires more than one word in order to be adequately
20299 if (TARGET_SUPPORTS_WIDE_INT
== 0
20300 && !SCALAR_FLOAT_MODE_P (GET_MODE (rtl
)))
20301 add_AT_double (die
, DW_AT_const_value
,
20302 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
20305 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
20306 unsigned int length
= GET_MODE_SIZE (mode
);
20307 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
20308 unsigned int elt_size
= insert_float (rtl
, array
);
20310 add_AT_vec (die
, DW_AT_const_value
, length
/ elt_size
, elt_size
,
20317 unsigned int length
;
20318 if (!CONST_VECTOR_NUNITS (rtl
).is_constant (&length
))
20321 machine_mode mode
= GET_MODE (rtl
);
20322 /* The combination of a length and byte elt_size doesn't extend
20323 naturally to boolean vectors, where several elements are packed
20324 into the same byte. */
20325 if (GET_MODE_CLASS (mode
) == MODE_VECTOR_BOOL
)
20328 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
20329 unsigned char *array
20330 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
20333 machine_mode imode
= GET_MODE_INNER (mode
);
20335 switch (GET_MODE_CLASS (mode
))
20337 case MODE_VECTOR_INT
:
20338 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
20340 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
20341 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
20345 case MODE_VECTOR_FLOAT
:
20346 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
20348 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
20349 insert_float (elt
, p
);
20354 gcc_unreachable ();
20357 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
20362 if (dwarf_version
>= 4 || !dwarf_strict
)
20364 dw_loc_descr_ref loc_result
;
20365 resolve_one_addr (&rtl
);
20367 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
20368 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
20369 add_AT_loc (die
, DW_AT_location
, loc_result
);
20370 vec_safe_push (used_rtx_array
, rtl
);
20376 if (CONSTANT_P (XEXP (rtl
, 0)))
20377 return add_const_value_attribute (die
, mode
, XEXP (rtl
, 0));
20380 if (!const_ok_for_output (rtl
))
20384 if (dwarf_version
>= 4 || !dwarf_strict
)
20389 /* In cases where an inlined instance of an inline function is passed
20390 the address of an `auto' variable (which is local to the caller) we
20391 can get a situation where the DECL_RTL of the artificial local
20392 variable (for the inlining) which acts as a stand-in for the
20393 corresponding formal parameter (of the inline function) will look
20394 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
20395 exactly a compile-time constant expression, but it isn't the address
20396 of the (artificial) local variable either. Rather, it represents the
20397 *value* which the artificial local variable always has during its
20398 lifetime. We currently have no way to represent such quasi-constant
20399 values in Dwarf, so for now we just punt and generate nothing. */
20407 case CONST_POLY_INT
:
20411 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
20412 && MEM_READONLY_P (rtl
)
20413 && GET_MODE (rtl
) == BLKmode
)
20415 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
20421 /* No other kinds of rtx should be possible here. */
20422 gcc_unreachable ();
20426 /* Determine whether the evaluation of EXPR references any variables
20427 or functions which aren't otherwise used (and therefore may not be
20430 reference_to_unused (tree
* tp
, int * walk_subtrees
,
20431 void * data ATTRIBUTE_UNUSED
)
20433 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
20434 *walk_subtrees
= 0;
20436 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
20437 && ! TREE_ASM_WRITTEN (*tp
))
20439 /* ??? The C++ FE emits debug information for using decls, so
20440 putting gcc_unreachable here falls over. See PR31899. For now
20441 be conservative. */
20442 else if (!symtab
->global_info_ready
&& VAR_P (*tp
))
20444 else if (VAR_P (*tp
))
20446 varpool_node
*node
= varpool_node::get (*tp
);
20447 if (!node
|| !node
->definition
)
20450 else if (TREE_CODE (*tp
) == FUNCTION_DECL
20451 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
20453 /* The call graph machinery must have finished analyzing,
20454 optimizing and gimplifying the CU by now.
20455 So if *TP has no call graph node associated
20456 to it, it means *TP will not be emitted. */
20457 if (!symtab
->global_info_ready
|| !cgraph_node::get (*tp
))
20460 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
20466 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
20467 for use in a later add_const_value_attribute call. */
20470 rtl_for_decl_init (tree init
, tree type
)
20472 rtx rtl
= NULL_RTX
;
20476 /* If a variable is initialized with a string constant without embedded
20477 zeros, build CONST_STRING. */
20478 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
20480 tree enttype
= TREE_TYPE (type
);
20481 tree domain
= TYPE_DOMAIN (type
);
20482 scalar_int_mode mode
;
20484 if (is_int_mode (TYPE_MODE (enttype
), &mode
)
20485 && GET_MODE_SIZE (mode
) == 1
20487 && TYPE_MAX_VALUE (domain
)
20488 && TREE_CODE (TYPE_MAX_VALUE (domain
)) == INTEGER_CST
20489 && integer_zerop (TYPE_MIN_VALUE (domain
))
20490 && compare_tree_int (TYPE_MAX_VALUE (domain
),
20491 TREE_STRING_LENGTH (init
) - 1) == 0
20492 && ((size_t) TREE_STRING_LENGTH (init
)
20493 == strlen (TREE_STRING_POINTER (init
)) + 1))
20495 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
20496 ggc_strdup (TREE_STRING_POINTER (init
)));
20497 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
20498 MEM_READONLY_P (rtl
) = 1;
20501 /* Other aggregates, and complex values, could be represented using
20503 If this changes, please adjust tree_add_const_value_attribute
20504 so that for early_dwarf it will for such initializers mangle referenced
20506 else if (AGGREGATE_TYPE_P (type
)
20507 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
20508 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
20509 || TREE_CODE (type
) == COMPLEX_TYPE
)
20511 /* Vectors only work if their mode is supported by the target.
20512 FIXME: generic vectors ought to work too. */
20513 else if (TREE_CODE (type
) == VECTOR_TYPE
20514 && !VECTOR_MODE_P (TYPE_MODE (type
)))
20516 /* If the initializer is something that we know will expand into an
20517 immediate RTL constant, expand it now. We must be careful not to
20518 reference variables which won't be output. */
20519 else if (initializer_constant_valid_p (init
, type
)
20520 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
20522 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
20524 if (TREE_CODE (type
) == VECTOR_TYPE
)
20525 switch (TREE_CODE (init
))
20530 if (TREE_CONSTANT (init
))
20532 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
20533 bool constant_p
= true;
20535 unsigned HOST_WIDE_INT ix
;
20537 /* Even when ctor is constant, it might contain non-*_CST
20538 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
20539 belong into VECTOR_CST nodes. */
20540 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
20541 if (!CONSTANT_CLASS_P (value
))
20543 constant_p
= false;
20549 init
= build_vector_from_ctor (type
, elts
);
20559 /* Large _BitInt BLKmode INTEGER_CSTs would yield a MEM. */
20560 if (TREE_CODE (init
) == INTEGER_CST
20561 && TREE_CODE (TREE_TYPE (init
)) == BITINT_TYPE
20562 && TYPE_MODE (TREE_TYPE (init
)) == BLKmode
)
20564 if (tree_fits_shwi_p (init
))
20565 return GEN_INT (tree_to_shwi (init
));
20570 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
20572 /* If expand_expr returns a MEM, it wasn't immediate. */
20573 gcc_assert (!rtl
|| !MEM_P (rtl
));
20579 /* Generate RTL for the variable DECL to represent its location. */
20582 rtl_for_decl_location (tree decl
)
20586 /* Here we have to decide where we are going to say the parameter "lives"
20587 (as far as the debugger is concerned). We only have a couple of
20588 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
20590 DECL_RTL normally indicates where the parameter lives during most of the
20591 activation of the function. If optimization is enabled however, this
20592 could be either NULL or else a pseudo-reg. Both of those cases indicate
20593 that the parameter doesn't really live anywhere (as far as the code
20594 generation parts of GCC are concerned) during most of the function's
20595 activation. That will happen (for example) if the parameter is never
20596 referenced within the function.
20598 We could just generate a location descriptor here for all non-NULL
20599 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
20600 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
20601 where DECL_RTL is NULL or is a pseudo-reg.
20603 Note however that we can only get away with using DECL_INCOMING_RTL as
20604 a backup substitute for DECL_RTL in certain limited cases. In cases
20605 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
20606 we can be sure that the parameter was passed using the same type as it is
20607 declared to have within the function, and that its DECL_INCOMING_RTL
20608 points us to a place where a value of that type is passed.
20610 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
20611 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
20612 because in these cases DECL_INCOMING_RTL points us to a value of some
20613 type which is *different* from the type of the parameter itself. Thus,
20614 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
20615 such cases, the debugger would end up (for example) trying to fetch a
20616 `float' from a place which actually contains the first part of a
20617 `double'. That would lead to really incorrect and confusing
20618 output at debug-time.
20620 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
20621 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
20622 are a couple of exceptions however. On little-endian machines we can
20623 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
20624 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
20625 an integral type that is smaller than TREE_TYPE (decl). These cases arise
20626 when (on a little-endian machine) a non-prototyped function has a
20627 parameter declared to be of type `short' or `char'. In such cases,
20628 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
20629 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
20630 passed `int' value. If the debugger then uses that address to fetch
20631 a `short' or a `char' (on a little-endian machine) the result will be
20632 the correct data, so we allow for such exceptional cases below.
20634 Note that our goal here is to describe the place where the given formal
20635 parameter lives during most of the function's activation (i.e. between the
20636 end of the prologue and the start of the epilogue). We'll do that as best
20637 as we can. Note however that if the given formal parameter is modified
20638 sometime during the execution of the function, then a stack backtrace (at
20639 debug-time) will show the function as having been called with the *new*
20640 value rather than the value which was originally passed in. This happens
20641 rarely enough that it is not a major problem, but it *is* a problem, and
20642 I'd like to fix it.
20644 A future version of dwarf2out.cc may generate two additional attributes for
20645 any given DW_TAG_formal_parameter DIE which will describe the "passed
20646 type" and the "passed location" for the given formal parameter in addition
20647 to the attributes we now generate to indicate the "declared type" and the
20648 "active location" for each parameter. This additional set of attributes
20649 could be used by debuggers for stack backtraces. Separately, note that
20650 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
20651 This happens (for example) for inlined-instances of inline function formal
20652 parameters which are never referenced. This really shouldn't be
20653 happening. All PARM_DECL nodes should get valid non-NULL
20654 DECL_INCOMING_RTL values. FIXME. */
20656 /* Use DECL_RTL as the "location" unless we find something better. */
20657 rtl
= DECL_RTL_IF_SET (decl
);
20659 /* When generating abstract instances, ignore everything except
20660 constants, symbols living in memory, and symbols living in
20661 fixed registers. */
20662 if (! reload_completed
)
20665 && (CONSTANT_P (rtl
)
20667 && CONSTANT_P (XEXP (rtl
, 0)))
20670 && TREE_STATIC (decl
))))
20672 rtl
= targetm
.delegitimize_address (rtl
);
20677 else if (TREE_CODE (decl
) == PARM_DECL
)
20679 if (rtl
== NULL_RTX
20680 || is_pseudo_reg (rtl
)
20682 && is_pseudo_reg (XEXP (rtl
, 0))
20683 && DECL_INCOMING_RTL (decl
)
20684 && MEM_P (DECL_INCOMING_RTL (decl
))
20685 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
20687 tree declared_type
= TREE_TYPE (decl
);
20688 tree passed_type
= DECL_ARG_TYPE (decl
);
20689 machine_mode dmode
= TYPE_MODE (declared_type
);
20690 machine_mode pmode
= TYPE_MODE (passed_type
);
20692 /* This decl represents a formal parameter which was optimized out.
20693 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
20694 all cases where (rtl == NULL_RTX) just below. */
20695 if (dmode
== pmode
)
20696 rtl
= DECL_INCOMING_RTL (decl
);
20697 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
20698 && SCALAR_INT_MODE_P (dmode
)
20699 && known_le (GET_MODE_SIZE (dmode
), GET_MODE_SIZE (pmode
))
20700 && DECL_INCOMING_RTL (decl
))
20702 rtx inc
= DECL_INCOMING_RTL (decl
);
20705 else if (MEM_P (inc
))
20707 if (BYTES_BIG_ENDIAN
)
20708 rtl
= adjust_address_nv (inc
, dmode
,
20709 GET_MODE_SIZE (pmode
)
20710 - GET_MODE_SIZE (dmode
));
20717 /* If the parm was passed in registers, but lives on the stack, then
20718 make a big endian correction if the mode of the type of the
20719 parameter is not the same as the mode of the rtl. */
20720 /* ??? This is the same series of checks that are made in dbxout.cc before
20721 we reach the big endian correction code there. It isn't clear if all
20722 of these checks are necessary here, but keeping them all is the safe
20724 else if (MEM_P (rtl
)
20725 && XEXP (rtl
, 0) != const0_rtx
20726 && ! CONSTANT_P (XEXP (rtl
, 0))
20727 /* Not passed in memory. */
20728 && !MEM_P (DECL_INCOMING_RTL (decl
))
20729 /* Not passed by invisible reference. */
20730 && (!REG_P (XEXP (rtl
, 0))
20731 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
20732 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
20733 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
20734 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
20737 /* Big endian correction check. */
20738 && BYTES_BIG_ENDIAN
20739 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
20740 && known_lt (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))),
20743 machine_mode addr_mode
= get_address_mode (rtl
);
20744 poly_int64 offset
= (UNITS_PER_WORD
20745 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
20747 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
20748 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
20751 else if (VAR_P (decl
)
20754 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
)))
20756 machine_mode addr_mode
= get_address_mode (rtl
);
20757 poly_int64 offset
= byte_lowpart_offset (TYPE_MODE (TREE_TYPE (decl
)),
20760 /* If a variable is declared "register" yet is smaller than
20761 a register, then if we store the variable to memory, it
20762 looks like we're storing a register-sized value, when in
20763 fact we are not. We need to adjust the offset of the
20764 storage location to reflect the actual value's bytes,
20765 else gdb will not be able to display it. */
20766 if (maybe_ne (offset
, 0))
20767 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
20768 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
20771 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
20772 and will have been substituted directly into all expressions that use it.
20773 C does not have such a concept, but C++ and other languages do. */
20774 if (!rtl
&& VAR_P (decl
) && DECL_INITIAL (decl
))
20775 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
20778 rtl
= targetm
.delegitimize_address (rtl
);
20780 /* If we don't look past the constant pool, we risk emitting a
20781 reference to a constant pool entry that isn't referenced from
20782 code, and thus is not emitted. */
20784 rtl
= avoid_constant_pool_reference (rtl
);
20786 /* Try harder to get a rtl. If this symbol ends up not being emitted
20787 in the current CU, resolve_addr will remove the expression referencing
20789 if (rtl
== NULL_RTX
20790 && !(early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
20792 && !DECL_EXTERNAL (decl
)
20793 && TREE_STATIC (decl
)
20794 && DECL_NAME (decl
)
20795 && !DECL_HARD_REGISTER (decl
)
20796 && DECL_MODE (decl
) != VOIDmode
)
20798 rtl
= make_decl_rtl_for_debug (decl
);
20800 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
20801 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
20808 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
20809 returned. If so, the decl for the COMMON block is returned, and the
20810 value is the offset into the common block for the symbol. */
20813 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
20815 tree val_expr
, cvar
;
20817 poly_int64 bitsize
, bitpos
;
20819 HOST_WIDE_INT cbitpos
;
20820 int unsignedp
, reversep
, volatilep
= 0;
20822 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
20823 it does not have a value (the offset into the common area), or if it
20824 is thread local (as opposed to global) then it isn't common, and shouldn't
20825 be handled as such. */
20827 || !TREE_STATIC (decl
)
20828 || !DECL_HAS_VALUE_EXPR_P (decl
)
20832 val_expr
= DECL_VALUE_EXPR (decl
);
20833 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
20836 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
, &mode
,
20837 &unsignedp
, &reversep
, &volatilep
);
20839 if (cvar
== NULL_TREE
20841 || DECL_ARTIFICIAL (cvar
)
20842 || !TREE_PUBLIC (cvar
)
20843 /* We don't expect to have to cope with variable offsets,
20844 since at present all static data must have a constant size. */
20845 || !bitpos
.is_constant (&cbitpos
))
20849 if (offset
!= NULL
)
20851 if (!tree_fits_shwi_p (offset
))
20853 *value
= tree_to_shwi (offset
);
20856 *value
+= cbitpos
/ BITS_PER_UNIT
;
20861 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
20862 data attribute for a variable or a parameter. We generate the
20863 DW_AT_const_value attribute only in those cases where the given variable
20864 or parameter does not have a true "location" either in memory or in a
20865 register. This can happen (for example) when a constant is passed as an
20866 actual argument in a call to an inline function. (It's possible that
20867 these things can crop up in other ways also.) Note that one type of
20868 constant value which can be passed into an inlined function is a constant
20869 pointer. This can happen for example if an actual argument in an inlined
20870 function call evaluates to a compile-time constant address.
20872 CACHE_P is true if it is worth caching the location list for DECL,
20873 so that future calls can reuse it rather than regenerate it from scratch.
20874 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
20875 since we will need to refer to them each time the function is inlined. */
20878 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
)
20881 dw_loc_list_ref list
;
20882 var_loc_list
*loc_list
;
20883 cached_dw_loc_list
*cache
;
20888 if (TREE_CODE (decl
) == ERROR_MARK
)
20891 if (get_AT (die
, DW_AT_location
)
20892 || get_AT (die
, DW_AT_const_value
))
20895 gcc_assert (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
20896 || TREE_CODE (decl
) == RESULT_DECL
);
20898 /* Try to get some constant RTL for this decl, and use that as the value of
20901 rtl
= rtl_for_decl_location (decl
);
20902 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
20903 && add_const_value_attribute (die
, DECL_MODE (decl
), rtl
))
20906 /* See if we have single element location list that is equivalent to
20907 a constant value. That way we are better to use add_const_value_attribute
20908 rather than expanding constant value equivalent. */
20909 loc_list
= lookup_decl_loc (decl
);
20912 && loc_list
->first
->next
== NULL
20913 && NOTE_P (loc_list
->first
->loc
)
20914 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
20915 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
20917 struct var_loc_node
*node
;
20919 node
= loc_list
->first
;
20920 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
20921 if (GET_CODE (rtl
) == EXPR_LIST
)
20922 rtl
= XEXP (rtl
, 0);
20923 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
20924 && add_const_value_attribute (die
, DECL_MODE (decl
), rtl
))
20927 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
20928 list several times. See if we've already cached the contents. */
20930 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
20934 cache
= cached_dw_loc_list_table
->find_with_hash (decl
, DECL_UID (decl
));
20936 list
= cache
->loc_list
;
20940 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2,
20942 /* It is usually worth caching this result if the decl is from
20943 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
20944 if (cache_p
&& list
&& list
->dw_loc_next
)
20946 cached_dw_loc_list
**slot
20947 = cached_dw_loc_list_table
->find_slot_with_hash (decl
,
20950 cache
= ggc_cleared_alloc
<cached_dw_loc_list
> ();
20951 cache
->decl_id
= DECL_UID (decl
);
20952 cache
->loc_list
= list
;
20958 add_AT_location_description (die
, DW_AT_location
, list
);
20961 /* None of that worked, so it must not really have a location;
20962 try adding a constant value attribute from the DECL_INITIAL. */
20963 return tree_add_const_value_attribute_for_decl (die
, decl
);
20966 /* Mangle referenced decls. */
20968 mangle_referenced_decls (tree
*tp
, int *walk_subtrees
, void *)
20970 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
20971 *walk_subtrees
= 0;
20973 if (VAR_OR_FUNCTION_DECL_P (*tp
))
20974 assign_assembler_name_if_needed (*tp
);
20979 /* Attach a DW_AT_const_value attribute to DIE. The value of the
20980 attribute is the const value T. */
20983 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
20986 tree type
= TREE_TYPE (t
);
20988 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
20992 gcc_assert (!DECL_P (init
));
20994 if (TREE_CODE (init
) == INTEGER_CST
)
20996 if (tree_fits_uhwi_p (init
))
20998 add_AT_unsigned (die
, DW_AT_const_value
, tree_to_uhwi (init
));
21001 if (tree_fits_shwi_p (init
))
21003 add_AT_int (die
, DW_AT_const_value
, tree_to_shwi (init
));
21009 rtx rtl
= rtl_for_decl_init (init
, type
);
21011 return add_const_value_attribute (die
, TYPE_MODE (type
), rtl
);
21015 /* For early_dwarf force mangling of all referenced symbols. */
21016 tree initializer
= init
;
21017 STRIP_NOPS (initializer
);
21018 /* rtl_for_decl_init punts on other aggregates, and complex values. */
21019 if (AGGREGATE_TYPE_P (type
)
21020 || (TREE_CODE (initializer
) == VIEW_CONVERT_EXPR
21021 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (initializer
, 0))))
21022 || TREE_CODE (type
) == COMPLEX_TYPE
)
21024 else if (initializer_constant_valid_p (initializer
, type
))
21025 walk_tree (&initializer
, mangle_referenced_decls
, NULL
, NULL
);
21027 /* If the host and target are sane, try harder. */
21028 if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
21029 && initializer_constant_valid_p (init
, type
))
21031 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
21032 if (size
> 0 && (int) size
== size
)
21034 unsigned char *array
= ggc_cleared_vec_alloc
<unsigned char> (size
);
21036 if (native_encode_initializer (init
, array
, size
) == size
)
21038 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
21047 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
21048 attribute is the const value of T, where T is an integral constant
21049 variable with static storage duration
21050 (so it can't be a PARM_DECL or a RESULT_DECL). */
21053 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
21057 || (!VAR_P (decl
) && TREE_CODE (decl
) != CONST_DECL
)
21058 || (VAR_P (decl
) && !TREE_STATIC (decl
)))
21061 if (TREE_READONLY (decl
)
21062 && ! TREE_THIS_VOLATILE (decl
)
21063 && DECL_INITIAL (decl
))
21068 /* Don't add DW_AT_const_value if abstract origin already has one. */
21069 if (get_AT (var_die
, DW_AT_const_value
))
21072 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
21075 /* Convert the CFI instructions for the current function into a
21076 location list. This is used for DW_AT_frame_base when we targeting
21077 a dwarf2 consumer that does not support the dwarf3
21078 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
21081 static dw_loc_list_ref
21082 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
21086 dw_loc_list_ref list
, *list_tail
;
21088 dw_cfa_location last_cfa
, next_cfa
;
21089 const char *start_label
, *last_label
, *section
;
21090 dw_cfa_location remember
;
21093 gcc_assert (fde
!= NULL
);
21095 section
= secname_for_decl (current_function_decl
);
21099 memset (&next_cfa
, 0, sizeof (next_cfa
));
21100 next_cfa
.reg
.set_by_dwreg (INVALID_REGNUM
);
21101 remember
= next_cfa
;
21103 start_label
= fde
->dw_fde_begin
;
21105 /* ??? Bald assumption that the CIE opcode list does not contain
21106 advance opcodes. */
21107 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
21108 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
21110 last_cfa
= next_cfa
;
21111 last_label
= start_label
;
21113 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
21115 /* If the first partition contained no CFI adjustments, the
21116 CIE opcodes apply to the whole first partition. */
21117 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
21118 fde
->dw_fde_begin
, 0, fde
->dw_fde_end
, 0, section
);
21119 list_tail
=&(*list_tail
)->dw_loc_next
;
21120 start_label
= last_label
= fde
->dw_fde_second_begin
;
21123 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
21125 switch (cfi
->dw_cfi_opc
)
21127 case DW_CFA_set_loc
:
21128 case DW_CFA_advance_loc1
:
21129 case DW_CFA_advance_loc2
:
21130 case DW_CFA_advance_loc4
:
21131 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
21133 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
21134 start_label
, 0, last_label
, 0, section
);
21136 list_tail
= &(*list_tail
)->dw_loc_next
;
21137 last_cfa
= next_cfa
;
21138 start_label
= last_label
;
21140 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
21143 case DW_CFA_advance_loc
:
21144 /* The encoding is complex enough that we should never emit this. */
21145 gcc_unreachable ();
21148 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
21151 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
21153 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
21155 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
21156 start_label
, 0, last_label
, 0, section
);
21158 list_tail
= &(*list_tail
)->dw_loc_next
;
21159 last_cfa
= next_cfa
;
21160 start_label
= last_label
;
21162 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
21163 start_label
, 0, fde
->dw_fde_end
, 0, section
);
21164 list_tail
= &(*list_tail
)->dw_loc_next
;
21165 start_label
= last_label
= fde
->dw_fde_second_begin
;
21169 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
21171 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
21172 start_label
, 0, last_label
, 0, section
);
21173 list_tail
= &(*list_tail
)->dw_loc_next
;
21174 start_label
= last_label
;
21177 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
21179 fde
->dw_fde_second_begin
21180 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
, 0,
21183 maybe_gen_llsym (list
);
21188 /* Compute a displacement from the "steady-state frame pointer" to the
21189 frame base (often the same as the CFA), and store it in
21190 frame_pointer_fb_offset. OFFSET is added to the displacement
21191 before the latter is negated. */
21194 compute_frame_pointer_to_fb_displacement (poly_int64 offset
)
21198 #ifdef FRAME_POINTER_CFA_OFFSET
21199 reg
= frame_pointer_rtx
;
21200 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
21202 reg
= arg_pointer_rtx
;
21203 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
21206 elim
= (ira_use_lra_p
21207 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
21208 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
21209 elim
= strip_offset_and_add (elim
, &offset
);
21211 frame_pointer_fb_offset
= -offset
;
21213 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
21214 in which to eliminate. This is because it's stack pointer isn't
21215 directly accessible as a register within the ISA. To work around
21216 this, assume that while we cannot provide a proper value for
21217 frame_pointer_fb_offset, we won't need one either. We can use
21218 hard frame pointer in debug info even if frame pointer isn't used
21219 since hard frame pointer in debug info is encoded with DW_OP_fbreg
21220 which uses the DW_AT_frame_base attribute, not hard frame pointer
21222 frame_pointer_fb_offset_valid
21223 = (elim
== hard_frame_pointer_rtx
|| elim
== stack_pointer_rtx
);
21226 /* Generate a DW_AT_name attribute given some string value to be included as
21227 the value of the attribute. */
21230 add_name_attribute (dw_die_ref die
, const char *name_string
)
21232 if (name_string
!= NULL
&& *name_string
!= 0)
21234 if (demangle_name_func
)
21235 name_string
= (*demangle_name_func
) (name_string
);
21237 add_AT_string (die
, DW_AT_name
, name_string
);
21241 /* Generate a DW_AT_name attribute given some string value representing a
21242 file or filepath to be included as value of the attribute. */
21244 add_filename_attribute (dw_die_ref die
, const char *name_string
)
21246 if (name_string
!= NULL
&& *name_string
!= 0)
21247 add_filepath_AT_string (die
, DW_AT_name
, name_string
);
21250 /* Generate a DW_AT_description attribute given some string value to be included
21251 as the value of the attribute. */
21254 add_desc_attribute (dw_die_ref die
, const char *name_string
)
21256 if (!flag_describe_dies
|| (dwarf_version
< 3 && dwarf_strict
))
21259 if (name_string
== NULL
|| *name_string
== 0)
21262 if (demangle_name_func
)
21263 name_string
= (*demangle_name_func
) (name_string
);
21265 add_AT_string (die
, DW_AT_description
, name_string
);
21268 /* Generate a DW_AT_description attribute given some decl to be included
21269 as the value of the attribute. */
21272 add_desc_attribute (dw_die_ref die
, tree decl
)
21276 if (!flag_describe_dies
|| (dwarf_version
< 3 && dwarf_strict
))
21279 if (decl
== NULL_TREE
|| !DECL_P (decl
))
21281 decl_name
= DECL_NAME (decl
);
21283 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
21285 const char *name
= dwarf2_name (decl
, 0);
21286 add_desc_attribute (die
, name
? name
: IDENTIFIER_POINTER (decl_name
));
21290 char *desc
= print_generic_expr_to_str (decl
);
21291 add_desc_attribute (die
, desc
);
21296 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
21297 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
21298 of TYPE accordingly.
21300 ??? This is a temporary measure until after we're able to generate
21301 regular DWARF for the complex Ada type system. */
21304 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
21305 dw_die_ref context_die
)
21308 dw_die_ref dtype_die
;
21310 if (!lang_hooks
.types
.descriptive_type
)
21313 dtype
= lang_hooks
.types
.descriptive_type (type
);
21317 dtype_die
= lookup_type_die (dtype
);
21320 gen_type_die (dtype
, context_die
);
21321 dtype_die
= lookup_type_die (dtype
);
21322 gcc_assert (dtype_die
);
21325 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
21328 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
21330 static const char *
21331 comp_dir_string (void)
21334 char *wd_plus_sep
= NULL
;
21335 static const char *cached_wd
= NULL
;
21337 if (cached_wd
!= NULL
)
21340 wd
= get_src_pwd ();
21344 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
21346 size_t wdlen
= strlen (wd
);
21347 wd_plus_sep
= XNEWVEC (char, wdlen
+ 2);
21348 strcpy (wd_plus_sep
, wd
);
21349 wd_plus_sep
[wdlen
] = DIR_SEPARATOR
;
21350 wd_plus_sep
[wdlen
+ 1] = 0;
21354 cached_wd
= remap_debug_filename (wd
);
21356 /* remap_debug_filename can just pass through wd or return a new gc string.
21357 These two types can't be both stored in a GTY(())-tagged string, but since
21358 the cached value lives forever just copy it if needed. */
21359 if (cached_wd
!= wd
)
21361 cached_wd
= xstrdup (cached_wd
);
21362 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
&& wd_plus_sep
!= NULL
)
21363 free (wd_plus_sep
);
21369 /* Generate a DW_AT_comp_dir attribute for DIE. */
21372 add_comp_dir_attribute (dw_die_ref die
)
21374 const char * wd
= comp_dir_string ();
21376 add_filepath_AT_string (die
, DW_AT_comp_dir
, wd
);
21379 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
21380 pointer computation, ...), output a representation for that bound according
21381 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
21382 loc_list_from_tree for the meaning of CONTEXT. */
21385 add_scalar_info (dw_die_ref die
, enum dwarf_attribute attr
, tree value
,
21386 int forms
, struct loc_descr_context
*context
)
21388 dw_die_ref context_die
, decl_die
= NULL
;
21389 dw_loc_list_ref list
;
21390 bool strip_conversions
= true;
21391 bool placeholder_seen
= false;
21393 while (strip_conversions
)
21394 switch (TREE_CODE (value
))
21401 case VIEW_CONVERT_EXPR
:
21402 value
= TREE_OPERAND (value
, 0);
21406 strip_conversions
= false;
21410 /* If possible and permitted, output the attribute as a constant. */
21411 if ((forms
& dw_scalar_form_constant
) != 0
21412 && TREE_CODE (value
) == INTEGER_CST
)
21414 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (value
));
21416 /* If HOST_WIDE_INT is big enough then represent the bound as
21417 a constant value. We need to choose a form based on
21418 whether the type is signed or unsigned. We cannot just
21419 call add_AT_unsigned if the value itself is positive
21420 (add_AT_unsigned might add the unsigned value encoded as
21421 DW_FORM_data[1248]). Some DWARF consumers will lookup the
21422 bounds type and then sign extend any unsigned values found
21423 for signed types. This is needed only for
21424 DW_AT_{lower,upper}_bound, since for most other attributes,
21425 consumers will treat DW_FORM_data[1248] as unsigned values,
21426 regardless of the underlying type. */
21427 if (prec
<= HOST_BITS_PER_WIDE_INT
21428 || tree_fits_uhwi_p (value
))
21430 if (TYPE_UNSIGNED (TREE_TYPE (value
)))
21431 add_AT_unsigned (die
, attr
, TREE_INT_CST_LOW (value
));
21433 add_AT_int (die
, attr
, TREE_INT_CST_LOW (value
));
21435 else if (dwarf_version
>= 5
21436 && TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (value
))) == 128)
21437 /* Otherwise represent the bound as an unsigned value with
21438 the precision of its type. The precision and signedness
21439 of the type will be necessary to re-interpret it
21441 add_AT_wide (die
, attr
, wi::to_wide (value
));
21444 rtx v
= immed_wide_int_const (wi::to_wide (value
),
21445 TYPE_MODE (TREE_TYPE (value
)));
21446 dw_loc_descr_ref loc
21447 = loc_descriptor (v
, TYPE_MODE (TREE_TYPE (value
)),
21448 VAR_INIT_STATUS_INITIALIZED
);
21450 add_AT_loc (die
, attr
, loc
);
21455 /* Otherwise, if it's possible and permitted too, output a reference to
21457 if ((forms
& dw_scalar_form_reference
) != 0)
21459 tree decl
= NULL_TREE
;
21461 /* Some type attributes reference an outer type. For instance, the upper
21462 bound of an array may reference an embedding record (this happens in
21464 if (TREE_CODE (value
) == COMPONENT_REF
21465 && TREE_CODE (TREE_OPERAND (value
, 0)) == PLACEHOLDER_EXPR
21466 && TREE_CODE (TREE_OPERAND (value
, 1)) == FIELD_DECL
)
21467 decl
= TREE_OPERAND (value
, 1);
21469 else if (VAR_P (value
)
21470 || TREE_CODE (value
) == PARM_DECL
21471 || TREE_CODE (value
) == RESULT_DECL
)
21474 if (decl
!= NULL_TREE
)
21476 decl_die
= lookup_decl_die (decl
);
21478 /* ??? Can this happen, or should the variable have been bound
21479 first? Probably it can, since I imagine that we try to create
21480 the types of parameters in the order in which they exist in
21481 the list, and won't have created a forward reference to a
21482 later parameter. */
21483 if (decl_die
!= NULL
)
21485 if (get_AT (decl_die
, DW_AT_location
)
21486 || get_AT (decl_die
, DW_AT_data_member_location
)
21487 || get_AT (decl_die
, DW_AT_data_bit_offset
)
21488 || get_AT (decl_die
, DW_AT_const_value
))
21490 add_AT_die_ref (die
, attr
, decl_die
);
21497 /* Last chance: try to create a stack operation procedure to evaluate the
21498 value. Do nothing if even that is not possible or permitted. */
21499 if ((forms
& dw_scalar_form_exprloc
) == 0)
21502 list
= loc_list_from_tree (value
, 2, context
);
21503 if (context
&& context
->placeholder_arg
)
21505 placeholder_seen
= context
->placeholder_seen
;
21506 context
->placeholder_seen
= false;
21508 if (list
== NULL
|| single_element_loc_list_p (list
))
21510 /* If this attribute is not a reference nor constant, it is
21511 a DWARF expression rather than location description. For that
21512 loc_list_from_tree (value, 0, &context) is needed. */
21513 dw_loc_list_ref list2
= loc_list_from_tree (value
, 0, context
);
21514 if (list2
&& single_element_loc_list_p (list2
))
21516 if (placeholder_seen
)
21518 struct dwarf_procedure_info dpi
;
21519 dpi
.fndecl
= NULL_TREE
;
21520 dpi
.args_count
= 1;
21521 if (!resolve_args_picking (list2
->expr
, 1, &dpi
))
21524 add_AT_loc (die
, attr
, list2
->expr
);
21529 /* If that failed to give a single element location list, fall back to
21530 outputting this as a reference... still if permitted. */
21532 || (forms
& dw_scalar_form_reference
) == 0
21533 || placeholder_seen
)
21538 if (current_function_decl
== 0)
21539 context_die
= comp_unit_die ();
21541 context_die
= lookup_decl_die (current_function_decl
);
21543 decl_die
= new_die (DW_TAG_variable
, context_die
, value
);
21544 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
21545 add_type_attribute (decl_die
, TREE_TYPE (value
), TYPE_QUAL_CONST
, false,
21549 add_AT_location_description (decl_die
, DW_AT_location
, list
);
21550 add_AT_die_ref (die
, attr
, decl_die
);
21553 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
21557 lower_bound_default (void)
21559 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
21565 case DW_LANG_C_plus_plus
:
21566 case DW_LANG_C_plus_plus_11
:
21567 case DW_LANG_C_plus_plus_14
:
21569 case DW_LANG_ObjC_plus_plus
:
21571 case DW_LANG_Fortran77
:
21572 case DW_LANG_Fortran90
:
21573 case DW_LANG_Fortran95
:
21574 case DW_LANG_Fortran03
:
21575 case DW_LANG_Fortran08
:
21579 case DW_LANG_Python
:
21580 return dwarf_version
>= 4 ? 0 : -1;
21581 case DW_LANG_Ada95
:
21582 case DW_LANG_Ada83
:
21583 case DW_LANG_Cobol74
:
21584 case DW_LANG_Cobol85
:
21585 case DW_LANG_Modula2
:
21587 return dwarf_version
>= 4 ? 1 : -1;
21593 /* Given a tree node describing an array bound (either lower or upper) output
21594 a representation for that bound. */
21597 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
,
21598 tree bound
, struct loc_descr_context
*context
)
21603 switch (TREE_CODE (bound
))
21605 /* Strip all conversions. */
21607 case VIEW_CONVERT_EXPR
:
21608 bound
= TREE_OPERAND (bound
, 0);
21611 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
21612 are even omitted when they are the default. */
21614 /* If the value for this bound is the default one, we can even omit the
21616 if (bound_attr
== DW_AT_lower_bound
21617 && tree_fits_shwi_p (bound
)
21618 && (dflt
= lower_bound_default ()) != -1
21619 && tree_to_shwi (bound
) == dflt
)
21625 /* Let GNAT encodings do the magic for self-referential bounds. */
21627 && gnat_encodings
== DWARF_GNAT_ENCODINGS_ALL
21628 && contains_placeholder_p (bound
))
21631 add_scalar_info (subrange_die
, bound_attr
, bound
,
21632 dw_scalar_form_constant
21633 | dw_scalar_form_exprloc
21634 | dw_scalar_form_reference
,
21640 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
21641 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
21643 This function reuses previously set type and bound information if
21647 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
21649 dw_die_ref child
= type_die
->die_child
;
21650 struct array_descr_info info
;
21651 int dimension_number
;
21653 if (lang_hooks
.types
.get_array_descr_info
)
21655 memset (&info
, 0, sizeof (info
));
21656 if (lang_hooks
.types
.get_array_descr_info (type
, &info
))
21657 /* Fortran sometimes emits array types with no dimension. */
21658 gcc_assert (info
.ndimensions
>= 0
21659 && info
.ndimensions
21660 <= DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN
);
21663 info
.ndimensions
= 0;
21665 for (dimension_number
= 0;
21666 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
21667 type
= TREE_TYPE (type
), dimension_number
++)
21669 tree domain
= TYPE_DOMAIN (type
);
21671 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
21674 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
21675 and (in GNU C only) variable bounds. Handle all three forms
21678 /* Find and reuse a previously generated DW_TAG_subrange_type if
21681 For multi-dimensional arrays, as we iterate through the
21682 various dimensions in the enclosing for loop above, we also
21683 iterate through the DIE children and pick at each
21684 DW_TAG_subrange_type previously generated (if available).
21685 Each child DW_TAG_subrange_type DIE describes the range of
21686 the current dimension. At this point we should have as many
21687 DW_TAG_subrange_type's as we have dimensions in the
21689 dw_die_ref subrange_die
= NULL
;
21693 child
= child
->die_sib
;
21694 if (child
->die_tag
== DW_TAG_subrange_type
)
21695 subrange_die
= child
;
21696 if (child
== type_die
->die_child
)
21698 /* If we wrapped around, stop looking next time. */
21702 if (child
->die_tag
== DW_TAG_subrange_type
)
21706 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
21710 /* We have an array type with specified bounds. */
21711 tree lower
= TYPE_MIN_VALUE (domain
);
21712 tree upper
= TYPE_MAX_VALUE (domain
);
21713 tree index_type
= TREE_TYPE (domain
);
21715 if (dimension_number
<= info
.ndimensions
- 1)
21717 lower
= info
.dimen
[dimension_number
].lower_bound
;
21718 upper
= info
.dimen
[dimension_number
].upper_bound
;
21719 index_type
= info
.dimen
[dimension_number
].bounds_type
;
21722 /* Define the index type. */
21723 if (index_type
&& !get_AT (subrange_die
, DW_AT_type
))
21724 add_type_attribute (subrange_die
, index_type
, TYPE_UNQUALIFIED
,
21727 /* ??? If upper is NULL, the array has unspecified length,
21728 but it does have a lower bound. This happens with Fortran
21730 Since the debugger is definitely going to need to know N
21731 to produce useful results, go ahead and output the lower
21732 bound solo, and hope the debugger can cope. */
21734 if (lower
&& !get_AT (subrange_die
, DW_AT_lower_bound
))
21735 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
, NULL
);
21737 if (!get_AT (subrange_die
, DW_AT_upper_bound
)
21738 && !get_AT (subrange_die
, DW_AT_count
))
21741 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
, NULL
);
21742 else if ((is_c () || is_cxx ()) && COMPLETE_TYPE_P (type
))
21743 /* Zero-length array. */
21744 add_bound_info (subrange_die
, DW_AT_count
,
21745 build_int_cst (TREE_TYPE (lower
), 0), NULL
);
21749 /* Otherwise we have an array type with an unspecified length. The
21750 DWARF-2 spec does not say how to handle this; let's just leave out the
21755 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
21758 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
21760 dw_die_ref decl_die
;
21761 HOST_WIDE_INT size
;
21763 switch (TREE_CODE (tree_node
))
21768 case ENUMERAL_TYPE
:
21771 case QUAL_UNION_TYPE
:
21772 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
21773 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
21775 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
21778 size
= int_size_in_bytes (tree_node
);
21781 /* For a data member of a struct or union, the DW_AT_byte_size is
21782 generally given as the number of bytes normally allocated for an
21783 object of the *declared* type of the member itself. This is true
21784 even for bit-fields. */
21785 size
= int_size_in_bytes (field_type (tree_node
));
21788 gcc_unreachable ();
21791 /* Note that `size' might be -1 when we get to this point. If it is, that
21792 indicates that the byte size of the entity in question is variable. */
21794 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
21796 /* Support for dynamically-sized objects was introduced in DWARF3. */
21797 else if (TYPE_P (tree_node
)
21798 && (dwarf_version
>= 3 || !dwarf_strict
)
21799 && gnat_encodings
!= DWARF_GNAT_ENCODINGS_ALL
)
21801 struct loc_descr_context ctx
= {
21802 const_cast<tree
> (tree_node
), /* context_type */
21803 NULL_TREE
, /* base_decl */
21805 false, /* placeholder_arg */
21806 false, /* placeholder_seen */
21807 false /* strict_signedness */
21810 tree tree_size
= TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (tree_node
));
21811 add_scalar_info (die
, DW_AT_byte_size
, tree_size
,
21812 dw_scalar_form_constant
21813 | dw_scalar_form_exprloc
21814 | dw_scalar_form_reference
,
21819 /* Add a DW_AT_alignment attribute to DIE with TREE_NODE's non-default
21823 add_alignment_attribute (dw_die_ref die
, tree tree_node
)
21825 if (dwarf_version
< 5 && dwarf_strict
)
21830 if (DECL_P (tree_node
))
21832 if (!DECL_USER_ALIGN (tree_node
))
21835 align
= DECL_ALIGN_UNIT (tree_node
);
21837 else if (TYPE_P (tree_node
))
21839 if (!TYPE_USER_ALIGN (tree_node
))
21842 align
= TYPE_ALIGN_UNIT (tree_node
);
21845 gcc_unreachable ();
21847 add_AT_unsigned (die
, DW_AT_alignment
, align
);
21850 /* For a FIELD_DECL node which represents a bit-field, output an attribute
21851 which specifies the distance in bits from the highest order bit of the
21852 "containing object" for the bit-field to the highest order bit of the
21855 For any given bit-field, the "containing object" is a hypothetical object
21856 (of some integral or enum type) within which the given bit-field lives. The
21857 type of this hypothetical "containing object" is always the same as the
21858 declared type of the individual bit-field itself. The determination of the
21859 exact location of the "containing object" for a bit-field is rather
21860 complicated. It's handled by the `field_byte_offset' function (above).
21862 Note that it is the size (in bytes) of the hypothetical "containing object"
21863 which will be given in the DW_AT_byte_size attribute for this bit-field.
21864 (See `byte_size_attribute' above). */
21867 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
21869 HOST_WIDE_INT object_offset_in_bytes
;
21870 tree original_type
= DECL_BIT_FIELD_TYPE (decl
);
21871 HOST_WIDE_INT bitpos_int
;
21872 HOST_WIDE_INT highest_order_object_bit_offset
;
21873 HOST_WIDE_INT highest_order_field_bit_offset
;
21874 HOST_WIDE_INT bit_offset
;
21876 /* The containing object is within the DECL_CONTEXT. */
21877 struct vlr_context ctx
= { DECL_CONTEXT (decl
), NULL_TREE
};
21879 field_byte_offset (decl
, &ctx
, &object_offset_in_bytes
);
21881 /* Must be a field and a bit field. */
21882 gcc_assert (original_type
&& TREE_CODE (decl
) == FIELD_DECL
);
21884 /* We can't yet handle bit-fields whose offsets are variable, so if we
21885 encounter such things, just return without generating any attribute
21886 whatsoever. Likewise for variable or too large size. */
21887 if (! tree_fits_shwi_p (bit_position (decl
))
21888 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
21891 bitpos_int
= int_bit_position (decl
);
21893 /* Note that the bit offset is always the distance (in bits) from the
21894 highest-order bit of the "containing object" to the highest-order bit of
21895 the bit-field itself. Since the "high-order end" of any object or field
21896 is different on big-endian and little-endian machines, the computation
21897 below must take account of these differences. */
21898 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
21899 highest_order_field_bit_offset
= bitpos_int
;
21901 if (! BYTES_BIG_ENDIAN
)
21903 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
21904 highest_order_object_bit_offset
+=
21905 simple_type_size_in_bits (original_type
);
21909 = (! BYTES_BIG_ENDIAN
21910 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
21911 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
21913 if (bit_offset
< 0)
21914 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
21916 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
21919 /* For a FIELD_DECL node which represents a bit field, output an attribute
21920 which specifies the length in bits of the given field. */
21923 add_bit_size_attribute (dw_die_ref die
, tree decl
)
21925 /* Must be a field and a bit field. */
21926 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
21927 && DECL_BIT_FIELD_TYPE (decl
));
21929 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
21930 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
21933 /* If the compiled language is ANSI C, then add a 'prototyped'
21934 attribute, if arg types are given for the parameters of a function. */
21937 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
21939 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
21946 if (prototype_p (func_type
))
21947 add_AT_flag (die
, DW_AT_prototyped
, 1);
21954 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
21955 by looking in the type declaration, the object declaration equate table or
21956 the block mapping. */
21959 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
21961 dw_die_ref origin_die
= NULL
;
21963 /* For late LTO debug output we want to refer directly to the abstract
21964 DIE in the early debug rather to the possibly existing concrete
21965 instance and avoid creating that just for this purpose. */
21966 sym_off_pair
*desc
;
21968 && external_die_map
21969 && (desc
= external_die_map
->get (origin
)))
21971 add_AT_external_die_ref (die
, DW_AT_abstract_origin
,
21972 desc
->sym
, desc
->off
);
21976 if (DECL_P (origin
))
21977 origin_die
= lookup_decl_die (origin
);
21978 else if (TYPE_P (origin
))
21979 origin_die
= lookup_type_die (origin
);
21980 else if (TREE_CODE (origin
) == BLOCK
)
21981 origin_die
= lookup_block_die (origin
);
21983 /* XXX: Functions that are never lowered don't always have correct block
21984 trees (in the case of java, they simply have no block tree, in some other
21985 languages). For these functions, there is nothing we can really do to
21986 output correct debug info for inlined functions in all cases. Rather
21987 than die, we'll just produce deficient debug info now, in that we will
21988 have variables without a proper abstract origin. In the future, when all
21989 functions are lowered, we should re-add a gcc_assert (origin_die)
21995 /* Like above, if we already created a concrete instance DIE
21996 do not use that for the abstract origin but the early DIE
21999 && (a
= get_AT (origin_die
, DW_AT_abstract_origin
)))
22000 origin_die
= AT_ref (a
);
22001 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
22005 /* We do not currently support the pure_virtual attribute. */
22008 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
22010 if (DECL_VINDEX (func_decl
))
22012 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
22014 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
22015 add_AT_loc (die
, DW_AT_vtable_elem_location
,
22016 new_loc_descr (DW_OP_constu
,
22017 tree_to_shwi (DECL_VINDEX (func_decl
)),
22020 /* GNU extension: Record what type this method came from originally. */
22021 if (debug_info_level
> DINFO_LEVEL_TERSE
22022 && DECL_CONTEXT (func_decl
))
22023 add_AT_die_ref (die
, DW_AT_containing_type
,
22024 lookup_type_die (DECL_CONTEXT (func_decl
)));
22028 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
22029 given decl. This used to be a vendor extension until after DWARF 4
22030 standardized it. */
22033 add_linkage_attr (dw_die_ref die
, tree decl
)
22035 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
22037 /* Mimic what assemble_name_raw does with a leading '*'. */
22038 if (name
[0] == '*')
22041 if (dwarf_version
>= 4)
22042 add_AT_string (die
, DW_AT_linkage_name
, name
);
22044 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
22047 /* Add source coordinate attributes for the given decl. */
22050 add_src_coords_attributes (dw_die_ref die
, tree decl
)
22052 expanded_location s
;
22054 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
22056 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
22057 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
22058 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
22059 if (debug_column_info
&& s
.column
)
22060 add_AT_unsigned (die
, DW_AT_decl_column
, s
.column
);
22063 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
22066 add_linkage_name_raw (dw_die_ref die
, tree decl
)
22068 /* Defer until we have an assembler name set. */
22069 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
22071 limbo_die_node
*asm_name
;
22073 asm_name
= ggc_cleared_alloc
<limbo_die_node
> ();
22074 asm_name
->die
= die
;
22075 asm_name
->created_for
= decl
;
22076 asm_name
->next
= deferred_asm_name
;
22077 deferred_asm_name
= asm_name
;
22079 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
22080 add_linkage_attr (die
, decl
);
22083 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl if desired. */
22086 add_linkage_name (dw_die_ref die
, tree decl
)
22088 if (debug_info_level
> DINFO_LEVEL_NONE
22089 && VAR_OR_FUNCTION_DECL_P (decl
)
22090 && TREE_PUBLIC (decl
)
22091 && !(VAR_P (decl
) && DECL_REGISTER (decl
))
22092 && die
->die_tag
!= DW_TAG_member
)
22093 add_linkage_name_raw (die
, decl
);
22096 /* Add a DW_AT_name attribute and source coordinate attribute for the
22097 given decl, but only if it actually has a name. */
22100 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
,
22101 bool no_linkage_name
)
22105 decl_name
= DECL_NAME (decl
);
22106 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
22108 const char *name
= dwarf2_name (decl
, 0);
22110 add_name_attribute (die
, name
);
22112 add_desc_attribute (die
, decl
);
22114 if (! DECL_ARTIFICIAL (decl
))
22115 add_src_coords_attributes (die
, decl
);
22117 if (!no_linkage_name
)
22118 add_linkage_name (die
, decl
);
22121 add_desc_attribute (die
, decl
);
22123 #ifdef VMS_DEBUGGING_INFO
22124 /* Get the function's name, as described by its RTL. This may be different
22125 from the DECL_NAME name used in the source file. */
22126 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
22128 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
22129 XEXP (DECL_RTL (decl
), 0), false);
22130 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
22132 #endif /* VMS_DEBUGGING_INFO */
22135 /* Add VALUE as a DW_AT_discr_value attribute to DIE. */
22138 add_discr_value (dw_die_ref die
, dw_discr_value
*value
)
22142 attr
.dw_attr
= DW_AT_discr_value
;
22143 attr
.dw_attr_val
.val_class
= dw_val_class_discr_value
;
22144 attr
.dw_attr_val
.val_entry
= NULL
;
22145 attr
.dw_attr_val
.v
.val_discr_value
.pos
= value
->pos
;
22147 attr
.dw_attr_val
.v
.val_discr_value
.v
.uval
= value
->v
.uval
;
22149 attr
.dw_attr_val
.v
.val_discr_value
.v
.sval
= value
->v
.sval
;
22150 add_dwarf_attr (die
, &attr
);
22153 /* Add DISCR_LIST as a DW_AT_discr_list to DIE. */
22156 add_discr_list (dw_die_ref die
, dw_discr_list_ref discr_list
)
22160 attr
.dw_attr
= DW_AT_discr_list
;
22161 attr
.dw_attr_val
.val_class
= dw_val_class_discr_list
;
22162 attr
.dw_attr_val
.val_entry
= NULL
;
22163 attr
.dw_attr_val
.v
.val_discr_list
= discr_list
;
22164 add_dwarf_attr (die
, &attr
);
22167 static inline dw_discr_list_ref
22168 AT_discr_list (dw_attr_node
*attr
)
22170 return attr
->dw_attr_val
.v
.val_discr_list
;
22173 #ifdef VMS_DEBUGGING_INFO
22174 /* Output the debug main pointer die for VMS */
22177 dwarf2out_vms_debug_main_pointer (void)
22179 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
22182 /* Allocate the VMS debug main subprogram die. */
22183 die
= new_die_raw (DW_TAG_subprogram
);
22184 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
22185 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
22186 current_function_funcdef_no
);
22187 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
22189 /* Make it the first child of comp_unit_die (). */
22190 die
->die_parent
= comp_unit_die ();
22191 if (comp_unit_die ()->die_child
)
22193 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
22194 comp_unit_die ()->die_child
->die_sib
= die
;
22198 die
->die_sib
= die
;
22199 comp_unit_die ()->die_child
= die
;
22202 #endif /* VMS_DEBUGGING_INFO */
22204 /* walk_tree helper function for uses_local_type, below. */
22207 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
22210 *walk_subtrees
= 0;
22213 tree name
= TYPE_NAME (*tp
);
22214 if (name
&& DECL_P (name
) && decl_function_context (name
))
22220 /* If TYPE involves a function-local type (including a local typedef to a
22221 non-local type), returns that type; otherwise returns NULL_TREE. */
22224 uses_local_type (tree type
)
22226 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
22230 /* Return the DIE for the scope that immediately contains this type.
22231 Non-named types that do not involve a function-local type get global
22232 scope. Named types nested in namespaces or other types get their
22233 containing scope. All other types (i.e. function-local named types) get
22234 the current active scope. */
22237 scope_die_for (tree t
, dw_die_ref context_die
)
22239 dw_die_ref scope_die
= NULL
;
22240 tree containing_scope
;
22242 /* Non-types always go in the current scope. */
22243 gcc_assert (TYPE_P (t
));
22245 /* Use the scope of the typedef, rather than the scope of the type
22247 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
22248 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
22250 containing_scope
= TYPE_CONTEXT (t
);
22252 /* Use the containing namespace if there is one. */
22253 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
22255 if (context_die
== lookup_decl_die (containing_scope
))
22257 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
22258 context_die
= get_context_die (containing_scope
);
22260 containing_scope
= NULL_TREE
;
22263 /* Ignore function type "scopes" from the C frontend. They mean that
22264 a tagged type is local to a parmlist of a function declarator, but
22265 that isn't useful to DWARF. */
22266 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
22267 containing_scope
= NULL_TREE
;
22269 if (SCOPE_FILE_SCOPE_P (containing_scope
))
22271 /* If T uses a local type keep it local as well, to avoid references
22272 to function-local DIEs from outside the function. */
22273 if (current_function_decl
&& uses_local_type (t
))
22274 scope_die
= context_die
;
22276 scope_die
= comp_unit_die ();
22278 else if (TYPE_P (containing_scope
))
22280 /* For types, we can just look up the appropriate DIE. */
22281 if (debug_info_level
> DINFO_LEVEL_TERSE
)
22282 scope_die
= get_context_die (containing_scope
);
22285 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
22286 if (scope_die
== NULL
)
22287 scope_die
= comp_unit_die ();
22291 scope_die
= context_die
;
22296 /* Returns true if CONTEXT_DIE is internal to a function. */
22299 local_scope_p (dw_die_ref context_die
)
22301 for (; context_die
; context_die
= context_die
->die_parent
)
22302 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
22303 || context_die
->die_tag
== DW_TAG_subprogram
)
22309 /* Returns true if CONTEXT_DIE is a class. */
22312 class_scope_p (dw_die_ref context_die
)
22314 return (context_die
22315 && (context_die
->die_tag
== DW_TAG_structure_type
22316 || context_die
->die_tag
== DW_TAG_class_type
22317 || context_die
->die_tag
== DW_TAG_interface_type
22318 || context_die
->die_tag
== DW_TAG_union_type
));
22321 /* Returns true if CONTEXT_DIE is a class or namespace, for deciding
22322 whether or not to treat a DIE in this context as a declaration. */
22325 class_or_namespace_scope_p (dw_die_ref context_die
)
22327 return (class_scope_p (context_die
)
22328 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
22331 /* Many forms of DIEs require a "type description" attribute. This
22332 routine locates the proper "type descriptor" die for the type given
22333 by 'type' plus any additional qualifiers given by 'cv_quals', and
22334 adds a DW_AT_type attribute below the given die. */
22337 add_type_attribute (dw_die_ref object_die
, tree type
, int cv_quals
,
22338 bool reverse
, dw_die_ref context_die
)
22340 enum tree_code code
= TREE_CODE (type
);
22341 dw_die_ref type_die
= NULL
;
22343 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
22346 /* ??? If this type is an unnamed subrange type of an integral, floating-point
22347 or fixed-point type, use the inner type. This is because we have no
22348 support for unnamed types in base_type_die. This can happen if this is
22349 an Ada subrange type. Correct solution is emit a subrange type die. */
22350 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
22351 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
22352 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
22354 if (code
== ERROR_MARK
22355 /* Handle a special case. For functions whose return type is void, we
22356 generate *no* type attribute. (Note that no object may have type
22357 `void', so this only applies to function return types). */
22358 || code
== VOID_TYPE
)
22361 type_die
= modified_type_die (type
,
22362 cv_quals
| TYPE_QUALS (type
),
22366 if (type_die
!= NULL
)
22367 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
22370 /* Given an object die, add the calling convention attribute for the
22371 function call type. */
22373 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
22375 enum dwarf_calling_convention value
= DW_CC_normal
;
22377 value
= ((enum dwarf_calling_convention
)
22378 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
22381 && id_equal (DECL_ASSEMBLER_NAME (decl
), "MAIN__"))
22383 /* DWARF 2 doesn't provide a way to identify a program's source-level
22384 entry point. DW_AT_calling_convention attributes are only meant
22385 to describe functions' calling conventions. However, lacking a
22386 better way to signal the Fortran main program, we used this for
22387 a long time, following existing custom. Now, DWARF 4 has
22388 DW_AT_main_subprogram, which we add below, but some tools still
22389 rely on the old way, which we thus keep. */
22390 value
= DW_CC_program
;
22392 if (dwarf_version
>= 4 || !dwarf_strict
)
22393 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
22396 /* Only add the attribute if the backend requests it, and
22397 is not DW_CC_normal. */
22398 if (value
&& (value
!= DW_CC_normal
))
22399 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
22402 /* Given a tree pointer to a struct, class, union, or enum type node, return
22403 a pointer to the (string) tag name for the given type, or zero if the type
22404 was declared without a tag. */
22406 static const char *
22407 type_tag (const_tree type
)
22409 const char *name
= 0;
22411 if (TYPE_NAME (type
) != 0)
22415 /* Find the IDENTIFIER_NODE for the type name. */
22416 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
22417 && !TYPE_NAMELESS (type
))
22418 t
= TYPE_NAME (type
);
22420 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
22421 a TYPE_DECL node, regardless of whether or not a `typedef' was
22423 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
22424 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
22426 /* We want to be extra verbose. Don't call dwarf_name if
22427 DECL_NAME isn't set. The default hook for decl_printable_name
22428 doesn't like that, and in this context it's correct to return
22429 0, instead of "<anonymous>" or the like. */
22430 if (DECL_NAME (TYPE_NAME (type
))
22431 && !DECL_NAMELESS (TYPE_NAME (type
)))
22432 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
22435 /* Now get the name as a string, or invent one. */
22436 if (!name
&& t
!= 0)
22437 name
= IDENTIFIER_POINTER (t
);
22440 return (name
== 0 || *name
== '\0') ? 0 : name
;
22443 /* Return the type associated with a data member, make a special check
22444 for bit field types. */
22447 member_declared_type (const_tree member
)
22449 return (DECL_BIT_FIELD_TYPE (member
)
22450 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
22453 /* Get the decl's label, as described by its RTL. This may be different
22454 from the DECL_NAME name used in the source file. */
22457 static const char *
22458 decl_start_label (tree decl
)
22461 const char *fnname
;
22463 x
= DECL_RTL (decl
);
22464 gcc_assert (MEM_P (x
));
22467 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
22469 fnname
= XSTR (x
, 0);
22474 /* For variable-length arrays that have been previously generated, but
22475 may be incomplete due to missing subscript info, fill the subscript
22476 info. Return TRUE if this is one of those cases. */
22479 fill_variable_array_bounds (tree type
)
22481 if (TREE_ASM_WRITTEN (type
)
22482 && TREE_CODE (type
) == ARRAY_TYPE
22483 && variably_modified_type_p (type
, NULL
))
22485 dw_die_ref array_die
= lookup_type_die (type
);
22488 add_subscript_info (array_die
, type
, !is_ada ());
22494 /* These routines generate the internal representation of the DIE's for
22495 the compilation unit. Debugging information is collected by walking
22496 the declaration trees passed in from dwarf2out_decl(). */
22499 gen_array_type_die (tree type
, dw_die_ref context_die
)
22501 dw_die_ref array_die
;
22503 /* GNU compilers represent multidimensional array types as sequences of one
22504 dimensional array types whose element types are themselves array types.
22505 We sometimes squish that down to a single array_type DIE with multiple
22506 subscripts in the Dwarf debugging info. The draft Dwarf specification
22507 say that we are allowed to do this kind of compression in C, because
22508 there is no difference between an array of arrays and a multidimensional
22509 array. We don't do this for Ada to remain as close as possible to the
22510 actual representation, which is especially important against the language
22511 flexibilty wrt arrays of variable size. */
22513 bool collapse_nested_arrays
= !is_ada ();
22515 if (fill_variable_array_bounds (type
))
22518 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
22521 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
22522 DW_TAG_string_type doesn't have DW_AT_type attribute). */
22523 if (TREE_CODE (type
) == ARRAY_TYPE
22524 && TYPE_STRING_FLAG (type
)
22526 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
22528 HOST_WIDE_INT size
;
22530 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
22531 add_name_attribute (array_die
, type_tag (type
));
22532 equate_type_number_to_die (type
, array_die
);
22533 size
= int_size_in_bytes (type
);
22535 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
22536 /* ??? We can't annotate types late, but for LTO we may not
22537 generate a location early either (gfortran.dg/save_6.f90). */
22538 else if (! (early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
22539 && TYPE_DOMAIN (type
) != NULL_TREE
22540 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
)
22542 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
22543 tree rszdecl
= szdecl
;
22545 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
22546 if (!DECL_P (szdecl
))
22548 if (INDIRECT_REF_P (szdecl
)
22549 && DECL_P (TREE_OPERAND (szdecl
, 0)))
22551 rszdecl
= TREE_OPERAND (szdecl
, 0);
22552 if (int_size_in_bytes (TREE_TYPE (rszdecl
))
22553 != DWARF2_ADDR_SIZE
)
22561 dw_loc_list_ref loc
22562 = loc_list_from_tree (rszdecl
, szdecl
== rszdecl
? 2 : 0,
22566 add_AT_location_description (array_die
, DW_AT_string_length
,
22568 if (size
!= DWARF2_ADDR_SIZE
)
22569 add_AT_unsigned (array_die
, dwarf_version
>= 5
22570 ? DW_AT_string_length_byte_size
22571 : DW_AT_byte_size
, size
);
22578 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
22579 add_name_attribute (array_die
, type_tag (type
));
22580 equate_type_number_to_die (type
, array_die
);
22582 if (VECTOR_TYPE_P (type
))
22583 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
22585 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
22587 && TREE_CODE (type
) == ARRAY_TYPE
22588 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
22589 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
22590 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
22593 /* We default the array ordering. Debuggers will probably do the right
22594 things even if DW_AT_ordering is not present. It's not even an issue
22595 until we start to get into multidimensional arrays anyway. If a debugger
22596 is ever caught doing the Wrong Thing for multi-dimensional arrays,
22597 then we'll have to put the DW_AT_ordering attribute back in. (But if
22598 and when we find out that we need to put these in, we will only do so
22599 for multidimensional arrays. */
22600 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
22603 if (VECTOR_TYPE_P (type
))
22605 /* For VECTOR_TYPEs we use an array DIE with appropriate bounds. */
22606 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
22607 int lb
= lower_bound_default ();
22610 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_int (lb
), NULL
);
22611 add_bound_info (subrange_die
, DW_AT_upper_bound
,
22612 size_int (lb
+ TYPE_VECTOR_SUBPARTS (type
) - 1), NULL
);
22615 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
22617 /* Add representation of the type of the elements of this array type and
22618 emit the corresponding DIE if we haven't done it already. */
22619 element_type
= TREE_TYPE (type
);
22620 if (collapse_nested_arrays
)
22621 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
22623 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
22625 element_type
= TREE_TYPE (element_type
);
22628 add_type_attribute (array_die
, element_type
, TYPE_UNQUALIFIED
,
22629 TREE_CODE (type
) == ARRAY_TYPE
22630 && TYPE_REVERSE_STORAGE_ORDER (type
),
22633 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
22634 if (TYPE_ARTIFICIAL (type
))
22635 add_AT_flag (array_die
, DW_AT_artificial
, 1);
22637 if (get_AT (array_die
, DW_AT_name
))
22638 add_pubtype (type
, array_die
);
22640 add_alignment_attribute (array_die
, type
);
22643 /* This routine generates DIE for array with hidden descriptor, details
22644 are filled into *info by a langhook. */
22647 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
22648 dw_die_ref context_die
)
22650 const dw_die_ref scope_die
= scope_die_for (type
, context_die
);
22651 const dw_die_ref array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
22652 struct loc_descr_context context
= {
22653 type
, /* context_type */
22654 info
->base_decl
, /* base_decl */
22656 false, /* placeholder_arg */
22657 false, /* placeholder_seen */
22658 false /* strict_signedness */
22660 enum dwarf_tag subrange_tag
= DW_TAG_subrange_type
;
22663 add_name_attribute (array_die
, type_tag (type
));
22664 equate_type_number_to_die (type
, array_die
);
22666 if (info
->ndimensions
> 1)
22667 switch (info
->ordering
)
22669 case array_descr_ordering_row_major
:
22670 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
22672 case array_descr_ordering_column_major
:
22673 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
22679 if (dwarf_version
>= 3 || !dwarf_strict
)
22681 if (info
->data_location
)
22682 add_scalar_info (array_die
, DW_AT_data_location
, info
->data_location
,
22683 dw_scalar_form_exprloc
, &context
);
22684 if (info
->associated
)
22685 add_scalar_info (array_die
, DW_AT_associated
, info
->associated
,
22686 dw_scalar_form_constant
22687 | dw_scalar_form_exprloc
22688 | dw_scalar_form_reference
, &context
);
22689 if (info
->allocated
)
22690 add_scalar_info (array_die
, DW_AT_allocated
, info
->allocated
,
22691 dw_scalar_form_constant
22692 | dw_scalar_form_exprloc
22693 | dw_scalar_form_reference
, &context
);
22696 const enum dwarf_attribute attr
22697 = (info
->stride_in_bits
) ? DW_AT_bit_stride
: DW_AT_byte_stride
;
22699 = (info
->stride_in_bits
)
22700 ? dw_scalar_form_constant
22701 : (dw_scalar_form_constant
22702 | dw_scalar_form_exprloc
22703 | dw_scalar_form_reference
);
22705 add_scalar_info (array_die
, attr
, info
->stride
, forms
, &context
);
22708 if (dwarf_version
>= 5)
22712 add_scalar_info (array_die
, DW_AT_rank
, info
->rank
,
22713 dw_scalar_form_constant
22714 | dw_scalar_form_exprloc
, &context
);
22715 subrange_tag
= DW_TAG_generic_subrange
;
22716 context
.placeholder_arg
= true;
22720 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
22722 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
22724 dw_die_ref subrange_die
= new_die (subrange_tag
, array_die
, NULL
);
22726 if (info
->dimen
[dim
].bounds_type
)
22727 add_type_attribute (subrange_die
,
22728 info
->dimen
[dim
].bounds_type
, TYPE_UNQUALIFIED
,
22729 false, context_die
);
22730 if (info
->dimen
[dim
].lower_bound
)
22731 add_bound_info (subrange_die
, DW_AT_lower_bound
,
22732 info
->dimen
[dim
].lower_bound
, &context
);
22733 if (info
->dimen
[dim
].upper_bound
)
22734 add_bound_info (subrange_die
, DW_AT_upper_bound
,
22735 info
->dimen
[dim
].upper_bound
, &context
);
22736 if ((dwarf_version
>= 3 || !dwarf_strict
) && info
->dimen
[dim
].stride
)
22737 add_scalar_info (subrange_die
, DW_AT_byte_stride
,
22738 info
->dimen
[dim
].stride
,
22739 dw_scalar_form_constant
22740 | dw_scalar_form_exprloc
22741 | dw_scalar_form_reference
,
22745 gen_type_die (info
->element_type
, context_die
);
22746 add_type_attribute (array_die
, info
->element_type
, TYPE_UNQUALIFIED
,
22747 TREE_CODE (type
) == ARRAY_TYPE
22748 && TYPE_REVERSE_STORAGE_ORDER (type
),
22751 if (get_AT (array_die
, DW_AT_name
))
22752 add_pubtype (type
, array_die
);
22754 add_alignment_attribute (array_die
, type
);
22759 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
22761 tree origin
= decl_ultimate_origin (decl
);
22762 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
22764 if (origin
!= NULL
)
22765 add_abstract_origin_attribute (decl_die
, origin
);
22768 add_name_and_src_coords_attributes (decl_die
, decl
);
22769 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
22770 TYPE_UNQUALIFIED
, false, context_die
);
22773 if (DECL_ABSTRACT_P (decl
))
22774 equate_decl_number_to_die (decl
, decl_die
);
22776 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
22780 /* Walk through the list of incomplete types again, trying once more to
22781 emit full debugging info for them. */
22784 retry_incomplete_types (void)
22789 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
22790 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
22791 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
22792 vec_safe_truncate (incomplete_types
, 0);
22795 /* Determine what tag to use for a record type. */
22797 static enum dwarf_tag
22798 record_type_tag (tree type
)
22800 if (! lang_hooks
.types
.classify_record
)
22801 return DW_TAG_structure_type
;
22803 switch (lang_hooks
.types
.classify_record (type
))
22805 case RECORD_IS_STRUCT
:
22806 return DW_TAG_structure_type
;
22808 case RECORD_IS_CLASS
:
22809 return DW_TAG_class_type
;
22811 case RECORD_IS_INTERFACE
:
22812 if (dwarf_version
>= 3 || !dwarf_strict
)
22813 return DW_TAG_interface_type
;
22814 return DW_TAG_structure_type
;
22817 gcc_unreachable ();
22821 /* Generate a DIE to represent an enumeration type. Note that these DIEs
22822 include all of the information about the enumeration values also. Each
22823 enumerated type name/value is listed as a child of the enumerated type
22827 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
22829 dw_die_ref type_die
= lookup_type_die (type
);
22830 dw_die_ref orig_type_die
= type_die
;
22832 if (type_die
== NULL
)
22834 type_die
= new_die (DW_TAG_enumeration_type
,
22835 scope_die_for (type
, context_die
), type
);
22836 equate_type_number_to_die (type
, type_die
);
22837 add_name_attribute (type_die
, type_tag (type
));
22838 if ((dwarf_version
>= 4 || !dwarf_strict
)
22839 && ENUM_IS_SCOPED (type
))
22840 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
22841 if (ENUM_IS_OPAQUE (type
) && TYPE_SIZE (type
))
22842 add_AT_flag (type_die
, DW_AT_declaration
, 1);
22844 add_AT_unsigned (type_die
, DW_AT_encoding
,
22845 TYPE_UNSIGNED (type
)
22849 else if (! TYPE_SIZE (type
) || ENUM_IS_OPAQUE (type
))
22852 remove_AT (type_die
, DW_AT_declaration
);
22854 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
22855 given enum type is incomplete, do not generate the DW_AT_byte_size
22856 attribute or the DW_AT_element_list attribute. */
22857 if (TYPE_SIZE (type
))
22861 if (!ENUM_IS_OPAQUE (type
))
22862 TREE_ASM_WRITTEN (type
) = 1;
22863 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_byte_size
))
22864 add_byte_size_attribute (type_die
, type
);
22865 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_alignment
))
22866 add_alignment_attribute (type_die
, type
);
22867 if ((dwarf_version
>= 3 || !dwarf_strict
)
22868 && (!orig_type_die
|| !get_AT (type_die
, DW_AT_type
)))
22870 tree underlying
= lang_hooks
.types
.enum_underlying_base_type (type
);
22871 add_type_attribute (type_die
, underlying
, TYPE_UNQUALIFIED
, false,
22874 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
22876 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_decl_file
))
22877 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
22878 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_accessibility
))
22879 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
22882 /* If the first reference to this type was as the return type of an
22883 inline function, then it may not have a parent. Fix this now. */
22884 if (type_die
->die_parent
== NULL
)
22885 add_child_die (scope_die_for (type
, context_die
), type_die
);
22887 for (link
= TYPE_VALUES (type
);
22888 link
!= NULL
; link
= TREE_CHAIN (link
))
22890 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
22891 tree value
= TREE_VALUE (link
);
22893 if (DECL_P (value
))
22894 equate_decl_number_to_die (value
, enum_die
);
22896 gcc_assert (!ENUM_IS_OPAQUE (type
));
22897 add_name_attribute (enum_die
,
22898 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
22900 if (TREE_CODE (value
) == CONST_DECL
)
22901 value
= DECL_INITIAL (value
);
22903 if (simple_type_size_in_bits (TREE_TYPE (value
))
22904 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
22906 /* For constant forms created by add_AT_unsigned DWARF
22907 consumers (GDB, elfutils, etc.) always zero extend
22908 the value. Only when the actual value is negative
22909 do we need to use add_AT_int to generate a constant
22910 form that can represent negative values. */
22911 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
22912 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
22913 add_AT_unsigned (enum_die
, DW_AT_const_value
,
22914 (unsigned HOST_WIDE_INT
) val
);
22916 add_AT_int (enum_die
, DW_AT_const_value
, val
);
22919 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
22920 that here. TODO: This should be re-worked to use correct
22921 signed/unsigned double tags for all cases. */
22922 add_AT_wide (enum_die
, DW_AT_const_value
, wi::to_wide (value
));
22925 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
22926 if (TYPE_ARTIFICIAL (type
)
22927 && (!orig_type_die
|| !get_AT (type_die
, DW_AT_artificial
)))
22928 add_AT_flag (type_die
, DW_AT_artificial
, 1);
22931 add_AT_flag (type_die
, DW_AT_declaration
, 1);
22933 add_pubtype (type
, type_die
);
22938 /* Generate a DIE to represent either a real live formal parameter decl or to
22939 represent just the type of some formal parameter position in some function
22942 Note that this routine is a bit unusual because its argument may be a
22943 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
22944 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
22945 node. If it's the former then this function is being called to output a
22946 DIE to represent a formal parameter object (or some inlining thereof). If
22947 it's the latter, then this function is only being called to output a
22948 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
22949 argument type of some subprogram type.
22950 If EMIT_NAME_P is true, name and source coordinate attributes
22954 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
22955 dw_die_ref context_die
)
22957 tree node_or_origin
= node
? node
: origin
;
22958 tree ultimate_origin
;
22959 dw_die_ref parm_die
= NULL
;
22961 if (DECL_P (node_or_origin
))
22963 parm_die
= lookup_decl_die (node
);
22965 /* If the contexts differ, we may not be talking about the same
22967 ??? When in LTO the DIE parent is the "abstract" copy and the
22968 context_die is the specification "copy". */
22970 && parm_die
->die_parent
!= context_die
22971 && (parm_die
->die_parent
->die_tag
!= DW_TAG_GNU_formal_parameter_pack
22972 || parm_die
->die_parent
->die_parent
!= context_die
)
22975 gcc_assert (!DECL_ABSTRACT_P (node
));
22976 /* This can happen when creating a concrete instance, in
22977 which case we need to create a new DIE that will get
22978 annotated with DW_AT_abstract_origin. */
22982 if (parm_die
&& parm_die
->die_parent
== NULL
)
22984 /* Check that parm_die already has the right attributes that
22985 we would have added below. If any attributes are
22986 missing, fall through to add them. */
22987 if (! DECL_ABSTRACT_P (node_or_origin
)
22988 && !get_AT (parm_die
, DW_AT_location
)
22989 && !get_AT (parm_die
, DW_AT_const_value
))
22990 /* We are missing location info, and are about to add it. */
22994 add_child_die (context_die
, parm_die
);
23000 /* If we have a previously generated DIE, use it, unless this is an
23001 concrete instance (origin != NULL), in which case we need a new
23002 DIE with a corresponding DW_AT_abstract_origin. */
23004 if (parm_die
&& origin
== NULL
)
23005 reusing_die
= true;
23008 parm_die
= new_die (DW_TAG_formal_parameter
, context_die
, node
);
23009 reusing_die
= false;
23012 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
23014 case tcc_declaration
:
23015 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
23016 if (node
|| ultimate_origin
)
23017 origin
= ultimate_origin
;
23022 if (origin
!= NULL
)
23023 add_abstract_origin_attribute (parm_die
, origin
);
23024 else if (emit_name_p
)
23025 add_name_and_src_coords_attributes (parm_die
, node
);
23027 || (! DECL_ABSTRACT_P (node_or_origin
)
23028 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
23029 decl_function_context
23030 (node_or_origin
))))
23032 tree type
= TREE_TYPE (node_or_origin
);
23033 if (decl_by_reference_p (node_or_origin
))
23034 add_type_attribute (parm_die
, TREE_TYPE (type
),
23036 false, context_die
);
23038 add_type_attribute (parm_die
, type
,
23039 decl_quals (node_or_origin
),
23040 false, context_die
);
23042 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
23043 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
23045 if (node
&& node
!= origin
)
23046 equate_decl_number_to_die (node
, parm_die
);
23047 if (! DECL_ABSTRACT_P (node_or_origin
))
23048 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
23054 /* We were called with some kind of a ..._TYPE node. */
23055 add_type_attribute (parm_die
, node_or_origin
, TYPE_UNQUALIFIED
, false,
23060 gcc_unreachable ();
23066 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
23067 children DW_TAG_formal_parameter DIEs representing the arguments of the
23070 PARM_PACK must be a function parameter pack.
23071 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
23072 must point to the subsequent arguments of the function PACK_ARG belongs to.
23073 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
23074 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
23075 following the last one for which a DIE was generated. */
23078 gen_formal_parameter_pack_die (tree parm_pack
,
23080 dw_die_ref subr_die
,
23084 dw_die_ref parm_pack_die
;
23086 gcc_assert (parm_pack
23087 && lang_hooks
.function_parameter_pack_p (parm_pack
)
23090 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
23091 add_src_coords_attributes (parm_pack_die
, parm_pack
);
23093 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
23095 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
23098 gen_formal_parameter_die (arg
, NULL
,
23099 false /* Don't emit name attribute. */,
23104 return parm_pack_die
;
23107 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
23108 at the end of an (ANSI prototyped) formal parameters list. */
23111 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
23113 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
23116 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
23117 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
23118 parameters as specified in some function type specification (except for
23119 those which appear as part of a function *definition*). */
23122 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
23125 tree formal_type
= NULL
;
23126 tree first_parm_type
;
23129 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
23131 arg
= DECL_ARGUMENTS (function_or_method_type
);
23132 function_or_method_type
= TREE_TYPE (function_or_method_type
);
23137 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
23139 /* Make our first pass over the list of formal parameter types and output a
23140 DW_TAG_formal_parameter DIE for each one. */
23141 for (link
= first_parm_type
; link
; )
23143 dw_die_ref parm_die
;
23145 formal_type
= TREE_VALUE (link
);
23146 if (formal_type
== void_type_node
)
23149 /* Output a (nameless) DIE to represent the formal parameter itself. */
23150 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
23151 true /* Emit name attribute. */,
23153 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
23154 && link
== first_parm_type
)
23156 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
23157 if (dwarf_version
>= 3 || !dwarf_strict
)
23158 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
23160 else if (arg
&& DECL_ARTIFICIAL (arg
))
23161 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
23163 link
= TREE_CHAIN (link
);
23165 arg
= DECL_CHAIN (arg
);
23168 /* If this function type has an ellipsis, add a
23169 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
23170 if (formal_type
!= void_type_node
)
23171 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
23173 /* Make our second (and final) pass over the list of formal parameter types
23174 and output DIEs to represent those types (as necessary). */
23175 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
23176 link
&& TREE_VALUE (link
);
23177 link
= TREE_CHAIN (link
))
23178 gen_type_die (TREE_VALUE (link
), context_die
);
23181 /* We want to generate the DIE for TYPE so that we can generate the
23182 die for MEMBER, which has been defined; we will need to refer back
23183 to the member declaration nested within TYPE. If we're trying to
23184 generate minimal debug info for TYPE, processing TYPE won't do the
23185 trick; we need to attach the member declaration by hand. */
23188 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
23190 gen_type_die (type
, context_die
);
23192 /* If we're trying to avoid duplicate debug info, we may not have
23193 emitted the member decl for this function. Emit it now. */
23194 if (TYPE_STUB_DECL (type
)
23195 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
23196 && ! lookup_decl_die (member
))
23198 dw_die_ref type_die
;
23199 gcc_assert (!decl_ultimate_origin (member
));
23201 type_die
= lookup_type_die_strip_naming_typedef (type
);
23202 if (TREE_CODE (member
) == FUNCTION_DECL
)
23203 gen_subprogram_die (member
, type_die
);
23204 else if (TREE_CODE (member
) == FIELD_DECL
)
23206 /* Ignore the nameless fields that are used to skip bits but handle
23207 C++ anonymous unions and structs. */
23208 if (DECL_NAME (member
) != NULL_TREE
23209 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
23210 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
23212 struct vlr_context vlr_ctx
= {
23213 DECL_CONTEXT (member
), /* struct_type */
23214 NULL_TREE
/* variant_part_offset */
23216 gen_type_die (member_declared_type (member
), type_die
);
23217 gen_field_die (member
, &vlr_ctx
, type_die
);
23221 gen_variable_die (member
, NULL_TREE
, type_die
);
23225 /* Forward declare these functions, because they are mutually recursive
23226 with their set_block_* pairing functions. */
23227 static void set_decl_origin_self (tree
);
23229 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
23230 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
23231 that it points to the node itself, thus indicating that the node is its
23232 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
23233 the given node is NULL, recursively descend the decl/block tree which
23234 it is the root of, and for each other ..._DECL or BLOCK node contained
23235 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
23236 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
23237 values to point to themselves. */
23240 set_block_origin_self (tree stmt
)
23242 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
23244 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
23249 for (local_decl
= BLOCK_VARS (stmt
);
23250 local_decl
!= NULL_TREE
;
23251 local_decl
= DECL_CHAIN (local_decl
))
23252 /* Do not recurse on nested functions since the inlining status
23253 of parent and child can be different as per the DWARF spec. */
23254 if (TREE_CODE (local_decl
) != FUNCTION_DECL
23255 && !DECL_EXTERNAL (local_decl
))
23256 set_decl_origin_self (local_decl
);
23262 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
23263 subblock
!= NULL_TREE
;
23264 subblock
= BLOCK_CHAIN (subblock
))
23265 set_block_origin_self (subblock
); /* Recurse. */
23270 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
23271 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
23272 node to so that it points to the node itself, thus indicating that the
23273 node represents its own (abstract) origin. Additionally, if the
23274 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
23275 the decl/block tree of which the given node is the root of, and for
23276 each other ..._DECL or BLOCK node contained therein whose
23277 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
23278 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
23279 point to themselves. */
23282 set_decl_origin_self (tree decl
)
23284 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
23286 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
23287 if (TREE_CODE (decl
) == FUNCTION_DECL
)
23291 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
23292 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
23293 if (DECL_INITIAL (decl
) != NULL_TREE
23294 && DECL_INITIAL (decl
) != error_mark_node
)
23295 set_block_origin_self (DECL_INITIAL (decl
));
23300 /* Mark the early DIE for DECL as the abstract instance. */
23303 dwarf2out_abstract_function (tree decl
)
23305 dw_die_ref old_die
;
23307 /* Make sure we have the actual abstract inline, not a clone. */
23308 decl
= DECL_ORIGIN (decl
);
23310 if (DECL_IGNORED_P (decl
))
23313 /* In LTO we're all set. We already created abstract instances
23314 early and we want to avoid creating a concrete instance of that
23315 if we don't output it. */
23319 old_die
= lookup_decl_die (decl
);
23320 gcc_assert (old_die
!= NULL
);
23321 if (get_AT (old_die
, DW_AT_inline
))
23322 /* We've already generated the abstract instance. */
23325 /* Go ahead and put DW_AT_inline on the DIE. */
23326 if (DECL_DECLARED_INLINE_P (decl
))
23328 if (cgraph_function_possibly_inlined_p (decl
))
23329 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_inlined
);
23331 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
23335 if (cgraph_function_possibly_inlined_p (decl
))
23336 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_inlined
);
23338 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_not_inlined
);
23341 if (DECL_DECLARED_INLINE_P (decl
)
23342 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
23343 add_AT_flag (old_die
, DW_AT_artificial
, 1);
23345 set_decl_origin_self (decl
);
23348 /* Helper function of premark_used_types() which gets called through
23351 Marks the DIE of a given type in *SLOT as perennial, so it never gets
23352 marked as unused by prune_unused_types. */
23355 premark_used_types_helper (tree
const &type
, void *)
23359 die
= lookup_type_die (type
);
23361 die
->die_perennial_p
= 1;
23365 /* Helper function of premark_types_used_by_global_vars which gets called
23366 through htab_traverse.
23368 Marks the DIE of a given type in *SLOT as perennial, so it never gets
23369 marked as unused by prune_unused_types. The DIE of the type is marked
23370 only if the global variable using the type will actually be emitted. */
23373 premark_types_used_by_global_vars_helper (types_used_by_vars_entry
**slot
,
23376 struct types_used_by_vars_entry
*entry
;
23379 entry
= (struct types_used_by_vars_entry
*) *slot
;
23380 gcc_assert (entry
->type
!= NULL
23381 && entry
->var_decl
!= NULL
);
23382 die
= lookup_type_die (entry
->type
);
23385 /* Ask cgraph if the global variable really is to be emitted.
23386 If yes, then we'll keep the DIE of ENTRY->TYPE. */
23387 varpool_node
*node
= varpool_node::get (entry
->var_decl
);
23388 if (node
&& node
->definition
)
23390 die
->die_perennial_p
= 1;
23391 /* Keep the parent DIEs as well. */
23392 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
23393 die
->die_perennial_p
= 1;
23399 /* Mark all members of used_types_hash as perennial. */
23402 premark_used_types (struct function
*fun
)
23404 if (fun
&& fun
->used_types_hash
)
23405 fun
->used_types_hash
->traverse
<void *, premark_used_types_helper
> (NULL
);
23408 /* Mark all members of types_used_by_vars_entry as perennial. */
23411 premark_types_used_by_global_vars (void)
23413 if (types_used_by_vars_hash
)
23414 types_used_by_vars_hash
23415 ->traverse
<void *, premark_types_used_by_global_vars_helper
> (NULL
);
23418 /* Mark all variables used by the symtab as perennial. */
23421 premark_used_variables (void)
23423 /* Mark DIEs in the symtab as used. */
23425 FOR_EACH_VARIABLE (var
)
23427 dw_die_ref die
= lookup_decl_die (var
->decl
);
23429 die
->die_perennial_p
= 1;
23433 /* Generate a DW_TAG_call_site DIE in function DECL under SUBR_DIE
23434 for CA_LOC call arg loc node. */
23437 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
23438 struct call_arg_loc_node
*ca_loc
)
23440 dw_die_ref stmt_die
= NULL
, die
;
23441 tree block
= ca_loc
->block
;
23444 && block
!= DECL_INITIAL (decl
)
23445 && TREE_CODE (block
) == BLOCK
)
23447 stmt_die
= lookup_block_die (block
);
23450 block
= BLOCK_SUPERCONTEXT (block
);
23452 if (stmt_die
== NULL
)
23453 stmt_die
= subr_die
;
23454 die
= new_die (dwarf_TAG (DW_TAG_call_site
), stmt_die
, NULL_TREE
);
23455 add_AT_lbl_id (die
, dwarf_AT (DW_AT_call_return_pc
), ca_loc
->label
);
23456 if (ca_loc
->tail_call_p
)
23457 add_AT_flag (die
, dwarf_AT (DW_AT_call_tail_call
), 1);
23458 if (ca_loc
->symbol_ref
)
23460 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
23462 add_AT_die_ref (die
, dwarf_AT (DW_AT_call_origin
), tdie
);
23464 add_AT_addr (die
, dwarf_AT (DW_AT_call_origin
), ca_loc
->symbol_ref
,
23470 /* Generate a DIE to represent a declared function (either file-scope or
23474 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
23476 tree origin
= decl_ultimate_origin (decl
);
23477 dw_die_ref subr_die
;
23478 dw_die_ref old_die
= lookup_decl_die (decl
);
23479 bool old_die_had_no_children
= false;
23481 /* This function gets called multiple times for different stages of
23482 the debug process. For example, for func() in this code:
23486 void func() { ... }
23489 ...we get called 4 times. Twice in early debug and twice in
23495 1. Once while generating func() within the namespace. This is
23496 the declaration. The declaration bit below is set, as the
23497 context is the namespace.
23499 A new DIE will be generated with DW_AT_declaration set.
23501 2. Once for func() itself. This is the specification. The
23502 declaration bit below is clear as the context is the CU.
23504 We will use the cached DIE from (1) to create a new DIE with
23505 DW_AT_specification pointing to the declaration in (1).
23507 Late debug via rest_of_handle_final()
23508 -------------------------------------
23510 3. Once generating func() within the namespace. This is also the
23511 declaration, as in (1), but this time we will early exit below
23512 as we have a cached DIE and a declaration needs no additional
23513 annotations (no locations), as the source declaration line
23516 4. Once for func() itself. As in (2), this is the specification,
23517 but this time we will re-use the cached DIE, and just annotate
23518 it with the location information that should now be available.
23520 For something without namespaces, but with abstract instances, we
23521 are also called a multiple times:
23526 Base (); // constructor declaration (1)
23529 Base::Base () { } // constructor specification (2)
23534 1. Once for the Base() constructor by virtue of it being a
23535 member of the Base class. This is done via
23536 rest_of_type_compilation.
23538 This is a declaration, so a new DIE will be created with
23541 2. Once for the Base() constructor definition, but this time
23542 while generating the abstract instance of the base
23543 constructor (__base_ctor) which is being generated via early
23544 debug of reachable functions.
23546 Even though we have a cached version of the declaration (1),
23547 we will create a DW_AT_specification of the declaration DIE
23550 3. Once for the __base_ctor itself, but this time, we generate
23551 an DW_AT_abstract_origin version of the DW_AT_specification in
23554 Late debug via rest_of_handle_final
23555 -----------------------------------
23557 4. One final time for the __base_ctor (which will have a cached
23558 DIE with DW_AT_abstract_origin created in (3). This time,
23559 we will just annotate the location information now
23562 int declaration
= (current_function_decl
!= decl
23563 || (!DECL_INITIAL (decl
) && !origin
)
23564 || class_or_namespace_scope_p (context_die
));
23566 /* A declaration that has been previously dumped needs no
23567 additional information. */
23568 if (old_die
&& declaration
)
23571 if (in_lto_p
&& old_die
&& old_die
->die_child
== NULL
)
23572 old_die_had_no_children
= true;
23574 /* Now that the C++ front end lazily declares artificial member fns, we
23575 might need to retrofit the declaration into its class. */
23576 if (!declaration
&& !origin
&& !old_die
23577 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
23578 && !class_or_namespace_scope_p (context_die
)
23579 && debug_info_level
> DINFO_LEVEL_TERSE
)
23580 old_die
= force_decl_die (decl
);
23582 /* A concrete instance, tag a new DIE with DW_AT_abstract_origin. */
23583 if (origin
!= NULL
)
23585 gcc_assert (!declaration
|| local_scope_p (context_die
));
23587 /* Fixup die_parent for the abstract instance of a nested
23588 inline function. */
23589 if (old_die
&& old_die
->die_parent
== NULL
)
23590 add_child_die (context_die
, old_die
);
23592 if (old_die
&& get_AT_ref (old_die
, DW_AT_abstract_origin
))
23594 /* If we have a DW_AT_abstract_origin we have a working
23596 subr_die
= old_die
;
23600 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
23601 add_abstract_origin_attribute (subr_die
, origin
);
23602 /* This is where the actual code for a cloned function is.
23603 Let's emit linkage name attribute for it. This helps
23604 debuggers to e.g, set breakpoints into
23605 constructors/destructors when the user asks "break
23607 add_linkage_name (subr_die
, decl
);
23610 /* A cached copy, possibly from early dwarf generation. Reuse as
23611 much as possible. */
23614 if (!get_AT_flag (old_die
, DW_AT_declaration
)
23615 /* We can have a normal definition following an inline one in the
23616 case of redefinition of GNU C extern inlines.
23617 It seems reasonable to use AT_specification in this case. */
23618 && !get_AT (old_die
, DW_AT_inline
))
23620 /* Detect and ignore this case, where we are trying to output
23621 something we have already output. */
23622 if (get_AT (old_die
, DW_AT_low_pc
)
23623 || get_AT (old_die
, DW_AT_ranges
))
23626 /* If we have no location information, this must be a
23627 partially generated DIE from early dwarf generation.
23628 Fall through and generate it. */
23631 /* If the definition comes from the same place as the declaration,
23632 maybe use the old DIE. We always want the DIE for this function
23633 that has the *_pc attributes to be under comp_unit_die so the
23634 debugger can find it. We also need to do this for abstract
23635 instances of inlines, since the spec requires the out-of-line copy
23636 to have the same parent. For local class methods, this doesn't
23637 apply; we just use the old DIE. */
23638 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
23639 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
23640 if (((is_unit_die (old_die
->die_parent
)
23641 /* This condition fixes the inconsistency/ICE with the
23642 following Fortran test (or some derivative thereof) while
23643 building libgfortran:
23647 logical function funky (FLAG)
23652 || (old_die
->die_parent
23653 && old_die
->die_parent
->die_tag
== DW_TAG_module
)
23654 || local_scope_p (old_die
->die_parent
)
23655 || context_die
== NULL
)
23656 && (DECL_ARTIFICIAL (decl
)
23657 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
23658 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
23659 == (unsigned) s
.line
)
23660 && (!debug_column_info
23662 || (get_AT_unsigned (old_die
, DW_AT_decl_column
)
23663 == (unsigned) s
.column
)))))
23664 /* With LTO if there's an abstract instance for
23665 the old DIE, this is a concrete instance and
23666 thus re-use the DIE. */
23667 || get_AT (old_die
, DW_AT_abstract_origin
))
23669 subr_die
= old_die
;
23671 /* Clear out the declaration attribute, but leave the
23672 parameters so they can be augmented with location
23673 information later. Unless this was a declaration, in
23674 which case, wipe out the nameless parameters and recreate
23675 them further down. */
23676 if (remove_AT (subr_die
, DW_AT_declaration
))
23679 remove_AT (subr_die
, DW_AT_object_pointer
);
23680 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
23683 /* Make a specification pointing to the previously built
23687 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
23688 add_AT_specification (subr_die
, old_die
);
23689 add_pubname (decl
, subr_die
);
23690 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
23691 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
23692 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
23693 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
23694 if (debug_column_info
23696 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
23697 != (unsigned) s
.column
))
23698 add_AT_unsigned (subr_die
, DW_AT_decl_column
, s
.column
);
23700 /* If the prototype had an 'auto' or 'decltype(auto)' in
23701 the return type, emit the real type on the definition die. */
23702 if (is_cxx () && debug_info_level
> DINFO_LEVEL_TERSE
)
23704 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
23706 && (die
->die_tag
== DW_TAG_reference_type
23707 || die
->die_tag
== DW_TAG_rvalue_reference_type
23708 || die
->die_tag
== DW_TAG_pointer_type
23709 || die
->die_tag
== DW_TAG_const_type
23710 || die
->die_tag
== DW_TAG_volatile_type
23711 || die
->die_tag
== DW_TAG_restrict_type
23712 || die
->die_tag
== DW_TAG_array_type
23713 || die
->die_tag
== DW_TAG_ptr_to_member_type
23714 || die
->die_tag
== DW_TAG_subroutine_type
))
23715 die
= get_AT_ref (die
, DW_AT_type
);
23716 if (die
== auto_die
|| die
== decltype_auto_die
)
23717 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
23718 TYPE_UNQUALIFIED
, false, context_die
);
23721 /* When we process the method declaration, we haven't seen
23722 the out-of-class defaulted definition yet, so we have to
23724 if ((dwarf_version
>= 5 || ! dwarf_strict
)
23725 && !get_AT (subr_die
, DW_AT_defaulted
))
23728 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23730 if (defaulted
!= -1)
23732 /* Other values must have been handled before. */
23733 gcc_assert (defaulted
== DW_DEFAULTED_out_of_class
);
23734 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
23739 /* Create a fresh DIE for anything else. */
23742 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
23744 if (TREE_PUBLIC (decl
))
23745 add_AT_flag (subr_die
, DW_AT_external
, 1);
23747 add_name_and_src_coords_attributes (subr_die
, decl
);
23748 add_pubname (decl
, subr_die
);
23749 if (debug_info_level
> DINFO_LEVEL_TERSE
)
23751 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
23752 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
23753 TYPE_UNQUALIFIED
, false, context_die
);
23756 add_pure_or_virtual_attribute (subr_die
, decl
);
23757 if (DECL_ARTIFICIAL (decl
))
23758 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
23760 if (TREE_THIS_VOLATILE (decl
) && (dwarf_version
>= 5 || !dwarf_strict
))
23761 add_AT_flag (subr_die
, DW_AT_noreturn
, 1);
23763 add_alignment_attribute (subr_die
, decl
);
23765 add_accessibility_attribute (subr_die
, decl
);
23768 /* Unless we have an existing non-declaration DIE, equate the new
23770 if (!old_die
|| is_declaration_die (old_die
))
23771 equate_decl_number_to_die (decl
, subr_die
);
23775 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
23777 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
23779 /* If this is an explicit function declaration then generate
23780 a DW_AT_explicit attribute. */
23781 if ((dwarf_version
>= 3 || !dwarf_strict
)
23782 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23783 DW_AT_explicit
) == 1)
23784 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
23786 /* If this is a C++11 deleted special function member then generate
23787 a DW_AT_deleted attribute. */
23788 if ((dwarf_version
>= 5 || !dwarf_strict
)
23789 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23790 DW_AT_deleted
) == 1)
23791 add_AT_flag (subr_die
, DW_AT_deleted
, 1);
23793 /* If this is a C++11 defaulted special function member then
23794 generate a DW_AT_defaulted attribute. */
23795 if (dwarf_version
>= 5 || !dwarf_strict
)
23798 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23800 if (defaulted
!= -1)
23801 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
23804 /* If this is a C++11 non-static member function with & ref-qualifier
23805 then generate a DW_AT_reference attribute. */
23806 if ((dwarf_version
>= 5 || !dwarf_strict
)
23807 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23808 DW_AT_reference
) == 1)
23809 add_AT_flag (subr_die
, DW_AT_reference
, 1);
23811 /* If this is a C++11 non-static member function with &&
23812 ref-qualifier then generate a DW_AT_reference attribute. */
23813 if ((dwarf_version
>= 5 || !dwarf_strict
)
23814 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23815 DW_AT_rvalue_reference
)
23817 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
23820 /* For non DECL_EXTERNALs, if range information is available, fill
23821 the DIE with it. */
23822 else if (!DECL_EXTERNAL (decl
) && !early_dwarf
)
23824 HOST_WIDE_INT cfa_fb_offset
;
23826 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
23828 if (!crtl
->has_bb_partition
)
23830 dw_fde_ref fde
= fun
->fde
;
23831 if (fde
->dw_fde_begin
)
23833 /* We have already generated the labels. */
23834 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
23835 fde
->dw_fde_end
, false);
23839 /* Create start/end labels and add the range. */
23840 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
23841 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
23842 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
23843 current_function_funcdef_no
);
23844 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
23845 current_function_funcdef_no
);
23846 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
23850 #if VMS_DEBUGGING_INFO
23851 /* HP OpenVMS Industry Standard 64: DWARF Extensions
23852 Section 2.3 Prologue and Epilogue Attributes:
23853 When a breakpoint is set on entry to a function, it is generally
23854 desirable for execution to be suspended, not on the very first
23855 instruction of the function, but rather at a point after the
23856 function's frame has been set up, after any language defined local
23857 declaration processing has been completed, and before execution of
23858 the first statement of the function begins. Debuggers generally
23859 cannot properly determine where this point is. Similarly for a
23860 breakpoint set on exit from a function. The prologue and epilogue
23861 attributes allow a compiler to communicate the location(s) to use. */
23864 if (fde
->dw_fde_vms_end_prologue
)
23865 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
23866 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
23868 if (fde
->dw_fde_vms_begin_epilogue
)
23869 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
23870 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
23877 /* Generate pubnames entries for the split function code ranges. */
23878 dw_fde_ref fde
= fun
->fde
;
23880 if (fde
->dw_fde_second_begin
)
23882 if (dwarf_version
>= 3 || !dwarf_strict
)
23884 /* We should use ranges for non-contiguous code section
23885 addresses. Use the actual code range for the initial
23886 section, since the HOT/COLD labels might precede an
23887 alignment offset. */
23888 bool range_list_added
= false;
23889 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
23890 fde
->dw_fde_end
, &range_list_added
,
23892 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
23893 fde
->dw_fde_second_end
,
23894 &range_list_added
, false);
23895 if (range_list_added
)
23900 /* There is no real support in DW2 for this .. so we make
23901 a work-around. First, emit the pub name for the segment
23902 containing the function label. Then make and emit a
23903 simplified subprogram DIE for the second segment with the
23904 name pre-fixed by __hot/cold_sect_of_. We use the same
23905 linkage name for the second die so that gdb will find both
23906 sections when given "b foo". */
23907 const char *name
= NULL
;
23908 tree decl_name
= DECL_NAME (decl
);
23909 dw_die_ref seg_die
;
23911 /* Do the 'primary' section. */
23912 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
23913 fde
->dw_fde_end
, false);
23915 /* Build a minimal DIE for the secondary section. */
23916 seg_die
= new_die (DW_TAG_subprogram
,
23917 subr_die
->die_parent
, decl
);
23919 if (TREE_PUBLIC (decl
))
23920 add_AT_flag (seg_die
, DW_AT_external
, 1);
23922 if (decl_name
!= NULL
23923 && IDENTIFIER_POINTER (decl_name
) != NULL
)
23925 name
= dwarf2_name (decl
, 1);
23926 if (! DECL_ARTIFICIAL (decl
))
23927 add_src_coords_attributes (seg_die
, decl
);
23929 add_linkage_name (seg_die
, decl
);
23931 gcc_assert (name
!= NULL
);
23932 add_pure_or_virtual_attribute (seg_die
, decl
);
23933 if (DECL_ARTIFICIAL (decl
))
23934 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
23936 name
= concat ("__second_sect_of_", name
, NULL
);
23937 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
23938 fde
->dw_fde_second_end
, false);
23939 add_name_attribute (seg_die
, name
);
23940 if (want_pubnames ())
23941 add_pubname_string (name
, seg_die
);
23945 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
23949 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
23951 /* We define the "frame base" as the function's CFA. This is more
23952 convenient for several reasons: (1) It's stable across the prologue
23953 and epilogue, which makes it better than just a frame pointer,
23954 (2) With dwarf3, there exists a one-byte encoding that allows us
23955 to reference the .debug_frame data by proxy, but failing that,
23956 (3) We can at least reuse the code inspection and interpretation
23957 code that determines the CFA position at various points in the
23959 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
23961 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
23962 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
23966 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
23967 if (list
->dw_loc_next
)
23968 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
23970 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
23973 /* Compute a displacement from the "steady-state frame pointer" to
23974 the CFA. The former is what all stack slots and argument slots
23975 will reference in the rtl; the latter is what we've told the
23976 debugger about. We'll need to adjust all frame_base references
23977 by this displacement. */
23978 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
23980 if (fun
->static_chain_decl
)
23982 /* DWARF requires here a location expression that computes the
23983 address of the enclosing subprogram's frame base. The machinery
23984 in tree-nested.cc is supposed to store this specific address in the
23985 last field of the FRAME record. */
23986 const tree frame_type
23987 = TREE_TYPE (TREE_TYPE (fun
->static_chain_decl
));
23988 const tree fb_decl
= tree_last (TYPE_FIELDS (frame_type
));
23991 = build1 (INDIRECT_REF
, frame_type
, fun
->static_chain_decl
);
23992 fb_expr
= build3 (COMPONENT_REF
, TREE_TYPE (fb_decl
),
23993 fb_expr
, fb_decl
, NULL_TREE
);
23995 add_AT_location_description (subr_die
, DW_AT_static_link
,
23996 loc_list_from_tree (fb_expr
, 0, NULL
));
23999 resolve_variable_values ();
24002 /* Generate child dies for template parameters. */
24003 if (early_dwarf
&& debug_info_level
> DINFO_LEVEL_TERSE
)
24004 gen_generic_params_dies (decl
);
24006 /* Now output descriptions of the arguments for this function. This gets
24007 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
24008 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
24009 `...' at the end of the formal parameter list. In order to find out if
24010 there was a trailing ellipsis or not, we must instead look at the type
24011 associated with the FUNCTION_DECL. This will be a node of type
24012 FUNCTION_TYPE. If the chain of type nodes hanging off of this
24013 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
24014 an ellipsis at the end. */
24016 /* In the case where we are describing a mere function declaration, all we
24017 need to do here (and all we *can* do here) is to describe the *types* of
24018 its formal parameters. */
24019 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
24021 else if (declaration
)
24022 gen_formal_types_die (decl
, subr_die
);
24025 /* Generate DIEs to represent all known formal parameters. */
24026 tree parm
= DECL_ARGUMENTS (decl
);
24027 tree generic_decl
= early_dwarf
24028 ? lang_hooks
.decls
.get_generic_function_decl (decl
) : NULL
;
24029 tree generic_decl_parm
= generic_decl
24030 ? DECL_ARGUMENTS (generic_decl
)
24033 /* Now we want to walk the list of parameters of the function and
24034 emit their relevant DIEs.
24036 We consider the case of DECL being an instance of a generic function
24037 as well as it being a normal function.
24039 If DECL is an instance of a generic function we walk the
24040 parameters of the generic function declaration _and_ the parameters of
24041 DECL itself. This is useful because we want to emit specific DIEs for
24042 function parameter packs and those are declared as part of the
24043 generic function declaration. In that particular case,
24044 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
24045 That DIE has children DIEs representing the set of arguments
24046 of the pack. Note that the set of pack arguments can be empty.
24047 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
24050 Otherwise, we just consider the parameters of DECL. */
24051 while (generic_decl_parm
|| parm
)
24053 if (generic_decl_parm
24054 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
24055 gen_formal_parameter_pack_die (generic_decl_parm
,
24060 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, NULL
, subr_die
);
24063 && parm
== DECL_ARGUMENTS (decl
)
24064 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
24066 && (dwarf_version
>= 3 || !dwarf_strict
))
24067 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
24069 parm
= DECL_CHAIN (parm
);
24072 if (generic_decl_parm
)
24073 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
24076 /* Decide whether we need an unspecified_parameters DIE at the end.
24077 There are 2 more cases to do this for: 1) the ansi ... declaration -
24078 this is detectable when the end of the arg list is not a
24079 void_type_node 2) an unprototyped function declaration (not a
24080 definition). This just means that we have no info about the
24081 parameters at all. */
24084 if (prototype_p (TREE_TYPE (decl
)))
24086 /* This is the prototyped case, check for.... */
24087 if (stdarg_p (TREE_TYPE (decl
)))
24088 gen_unspecified_parameters_die (decl
, subr_die
);
24090 else if (DECL_INITIAL (decl
) == NULL_TREE
)
24091 gen_unspecified_parameters_die (decl
, subr_die
);
24093 else if ((subr_die
!= old_die
|| old_die_had_no_children
)
24094 && prototype_p (TREE_TYPE (decl
))
24095 && stdarg_p (TREE_TYPE (decl
)))
24096 gen_unspecified_parameters_die (decl
, subr_die
);
24099 if (subr_die
!= old_die
)
24100 /* Add the calling convention attribute if requested. */
24101 add_calling_convention_attribute (subr_die
, decl
);
24103 /* Output Dwarf info for all of the stuff within the body of the function
24104 (if it has one - it may be just a declaration).
24106 OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
24107 a function. This BLOCK actually represents the outermost binding contour
24108 for the function, i.e. the contour in which the function's formal
24109 parameters and labels get declared. Curiously, it appears that the front
24110 end doesn't actually put the PARM_DECL nodes for the current function onto
24111 the BLOCK_VARS list for this outer scope, but are strung off of the
24112 DECL_ARGUMENTS list for the function instead.
24114 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
24115 the LABEL_DECL nodes for the function however, and we output DWARF info
24116 for those in decls_for_scope. Just within the `outer_scope' there will be
24117 a BLOCK node representing the function's outermost pair of curly braces,
24118 and any blocks used for the base and member initializers of a C++
24119 constructor function. */
24120 tree outer_scope
= DECL_INITIAL (decl
);
24121 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
24123 int call_site_note_count
= 0;
24124 int tail_call_site_note_count
= 0;
24126 /* Emit a DW_TAG_variable DIE for a named return value. */
24127 if (DECL_NAME (DECL_RESULT (decl
)))
24128 gen_decl_die (DECL_RESULT (decl
), NULL
, NULL
, subr_die
);
24130 /* The first time through decls_for_scope we will generate the
24131 DIEs for the locals. The second time, we fill in the
24133 decls_for_scope (outer_scope
, subr_die
);
24135 if (call_arg_locations
&& (!dwarf_strict
|| dwarf_version
>= 5))
24137 struct call_arg_loc_node
*ca_loc
;
24138 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
24140 dw_die_ref die
= NULL
;
24141 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
24143 tree arg_decl
= NULL_TREE
;
24145 for (arg
= (ca_loc
->call_arg_loc_note
!= NULL_RTX
24146 ? XEXP (ca_loc
->call_arg_loc_note
, 0)
24148 arg
; arg
= next_arg
)
24150 dw_loc_descr_ref reg
, val
;
24151 machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
24152 dw_die_ref cdie
, tdie
= NULL
;
24154 next_arg
= XEXP (arg
, 1);
24155 if (REG_P (XEXP (XEXP (arg
, 0), 0))
24157 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
24158 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
24159 && REGNO (XEXP (XEXP (arg
, 0), 0))
24160 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
24161 next_arg
= XEXP (next_arg
, 1);
24162 if (mode
== VOIDmode
)
24164 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
24165 if (mode
== VOIDmode
)
24166 mode
= GET_MODE (XEXP (arg
, 0));
24168 if (mode
== VOIDmode
|| mode
== BLKmode
)
24170 /* Get dynamic information about call target only if we
24171 have no static information: we cannot generate both
24172 DW_AT_call_origin and DW_AT_call_target
24174 if (ca_loc
->symbol_ref
== NULL_RTX
)
24176 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
24178 tloc
= XEXP (XEXP (arg
, 0), 1);
24181 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
24182 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
24184 tlocc
= XEXP (XEXP (arg
, 0), 1);
24189 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
24190 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
24191 VAR_INIT_STATUS_INITIALIZED
);
24192 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
24194 rtx mem
= XEXP (XEXP (arg
, 0), 0);
24195 reg
= mem_loc_descriptor (XEXP (mem
, 0),
24196 get_address_mode (mem
),
24198 VAR_INIT_STATUS_INITIALIZED
);
24200 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
24201 == DEBUG_PARAMETER_REF
)
24204 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
24205 tdie
= lookup_decl_die (tdecl
);
24213 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
24214 != DEBUG_PARAMETER_REF
)
24216 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
24218 VAR_INIT_STATUS_INITIALIZED
);
24222 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
24223 cdie
= new_die (dwarf_TAG (DW_TAG_call_site_parameter
), die
,
24225 add_desc_attribute (cdie
, arg_decl
);
24227 add_AT_loc (cdie
, DW_AT_location
, reg
);
24228 else if (tdie
!= NULL
)
24229 add_AT_die_ref (cdie
, dwarf_AT (DW_AT_call_parameter
),
24231 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_value
), val
);
24232 if (next_arg
!= XEXP (arg
, 1))
24234 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
24235 if (mode
== VOIDmode
)
24236 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
24237 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
24240 VAR_INIT_STATUS_INITIALIZED
);
24242 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_data_value
),
24247 && (ca_loc
->symbol_ref
|| tloc
))
24248 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
24249 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
24251 dw_loc_descr_ref tval
= NULL
;
24253 if (tloc
!= NULL_RTX
)
24254 tval
= mem_loc_descriptor (tloc
,
24255 GET_MODE (tloc
) == VOIDmode
24256 ? Pmode
: GET_MODE (tloc
),
24258 VAR_INIT_STATUS_INITIALIZED
);
24260 add_AT_loc (die
, dwarf_AT (DW_AT_call_target
), tval
);
24261 else if (tlocc
!= NULL_RTX
)
24263 tval
= mem_loc_descriptor (tlocc
,
24264 GET_MODE (tlocc
) == VOIDmode
24265 ? Pmode
: GET_MODE (tlocc
),
24267 VAR_INIT_STATUS_INITIALIZED
);
24270 dwarf_AT (DW_AT_call_target_clobbered
),
24276 call_site_note_count
++;
24277 if (ca_loc
->tail_call_p
)
24278 tail_call_site_note_count
++;
24282 call_arg_locations
= NULL
;
24283 call_arg_loc_last
= NULL
;
24284 if (tail_call_site_count
>= 0
24285 && tail_call_site_count
== tail_call_site_note_count
24286 && (!dwarf_strict
|| dwarf_version
>= 5))
24288 if (call_site_count
>= 0
24289 && call_site_count
== call_site_note_count
)
24290 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_calls
), 1);
24292 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_tail_calls
), 1);
24294 call_site_count
= -1;
24295 tail_call_site_count
= -1;
24298 /* Mark used types after we have created DIEs for the functions scopes. */
24299 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
24302 /* Returns a hash value for X (which really is a die_struct). */
24305 block_die_hasher::hash (die_struct
*d
)
24307 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
24310 /* Return true if decl_id and die_parent of die_struct X is the same
24311 as decl_id and die_parent of die_struct Y. */
24314 block_die_hasher::equal (die_struct
*x
, die_struct
*y
)
24316 return x
->decl_id
== y
->decl_id
&& x
->die_parent
== y
->die_parent
;
24319 /* Hold information about markers for inlined entry points. */
24320 struct GTY ((for_user
)) inline_entry_data
24322 /* The block that's the inlined_function_outer_scope for an inlined
24326 /* The label at the inlined entry point. */
24327 const char *label_pfx
;
24328 unsigned int label_num
;
24330 /* The view number to be used as the inlined entry point. */
24334 struct inline_entry_data_hasher
: ggc_ptr_hash
<inline_entry_data
>
24336 typedef tree compare_type
;
24337 static inline hashval_t
hash (const inline_entry_data
*);
24338 static inline bool equal (const inline_entry_data
*, const_tree
);
24341 /* Hash table routines for inline_entry_data. */
24344 inline_entry_data_hasher::hash (const inline_entry_data
*data
)
24346 return htab_hash_pointer (data
->block
);
24350 inline_entry_data_hasher::equal (const inline_entry_data
*data
,
24353 return data
->block
== block
;
24356 /* Inlined entry points pending DIE creation in this compilation unit. */
24358 static GTY(()) hash_table
<inline_entry_data_hasher
> *inline_entry_data_table
;
24361 /* Return TRUE if DECL, which may have been previously generated as
24362 OLD_DIE, is a candidate for a DW_AT_specification. DECLARATION is
24363 true if decl (or its origin) is either an extern declaration or a
24364 class/namespace scoped declaration.
24366 The declare_in_namespace support causes us to get two DIEs for one
24367 variable, both of which are declarations. We want to avoid
24368 considering one to be a specification, so we must test for
24369 DECLARATION and DW_AT_declaration. */
24371 decl_will_get_specification_p (dw_die_ref old_die
, tree decl
, bool declaration
)
24373 return (old_die
&& TREE_STATIC (decl
) && !declaration
24374 && get_AT_flag (old_die
, DW_AT_declaration
) == 1);
24377 /* Return true if DECL is a local static. */
24380 local_function_static (tree decl
)
24382 gcc_assert (VAR_P (decl
));
24383 return TREE_STATIC (decl
)
24384 && DECL_CONTEXT (decl
)
24385 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
;
24388 /* Return true iff DECL overrides (presumably completes) the type of
24389 OLD_DIE within CONTEXT_DIE. */
24392 override_type_for_decl_p (tree decl
, dw_die_ref old_die
,
24393 dw_die_ref context_die
)
24395 tree type
= TREE_TYPE (decl
);
24398 if (decl_by_reference_p (decl
))
24400 type
= TREE_TYPE (type
);
24401 cv_quals
= TYPE_UNQUALIFIED
;
24404 cv_quals
= decl_quals (decl
);
24406 dw_die_ref type_die
= modified_type_die (type
,
24407 cv_quals
| TYPE_QUALS (type
),
24411 dw_die_ref old_type_die
= get_AT_ref (old_die
, DW_AT_type
);
24413 return type_die
!= old_type_die
;
24416 /* Generate a DIE to represent a declared data object.
24417 Either DECL or ORIGIN must be non-null. */
24420 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
24422 HOST_WIDE_INT off
= 0;
24424 tree decl_or_origin
= decl
? decl
: origin
;
24425 tree ultimate_origin
;
24426 dw_die_ref var_die
;
24427 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
24428 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
24429 || class_or_namespace_scope_p (context_die
));
24430 bool specialization_p
= false;
24431 bool no_linkage_name
= false;
24433 /* While C++ inline static data members have definitions inside of the
24434 class, force the first DIE to be a declaration, then let gen_member_die
24435 reparent it to the class context and call gen_variable_die again
24436 to create the outside of the class DIE for the definition. */
24440 && DECL_CONTEXT (decl
)
24441 && TYPE_P (DECL_CONTEXT (decl
))
24442 && lang_hooks
.decls
.decl_dwarf_attribute (decl
, DW_AT_inline
) != -1)
24444 declaration
= true;
24445 if (dwarf_version
< 5)
24446 no_linkage_name
= true;
24449 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
24450 if (decl
|| ultimate_origin
)
24451 origin
= ultimate_origin
;
24452 com_decl
= fortran_common (decl_or_origin
, &off
);
24454 /* Symbol in common gets emitted as a child of the common block, in the form
24455 of a data member. */
24458 dw_die_ref com_die
;
24459 dw_loc_list_ref loc
= NULL
;
24460 die_node com_die_arg
;
24462 var_die
= lookup_decl_die (decl_or_origin
);
24465 if (! early_dwarf
&& get_AT (var_die
, DW_AT_location
) == NULL
)
24467 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2, NULL
);
24472 /* Optimize the common case. */
24473 if (single_element_loc_list_p (loc
)
24474 && loc
->expr
->dw_loc_opc
== DW_OP_addr
24475 && loc
->expr
->dw_loc_next
== NULL
24476 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
24479 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
24480 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
24481 = plus_constant (GET_MODE (x
), x
, off
);
24484 loc_list_plus_const (loc
, off
);
24486 add_AT_location_description (var_die
, DW_AT_location
, loc
);
24487 remove_AT (var_die
, DW_AT_declaration
);
24493 if (common_block_die_table
== NULL
)
24494 common_block_die_table
= hash_table
<block_die_hasher
>::create_ggc (10);
24496 com_die_arg
.decl_id
= DECL_UID (com_decl
);
24497 com_die_arg
.die_parent
= context_die
;
24498 com_die
= common_block_die_table
->find (&com_die_arg
);
24500 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
24501 if (com_die
== NULL
)
24504 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
24507 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
24508 add_name_and_src_coords_attributes (com_die
, com_decl
);
24511 add_AT_location_description (com_die
, DW_AT_location
, loc
);
24512 /* Avoid sharing the same loc descriptor between
24513 DW_TAG_common_block and DW_TAG_variable. */
24514 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
24516 else if (DECL_EXTERNAL (decl_or_origin
))
24517 add_AT_flag (com_die
, DW_AT_declaration
, 1);
24518 if (want_pubnames ())
24519 add_pubname_string (cnam
, com_die
); /* ??? needed? */
24520 com_die
->decl_id
= DECL_UID (com_decl
);
24521 slot
= common_block_die_table
->find_slot (com_die
, INSERT
);
24524 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
24526 add_AT_location_description (com_die
, DW_AT_location
, loc
);
24527 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
24528 remove_AT (com_die
, DW_AT_declaration
);
24530 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
24531 add_name_and_src_coords_attributes (var_die
, decl_or_origin
);
24532 add_type_attribute (var_die
, TREE_TYPE (decl_or_origin
),
24533 decl_quals (decl_or_origin
), false,
24535 add_alignment_attribute (var_die
, decl
);
24536 add_AT_flag (var_die
, DW_AT_external
, 1);
24541 /* Optimize the common case. */
24542 if (single_element_loc_list_p (loc
)
24543 && loc
->expr
->dw_loc_opc
== DW_OP_addr
24544 && loc
->expr
->dw_loc_next
== NULL
24545 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
24547 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
24548 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
24549 = plus_constant (GET_MODE (x
), x
, off
);
24552 loc_list_plus_const (loc
, off
);
24554 add_AT_location_description (var_die
, DW_AT_location
, loc
);
24556 else if (DECL_EXTERNAL (decl_or_origin
))
24557 add_AT_flag (var_die
, DW_AT_declaration
, 1);
24559 equate_decl_number_to_die (decl
, var_die
);
24567 /* A declaration that has been previously dumped, needs no
24568 further annotations, since it doesn't need location on
24569 the second pass. */
24572 else if (decl_will_get_specification_p (old_die
, decl
, declaration
)
24573 && !get_AT (old_die
, DW_AT_specification
))
24575 /* Fall-thru so we can make a new variable die along with a
24576 DW_AT_specification. */
24578 else if (origin
&& old_die
->die_parent
!= context_die
)
24580 /* If we will be creating an inlined instance, we need a
24581 new DIE that will get annotated with
24582 DW_AT_abstract_origin. */
24583 gcc_assert (!DECL_ABSTRACT_P (decl
));
24587 /* If a DIE was dumped early, it still needs location info.
24588 Skip to where we fill the location bits. */
24591 /* ??? In LTRANS we cannot annotate early created variably
24592 modified type DIEs without copying them and adjusting all
24593 references to them. Thus we dumped them again. Also add a
24594 reference to them but beware of -g0 compile and -g link
24595 in which case the reference will be already present. */
24596 tree type
= TREE_TYPE (decl_or_origin
);
24598 && ! get_AT (var_die
, DW_AT_type
)
24599 && variably_modified_type_p
24600 (type
, decl_function_context (decl_or_origin
)))
24602 if (decl_by_reference_p (decl_or_origin
))
24603 add_type_attribute (var_die
, TREE_TYPE (type
),
24604 TYPE_UNQUALIFIED
, false, context_die
);
24606 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
),
24607 false, context_die
);
24610 goto gen_variable_die_location
;
24614 /* For static data members, the declaration in the class is supposed
24615 to have DW_TAG_member tag in DWARF{3,4} and we emit it for compatibility
24616 also in DWARF2; the specification should still be DW_TAG_variable
24617 referencing the DW_TAG_member DIE. */
24618 if (declaration
&& class_scope_p (context_die
) && dwarf_version
< 5)
24619 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
24621 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
24623 if (origin
!= NULL
)
24624 add_abstract_origin_attribute (var_die
, origin
);
24626 /* Loop unrolling can create multiple blocks that refer to the same
24627 static variable, so we must test for the DW_AT_declaration flag.
24629 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
24630 copy decls and set the DECL_ABSTRACT_P flag on them instead of
24633 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
24634 else if (decl_will_get_specification_p (old_die
, decl
, declaration
))
24636 /* This is a definition of a C++ class level static. */
24637 add_AT_specification (var_die
, old_die
);
24638 specialization_p
= true;
24639 if (DECL_NAME (decl
))
24641 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
24642 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
24644 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
24645 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
24647 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
24648 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
24650 if (debug_column_info
24652 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
24653 != (unsigned) s
.column
))
24654 add_AT_unsigned (var_die
, DW_AT_decl_column
, s
.column
);
24656 if (old_die
->die_tag
== DW_TAG_member
)
24657 add_linkage_name (var_die
, decl
);
24661 add_name_and_src_coords_attributes (var_die
, decl
, no_linkage_name
);
24663 if ((origin
== NULL
&& !specialization_p
)
24665 && !DECL_ABSTRACT_P (decl_or_origin
)
24666 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
24667 decl_function_context
24669 || (old_die
&& specialization_p
24670 && override_type_for_decl_p (decl_or_origin
, old_die
, context_die
)))
24672 tree type
= TREE_TYPE (decl_or_origin
);
24674 if (decl_by_reference_p (decl_or_origin
))
24675 add_type_attribute (var_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
24678 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
), false,
24682 if (origin
== NULL
&& !specialization_p
)
24684 if (TREE_PUBLIC (decl
))
24685 add_AT_flag (var_die
, DW_AT_external
, 1);
24687 if (DECL_ARTIFICIAL (decl
))
24688 add_AT_flag (var_die
, DW_AT_artificial
, 1);
24690 add_alignment_attribute (var_die
, decl
);
24692 add_accessibility_attribute (var_die
, decl
);
24696 add_AT_flag (var_die
, DW_AT_declaration
, 1);
24698 if (decl
&& (DECL_ABSTRACT_P (decl
)
24699 || !old_die
|| is_declaration_die (old_die
)))
24700 equate_decl_number_to_die (decl
, var_die
);
24702 gen_variable_die_location
:
24704 && (! DECL_ABSTRACT_P (decl_or_origin
)
24705 /* Local static vars are shared between all clones/inlines,
24706 so emit DW_AT_location on the abstract DIE if DECL_RTL is
24708 || (VAR_P (decl_or_origin
)
24709 && TREE_STATIC (decl_or_origin
)
24710 && DECL_RTL_SET_P (decl_or_origin
))))
24714 add_pubname (decl_or_origin
, var_die
);
24715 /* For global register variables, emit DW_AT_location if possible
24716 already during early_dwarf, as late_global_decl won't be usually
24718 if (DECL_HARD_REGISTER (decl_or_origin
)
24719 && TREE_STATIC (decl_or_origin
)
24720 && !decl_by_reference_p (decl_or_origin
)
24721 && !get_AT (var_die
, DW_AT_location
)
24722 && !get_AT (var_die
, DW_AT_const_value
)
24723 && DECL_RTL_SET_P (decl_or_origin
)
24724 && REG_P (DECL_RTL (decl_or_origin
)))
24726 dw_loc_descr_ref descr
24727 = reg_loc_descriptor (DECL_RTL (decl_or_origin
),
24728 VAR_INIT_STATUS_INITIALIZED
);
24730 add_AT_loc (var_die
, DW_AT_location
, descr
);
24734 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
24738 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
24740 if ((dwarf_version
>= 4 || !dwarf_strict
)
24741 && lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
24742 DW_AT_const_expr
) == 1
24743 && !get_AT (var_die
, DW_AT_const_expr
)
24744 && !specialization_p
)
24745 add_AT_flag (var_die
, DW_AT_const_expr
, 1);
24749 int inl
= lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
24752 && !get_AT (var_die
, DW_AT_inline
)
24753 && !specialization_p
)
24754 add_AT_unsigned (var_die
, DW_AT_inline
, inl
);
24758 /* Generate a DIE to represent a named constant. */
24761 gen_const_die (tree decl
, dw_die_ref context_die
)
24763 dw_die_ref const_die
;
24764 tree type
= TREE_TYPE (decl
);
24766 const_die
= lookup_decl_die (decl
);
24770 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
24771 equate_decl_number_to_die (decl
, const_die
);
24772 add_name_and_src_coords_attributes (const_die
, decl
);
24773 add_type_attribute (const_die
, type
, TYPE_QUAL_CONST
, false, context_die
);
24774 if (TREE_PUBLIC (decl
))
24775 add_AT_flag (const_die
, DW_AT_external
, 1);
24776 if (DECL_ARTIFICIAL (decl
))
24777 add_AT_flag (const_die
, DW_AT_artificial
, 1);
24778 tree_add_const_value_attribute_for_decl (const_die
, decl
);
24781 /* Generate a DIE to represent a label identifier. */
24784 gen_label_die (tree decl
, dw_die_ref context_die
)
24786 tree origin
= decl_ultimate_origin (decl
);
24787 dw_die_ref lbl_die
= lookup_decl_die (decl
);
24789 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
24793 lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
24794 equate_decl_number_to_die (decl
, lbl_die
);
24796 if (origin
!= NULL
)
24797 add_abstract_origin_attribute (lbl_die
, origin
);
24799 add_name_and_src_coords_attributes (lbl_die
, decl
);
24802 if (DECL_ABSTRACT_P (decl
))
24803 equate_decl_number_to_die (decl
, lbl_die
);
24804 else if (! early_dwarf
)
24806 insn
= DECL_RTL_IF_SET (decl
);
24808 /* Deleted labels are programmer specified labels which have been
24809 eliminated because of various optimizations. We still emit them
24810 here so that it is possible to put breakpoints on them. */
24814 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
24816 /* When optimization is enabled (via -O) some parts of the compiler
24817 (e.g. jump.cc and cse.cc) may try to delete CODE_LABEL insns which
24818 represent source-level labels which were explicitly declared by
24819 the user. This really shouldn't be happening though, so catch
24820 it if it ever does happen. */
24821 gcc_assert (!as_a
<rtx_insn
*> (insn
)->deleted ());
24823 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
24824 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
24828 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
24829 && CODE_LABEL_NUMBER (insn
) != -1)
24831 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
24832 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
24837 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
24838 attributes to the DIE for a block STMT, to describe where the inlined
24839 function was called from. This is similar to add_src_coords_attributes. */
24842 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
24844 /* We can end up with BUILTINS_LOCATION here. */
24845 if (RESERVED_LOCATION_P (BLOCK_SOURCE_LOCATION (stmt
)))
24848 location_t locus
= BLOCK_SOURCE_LOCATION (stmt
);
24849 expanded_location s
= expand_location (locus
);
24851 if (dwarf_version
>= 3 || !dwarf_strict
)
24853 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
24854 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
24855 if (debug_column_info
&& s
.column
)
24856 add_AT_unsigned (die
, DW_AT_call_column
, s
.column
);
24857 unsigned discr
= get_discriminator_from_loc (locus
);
24859 add_AT_unsigned (die
, DW_AT_GNU_discriminator
, discr
);
24864 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
24865 Add low_pc and high_pc attributes to the DIE for a block STMT. */
24868 add_high_low_attributes (tree stmt
, dw_die_ref die
)
24870 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
24872 if (inline_entry_data
**iedp
24873 = !inline_entry_data_table
? NULL
24874 : inline_entry_data_table
->find_slot_with_hash (stmt
,
24875 htab_hash_pointer (stmt
),
24878 inline_entry_data
*ied
= *iedp
;
24879 gcc_assert (MAY_HAVE_DEBUG_MARKER_INSNS
);
24880 gcc_assert (debug_inline_points
);
24881 gcc_assert (inlined_function_outer_scope_p (stmt
));
24883 ASM_GENERATE_INTERNAL_LABEL (label
, ied
->label_pfx
, ied
->label_num
);
24884 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
24886 if (debug_variable_location_views
&& !ZERO_VIEW_P (ied
->view
)
24889 if (!output_asm_line_debug_info ())
24890 add_AT_unsigned (die
, DW_AT_GNU_entry_view
, ied
->view
);
24893 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", ied
->view
);
24894 /* FIXME: this will resolve to a small number. Could we
24895 possibly emit smaller data? Ideally we'd emit a
24896 uleb128, but that would make the size of DIEs
24897 impossible for the compiler to compute, since it's
24898 the assembler that computes the value of the view
24899 label in this case. Ideally, we'd have a single form
24900 encompassing both the address and the view, and
24901 indirecting them through a table might make things
24902 easier, but even that would be more wasteful,
24903 space-wise, than what we have now. */
24904 add_AT_symview (die
, DW_AT_GNU_entry_view
, label
);
24908 inline_entry_data_table
->clear_slot (iedp
);
24911 if (BLOCK_FRAGMENT_CHAIN (stmt
)
24912 && (dwarf_version
>= 3 || !dwarf_strict
))
24914 tree chain
, superblock
= NULL_TREE
;
24916 dw_attr_node
*attr
= NULL
;
24918 if (!debug_inline_points
&& inlined_function_outer_scope_p (stmt
))
24920 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
24921 BLOCK_NUMBER (stmt
));
24922 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
24925 /* Optimize duplicate .debug_ranges lists or even tails of
24926 lists. If this BLOCK has same ranges as its supercontext,
24927 lookup DW_AT_ranges attribute in the supercontext (and
24928 recursively so), verify that the ranges_table contains the
24929 right values and use it instead of adding a new .debug_range. */
24930 for (chain
= stmt
, pdie
= die
;
24931 BLOCK_SAME_RANGE (chain
);
24932 chain
= BLOCK_SUPERCONTEXT (chain
))
24934 dw_attr_node
*new_attr
;
24936 pdie
= pdie
->die_parent
;
24939 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
24941 new_attr
= get_AT (pdie
, DW_AT_ranges
);
24942 if (new_attr
== NULL
24943 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
24946 superblock
= BLOCK_SUPERCONTEXT (chain
);
24949 && ((*ranges_table
)[attr
->dw_attr_val
.v
.val_offset
].num
24950 == (int)BLOCK_NUMBER (superblock
))
24951 && BLOCK_FRAGMENT_CHAIN (superblock
))
24953 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
;
24954 unsigned long supercnt
= 0, thiscnt
= 0;
24955 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
24956 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
24959 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
].num
24960 == (int)BLOCK_NUMBER (chain
));
24962 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
+ 1].num
== 0);
24963 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
24964 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
24966 gcc_assert (supercnt
>= thiscnt
);
24967 add_AT_range_list (die
, DW_AT_ranges
, off
+ supercnt
- thiscnt
,
24969 note_rnglist_head (off
+ supercnt
- thiscnt
);
24973 unsigned int offset
= add_ranges (stmt
, true);
24974 add_AT_range_list (die
, DW_AT_ranges
, offset
, false);
24975 note_rnglist_head (offset
);
24977 bool prev_in_cold
= BLOCK_IN_COLD_SECTION_P (stmt
);
24978 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
24981 add_ranges (chain
, prev_in_cold
!= BLOCK_IN_COLD_SECTION_P (chain
));
24982 prev_in_cold
= BLOCK_IN_COLD_SECTION_P (chain
);
24983 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
24990 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
24991 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
24992 BLOCK_NUMBER (stmt
));
24993 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
24994 BLOCK_NUMBER (stmt
));
24995 add_AT_low_high_pc (die
, label
, label_high
, false);
24999 /* Generate a DIE for a lexical block. */
25002 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
)
25004 dw_die_ref old_die
= lookup_block_die (stmt
);
25005 dw_die_ref stmt_die
= NULL
;
25008 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
25009 equate_block_to_die (stmt
, stmt_die
);
25012 if (BLOCK_ABSTRACT_ORIGIN (stmt
))
25014 /* If this is an inlined or conrecte instance, create a new lexical
25015 die for anything below to attach DW_AT_abstract_origin to. */
25017 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
25019 tree origin
= block_ultimate_origin (stmt
);
25020 if (origin
!= NULL_TREE
&& (origin
!= stmt
|| old_die
))
25021 add_abstract_origin_attribute (stmt_die
, origin
);
25027 stmt_die
= old_die
;
25029 /* A non abstract block whose blocks have already been reordered
25030 should have the instruction range for this block. If so, set the
25031 high/low attributes. */
25032 if (!early_dwarf
&& TREE_ASM_WRITTEN (stmt
))
25034 gcc_assert (stmt_die
);
25035 add_high_low_attributes (stmt
, stmt_die
);
25038 decls_for_scope (stmt
, stmt_die
);
25041 /* Generate a DIE for an inlined subprogram. */
25044 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
)
25046 tree decl
= block_ultimate_origin (stmt
);
25048 /* Make sure any inlined functions are known to be inlineable. */
25049 gcc_checking_assert (DECL_ABSTRACT_P (decl
)
25050 || cgraph_function_possibly_inlined_p (decl
));
25052 dw_die_ref subr_die
= new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
25054 if (call_arg_locations
|| debug_inline_points
)
25055 equate_block_to_die (stmt
, subr_die
);
25056 add_abstract_origin_attribute (subr_die
, decl
);
25057 if (TREE_ASM_WRITTEN (stmt
))
25058 add_high_low_attributes (stmt
, subr_die
);
25059 add_call_src_coords_attributes (stmt
, subr_die
);
25061 /* The inliner creates an extra BLOCK for the parameter setup,
25062 we want to merge that with the actual outermost BLOCK of the
25063 inlined function to avoid duplicate locals in consumers.
25064 Do that by doing the recursion to subblocks on the single subblock
25066 bool unwrap_one
= false;
25067 if (BLOCK_SUBBLOCKS (stmt
) && !BLOCK_CHAIN (BLOCK_SUBBLOCKS (stmt
)))
25069 tree origin
= block_ultimate_origin (BLOCK_SUBBLOCKS (stmt
));
25071 && TREE_CODE (origin
) == BLOCK
25072 && BLOCK_SUPERCONTEXT (origin
) == decl
)
25075 decls_for_scope (stmt
, subr_die
, !unwrap_one
);
25077 decls_for_scope (BLOCK_SUBBLOCKS (stmt
), subr_die
);
25080 /* Generate a DIE for a field in a record, or structure. CTX is required: see
25081 the comment for VLR_CONTEXT. */
25084 gen_field_die (tree decl
, struct vlr_context
*ctx
, dw_die_ref context_die
)
25086 dw_die_ref decl_die
;
25088 if (TREE_TYPE (decl
) == error_mark_node
)
25091 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
25092 add_name_and_src_coords_attributes (decl_die
, decl
);
25093 add_type_attribute (decl_die
, member_declared_type (decl
), decl_quals (decl
),
25094 TYPE_REVERSE_STORAGE_ORDER (DECL_FIELD_CONTEXT (decl
)),
25097 if (DECL_BIT_FIELD_TYPE (decl
))
25099 add_byte_size_attribute (decl_die
, decl
);
25100 add_bit_size_attribute (decl_die
, decl
);
25101 add_bit_offset_attribute (decl_die
, decl
);
25104 add_alignment_attribute (decl_die
, decl
);
25106 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
25107 add_data_member_location_attribute (decl_die
, decl
, ctx
);
25109 if (DECL_ARTIFICIAL (decl
))
25110 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
25112 add_accessibility_attribute (decl_die
, decl
);
25114 /* Equate decl number to die, so that we can look up this decl later on. */
25115 equate_decl_number_to_die (decl
, decl_die
);
25118 /* Generate a DIE for a pointer to a member type. TYPE can be an
25119 OFFSET_TYPE, for a pointer to data member, or a RECORD_TYPE, for a
25120 pointer to member function. */
25123 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
25125 if (lookup_type_die (type
))
25128 dw_die_ref ptr_die
= new_die (DW_TAG_ptr_to_member_type
,
25129 scope_die_for (type
, context_die
), type
);
25131 equate_type_number_to_die (type
, ptr_die
);
25132 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
25133 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
25134 add_type_attribute (ptr_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
25136 add_alignment_attribute (ptr_die
, type
);
25138 if (TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
25139 && TREE_CODE (TREE_TYPE (type
)) != METHOD_TYPE
)
25141 dw_loc_descr_ref op
= new_loc_descr (DW_OP_plus
, 0, 0);
25142 add_AT_loc (ptr_die
, DW_AT_use_location
, op
);
25146 static char *producer_string
;
25148 /* Given a C and/or C++ language/version string return the "highest".
25149 C++ is assumed to be "higher" than C in this case. Used for merging
25150 LTO translation unit languages. */
25151 static const char *
25152 highest_c_language (const char *lang1
, const char *lang2
)
25154 if (strcmp ("GNU C++26", lang1
) == 0 || strcmp ("GNU C++26", lang2
) == 0)
25155 return "GNU C++26";
25156 if (strcmp ("GNU C++23", lang1
) == 0 || strcmp ("GNU C++23", lang2
) == 0)
25157 return "GNU C++23";
25158 if (strcmp ("GNU C++20", lang1
) == 0 || strcmp ("GNU C++20", lang2
) == 0)
25159 return "GNU C++20";
25160 if (strcmp ("GNU C++17", lang1
) == 0 || strcmp ("GNU C++17", lang2
) == 0)
25161 return "GNU C++17";
25162 if (strcmp ("GNU C++14", lang1
) == 0 || strcmp ("GNU C++14", lang2
) == 0)
25163 return "GNU C++14";
25164 if (strcmp ("GNU C++11", lang1
) == 0 || strcmp ("GNU C++11", lang2
) == 0)
25165 return "GNU C++11";
25166 if (strcmp ("GNU C++98", lang1
) == 0 || strcmp ("GNU C++98", lang2
) == 0)
25167 return "GNU C++98";
25169 if (strcmp ("GNU C23", lang1
) == 0 || strcmp ("GNU C23", lang2
) == 0)
25171 if (strcmp ("GNU C17", lang1
) == 0 || strcmp ("GNU C17", lang2
) == 0)
25173 if (strcmp ("GNU C11", lang1
) == 0 || strcmp ("GNU C11", lang2
) == 0)
25175 if (strcmp ("GNU C99", lang1
) == 0 || strcmp ("GNU C99", lang2
) == 0)
25177 if (strcmp ("GNU C89", lang1
) == 0 || strcmp ("GNU C89", lang2
) == 0)
25180 gcc_unreachable ();
25184 /* Generate the DIE for the compilation unit. */
25187 gen_compile_unit_die (const char *filename
)
25190 const char *language_string
= lang_hooks
.name
;
25193 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
25197 add_filename_attribute (die
, filename
);
25198 /* Don't add cwd for <built-in>. */
25199 if (filename
[0] != '<')
25200 add_comp_dir_attribute (die
);
25203 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
25205 /* If our producer is LTO try to figure out a common language to use
25206 from the global list of translation units. */
25207 if (strcmp (language_string
, "GNU GIMPLE") == 0)
25211 const char *common_lang
= NULL
;
25213 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
25215 if (!TRANSLATION_UNIT_LANGUAGE (t
))
25218 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
25219 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
25221 else if (startswith (common_lang
, "GNU C")
25222 && startswith (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C"))
25223 /* Mixing C and C++ is ok, use C++ in that case. */
25224 common_lang
= highest_c_language (common_lang
,
25225 TRANSLATION_UNIT_LANGUAGE (t
));
25228 /* Fall back to C. */
25229 common_lang
= NULL
;
25235 language_string
= common_lang
;
25238 language
= DW_LANG_C
;
25239 if (startswith (language_string
, "GNU C")
25240 && ISDIGIT (language_string
[5]))
25242 language
= DW_LANG_C89
;
25243 if (dwarf_version
>= 3 || !dwarf_strict
)
25245 if (strcmp (language_string
, "GNU C89") != 0)
25246 language
= DW_LANG_C99
;
25248 if (dwarf_version
>= 5 /* || !dwarf_strict */)
25249 if (strcmp (language_string
, "GNU C11") == 0
25250 || strcmp (language_string
, "GNU C17") == 0
25251 || strcmp (language_string
, "GNU C23") == 0)
25252 language
= DW_LANG_C11
;
25255 else if (startswith (language_string
, "GNU C++"))
25257 language
= DW_LANG_C_plus_plus
;
25258 if (dwarf_version
>= 5 /* || !dwarf_strict */)
25260 if (strcmp (language_string
, "GNU C++11") == 0)
25261 language
= DW_LANG_C_plus_plus_11
;
25262 else if (strcmp (language_string
, "GNU C++14") == 0)
25263 language
= DW_LANG_C_plus_plus_14
;
25264 else if (strcmp (language_string
, "GNU C++17") == 0
25265 || strcmp (language_string
, "GNU C++20") == 0
25266 || strcmp (language_string
, "GNU C++23") == 0
25267 || strcmp (language_string
, "GNU C++26") == 0)
25269 language
= DW_LANG_C_plus_plus_14
;
25272 else if (strcmp (language_string
, "GNU F77") == 0)
25273 language
= DW_LANG_Fortran77
;
25274 else if (strcmp (language_string
, "GNU Modula-2") == 0)
25275 language
= DW_LANG_Modula2
;
25276 else if (dwarf_version
>= 3 || !dwarf_strict
)
25278 if (strcmp (language_string
, "GNU Ada") == 0)
25279 language
= DW_LANG_Ada95
;
25280 else if (startswith (language_string
, "GNU Fortran"))
25282 language
= DW_LANG_Fortran95
;
25283 if (dwarf_version
>= 5 /* || !dwarf_strict */)
25285 if (strcmp (language_string
, "GNU Fortran2003") == 0)
25286 language
= DW_LANG_Fortran03
;
25287 else if (strcmp (language_string
, "GNU Fortran2008") == 0)
25288 language
= DW_LANG_Fortran08
;
25291 else if (strcmp (language_string
, "GNU Objective-C") == 0)
25292 language
= DW_LANG_ObjC
;
25293 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
25294 language
= DW_LANG_ObjC_plus_plus
;
25295 else if (strcmp (language_string
, "GNU D") == 0)
25296 language
= DW_LANG_D
;
25297 else if (dwarf_version
>= 5 || !dwarf_strict
)
25299 if (strcmp (language_string
, "GNU Go") == 0)
25300 language
= DW_LANG_Go
;
25301 else if (strcmp (language_string
, "GNU Rust") == 0)
25302 language
= DW_LANG_Rust
;
25305 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
25306 else if (startswith (language_string
, "GNU Fortran"))
25307 language
= DW_LANG_Fortran90
;
25308 /* Likewise for Ada. */
25309 else if (strcmp (language_string
, "GNU Ada") == 0)
25310 language
= DW_LANG_Ada83
;
25312 add_AT_unsigned (die
, DW_AT_language
, language
);
25316 case DW_LANG_Fortran77
:
25317 case DW_LANG_Fortran90
:
25318 case DW_LANG_Fortran95
:
25319 case DW_LANG_Fortran03
:
25320 case DW_LANG_Fortran08
:
25321 /* Fortran has case insensitive identifiers and the front-end
25322 lowercases everything. */
25323 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
25326 /* The default DW_ID_case_sensitive doesn't need to be specified. */
25332 /* Generate the DIE for a base class. */
25335 gen_inheritance_die (tree binfo
, tree access
, tree type
,
25336 dw_die_ref context_die
)
25338 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
25339 struct vlr_context ctx
= { type
, NULL
};
25341 add_type_attribute (die
, BINFO_TYPE (binfo
), TYPE_UNQUALIFIED
, false,
25343 add_data_member_location_attribute (die
, binfo
, &ctx
);
25345 if (BINFO_VIRTUAL_P (binfo
))
25346 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
25348 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
25349 children, otherwise the default is DW_ACCESS_public. In DWARF2
25350 the default has always been DW_ACCESS_private. */
25351 if (access
== access_public_node
)
25353 if (dwarf_version
== 2
25354 || context_die
->die_tag
== DW_TAG_class_type
)
25355 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
25357 else if (access
== access_protected_node
)
25358 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
25359 else if (dwarf_version
> 2
25360 && context_die
->die_tag
!= DW_TAG_class_type
)
25361 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
25364 /* Return whether DECL is a FIELD_DECL that represents the variant part of a
25368 is_variant_part (tree decl
)
25370 return (TREE_CODE (decl
) == FIELD_DECL
25371 && TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
);
25374 /* Check that OPERAND is a reference to a field in STRUCT_TYPE. If it is,
25375 return the FIELD_DECL. Return NULL_TREE otherwise. */
25378 analyze_discr_in_predicate (tree operand
, tree struct_type
)
25380 while (CONVERT_EXPR_P (operand
))
25381 operand
= TREE_OPERAND (operand
, 0);
25383 /* Match field access to members of struct_type only. */
25384 if (TREE_CODE (operand
) == COMPONENT_REF
25385 && TREE_CODE (TREE_OPERAND (operand
, 0)) == PLACEHOLDER_EXPR
25386 && TREE_TYPE (TREE_OPERAND (operand
, 0)) == struct_type
25387 && TREE_CODE (TREE_OPERAND (operand
, 1)) == FIELD_DECL
)
25388 return TREE_OPERAND (operand
, 1);
25393 /* Check that SRC is a constant integer that can be represented as a native
25394 integer constant (either signed or unsigned). If so, store it into DEST and
25395 return true. Return false otherwise. */
25398 get_discr_value (tree src
, dw_discr_value
*dest
)
25400 tree discr_type
= TREE_TYPE (src
);
25402 if (lang_hooks
.types
.get_debug_type
)
25404 tree debug_type
= lang_hooks
.types
.get_debug_type (discr_type
);
25405 if (debug_type
!= NULL
)
25406 discr_type
= debug_type
;
25409 if (TREE_CODE (src
) != INTEGER_CST
|| !INTEGRAL_TYPE_P (discr_type
))
25412 /* Signedness can vary between the original type and the debug type. This
25413 can happen for character types in Ada for instance: the character type
25414 used for code generation can be signed, to be compatible with the C one,
25415 but from a debugger point of view, it must be unsigned. */
25416 bool is_orig_unsigned
= TYPE_UNSIGNED (TREE_TYPE (src
));
25417 bool is_debug_unsigned
= TYPE_UNSIGNED (discr_type
);
25419 if (is_orig_unsigned
!= is_debug_unsigned
)
25420 src
= fold_convert (discr_type
, src
);
25422 if (!(is_debug_unsigned
? tree_fits_uhwi_p (src
) : tree_fits_shwi_p (src
)))
25425 dest
->pos
= is_debug_unsigned
;
25426 if (is_debug_unsigned
)
25427 dest
->v
.uval
= tree_to_uhwi (src
);
25429 dest
->v
.sval
= tree_to_shwi (src
);
25434 /* Try to extract synthetic properties out of VARIANT_PART_DECL, which is a
25435 FIELD_DECL in STRUCT_TYPE that represents a variant part. If unsuccessful,
25436 store NULL_TREE in DISCR_DECL. Otherwise:
25438 - store the discriminant field in STRUCT_TYPE that controls the variant
25439 part to *DISCR_DECL
25441 - put in *DISCR_LISTS_P an array where for each variant, the item
25442 represents the corresponding matching list of discriminant values.
25444 - put in *DISCR_LISTS_LENGTH the number of variants, which is the size of
25447 Note that when the array is allocated (i.e. when the analysis is
25448 successful), it is up to the caller to free the array. */
25451 analyze_variants_discr (tree variant_part_decl
,
25454 dw_discr_list_ref
**discr_lists_p
,
25455 unsigned *discr_lists_length
)
25457 tree variant_part_type
= TREE_TYPE (variant_part_decl
);
25459 dw_discr_list_ref
*discr_lists
;
25462 /* Compute how many variants there are in this variant part. */
25463 *discr_lists_length
= 0;
25464 for (variant
= TYPE_FIELDS (variant_part_type
);
25465 variant
!= NULL_TREE
;
25466 variant
= DECL_CHAIN (variant
))
25467 ++*discr_lists_length
;
25469 *discr_decl
= NULL_TREE
;
25471 = (dw_discr_list_ref
*) xcalloc (*discr_lists_length
,
25472 sizeof (**discr_lists_p
));
25473 discr_lists
= *discr_lists_p
;
25475 /* And then analyze all variants to extract discriminant information for all
25476 of them. This analysis is conservative: as soon as we detect something we
25477 do not support, abort everything and pretend we found nothing. */
25478 for (variant
= TYPE_FIELDS (variant_part_type
), i
= 0;
25479 variant
!= NULL_TREE
;
25480 variant
= DECL_CHAIN (variant
), ++i
)
25482 tree match_expr
= DECL_QUALIFIER (variant
);
25484 /* Now, try to analyze the predicate and deduce a discriminant for
25486 if (match_expr
== boolean_true_node
)
25487 /* Typically happens for the default variant: it matches all cases that
25488 previous variants rejected. Don't output any matching value for
25492 /* The following loop tries to iterate over each discriminant
25493 possibility: single values or ranges. */
25494 while (match_expr
!= NULL_TREE
)
25496 tree next_round_match_expr
;
25497 tree candidate_discr
= NULL_TREE
;
25498 dw_discr_list_ref new_node
= NULL
;
25500 /* Possibilities are matched one after the other by nested
25501 TRUTH_ORIF_EXPR expressions. Process the current possibility and
25502 continue with the rest at next iteration. */
25503 if (TREE_CODE (match_expr
) == TRUTH_ORIF_EXPR
)
25505 next_round_match_expr
= TREE_OPERAND (match_expr
, 0);
25506 match_expr
= TREE_OPERAND (match_expr
, 1);
25509 next_round_match_expr
= NULL_TREE
;
25511 if (match_expr
== boolean_false_node
)
25512 /* This sub-expression matches nothing: just wait for the next
25516 else if (TREE_CODE (match_expr
) == EQ_EXPR
)
25518 /* We are matching: <discr_field> == <integer_cst>
25519 This sub-expression matches a single value. */
25520 tree integer_cst
= TREE_OPERAND (match_expr
, 1);
25523 = analyze_discr_in_predicate (TREE_OPERAND (match_expr
, 0),
25526 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
25527 if (!get_discr_value (integer_cst
,
25528 &new_node
->dw_discr_lower_bound
))
25530 new_node
->dw_discr_range
= false;
25533 else if (TREE_CODE (match_expr
) == TRUTH_ANDIF_EXPR
)
25535 /* We are matching:
25536 <discr_field> > <integer_cst>
25537 && <discr_field> < <integer_cst>.
25538 This sub-expression matches the range of values between the
25539 two matched integer constants. Note that comparisons can be
25540 inclusive or exclusive. */
25541 tree candidate_discr_1
, candidate_discr_2
;
25542 tree lower_cst
, upper_cst
;
25543 bool lower_cst_included
, upper_cst_included
;
25544 tree lower_op
= TREE_OPERAND (match_expr
, 0);
25545 tree upper_op
= TREE_OPERAND (match_expr
, 1);
25547 /* When the comparison is exclusive, the integer constant is not
25548 the discriminant range bound we are looking for: we will have
25549 to increment or decrement it. */
25550 if (TREE_CODE (lower_op
) == GE_EXPR
)
25551 lower_cst_included
= true;
25552 else if (TREE_CODE (lower_op
) == GT_EXPR
)
25553 lower_cst_included
= false;
25557 if (TREE_CODE (upper_op
) == LE_EXPR
)
25558 upper_cst_included
= true;
25559 else if (TREE_CODE (upper_op
) == LT_EXPR
)
25560 upper_cst_included
= false;
25564 /* Extract the discriminant from the first operand and check it
25565 is consistant with the same analysis in the second
25568 = analyze_discr_in_predicate (TREE_OPERAND (lower_op
, 0),
25571 = analyze_discr_in_predicate (TREE_OPERAND (upper_op
, 0),
25573 if (candidate_discr_1
== candidate_discr_2
)
25574 candidate_discr
= candidate_discr_1
;
25578 /* Extract bounds from both. */
25579 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
25580 lower_cst
= TREE_OPERAND (lower_op
, 1);
25581 upper_cst
= TREE_OPERAND (upper_op
, 1);
25583 if (!lower_cst_included
)
25585 = fold_build2 (PLUS_EXPR
, TREE_TYPE (lower_cst
), lower_cst
,
25586 build_int_cst (TREE_TYPE (lower_cst
), 1));
25587 if (!upper_cst_included
)
25589 = fold_build2 (MINUS_EXPR
, TREE_TYPE (upper_cst
), upper_cst
,
25590 build_int_cst (TREE_TYPE (upper_cst
), 1));
25592 if (!get_discr_value (lower_cst
,
25593 &new_node
->dw_discr_lower_bound
)
25594 || !get_discr_value (upper_cst
,
25595 &new_node
->dw_discr_upper_bound
))
25598 new_node
->dw_discr_range
= true;
25601 else if ((candidate_discr
25602 = analyze_discr_in_predicate (match_expr
, struct_type
))
25603 && (TREE_TYPE (candidate_discr
) == boolean_type_node
25604 || TREE_TYPE (TREE_TYPE (candidate_discr
))
25605 == boolean_type_node
))
25607 /* We are matching: <discr_field> for a boolean discriminant.
25608 This sub-expression matches boolean_true_node. */
25609 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
25610 if (!get_discr_value (boolean_true_node
,
25611 &new_node
->dw_discr_lower_bound
))
25613 new_node
->dw_discr_range
= false;
25617 /* Unsupported sub-expression: we cannot determine the set of
25618 matching discriminant values. Abort everything. */
25621 /* If the discriminant info is not consistant with what we saw so
25622 far, consider the analysis failed and abort everything. */
25623 if (candidate_discr
== NULL_TREE
25624 || (*discr_decl
!= NULL_TREE
&& candidate_discr
!= *discr_decl
))
25627 *discr_decl
= candidate_discr
;
25629 if (new_node
!= NULL
)
25631 new_node
->dw_discr_next
= discr_lists
[i
];
25632 discr_lists
[i
] = new_node
;
25634 match_expr
= next_round_match_expr
;
25638 /* If we reach this point, we could match everything we were interested
25643 /* Clean all data structure and return no result. */
25644 free (*discr_lists_p
);
25645 *discr_lists_p
= NULL
;
25646 *discr_decl
= NULL_TREE
;
25649 /* Generate a DIE to represent VARIANT_PART_DECL, a variant part that is part
25650 of STRUCT_TYPE, a record type. This new DIE is emitted as the next child
25653 Variant parts are supposed to be implemented as a FIELD_DECL whose type is a
25654 QUAL_UNION_TYPE: this is the VARIANT_PART_DECL parameter. The members for
25655 this type, which are record types, represent the available variants and each
25656 has a DECL_QUALIFIER attribute. The discriminant and the discriminant
25657 values are inferred from these attributes.
25659 In trees, the offsets for the fields inside these sub-records are relative
25660 to the variant part itself, whereas the corresponding DIEs should have
25661 offset attributes that are relative to the embedding record base address.
25662 This is why the caller must provide a VARIANT_PART_OFFSET expression: it
25663 must be an expression that computes the offset of the variant part to
25664 describe in DWARF. */
25667 gen_variant_part (tree variant_part_decl
, struct vlr_context
*vlr_ctx
,
25668 dw_die_ref context_die
)
25670 const tree variant_part_type
= TREE_TYPE (variant_part_decl
);
25671 tree variant_part_offset
= vlr_ctx
->variant_part_offset
;
25673 /* The FIELD_DECL node in STRUCT_TYPE that acts as the discriminant, or
25674 NULL_TREE if there is no such field. */
25675 tree discr_decl
= NULL_TREE
;
25676 dw_discr_list_ref
*discr_lists
;
25677 unsigned discr_lists_length
= 0;
25680 dw_die_ref dwarf_proc_die
= NULL
;
25681 dw_die_ref variant_part_die
25682 = new_die (DW_TAG_variant_part
, context_die
, variant_part_type
);
25684 equate_decl_number_to_die (variant_part_decl
, variant_part_die
);
25686 analyze_variants_discr (variant_part_decl
, vlr_ctx
->struct_type
,
25687 &discr_decl
, &discr_lists
, &discr_lists_length
);
25689 if (discr_decl
!= NULL_TREE
)
25691 dw_die_ref discr_die
= lookup_decl_die (discr_decl
);
25694 add_AT_die_ref (variant_part_die
, DW_AT_discr
, discr_die
);
25696 /* We have no DIE for the discriminant, so just discard all
25697 discrimimant information in the output. */
25698 discr_decl
= NULL_TREE
;
25701 /* If the offset for this variant part is more complex than a constant,
25702 create a DWARF procedure for it so that we will not have to generate
25703 DWARF expressions for it for each member. */
25704 if (TREE_CODE (variant_part_offset
) != INTEGER_CST
25705 && (dwarf_version
>= 3 || !dwarf_strict
))
25707 struct loc_descr_context ctx
= {
25708 vlr_ctx
->struct_type
, /* context_type */
25709 NULL_TREE
, /* base_decl */
25711 false, /* placeholder_arg */
25712 false, /* placeholder_seen */
25713 false /* strict_signedness */
25715 const tree dwarf_proc_fndecl
25716 = build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
25717 build_function_type (TREE_TYPE (variant_part_offset
),
25719 const tree dwarf_proc_call
= build_call_expr (dwarf_proc_fndecl
, 0);
25720 const dw_loc_descr_ref dwarf_proc_body
25721 = loc_descriptor_from_tree (variant_part_offset
, 0, &ctx
);
25723 dwarf_proc_die
= new_dwarf_proc_die (dwarf_proc_body
,
25724 dwarf_proc_fndecl
, context_die
);
25725 if (dwarf_proc_die
!= NULL
)
25726 variant_part_offset
= dwarf_proc_call
;
25729 /* Output DIEs for all variants. */
25731 for (tree variant
= TYPE_FIELDS (variant_part_type
);
25732 variant
!= NULL_TREE
;
25733 variant
= DECL_CHAIN (variant
), ++i
)
25735 tree variant_type
= TREE_TYPE (variant
);
25736 dw_die_ref variant_die
;
25738 /* All variants (i.e. members of a variant part) are supposed to be
25739 encoded as structures. Sub-variant parts are QUAL_UNION_TYPE fields
25740 under these records. */
25741 gcc_assert (TREE_CODE (variant_type
) == RECORD_TYPE
);
25743 variant_die
= new_die (DW_TAG_variant
, variant_part_die
, variant_type
);
25744 equate_decl_number_to_die (variant
, variant_die
);
25746 /* Output discriminant values this variant matches, if any. */
25747 if (discr_decl
== NULL
|| discr_lists
[i
] == NULL
)
25748 /* In the case we have discriminant information at all, this is
25749 probably the default variant: as the standard says, don't
25750 output any discriminant value/list attribute. */
25752 else if (discr_lists
[i
]->dw_discr_next
== NULL
25753 && !discr_lists
[i
]->dw_discr_range
)
25754 /* If there is only one accepted value, don't bother outputting a
25756 add_discr_value (variant_die
, &discr_lists
[i
]->dw_discr_lower_bound
);
25758 add_discr_list (variant_die
, discr_lists
[i
]);
25760 for (tree member
= TYPE_FIELDS (variant_type
);
25761 member
!= NULL_TREE
;
25762 member
= DECL_CHAIN (member
))
25764 struct vlr_context vlr_sub_ctx
= {
25765 vlr_ctx
->struct_type
, /* struct_type */
25766 NULL
/* variant_part_offset */
25768 if (is_variant_part (member
))
25770 /* All offsets for fields inside variant parts are relative to
25771 the top-level embedding RECORD_TYPE's base address. On the
25772 other hand, offsets in GCC's types are relative to the
25773 nested-most variant part. So we have to sum offsets each time
25776 vlr_sub_ctx
.variant_part_offset
25777 = fold_build2 (PLUS_EXPR
, TREE_TYPE (variant_part_offset
),
25778 variant_part_offset
, byte_position (member
));
25779 gen_variant_part (member
, &vlr_sub_ctx
, variant_die
);
25783 vlr_sub_ctx
.variant_part_offset
= variant_part_offset
;
25784 gen_decl_die (member
, NULL
, &vlr_sub_ctx
, variant_die
);
25789 free (discr_lists
);
25792 /* Generate a DIE for a class member. */
25795 gen_member_die (tree type
, dw_die_ref context_die
)
25798 tree binfo
= TYPE_BINFO (type
);
25800 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
25802 /* If this is not an incomplete type, output descriptions of each of its
25803 members. Note that as we output the DIEs necessary to represent the
25804 members of this record or union type, we will also be trying to output
25805 DIEs to represent the *types* of those members. However the `type'
25806 function (above) will specifically avoid generating type DIEs for member
25807 types *within* the list of member DIEs for this (containing) type except
25808 for those types (of members) which are explicitly marked as also being
25809 members of this (containing) type themselves. The g++ front- end can
25810 force any given type to be treated as a member of some other (containing)
25811 type by setting the TYPE_CONTEXT of the given (member) type to point to
25812 the TREE node representing the appropriate (containing) type. */
25814 /* First output info about the base classes. */
25815 if (binfo
&& early_dwarf
)
25817 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
25821 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
25822 gen_inheritance_die (base
,
25823 (accesses
? (*accesses
)[i
] : access_public_node
),
25828 /* Now output info about the members. */
25829 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
25831 /* Ignore clones. */
25832 if (DECL_ABSTRACT_ORIGIN (member
))
25835 struct vlr_context vlr_ctx
= { type
, NULL_TREE
};
25836 bool static_inline_p
25838 && TREE_STATIC (member
)
25839 && (lang_hooks
.decls
.decl_dwarf_attribute (member
, DW_AT_inline
)
25842 /* If we thought we were generating minimal debug info for TYPE
25843 and then changed our minds, some of the member declarations
25844 may have already been defined. Don't define them again, but
25845 do put them in the right order. */
25847 if (dw_die_ref child
= lookup_decl_die (member
))
25849 /* Handle inline static data members, which only have in-class
25851 bool splice
= true;
25853 dw_die_ref ref
= NULL
;
25854 if (child
->die_tag
== DW_TAG_variable
25855 && child
->die_parent
== comp_unit_die ())
25857 ref
= get_AT_ref (child
, DW_AT_specification
);
25859 /* For C++17 inline static data members followed by redundant
25860 out of class redeclaration, we might get here with
25861 child being the DIE created for the out of class
25862 redeclaration and with its DW_AT_specification being
25863 the DIE created for in-class definition. We want to
25864 reparent the latter, and don't want to create another
25865 DIE with DW_AT_specification in that case, because
25866 we already have one. */
25869 && ref
->die_tag
== DW_TAG_variable
25870 && ref
->die_parent
== comp_unit_die ()
25871 && get_AT (ref
, DW_AT_specification
) == NULL
)
25875 static_inline_p
= false;
25880 reparent_child (child
, context_die
);
25881 if (dwarf_version
< 5)
25882 child
->die_tag
= DW_TAG_member
;
25886 else if (child
->die_tag
== DW_TAG_enumerator
)
25887 /* Enumerators remain under their enumeration even if
25888 their names are introduced in the enclosing scope. */
25892 splice_child_die (context_die
, child
);
25895 /* Do not generate DWARF for variant parts if we are generating the
25896 corresponding GNAT encodings: DIEs generated for the two schemes
25897 would conflict in our mappings. */
25898 else if (is_variant_part (member
)
25899 && gnat_encodings
!= DWARF_GNAT_ENCODINGS_ALL
)
25901 vlr_ctx
.variant_part_offset
= byte_position (member
);
25902 gen_variant_part (member
, &vlr_ctx
, context_die
);
25906 vlr_ctx
.variant_part_offset
= NULL_TREE
;
25907 gen_decl_die (member
, NULL
, &vlr_ctx
, context_die
);
25910 /* For C++ inline static data members emit immediately a DW_TAG_variable
25911 DIE that will refer to that DW_TAG_member/DW_TAG_variable through
25912 DW_AT_specification. */
25913 if (static_inline_p
)
25915 int old_extern
= DECL_EXTERNAL (member
);
25916 DECL_EXTERNAL (member
) = 0;
25917 gen_decl_die (member
, NULL
, NULL
, comp_unit_die ());
25918 DECL_EXTERNAL (member
) = old_extern
;
25923 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
25924 is set, we pretend that the type was never defined, so we only get the
25925 member DIEs needed by later specification DIEs. */
25928 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
25929 enum debug_info_usage usage
)
25931 if (TREE_ASM_WRITTEN (type
))
25933 /* Fill in the bound of variable-length fields in late dwarf if
25934 still incomplete. */
25935 if (!early_dwarf
&& variably_modified_type_p (type
, NULL
))
25936 for (tree member
= TYPE_FIELDS (type
);
25938 member
= DECL_CHAIN (member
))
25939 fill_variable_array_bounds (TREE_TYPE (member
));
25943 dw_die_ref type_die
= lookup_type_die (type
);
25944 dw_die_ref scope_die
= 0;
25945 bool nested
= false;
25946 bool complete
= (TYPE_SIZE (type
)
25947 && (! TYPE_STUB_DECL (type
)
25948 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
25949 bool ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
25950 complete
= complete
&& should_emit_struct_debug (type
, usage
);
25952 if (type_die
&& ! complete
)
25955 if (TYPE_CONTEXT (type
) != NULL_TREE
25956 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
25957 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
25960 scope_die
= scope_die_for (type
, context_die
);
25962 /* Generate child dies for template parameters. */
25963 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
25964 schedule_generic_params_dies_gen (type
);
25966 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
25967 /* First occurrence of type or toplevel definition of nested class. */
25969 dw_die_ref old_die
= type_die
;
25971 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
25972 ? record_type_tag (type
) : DW_TAG_union_type
,
25974 equate_type_number_to_die (type
, type_die
);
25976 add_AT_specification (type_die
, old_die
);
25978 add_name_attribute (type_die
, type_tag (type
));
25981 remove_AT (type_die
, DW_AT_declaration
);
25983 /* If this type has been completed, then give it a byte_size attribute and
25984 then give a list of members. */
25985 if (complete
&& !ns_decl
)
25987 /* Prevent infinite recursion in cases where the type of some member of
25988 this type is expressed in terms of this type itself. */
25989 TREE_ASM_WRITTEN (type
) = 1;
25990 add_byte_size_attribute (type_die
, type
);
25991 add_alignment_attribute (type_die
, type
);
25992 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
25994 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
25995 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
25998 /* If the first reference to this type was as the return type of an
25999 inline function, then it may not have a parent. Fix this now. */
26000 if (type_die
->die_parent
== NULL
)
26001 add_child_die (scope_die
, type_die
);
26003 gen_member_die (type
, type_die
);
26005 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
26006 if (TYPE_ARTIFICIAL (type
))
26007 add_AT_flag (type_die
, DW_AT_artificial
, 1);
26009 /* GNU extension: Record what type our vtable lives in. */
26010 if (TYPE_VFIELD (type
))
26012 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
26014 gen_type_die (vtype
, context_die
);
26015 add_AT_die_ref (type_die
, DW_AT_containing_type
,
26016 lookup_type_die (vtype
));
26021 add_AT_flag (type_die
, DW_AT_declaration
, 1);
26023 /* We don't need to do this for function-local types. */
26024 if (TYPE_STUB_DECL (type
)
26025 && ! decl_function_context (TYPE_STUB_DECL (type
)))
26026 vec_safe_push (incomplete_types
, type
);
26029 if (get_AT (type_die
, DW_AT_name
))
26030 add_pubtype (type
, type_die
);
26033 /* Generate a DIE for a subroutine _type_. */
26036 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
26038 tree return_type
= TREE_TYPE (type
);
26039 dw_die_ref subr_die
26040 = new_die (DW_TAG_subroutine_type
,
26041 scope_die_for (type
, context_die
), type
);
26043 equate_type_number_to_die (type
, subr_die
);
26044 add_prototyped_attribute (subr_die
, type
);
26045 add_type_attribute (subr_die
, return_type
, TYPE_UNQUALIFIED
, false,
26047 add_alignment_attribute (subr_die
, type
);
26048 gen_formal_types_die (type
, subr_die
);
26050 if (get_AT (subr_die
, DW_AT_name
))
26051 add_pubtype (type
, subr_die
);
26052 if ((dwarf_version
>= 5 || !dwarf_strict
)
26053 && lang_hooks
.types
.type_dwarf_attribute (type
, DW_AT_reference
) != -1)
26054 add_AT_flag (subr_die
, DW_AT_reference
, 1);
26055 if ((dwarf_version
>= 5 || !dwarf_strict
)
26056 && lang_hooks
.types
.type_dwarf_attribute (type
,
26057 DW_AT_rvalue_reference
) != -1)
26058 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
26061 /* Generate a DIE for a type definition. */
26064 gen_typedef_die (tree decl
, dw_die_ref context_die
)
26066 dw_die_ref type_die
;
26069 if (TREE_ASM_WRITTEN (decl
))
26071 if (DECL_ORIGINAL_TYPE (decl
))
26072 fill_variable_array_bounds (DECL_ORIGINAL_TYPE (decl
));
26076 /* As we avoid creating DIEs for local typedefs (see decl_ultimate_origin
26077 checks in process_scope_var and modified_type_die), this should be called
26078 only for original types. */
26079 gcc_assert (decl_ultimate_origin (decl
) == NULL
26080 || decl_ultimate_origin (decl
) == decl
);
26082 TREE_ASM_WRITTEN (decl
) = 1;
26083 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
26085 add_name_and_src_coords_attributes (type_die
, decl
);
26086 if (DECL_ORIGINAL_TYPE (decl
))
26088 type
= DECL_ORIGINAL_TYPE (decl
);
26089 if (type
== error_mark_node
)
26092 gcc_assert (type
!= TREE_TYPE (decl
));
26093 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
26097 type
= TREE_TYPE (decl
);
26098 if (type
== error_mark_node
)
26101 if (is_naming_typedef_decl (TYPE_NAME (type
)))
26103 /* Here, we are in the case of decl being a typedef naming
26104 an anonymous type, e.g:
26105 typedef struct {...} foo;
26106 In that case TREE_TYPE (decl) is not a typedef variant
26107 type and TYPE_NAME of the anonymous type is set to the
26108 TYPE_DECL of the typedef. This construct is emitted by
26111 TYPE is the anonymous struct named by the typedef
26112 DECL. As we need the DW_AT_type attribute of the
26113 DW_TAG_typedef to point to the DIE of TYPE, let's
26114 generate that DIE right away. add_type_attribute
26115 called below will then pick (via lookup_type_die) that
26116 anonymous struct DIE. */
26117 if (!TREE_ASM_WRITTEN (type
))
26118 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
26120 /* This is a GNU Extension. We are adding a
26121 DW_AT_linkage_name attribute to the DIE of the
26122 anonymous struct TYPE. The value of that attribute
26123 is the name of the typedef decl naming the anonymous
26124 struct. This greatly eases the work of consumers of
26125 this debug info. */
26126 add_linkage_name_raw (lookup_type_die (type
), decl
);
26130 add_type_attribute (type_die
, type
, decl_quals (decl
), false,
26133 if (is_naming_typedef_decl (decl
))
26134 /* We want that all subsequent calls to lookup_type_die with
26135 TYPE in argument yield the DW_TAG_typedef we have just
26137 equate_type_number_to_die (type
, type_die
);
26139 add_alignment_attribute (type_die
, TREE_TYPE (decl
));
26141 add_accessibility_attribute (type_die
, decl
);
26143 if (DECL_ABSTRACT_P (decl
))
26144 equate_decl_number_to_die (decl
, type_die
);
26146 if (get_AT (type_die
, DW_AT_name
))
26147 add_pubtype (decl
, type_die
);
26150 /* Generate a DIE for a struct, class, enum or union type. */
26153 gen_tagged_type_die (tree type
,
26154 dw_die_ref context_die
,
26155 enum debug_info_usage usage
)
26157 if (type
== NULL_TREE
26158 || !is_tagged_type (type
))
26161 if (TREE_ASM_WRITTEN (type
))
26163 /* If this is a nested type whose containing class hasn't been written
26164 out yet, writing it out will cover this one, too. This does not apply
26165 to instantiations of member class templates; they need to be added to
26166 the containing class as they are generated. FIXME: This hurts the
26167 idea of combining type decls from multiple TUs, since we can't predict
26168 what set of template instantiations we'll get. */
26169 else if (TYPE_CONTEXT (type
)
26170 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
26171 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
26173 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
26175 if (TREE_ASM_WRITTEN (type
))
26178 /* If that failed, attach ourselves to the stub. */
26179 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
26181 else if (TYPE_CONTEXT (type
) != NULL_TREE
26182 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
26184 /* If this type is local to a function that hasn't been written
26185 out yet, use a NULL context for now; it will be fixed up in
26186 decls_for_scope. */
26187 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
26188 /* A declaration DIE doesn't count; nested types need to go in the
26190 if (context_die
&& is_declaration_die (context_die
))
26191 context_die
= NULL
;
26194 context_die
= declare_in_namespace (type
, context_die
);
26196 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
26198 /* This might have been written out by the call to
26199 declare_in_namespace. */
26200 if (!TREE_ASM_WRITTEN (type
))
26201 gen_enumeration_type_die (type
, context_die
);
26204 gen_struct_or_union_type_die (type
, context_die
, usage
);
26206 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
26207 it up if it is ever completed. gen_*_type_die will set it for us
26208 when appropriate. */
26211 /* Generate a type description DIE. */
26214 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
26215 enum debug_info_usage usage
)
26217 struct array_descr_info info
;
26219 if (type
== NULL_TREE
|| type
== error_mark_node
)
26222 if (flag_checking
&& type
)
26223 verify_type (type
);
26225 if (TYPE_NAME (type
) != NULL_TREE
26226 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
26227 && is_redundant_typedef (TYPE_NAME (type
))
26228 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
26229 /* The DECL of this type is a typedef we don't want to emit debug
26230 info for but we want debug info for its underlying typedef.
26231 This can happen for e.g, the injected-class-name of a C++
26233 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
26235 /* If TYPE is a typedef type variant, let's generate debug info
26236 for the parent typedef which TYPE is a type of. */
26237 if (typedef_variant_p (type
))
26239 if (TREE_ASM_WRITTEN (type
))
26242 tree name
= TYPE_NAME (type
);
26243 tree origin
= decl_ultimate_origin (name
);
26244 if (origin
!= NULL
&& origin
!= name
)
26246 gen_decl_die (origin
, NULL
, NULL
, context_die
);
26250 /* Prevent broken recursion; we can't hand off to the same type. */
26251 gcc_assert (DECL_ORIGINAL_TYPE (name
) != type
);
26253 /* Give typedefs the right scope. */
26254 context_die
= scope_die_for (type
, context_die
);
26256 TREE_ASM_WRITTEN (type
) = 1;
26258 gen_decl_die (name
, NULL
, NULL
, context_die
);
26262 /* If type is an anonymous tagged type named by a typedef, let's
26263 generate debug info for the typedef. */
26264 if (is_naming_typedef_decl (TYPE_NAME (type
)))
26266 /* Give typedefs the right scope. */
26267 context_die
= scope_die_for (type
, context_die
);
26269 gen_decl_die (TYPE_NAME (type
), NULL
, NULL
, context_die
);
26273 if (lang_hooks
.types
.get_debug_type
)
26275 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
26277 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
26279 gen_type_die_with_usage (debug_type
, context_die
, usage
);
26284 /* We are going to output a DIE to represent the unqualified version
26285 of this type (i.e. without any const or volatile qualifiers) so
26286 get the main variant (i.e. the unqualified version) of this type
26287 now. (Vectors and arrays are special because the debugging info is in the
26288 cloned type itself. Similarly function/method types can contain extra
26289 ref-qualification). */
26290 if (FUNC_OR_METHOD_TYPE_P (type
))
26292 /* For function/method types, can't use type_main_variant here,
26293 because that can have different ref-qualifiers for C++,
26294 but try to canonicalize. */
26295 tree main
= TYPE_MAIN_VARIANT (type
);
26296 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
26297 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
26298 && check_base_type (t
, main
)
26299 && check_lang_type (t
, type
))
26305 else if (TREE_CODE (type
) != VECTOR_TYPE
26306 && TREE_CODE (type
) != ARRAY_TYPE
)
26307 type
= type_main_variant (type
);
26309 /* If this is an array type with hidden descriptor, handle it first. */
26310 if (!TREE_ASM_WRITTEN (type
)
26311 && lang_hooks
.types
.get_array_descr_info
)
26313 memset (&info
, 0, sizeof (info
));
26314 if (lang_hooks
.types
.get_array_descr_info (type
, &info
))
26316 /* Fortran sometimes emits array types with no dimension. */
26317 gcc_assert (info
.ndimensions
>= 0
26318 && (info
.ndimensions
26319 <= DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN
));
26320 gen_descr_array_type_die (type
, &info
, context_die
);
26321 TREE_ASM_WRITTEN (type
) = 1;
26326 if (TREE_ASM_WRITTEN (type
))
26328 /* Variable-length types may be incomplete even if
26329 TREE_ASM_WRITTEN. For such types, fall through to
26330 gen_array_type_die() and possibly fill in
26331 DW_AT_{upper,lower}_bound attributes. */
26332 if ((TREE_CODE (type
) != ARRAY_TYPE
26333 && TREE_CODE (type
) != RECORD_TYPE
26334 && TREE_CODE (type
) != UNION_TYPE
26335 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
26336 || !variably_modified_type_p (type
, NULL
))
26340 switch (TREE_CODE (type
))
26346 case REFERENCE_TYPE
:
26347 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
26348 ensures that the gen_type_die recursion will terminate even if the
26349 type is recursive. Recursive types are possible in Ada. */
26350 /* ??? We could perhaps do this for all types before the switch
26352 TREE_ASM_WRITTEN (type
) = 1;
26354 /* For these types, all that is required is that we output a DIE (or a
26355 set of DIEs) to represent the "basis" type. */
26356 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
26357 DINFO_USAGE_IND_USE
);
26361 /* This code is used for C++ pointer-to-data-member types.
26362 Output a description of the relevant class type. */
26363 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
26364 DINFO_USAGE_IND_USE
);
26366 /* Output a description of the type of the object pointed to. */
26367 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
26368 DINFO_USAGE_IND_USE
);
26370 /* Now output a DIE to represent this pointer-to-data-member type
26372 gen_ptr_to_mbr_type_die (type
, context_die
);
26375 case FUNCTION_TYPE
:
26376 /* Force out return type (in case it wasn't forced out already). */
26377 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
26378 DINFO_USAGE_DIR_USE
);
26379 gen_subroutine_type_die (type
, context_die
);
26383 /* Force out return type (in case it wasn't forced out already). */
26384 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
26385 DINFO_USAGE_DIR_USE
);
26386 gen_subroutine_type_die (type
, context_die
);
26391 gen_array_type_die (type
, context_die
);
26394 case ENUMERAL_TYPE
:
26397 case QUAL_UNION_TYPE
:
26398 gen_tagged_type_die (type
, context_die
, usage
);
26405 case FIXED_POINT_TYPE
:
26409 /* No DIEs needed for fundamental types. */
26414 /* Just use DW_TAG_unspecified_type. */
26416 dw_die_ref type_die
= lookup_type_die (type
);
26417 if (type_die
== NULL
)
26419 tree name
= TYPE_IDENTIFIER (type
);
26420 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
26422 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
26423 equate_type_number_to_die (type
, type_die
);
26429 if (is_cxx_auto (type
))
26431 tree name
= TYPE_IDENTIFIER (type
);
26432 dw_die_ref
*die
= (name
== get_identifier ("auto")
26433 ? &auto_die
: &decltype_auto_die
);
26436 *die
= new_die (DW_TAG_unspecified_type
,
26437 comp_unit_die (), NULL_TREE
);
26438 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
26440 equate_type_number_to_die (type
, *die
);
26443 gcc_unreachable ();
26446 TREE_ASM_WRITTEN (type
) = 1;
26450 gen_type_die (tree type
, dw_die_ref context_die
)
26452 if (type
!= error_mark_node
)
26454 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
26457 dw_die_ref die
= lookup_type_die (type
);
26464 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
26465 things which are local to the given block. */
26468 gen_block_die (tree stmt
, dw_die_ref context_die
)
26470 int must_output_die
= 0;
26473 /* Ignore blocks that are NULL. */
26474 if (stmt
== NULL_TREE
)
26477 inlined_func
= inlined_function_outer_scope_p (stmt
);
26479 /* If the block is one fragment of a non-contiguous block, do not
26480 process the variables, since they will have been done by the
26481 origin block. Do process subblocks. */
26482 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
26486 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
26487 gen_block_die (sub
, context_die
);
26492 /* Determine if we need to output any Dwarf DIEs at all to represent this
26495 /* The outer scopes for inlinings *must* always be represented. We
26496 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
26497 must_output_die
= 1;
26498 else if (lookup_block_die (stmt
))
26499 /* If we already have a DIE then it was filled early. Meanwhile
26500 we might have pruned all BLOCK_VARS as optimized out but we
26501 still want to generate high/low PC attributes so output it. */
26502 must_output_die
= 1;
26503 else if (TREE_USED (stmt
)
26504 || TREE_ASM_WRITTEN (stmt
))
26506 /* Determine if this block directly contains any "significant"
26507 local declarations which we will need to output DIEs for. */
26508 if (debug_info_level
> DINFO_LEVEL_TERSE
)
26510 /* We are not in terse mode so any local declaration that
26511 is not ignored for debug purposes counts as being a
26512 "significant" one. */
26513 if (BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
26514 must_output_die
= 1;
26516 for (tree var
= BLOCK_VARS (stmt
); var
; var
= DECL_CHAIN (var
))
26517 if (!DECL_IGNORED_P (var
))
26519 must_output_die
= 1;
26523 else if (!dwarf2out_ignore_block (stmt
))
26524 must_output_die
= 1;
26527 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
26528 DIE for any block which contains no significant local declarations at
26529 all. Rather, in such cases we just call `decls_for_scope' so that any
26530 needed Dwarf info for any sub-blocks will get properly generated. Note
26531 that in terse mode, our definition of what constitutes a "significant"
26532 local declaration gets restricted to include only inlined function
26533 instances and local (nested) function definitions. */
26534 if (must_output_die
)
26537 gen_inlined_subroutine_die (stmt
, context_die
);
26539 gen_lexical_block_die (stmt
, context_die
);
26542 decls_for_scope (stmt
, context_die
);
26545 /* Process variable DECL (or variable with origin ORIGIN) within
26546 block STMT and add it to CONTEXT_DIE. */
26548 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
26551 tree decl_or_origin
= decl
? decl
: origin
;
26553 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
26554 die
= lookup_decl_die (decl_or_origin
);
26555 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
)
26557 if (TYPE_DECL_IS_STUB (decl_or_origin
))
26558 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
26560 die
= lookup_decl_die (decl_or_origin
);
26561 /* Avoid re-creating the DIE late if it was optimized as unused early. */
26562 if (! die
&& ! early_dwarf
)
26568 /* Avoid creating DIEs for local typedefs and concrete static variables that
26569 will only be pruned later. */
26570 if ((origin
|| decl_ultimate_origin (decl
))
26571 && (TREE_CODE (decl_or_origin
) == TYPE_DECL
26572 || (VAR_P (decl_or_origin
) && TREE_STATIC (decl_or_origin
))))
26574 origin
= decl_ultimate_origin (decl_or_origin
);
26575 if (decl
&& VAR_P (decl
) && die
!= NULL
)
26577 die
= lookup_decl_die (origin
);
26579 equate_decl_number_to_die (decl
, die
);
26584 if (die
!= NULL
&& die
->die_parent
== NULL
)
26585 add_child_die (context_die
, die
);
26587 if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
26590 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
26591 stmt
, context_die
);
26595 if (decl
&& DECL_P (decl
))
26597 die
= lookup_decl_die (decl
);
26599 /* Early created DIEs do not have a parent as the decls refer
26600 to the function as DECL_CONTEXT rather than the BLOCK. */
26601 if (die
&& die
->die_parent
== NULL
)
26603 gcc_assert (in_lto_p
);
26604 add_child_die (context_die
, die
);
26608 gen_decl_die (decl
, origin
, NULL
, context_die
);
26612 /* Generate all of the decls declared within a given scope and (recursively)
26613 all of its sub-blocks. */
26616 decls_for_scope (tree stmt
, dw_die_ref context_die
, bool recurse
)
26622 /* Ignore NULL blocks. */
26623 if (stmt
== NULL_TREE
)
26626 /* Output the DIEs to represent all of the data objects and typedefs
26627 declared directly within this block but not within any nested
26628 sub-blocks. Also, nested function and tag DIEs have been
26629 generated with a parent of NULL; fix that up now. We don't
26630 have to do this if we're at -g1. */
26631 if (debug_info_level
> DINFO_LEVEL_TERSE
)
26633 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
26634 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
26635 /* BLOCK_NONLOCALIZED_VARs simply generate DIE stubs with abstract
26636 origin - avoid doing this twice as we have no good way to see
26637 if we've done it once already. */
26639 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
26641 decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
26642 if (decl
== current_function_decl
)
26643 /* Ignore declarations of the current function, while they
26644 are declarations, gen_subprogram_die would treat them
26645 as definitions again, because they are equal to
26646 current_function_decl and endlessly recurse. */;
26647 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
26648 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
26650 process_scope_var (stmt
, NULL_TREE
, decl
, context_die
);
26654 /* Even if we're at -g1, we need to process the subblocks in order to get
26655 inlined call information. */
26657 /* Output the DIEs to represent all sub-blocks (and the items declared
26658 therein) of this block. */
26660 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
26662 subblocks
= BLOCK_CHAIN (subblocks
))
26663 gen_block_die (subblocks
, context_die
);
26666 /* Is this a typedef we can avoid emitting? */
26669 is_redundant_typedef (const_tree decl
)
26671 if (TYPE_DECL_IS_STUB (decl
))
26674 if (DECL_ARTIFICIAL (decl
)
26675 && DECL_CONTEXT (decl
)
26676 && is_tagged_type (DECL_CONTEXT (decl
))
26677 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
26678 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
26679 /* Also ignore the artificial member typedef for the class name. */
26685 /* Return TRUE if TYPE is a typedef that names a type for linkage
26686 purposes. This kind of typedefs is produced by the C++ FE for
26689 typedef struct {...} foo;
26691 In that case, there is no typedef variant type produced for foo.
26692 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
26696 is_naming_typedef_decl (const_tree decl
)
26698 if (decl
== NULL_TREE
26699 || TREE_CODE (decl
) != TYPE_DECL
26700 || DECL_NAMELESS (decl
)
26701 || !is_tagged_type (TREE_TYPE (decl
))
26702 || DECL_IS_UNDECLARED_BUILTIN (decl
)
26703 || is_redundant_typedef (decl
)
26704 /* It looks like Ada produces TYPE_DECLs that are very similar
26705 to C++ naming typedefs but that have different
26706 semantics. Let's be specific to c++ for now. */
26710 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
26711 && TYPE_NAME (TREE_TYPE (decl
)) == decl
26712 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
26713 != TYPE_NAME (TREE_TYPE (decl
))));
26716 /* Looks up the DIE for a context. */
26718 static inline dw_die_ref
26719 lookup_context_die (tree context
)
26723 /* Find die that represents this context. */
26724 if (TYPE_P (context
))
26726 context
= TYPE_MAIN_VARIANT (context
);
26727 dw_die_ref ctx
= lookup_type_die (context
);
26730 return strip_naming_typedef (context
, ctx
);
26733 return lookup_decl_die (context
);
26735 return comp_unit_die ();
26738 /* Returns the DIE for a context. */
26740 static inline dw_die_ref
26741 get_context_die (tree context
)
26745 /* Find die that represents this context. */
26746 if (TYPE_P (context
))
26748 context
= TYPE_MAIN_VARIANT (context
);
26749 return strip_naming_typedef (context
, force_type_die (context
));
26752 return force_decl_die (context
);
26754 return comp_unit_die ();
26757 /* Returns the DIE for decl. A DIE will always be returned. */
26760 force_decl_die (tree decl
)
26762 dw_die_ref decl_die
;
26763 unsigned saved_external_flag
;
26764 tree save_fn
= NULL_TREE
;
26765 decl_die
= lookup_decl_die (decl
);
26768 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
26770 decl_die
= lookup_decl_die (decl
);
26774 switch (TREE_CODE (decl
))
26776 case FUNCTION_DECL
:
26777 /* Clear current_function_decl, so that gen_subprogram_die thinks
26778 that this is a declaration. At this point, we just want to force
26779 declaration die. */
26780 save_fn
= current_function_decl
;
26781 current_function_decl
= NULL_TREE
;
26782 gen_subprogram_die (decl
, context_die
);
26783 current_function_decl
= save_fn
;
26787 /* Set external flag to force declaration die. Restore it after
26788 gen_decl_die() call. */
26789 saved_external_flag
= DECL_EXTERNAL (decl
);
26790 DECL_EXTERNAL (decl
) = 1;
26791 gen_decl_die (decl
, NULL
, NULL
, context_die
);
26792 DECL_EXTERNAL (decl
) = saved_external_flag
;
26795 case NAMESPACE_DECL
:
26796 if (dwarf_version
>= 3 || !dwarf_strict
)
26797 dwarf2out_decl (decl
);
26799 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
26800 decl_die
= comp_unit_die ();
26804 /* Enumerators shouldn't need force_decl_die. */
26805 gcc_assert (DECL_CONTEXT (decl
) == NULL_TREE
26806 || TREE_CODE (DECL_CONTEXT (decl
)) != ENUMERAL_TYPE
);
26807 gen_decl_die (decl
, NULL
, NULL
, context_die
);
26810 case TRANSLATION_UNIT_DECL
:
26811 decl_die
= comp_unit_die ();
26815 gcc_unreachable ();
26818 /* We should be able to find the DIE now. */
26820 decl_die
= lookup_decl_die (decl
);
26821 gcc_assert (decl_die
);
26827 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
26828 always returned. */
26831 force_type_die (tree type
)
26833 dw_die_ref type_die
;
26835 type_die
= lookup_type_die (type
);
26838 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
26840 type_die
= modified_type_die (type
, TYPE_QUALS_NO_ADDR_SPACE (type
),
26841 false, context_die
);
26842 gcc_assert (type_die
);
26847 /* Force out any required namespaces to be able to output DECL,
26848 and return the new context_die for it, if it's changed. */
26851 setup_namespace_context (tree thing
, dw_die_ref context_die
)
26853 tree context
= (DECL_P (thing
)
26854 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
26855 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
26856 /* Force out the namespace. */
26857 context_die
= force_decl_die (context
);
26859 return context_die
;
26862 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
26863 type) within its namespace, if appropriate.
26865 For compatibility with older debuggers, namespace DIEs only contain
26866 declarations; all definitions are emitted at CU scope, with
26867 DW_AT_specification pointing to the declaration (like with class
26871 declare_in_namespace (tree thing
, dw_die_ref context_die
)
26873 dw_die_ref ns_context
;
26875 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26876 return context_die
;
26878 /* External declarations in the local scope only need to be emitted
26879 once, not once in the namespace and once in the scope.
26881 This avoids declaring the `extern' below in the
26882 namespace DIE as well as in the innermost scope:
26895 if (DECL_P (thing
) && DECL_EXTERNAL (thing
) && local_scope_p (context_die
))
26896 return context_die
;
26898 /* If this decl is from an inlined function, then don't try to emit it in its
26899 namespace, as we will get confused. It would have already been emitted
26900 when the abstract instance of the inline function was emitted anyways. */
26901 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
26902 return context_die
;
26904 ns_context
= setup_namespace_context (thing
, context_die
);
26906 if (ns_context
!= context_die
)
26908 if (is_fortran () || is_dlang ())
26910 if (DECL_P (thing
))
26911 gen_decl_die (thing
, NULL
, NULL
, ns_context
);
26913 gen_type_die (thing
, ns_context
);
26915 return context_die
;
26918 /* Generate a DIE for a namespace or namespace alias. */
26921 gen_namespace_die (tree decl
, dw_die_ref context_die
)
26923 dw_die_ref namespace_die
;
26925 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
26926 they are an alias of. */
26927 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
26929 /* Output a real namespace or module. */
26930 context_die
= setup_namespace_context (decl
, comp_unit_die ());
26931 namespace_die
= new_die (is_fortran () || is_dlang ()
26932 ? DW_TAG_module
: DW_TAG_namespace
,
26933 context_die
, decl
);
26934 /* For Fortran modules defined in different CU don't add src coords. */
26935 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
26937 const char *name
= dwarf2_name (decl
, 0);
26939 add_name_attribute (namespace_die
, name
);
26942 add_name_and_src_coords_attributes (namespace_die
, decl
);
26943 if (DECL_EXTERNAL (decl
))
26944 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
26945 equate_decl_number_to_die (decl
, namespace_die
);
26949 /* Output a namespace alias. */
26951 /* Force out the namespace we are an alias of, if necessary. */
26952 dw_die_ref origin_die
26953 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
26955 if (DECL_FILE_SCOPE_P (decl
)
26956 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
26957 context_die
= setup_namespace_context (decl
, comp_unit_die ());
26958 /* Now create the namespace alias DIE. */
26959 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
26960 add_name_and_src_coords_attributes (namespace_die
, decl
);
26961 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
26962 equate_decl_number_to_die (decl
, namespace_die
);
26964 if ((dwarf_version
>= 5 || !dwarf_strict
)
26965 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
26966 DW_AT_export_symbols
) == 1)
26967 add_AT_flag (namespace_die
, DW_AT_export_symbols
, 1);
26969 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
26970 if (want_pubnames ())
26971 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
26974 /* Generate Dwarf debug information for a decl described by DECL.
26975 The return value is currently only meaningful for PARM_DECLs,
26976 for all other decls it returns NULL.
26978 If DECL is a FIELD_DECL, CTX is required: see the comment for VLR_CONTEXT.
26979 It can be NULL otherwise. */
26982 gen_decl_die (tree decl
, tree origin
, struct vlr_context
*ctx
,
26983 dw_die_ref context_die
)
26985 tree decl_or_origin
= decl
? decl
: origin
;
26986 tree class_origin
= NULL
, ultimate_origin
;
26988 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
26991 switch (TREE_CODE (decl_or_origin
))
26997 if (!is_fortran () && !is_ada () && !is_dlang ())
26999 /* The individual enumerators of an enum type get output when we output
27000 the Dwarf representation of the relevant enum type itself. */
27004 /* Emit its type. */
27005 gen_type_die (TREE_TYPE (decl
), context_die
);
27007 /* And its containing namespace. */
27008 context_die
= declare_in_namespace (decl
, context_die
);
27010 gen_const_die (decl
, context_die
);
27013 case FUNCTION_DECL
:
27016 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
27017 on local redeclarations of global functions. That seems broken. */
27018 if (current_function_decl
!= decl
)
27019 /* This is only a declaration. */;
27022 /* We should have abstract copies already and should not generate
27023 stray type DIEs in late LTO dumping. */
27027 /* If we're emitting a clone, emit info for the abstract instance. */
27028 else if (origin
|| DECL_ORIGIN (decl
) != decl
)
27029 dwarf2out_abstract_function (origin
27030 ? DECL_ORIGIN (origin
)
27031 : DECL_ABSTRACT_ORIGIN (decl
));
27033 /* If we're emitting a possibly inlined function emit it as
27034 abstract instance. */
27035 else if (cgraph_function_possibly_inlined_p (decl
)
27036 && ! DECL_ABSTRACT_P (decl
)
27037 && ! class_or_namespace_scope_p (context_die
)
27038 /* dwarf2out_abstract_function won't emit a die if this is just
27039 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
27040 that case, because that works only if we have a die. */
27041 && DECL_INITIAL (decl
) != NULL_TREE
)
27042 dwarf2out_abstract_function (decl
);
27044 /* Otherwise we're emitting the primary DIE for this decl. */
27045 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
27047 /* Before we describe the FUNCTION_DECL itself, make sure that we
27048 have its containing type. */
27050 origin
= decl_class_context (decl
);
27051 if (origin
!= NULL_TREE
)
27052 gen_type_die (origin
, context_die
);
27054 /* And its return type. */
27055 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
27057 /* And its virtual context. */
27058 if (DECL_VINDEX (decl
) != NULL_TREE
)
27059 gen_type_die (DECL_CONTEXT (decl
), context_die
);
27061 /* Make sure we have a member DIE for decl. */
27062 if (origin
!= NULL_TREE
)
27063 gen_type_die_for_member (origin
, decl
, context_die
);
27065 /* And its containing namespace. */
27066 context_die
= declare_in_namespace (decl
, context_die
);
27069 /* Now output a DIE to represent the function itself. */
27071 gen_subprogram_die (decl
, context_die
);
27075 /* If we are in terse mode, don't generate any DIEs to represent any
27076 actual typedefs. */
27077 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
27080 /* In the special case of a TYPE_DECL node representing the declaration
27081 of some type tag, if the given TYPE_DECL is marked as having been
27082 instantiated from some other (original) TYPE_DECL node (e.g. one which
27083 was generated within the original definition of an inline function) we
27084 used to generate a special (abbreviated) DW_TAG_structure_type,
27085 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
27086 should be actually referencing those DIEs, as variable DIEs with that
27087 type would be emitted already in the abstract origin, so it was always
27088 removed during unused type prunning. Don't add anything in this
27090 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
27093 if (is_redundant_typedef (decl
))
27094 gen_type_die (TREE_TYPE (decl
), context_die
);
27096 /* Output a DIE to represent the typedef itself. */
27097 gen_typedef_die (decl
, context_die
);
27101 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
27102 gen_label_die (decl
, context_die
);
27107 /* If we are in terse mode, don't generate any DIEs to represent any
27108 variable declarations or definitions unless it is external. */
27109 if (debug_info_level
< DINFO_LEVEL_TERSE
27110 || (debug_info_level
== DINFO_LEVEL_TERSE
27111 && !TREE_PUBLIC (decl_or_origin
)))
27114 if (debug_info_level
> DINFO_LEVEL_TERSE
)
27116 /* Avoid generating stray type DIEs during late dwarf dumping.
27117 All types have been dumped early. */
27119 /* ??? But in LTRANS we cannot annotate early created variably
27120 modified type DIEs without copying them and adjusting all
27121 references to them. Dump them again as happens for inlining
27122 which copies both the decl and the types. */
27123 /* ??? And even non-LTO needs to re-visit type DIEs to fill
27124 in VLA bound information for example. */
27125 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
27126 current_function_decl
)))
27128 /* Output any DIEs that are needed to specify the type of this data
27130 if (decl_by_reference_p (decl_or_origin
))
27131 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
27133 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
27138 /* And its containing type. */
27139 class_origin
= decl_class_context (decl_or_origin
);
27140 if (class_origin
!= NULL_TREE
)
27141 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
27143 /* And its containing namespace. */
27144 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
27148 /* Now output the DIE to represent the data object itself. This gets
27149 complicated because of the possibility that the VAR_DECL really
27150 represents an inlined instance of a formal parameter for an inline
27152 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
27153 if (ultimate_origin
!= NULL_TREE
27154 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
27155 gen_formal_parameter_die (decl
, origin
,
27156 true /* Emit name attribute. */,
27159 gen_variable_die (decl
, origin
, context_die
);
27163 gcc_assert (ctx
!= NULL
&& ctx
->struct_type
!= NULL
);
27164 /* Ignore the nameless fields that are used to skip bits but handle C++
27165 anonymous unions and structs. */
27166 if (DECL_NAME (decl
) != NULL_TREE
27167 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
27168 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
27170 gen_type_die (member_declared_type (decl
), context_die
);
27171 gen_field_die (decl
, ctx
, context_die
);
27176 /* Avoid generating stray type DIEs during late dwarf dumping.
27177 All types have been dumped early. */
27179 /* ??? But in LTRANS we cannot annotate early created variably
27180 modified type DIEs without copying them and adjusting all
27181 references to them. Dump them again as happens for inlining
27182 which copies both the decl and the types. */
27183 /* ??? And even non-LTO needs to re-visit type DIEs to fill
27184 in VLA bound information for example. */
27185 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
27186 current_function_decl
)))
27188 if (DECL_BY_REFERENCE (decl_or_origin
))
27189 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
27191 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
27193 return gen_formal_parameter_die (decl
, origin
,
27194 true /* Emit name attribute. */,
27197 case NAMESPACE_DECL
:
27198 if (dwarf_version
>= 3 || !dwarf_strict
)
27199 gen_namespace_die (decl
, context_die
);
27202 case IMPORTED_DECL
:
27203 dwarf2out_imported_module_or_decl_1 (decl
, DECL_NAME (decl
),
27204 DECL_CONTEXT (decl
), context_die
);
27207 case NAMELIST_DECL
:
27208 gen_namelist_decl (DECL_NAME (decl
), context_die
,
27209 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
27213 /* Probably some frontend-internal decl. Assume we don't care. */
27214 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
27221 /* Output initial debug information for global DECL. Called at the
27222 end of the parsing process.
27224 This is the initial debug generation process. As such, the DIEs
27225 generated may be incomplete. A later debug generation pass
27226 (dwarf2out_late_global_decl) will augment the information generated
27227 in this pass (e.g., with complete location info). */
27230 dwarf2out_early_global_decl (tree decl
)
27234 /* gen_decl_die() will set DECL_ABSTRACT because
27235 cgraph_function_possibly_inlined_p() returns true. This is in
27236 turn will cause DW_AT_inline attributes to be set.
27238 This happens because at early dwarf generation, there is no
27239 cgraph information, causing cgraph_function_possibly_inlined_p()
27240 to return true. Trick cgraph_function_possibly_inlined_p()
27241 while we generate dwarf early. */
27242 bool save
= symtab
->global_info_ready
;
27243 symtab
->global_info_ready
= true;
27245 /* We don't handle TYPE_DECLs. If required, they'll be reached via
27246 other DECLs and they can point to template types or other things
27247 that dwarf2out can't handle when done via dwarf2out_decl. */
27248 if (TREE_CODE (decl
) != TYPE_DECL
27249 && TREE_CODE (decl
) != PARM_DECL
)
27251 if (TREE_CODE (decl
) == FUNCTION_DECL
)
27253 tree save_fndecl
= current_function_decl
;
27255 /* For nested functions, make sure we have DIEs for the parents first
27256 so that all nested DIEs are generated at the proper scope in the
27258 tree context
= decl_function_context (decl
);
27259 if (context
!= NULL
)
27261 dw_die_ref context_die
= lookup_decl_die (context
);
27262 current_function_decl
= context
;
27264 /* Avoid emitting DIEs multiple times, but still process CONTEXT
27265 enough so that it lands in its own context. This avoids type
27266 pruning issues later on. */
27267 if (context_die
== NULL
|| is_declaration_die (context_die
))
27268 dwarf2out_early_global_decl (context
);
27271 /* Emit an abstract origin of a function first. This happens
27272 with C++ constructor clones for example and makes
27273 dwarf2out_abstract_function happy which requires the early
27274 DIE of the abstract instance to be present. */
27275 tree origin
= DECL_ABSTRACT_ORIGIN (decl
);
27276 dw_die_ref origin_die
;
27278 /* Do not emit the DIE multiple times but make sure to
27279 process it fully here in case we just saw a declaration. */
27280 && ((origin_die
= lookup_decl_die (origin
)) == NULL
27281 || is_declaration_die (origin_die
)))
27283 current_function_decl
= origin
;
27284 dwarf2out_decl (origin
);
27287 /* Emit the DIE for decl but avoid doing that multiple times. */
27288 dw_die_ref old_die
;
27289 if ((old_die
= lookup_decl_die (decl
)) == NULL
27290 || is_declaration_die (old_die
))
27292 current_function_decl
= decl
;
27293 dwarf2out_decl (decl
);
27296 current_function_decl
= save_fndecl
;
27299 dwarf2out_decl (decl
);
27301 symtab
->global_info_ready
= save
;
27304 /* Return whether EXPR is an expression with the following pattern:
27305 INDIRECT_REF (NOP_EXPR (INTEGER_CST)). */
27308 is_trivial_indirect_ref (tree expr
)
27310 if (expr
== NULL_TREE
|| TREE_CODE (expr
) != INDIRECT_REF
)
27313 tree nop
= TREE_OPERAND (expr
, 0);
27314 if (nop
== NULL_TREE
|| TREE_CODE (nop
) != NOP_EXPR
)
27317 tree int_cst
= TREE_OPERAND (nop
, 0);
27318 return int_cst
!= NULL_TREE
&& TREE_CODE (int_cst
) == INTEGER_CST
;
27321 /* Output debug information for global decl DECL. Called from
27322 toplev.cc after compilation proper has finished. */
27325 dwarf2out_late_global_decl (tree decl
)
27327 /* Fill-in any location information we were unable to determine
27328 on the first pass. */
27331 dw_die_ref die
= lookup_decl_die (decl
);
27333 /* We may have to generate full debug late for LTO in case debug
27334 was not enabled at compile-time or the target doesn't support
27335 the LTO early debug scheme. */
27336 if (! die
&& in_lto_p
27337 /* Function scope variables are emitted when emitting the
27338 DIE for the function. */
27339 && ! local_function_static (decl
))
27340 dwarf2out_decl (decl
);
27343 /* We get called via the symtab code invoking late_global_decl
27344 for symbols that are optimized out.
27346 Do not add locations for those, except if they have a
27347 DECL_VALUE_EXPR, in which case they are relevant for debuggers.
27348 Still don't add a location if the DECL_VALUE_EXPR is not a trivial
27349 INDIRECT_REF expression, as this could generate relocations to
27350 text symbols in LTO object files, which is invalid. */
27351 varpool_node
*node
= varpool_node::get (decl
);
27352 if ((! node
|| ! node
->definition
)
27353 && ! (DECL_HAS_VALUE_EXPR_P (decl
)
27354 && is_trivial_indirect_ref (DECL_VALUE_EXPR (decl
))))
27355 tree_add_const_value_attribute_for_decl (die
, decl
);
27357 add_location_or_const_value_attribute (die
, decl
, false);
27362 /* Output debug information for type decl DECL. Called from toplev.cc
27363 and from language front ends (to record built-in types). */
27365 dwarf2out_type_decl (tree decl
, int local
)
27370 dwarf2out_decl (decl
);
27374 /* Output debug information for imported module or decl DECL.
27375 NAME is non-NULL name in the lexical block if the decl has been renamed.
27376 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
27377 that DECL belongs to.
27378 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
27380 dwarf2out_imported_module_or_decl_1 (tree decl
,
27382 tree lexical_block
,
27383 dw_die_ref lexical_block_die
)
27385 expanded_location xloc
;
27386 dw_die_ref imported_die
= NULL
;
27387 dw_die_ref at_import_die
;
27389 if (TREE_CODE (decl
) == IMPORTED_DECL
)
27391 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
27392 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
27396 xloc
= expand_location (input_location
);
27398 if (TREE_CODE (decl
) == TYPE_DECL
)
27400 at_import_die
= force_type_die (TREE_TYPE (decl
));
27401 /* For namespace N { typedef void T; } using N::T; base_type_die
27402 returns NULL, but DW_TAG_imported_declaration requires
27403 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
27404 if (!at_import_die
)
27406 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
27407 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
27408 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
27409 gcc_assert (at_import_die
);
27414 at_import_die
= lookup_decl_die (decl
);
27415 if (!at_import_die
)
27417 /* If we're trying to avoid duplicate debug info, we may not have
27418 emitted the member decl for this field. Emit it now. */
27419 if (TREE_CODE (decl
) == FIELD_DECL
)
27421 tree type
= DECL_CONTEXT (decl
);
27423 if (TYPE_CONTEXT (type
)
27424 && TYPE_P (TYPE_CONTEXT (type
))
27425 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
27426 DINFO_USAGE_DIR_USE
))
27428 gen_type_die_for_member (type
, decl
,
27429 get_context_die (TYPE_CONTEXT (type
)));
27431 if (TREE_CODE (decl
) == CONST_DECL
)
27433 /* Individual enumerators of an enum type do not get output here
27434 (see gen_decl_die), so we cannot call force_decl_die. */
27435 if (!is_fortran () && !is_ada () && !is_dlang ())
27438 if (TREE_CODE (decl
) == NAMELIST_DECL
)
27439 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
27440 get_context_die (DECL_CONTEXT (decl
)),
27443 at_import_die
= force_decl_die (decl
);
27447 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
27449 if (dwarf_version
>= 3 || !dwarf_strict
)
27450 imported_die
= new_die (DW_TAG_imported_module
,
27457 imported_die
= new_die (DW_TAG_imported_declaration
,
27461 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
27462 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
27463 if (debug_column_info
&& xloc
.column
)
27464 add_AT_unsigned (imported_die
, DW_AT_decl_column
, xloc
.column
);
27466 add_AT_string (imported_die
, DW_AT_name
,
27467 IDENTIFIER_POINTER (name
));
27468 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
27471 /* Output debug information for imported module or decl DECL.
27472 NAME is non-NULL name in context if the decl has been renamed.
27473 CHILD is true if decl is one of the renamed decls as part of
27474 importing whole module.
27475 IMPLICIT is set if this hook is called for an implicit import
27476 such as inline namespace. */
27479 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
27480 bool child
, bool implicit
)
27482 /* dw_die_ref at_import_die; */
27483 dw_die_ref scope_die
;
27485 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
27490 /* For DWARF5, just DW_AT_export_symbols on the DW_TAG_namespace
27491 should be enough, for DWARF4 and older even if we emit as extension
27492 DW_AT_export_symbols add the implicit DW_TAG_imported_module anyway
27493 for the benefit of consumers unaware of DW_AT_export_symbols. */
27495 && dwarf_version
>= 5
27496 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
27497 DW_AT_export_symbols
) == 1)
27502 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
27503 We need decl DIE for reference and scope die. First, get DIE for the decl
27506 /* Get the scope die for decl context. Use comp_unit_die for global module
27507 or decl. If die is not found for non globals, force new die. */
27509 && TYPE_P (context
)
27510 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
27513 scope_die
= get_context_die (context
);
27517 /* DW_TAG_imported_module was introduced in the DWARFv3 specification, so
27518 there is nothing we can do, here. */
27519 if (dwarf_version
< 3 && dwarf_strict
)
27522 gcc_assert (scope_die
->die_child
);
27523 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
27524 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
27525 scope_die
= scope_die
->die_child
;
27528 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
27529 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
27532 /* Output debug information for namelists. */
27535 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
27537 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
27541 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
27544 gcc_assert (scope_die
!= NULL
);
27545 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
27546 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
27548 /* If there are no item_decls, we have a nondefining namelist, e.g.
27549 with USE association; hence, set DW_AT_declaration. */
27550 if (item_decls
== NULL_TREE
)
27552 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
27556 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
27558 nml_item_ref_die
= lookup_decl_die (value
);
27559 if (!nml_item_ref_die
)
27560 nml_item_ref_die
= force_decl_die (value
);
27562 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
27563 add_AT_die_ref (nml_item_die
, DW_AT_namelist_item
, nml_item_ref_die
);
27569 /* Write the debugging output for DECL and return the DIE. */
27572 dwarf2out_decl (tree decl
)
27574 dw_die_ref context_die
= comp_unit_die ();
27576 switch (TREE_CODE (decl
))
27581 case FUNCTION_DECL
:
27582 /* If we're a nested function, initially use a parent of NULL; if we're
27583 a plain function, this will be fixed up in decls_for_scope. If
27584 we're a method, it will be ignored, since we already have a DIE.
27585 Avoid doing this late though since clones of class methods may
27586 otherwise end up in limbo and create type DIEs late. */
27588 && decl_function_context (decl
)
27589 /* But if we're in terse mode, we don't care about scope. */
27590 && debug_info_level
> DINFO_LEVEL_TERSE
)
27591 context_die
= NULL
;
27595 /* For local statics lookup proper context die. */
27596 if (local_function_static (decl
))
27597 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
27599 /* If we are in terse mode, don't generate any DIEs to represent any
27600 variable declarations or definitions unless it is external. */
27601 if (debug_info_level
< DINFO_LEVEL_TERSE
27602 || (debug_info_level
== DINFO_LEVEL_TERSE
27603 && !TREE_PUBLIC (decl
)))
27608 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
27610 if (!is_fortran () && !is_ada () && !is_dlang ())
27612 if (TREE_STATIC (decl
) && decl_function_context (decl
))
27613 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
27616 case NAMESPACE_DECL
:
27617 case IMPORTED_DECL
:
27618 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
27620 if (lookup_decl_die (decl
) != NULL
)
27625 /* Don't emit stubs for types unless they are needed by other DIEs. */
27626 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
27629 /* Don't bother trying to generate any DIEs to represent any of the
27630 normal built-in types for the language we are compiling. */
27631 if (DECL_IS_UNDECLARED_BUILTIN (decl
))
27634 /* If we are in terse mode, don't generate any DIEs for types. */
27635 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
27638 /* If we're a function-scope tag, initially use a parent of NULL;
27639 this will be fixed up in decls_for_scope. */
27640 if (decl_function_context (decl
))
27641 context_die
= NULL
;
27645 case NAMELIST_DECL
:
27652 gen_decl_die (decl
, NULL
, NULL
, context_die
);
27656 dw_die_ref die
= lookup_decl_die (decl
);
27662 /* Write the debugging output for DECL. */
27665 dwarf2out_function_decl (tree decl
)
27667 dwarf2out_decl (decl
);
27668 call_arg_locations
= NULL
;
27669 call_arg_loc_last
= NULL
;
27670 call_site_count
= -1;
27671 tail_call_site_count
= -1;
27672 decl_loc_table
->empty ();
27673 cached_dw_loc_list_table
->empty ();
27676 /* Output a marker (i.e. a label) for the beginning of the generated code for
27677 a lexical block. */
27680 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
27681 unsigned int blocknum
)
27683 switch_to_section (current_function_section ());
27684 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
27687 /* Output a marker (i.e. a label) for the end of the generated code for a
27691 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
27693 switch_to_section (current_function_section ());
27694 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
27697 /* Returns true if it is appropriate not to emit any debugging
27698 information for BLOCK, because it doesn't contain any instructions.
27700 Don't allow this for blocks with nested functions or local classes
27701 as we would end up with orphans, and in the presence of scheduling
27702 we may end up calling them anyway. */
27705 dwarf2out_ignore_block (const_tree block
)
27710 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
27711 if (TREE_CODE (decl
) == FUNCTION_DECL
27712 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
27714 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
27716 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
27717 if (TREE_CODE (decl
) == FUNCTION_DECL
27718 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
27725 /* Hash table routines for file_hash. */
27728 dwarf_file_hasher::equal (dwarf_file_data
*p1
, const char *p2
)
27730 return filename_cmp (p1
->key
, p2
) == 0;
27734 dwarf_file_hasher::hash (dwarf_file_data
*p
)
27736 return htab_hash_string (p
->key
);
27739 /* Lookup FILE_NAME (in the list of filenames that we know about here in
27740 dwarf2out.cc) and return its "index". The index of each (known) filename is
27741 just a unique number which is associated with only that one filename. We
27742 need such numbers for the sake of generating labels (in the .debug_sfnames
27743 section) and references to those files numbers (in the .debug_srcinfo
27744 and .debug_macinfo sections). If the filename given as an argument is not
27745 found in our current list, add it to the list and assign it the next
27746 available unique index number. */
27748 static struct dwarf_file_data
*
27749 lookup_filename (const char *file_name
)
27751 struct dwarf_file_data
* created
;
27757 file_name
= "<stdin>";
27759 dwarf_file_data
**slot
27760 = file_table
->find_slot_with_hash (file_name
, htab_hash_string (file_name
),
27765 created
= ggc_alloc
<dwarf_file_data
> ();
27766 created
->key
= file_name
;
27767 created
->filename
= remap_debug_filename (file_name
);
27768 created
->emitted_number
= 0;
27773 /* If the assembler will construct the file table, then translate the compiler
27774 internal file table number into the assembler file table number, and emit
27775 a .file directive if we haven't already emitted one yet. The file table
27776 numbers are different because we prune debug info for unused variables and
27777 types, which may include filenames. */
27780 maybe_emit_file (struct dwarf_file_data
* fd
)
27782 if (! fd
->emitted_number
)
27784 if (last_emitted_file
)
27785 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
27787 fd
->emitted_number
= 1;
27788 last_emitted_file
= fd
;
27790 if (output_asm_line_debug_info ())
27792 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
27793 output_quoted_string (asm_out_file
, fd
->filename
);
27794 fputc ('\n', asm_out_file
);
27798 return fd
->emitted_number
;
27801 /* Schedule generation of a DW_AT_const_value attribute to DIE.
27802 That generation should happen after function debug info has been
27803 generated. The value of the attribute is the constant value of ARG. */
27806 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
27808 die_arg_entry entry
;
27813 gcc_assert (early_dwarf
);
27815 if (!tmpl_value_parm_die_table
)
27816 vec_alloc (tmpl_value_parm_die_table
, 32);
27820 vec_safe_push (tmpl_value_parm_die_table
, entry
);
27823 /* Return TRUE if T is an instance of generic type, FALSE
27827 generic_type_p (tree t
)
27829 if (t
== NULL_TREE
|| !TYPE_P (t
))
27831 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
27834 /* Schedule the generation of the generic parameter dies for the
27835 instance of generic type T. The proper generation itself is later
27836 done by gen_scheduled_generic_parms_dies. */
27839 schedule_generic_params_dies_gen (tree t
)
27841 if (!generic_type_p (t
))
27844 gcc_assert (early_dwarf
);
27846 if (!generic_type_instances
)
27847 vec_alloc (generic_type_instances
, 256);
27849 vec_safe_push (generic_type_instances
, t
);
27852 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
27853 by append_entry_to_tmpl_value_parm_die_table. This function must
27854 be called after function DIEs have been generated. */
27857 gen_remaining_tmpl_value_param_die_attribute (void)
27859 if (tmpl_value_parm_die_table
)
27864 /* We do this in two phases - first get the cases we can
27865 handle during early-finish, preserving those we cannot
27866 (containing symbolic constants where we don't yet know
27867 whether we are going to output the referenced symbols).
27868 For those we try again at late-finish. */
27870 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
27872 if (!e
->die
->removed
27873 && !tree_add_const_value_attribute (e
->die
, e
->arg
))
27875 dw_loc_descr_ref loc
= NULL
;
27877 && (dwarf_version
>= 5 || !dwarf_strict
))
27878 loc
= loc_descriptor_from_tree (e
->arg
, 2, NULL
);
27880 add_AT_loc (e
->die
, DW_AT_location
, loc
);
27882 (*tmpl_value_parm_die_table
)[j
++] = *e
;
27885 tmpl_value_parm_die_table
->truncate (j
);
27889 /* Generate generic parameters DIEs for instances of generic types
27890 that have been previously scheduled by
27891 schedule_generic_params_dies_gen. This function must be called
27892 after all the types of the CU have been laid out. */
27895 gen_scheduled_generic_parms_dies (void)
27900 if (!generic_type_instances
)
27903 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
27904 if (COMPLETE_TYPE_P (t
))
27905 gen_generic_params_dies (t
);
27907 generic_type_instances
= NULL
;
27911 /* Replace DW_AT_name for the decl with name. */
27914 dwarf2out_set_name (tree decl
, tree name
)
27917 dw_attr_node
*attr
;
27920 die
= TYPE_SYMTAB_DIE (decl
);
27924 dname
= dwarf2_name (name
, 0);
27928 attr
= get_AT (die
, DW_AT_name
);
27931 struct indirect_string_node
*node
;
27933 node
= find_AT_string (dname
);
27934 /* replace the string. */
27935 attr
->dw_attr_val
.v
.val_str
= node
;
27939 add_name_attribute (die
, dname
);
27942 /* True if before or during processing of the first function being emitted. */
27943 static bool in_first_function_p
= true;
27944 /* True if loc_note during dwarf2out_var_location call might still be
27945 before first real instruction at address equal to .Ltext0. */
27946 static bool maybe_at_text_label_p
= true;
27947 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
27948 static unsigned int first_loclabel_num_not_at_text_label
;
27950 /* Look ahead for a real insn. */
27953 dwarf2out_next_real_insn (rtx_insn
*loc_note
)
27955 rtx_insn
*next_real
= NEXT_INSN (loc_note
);
27958 if (INSN_P (next_real
))
27961 next_real
= NEXT_INSN (next_real
);
27966 /* Called by the final INSN scan whenever we see a var location. We
27967 use it to drop labels in the right places, and throw the location in
27968 our lookup table. */
27971 dwarf2out_var_location (rtx_insn
*loc_note
)
27973 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
27974 struct var_loc_node
*newloc
;
27975 rtx_insn
*next_real
;
27976 rtx_insn
*call_insn
= NULL
;
27977 static const char *last_label
;
27978 static const char *last_postcall_label
;
27979 static bool last_in_cold_section_p
;
27980 static rtx_insn
*expected_next_loc_note
;
27983 var_loc_view view
= 0;
27985 if (!NOTE_P (loc_note
))
27987 if (CALL_P (loc_note
))
27989 maybe_reset_location_view (loc_note
, cur_line_info_table
);
27991 if (SIBLING_CALL_P (loc_note
))
27992 tail_call_site_count
++;
27993 if (find_reg_note (loc_note
, REG_CALL_ARG_LOCATION
, NULL_RTX
))
27995 call_insn
= loc_note
;
27999 next_real
= dwarf2out_next_real_insn (call_insn
);
28000 cached_next_real_insn
= NULL
;
28003 if (optimize
== 0 && !flag_var_tracking
)
28005 /* When the var-tracking pass is not running, there is no note
28006 for indirect calls whose target is compile-time known. In this
28007 case, process such calls specifically so that we generate call
28008 sites for them anyway. */
28009 rtx x
= PATTERN (loc_note
);
28010 if (GET_CODE (x
) == PARALLEL
)
28011 x
= XVECEXP (x
, 0, 0);
28012 if (GET_CODE (x
) == SET
)
28014 if (GET_CODE (x
) == CALL
)
28017 || GET_CODE (XEXP (x
, 0)) != SYMBOL_REF
28018 || !SYMBOL_REF_DECL (XEXP (x
, 0))
28019 || (TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0)))
28022 call_insn
= loc_note
;
28026 next_real
= dwarf2out_next_real_insn (call_insn
);
28027 cached_next_real_insn
= NULL
;
28032 else if (!debug_variable_location_views
)
28033 gcc_unreachable ();
28035 maybe_reset_location_view (loc_note
, cur_line_info_table
);
28040 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
28041 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
28044 /* Optimize processing a large consecutive sequence of location
28045 notes so we don't spend too much time in next_real_insn. If the
28046 next insn is another location note, remember the next_real_insn
28047 calculation for next time. */
28048 next_real
= cached_next_real_insn
;
28051 if (expected_next_loc_note
!= loc_note
)
28056 next_real
= dwarf2out_next_real_insn (loc_note
);
28060 rtx_insn
*next_note
= NEXT_INSN (loc_note
);
28061 while (next_note
!= next_real
)
28063 if (! next_note
->deleted ()
28064 && NOTE_P (next_note
)
28065 && NOTE_KIND (next_note
) == NOTE_INSN_VAR_LOCATION
)
28067 next_note
= NEXT_INSN (next_note
);
28070 if (next_note
== next_real
)
28071 cached_next_real_insn
= NULL
;
28074 expected_next_loc_note
= next_note
;
28075 cached_next_real_insn
= next_real
;
28079 cached_next_real_insn
= NULL
;
28081 /* If there are no instructions which would be affected by this note,
28082 don't do anything. */
28084 && next_real
== NULL_RTX
28085 && !NOTE_DURING_CALL_P (loc_note
))
28090 if (next_real
== NULL_RTX
)
28091 next_real
= get_last_insn ();
28093 /* If there were any real insns between note we processed last time
28094 and this note (or if it is the first note), clear
28095 last_{,postcall_}label so that they are not reused this time. */
28096 if (last_var_location_insn
== NULL_RTX
28097 || last_var_location_insn
!= next_real
28098 || last_in_cold_section_p
!= in_cold_section_p
)
28101 last_postcall_label
= NULL
;
28107 = NOTE_DURING_CALL_P (loc_note
) ? last_postcall_label
: last_label
;
28108 view
= cur_line_info_table
->view
;
28109 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
28110 newloc
= add_var_loc_to_decl (decl
, loc_note
, label
, view
);
28111 if (newloc
== NULL
)
28120 /* If there were no real insns between note we processed last time
28121 and this note, use the label we emitted last time. Otherwise
28122 create a new label and emit it. */
28123 if (last_label
== NULL
)
28125 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
28126 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
28128 last_label
= ggc_strdup (loclabel
);
28129 /* See if loclabel might be equal to .Ltext0. If yes,
28130 bump first_loclabel_num_not_at_text_label. */
28131 if (!have_multiple_function_sections
28132 && in_first_function_p
28133 && maybe_at_text_label_p
)
28135 static rtx_insn
*last_start
;
28137 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
28138 if (insn
== last_start
)
28140 else if (!NONDEBUG_INSN_P (insn
))
28144 rtx body
= PATTERN (insn
);
28145 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
28147 /* Inline asm could occupy zero bytes. */
28148 else if (GET_CODE (body
) == ASM_INPUT
28149 || asm_noperands (body
) >= 0)
28151 #ifdef HAVE_ATTR_length /* ??? We don't include insn-attr.h. */
28152 else if (HAVE_ATTR_length
&& get_attr_min_length (insn
) == 0)
28157 /* Assume insn has non-zero length. */
28158 maybe_at_text_label_p
= false;
28162 if (maybe_at_text_label_p
)
28164 last_start
= loc_note
;
28165 first_loclabel_num_not_at_text_label
= loclabel_num
;
28170 gcc_assert ((loc_note
== NULL_RTX
&& call_insn
!= NULL_RTX
)
28171 || (loc_note
!= NULL_RTX
&& call_insn
== NULL_RTX
));
28175 struct call_arg_loc_node
*ca_loc
28176 = ggc_cleared_alloc
<call_arg_loc_node
> ();
28177 rtx_insn
*prev
= call_insn
;
28179 ca_loc
->call_arg_loc_note
28180 = find_reg_note (call_insn
, REG_CALL_ARG_LOCATION
, NULL_RTX
);
28181 ca_loc
->next
= NULL
;
28182 ca_loc
->label
= last_label
;
28185 || (NONJUMP_INSN_P (prev
)
28186 && GET_CODE (PATTERN (prev
)) == SEQUENCE
28187 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
28188 if (!CALL_P (prev
))
28189 prev
= as_a
<rtx_sequence
*> (PATTERN (prev
))->insn (0);
28190 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
28192 /* Look for a SYMBOL_REF in the "prev" instruction. */
28193 rtx x
= get_call_rtx_from (prev
);
28196 /* Try to get the call symbol, if any. */
28197 if (MEM_P (XEXP (x
, 0)))
28199 /* First, look for a memory access to a symbol_ref. */
28200 if (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
28201 && SYMBOL_REF_DECL (XEXP (x
, 0))
28202 && TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0))) == FUNCTION_DECL
)
28203 ca_loc
->symbol_ref
= XEXP (x
, 0);
28204 /* Otherwise, look at a compile-time known user-level function
28208 && TREE_CODE (MEM_EXPR (x
)) == FUNCTION_DECL
)
28209 ca_loc
->symbol_ref
= XEXP (DECL_RTL (MEM_EXPR (x
)), 0);
28212 ca_loc
->block
= insn_scope (prev
);
28213 if (call_arg_locations
)
28214 call_arg_loc_last
->next
= ca_loc
;
28216 call_arg_locations
= ca_loc
;
28217 call_arg_loc_last
= ca_loc
;
28219 else if (loc_note
!= NULL_RTX
&& !NOTE_DURING_CALL_P (loc_note
))
28221 newloc
->label
= last_label
;
28222 newloc
->view
= view
;
28226 if (!last_postcall_label
)
28228 sprintf (loclabel
, "%s-1", last_label
);
28229 last_postcall_label
= ggc_strdup (loclabel
);
28231 newloc
->label
= last_postcall_label
;
28232 /* ??? This view is at last_label, not last_label-1, but we
28233 could only assume view at last_label-1 is zero if we could
28234 assume calls always have length greater than one. This is
28235 probably true in general, though there might be a rare
28236 exception to this rule, e.g. if a call insn is optimized out
28237 by target magic. Then, even the -1 in the label will be
28238 wrong, which might invalidate the range. Anyway, using view,
28239 though technically possibly incorrect, will work as far as
28240 ranges go: since L-1 is in the middle of the call insn,
28241 (L-1).0 and (L-1).V shouldn't make any difference, and having
28242 the loclist entry refer to the .loc entry might be useful, so
28243 leave it like this. */
28244 newloc
->view
= view
;
28247 if (var_loc_p
&& flag_debug_asm
)
28249 const char *name
, *sep
, *patstr
;
28250 if (decl
&& DECL_NAME (decl
))
28251 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
28254 if (NOTE_VAR_LOCATION_LOC (loc_note
))
28257 patstr
= str_pattern_slim (NOTE_VAR_LOCATION_LOC (loc_note
));
28264 fprintf (asm_out_file
, "\t%s DEBUG %s%s%s\n", ASM_COMMENT_START
,
28265 name
, sep
, patstr
);
28268 last_var_location_insn
= next_real
;
28269 last_in_cold_section_p
= in_cold_section_p
;
28272 /* Check whether BLOCK, a lexical block, is nested within OUTER, or is
28273 OUTER itself. If BOTHWAYS, check not only that BLOCK can reach
28274 OUTER through BLOCK_SUPERCONTEXT links, but also that there is a
28275 path from OUTER to BLOCK through BLOCK_SUBBLOCKs and
28276 BLOCK_FRAGMENT_ORIGIN links. */
28278 block_within_block_p (tree block
, tree outer
, bool bothways
)
28280 if (block
== outer
)
28283 /* Quickly check that OUTER is up BLOCK's supercontext chain. */
28284 for (tree context
= BLOCK_SUPERCONTEXT (block
);
28286 context
= BLOCK_SUPERCONTEXT (context
))
28287 if (!context
|| TREE_CODE (context
) != BLOCK
)
28293 /* Now check that each block is actually referenced by its
28295 for (tree context
= BLOCK_SUPERCONTEXT (block
); ;
28296 context
= BLOCK_SUPERCONTEXT (context
))
28298 if (BLOCK_FRAGMENT_ORIGIN (context
))
28300 gcc_assert (!BLOCK_SUBBLOCKS (context
));
28301 context
= BLOCK_FRAGMENT_ORIGIN (context
);
28303 for (tree sub
= BLOCK_SUBBLOCKS (context
);
28305 sub
= BLOCK_CHAIN (sub
))
28308 if (context
== outer
)
28315 /* Called during final while assembling the marker of the entry point
28316 for an inlined function. */
28319 dwarf2out_inline_entry (tree block
)
28321 gcc_assert (debug_inline_points
);
28323 /* If we can't represent it, don't bother. */
28324 if (!(dwarf_version
>= 3 || !dwarf_strict
))
28327 gcc_assert (DECL_P (block_ultimate_origin (block
)));
28329 /* Sanity check the block tree. This would catch a case in which
28330 BLOCK got removed from the tree reachable from the outermost
28331 lexical block, but got retained in markers. It would still link
28332 back to its parents, but some ancestor would be missing a link
28333 down the path to the sub BLOCK. If the block got removed, its
28334 BLOCK_NUMBER will not be a usable value. */
28336 gcc_assert (block_within_block_p (block
,
28337 DECL_INITIAL (current_function_decl
),
28340 gcc_assert (inlined_function_outer_scope_p (block
));
28341 gcc_assert (!lookup_block_die (block
));
28343 if (BLOCK_FRAGMENT_ORIGIN (block
))
28344 block
= BLOCK_FRAGMENT_ORIGIN (block
);
28345 /* Can the entry point ever not be at the beginning of an
28346 unfragmented lexical block? */
28347 else if (!(BLOCK_FRAGMENT_CHAIN (block
)
28348 || (cur_line_info_table
28349 && !ZERO_VIEW_P (cur_line_info_table
->view
))))
28352 if (!inline_entry_data_table
)
28353 inline_entry_data_table
28354 = hash_table
<inline_entry_data_hasher
>::create_ggc (10);
28357 inline_entry_data
**iedp
28358 = inline_entry_data_table
->find_slot_with_hash (block
,
28359 htab_hash_pointer (block
),
28362 /* ??? Ideally, we'd record all entry points for the same inlined
28363 function (some may have been duplicated by e.g. unrolling), but
28364 we have no way to represent that ATM. */
28367 inline_entry_data
*ied
= *iedp
= ggc_cleared_alloc
<inline_entry_data
> ();
28368 ied
->block
= block
;
28369 ied
->label_pfx
= BLOCK_INLINE_ENTRY_LABEL
;
28370 ied
->label_num
= BLOCK_NUMBER (block
);
28371 if (cur_line_info_table
)
28372 ied
->view
= cur_line_info_table
->view
;
28374 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_INLINE_ENTRY_LABEL
,
28375 BLOCK_NUMBER (block
));
28378 /* Called from finalize_size_functions for size functions so that their body
28379 can be encoded in the debug info to describe the layout of variable-length
28383 dwarf2out_size_function (tree decl
)
28386 function_to_dwarf_procedure (decl
);
28389 /* Note in one location list that text section has changed. */
28392 var_location_switch_text_section_1 (var_loc_list
**slot
, void *)
28394 var_loc_list
*list
= *slot
;
28396 list
->last_before_switch
28397 = list
->last
->next
? list
->last
->next
: list
->last
;
28401 /* Note in all location lists that text section has changed. */
28404 var_location_switch_text_section (void)
28406 if (decl_loc_table
== NULL
)
28409 decl_loc_table
->traverse
<void *, var_location_switch_text_section_1
> (NULL
);
28412 /* Create a new line number table. */
28414 static dw_line_info_table
*
28415 new_line_info_table (void)
28417 dw_line_info_table
*table
;
28419 table
= ggc_cleared_alloc
<dw_line_info_table
> ();
28420 table
->file_num
= 1;
28421 table
->line_num
= 1;
28422 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
28423 FORCE_RESET_NEXT_VIEW (table
->view
);
28424 table
->symviews_since_reset
= 0;
28429 /* Lookup the "current" table into which we emit line info, so
28430 that we don't have to do it for every source line. */
28433 set_cur_line_info_table (section
*sec
)
28435 dw_line_info_table
*table
;
28437 if (sec
== text_section
)
28438 table
= text_section_line_info
;
28439 else if (sec
== cold_text_section
)
28441 table
= cold_text_section_line_info
;
28444 cold_text_section_line_info
= table
= new_line_info_table ();
28445 table
->end_label
= cold_end_label
;
28450 const char *end_label
;
28452 if (crtl
->has_bb_partition
)
28454 if (in_cold_section_p
)
28455 end_label
= crtl
->subsections
.cold_section_end_label
;
28457 end_label
= crtl
->subsections
.hot_section_end_label
;
28461 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28462 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
28463 current_function_funcdef_no
);
28464 end_label
= ggc_strdup (label
);
28467 table
= new_line_info_table ();
28468 table
->end_label
= end_label
;
28470 vec_safe_push (separate_line_info
, table
);
28473 if (output_asm_line_debug_info ())
28474 table
->is_stmt
= (cur_line_info_table
28475 ? cur_line_info_table
->is_stmt
28476 : DWARF_LINE_DEFAULT_IS_STMT_START
);
28477 cur_line_info_table
= table
;
28481 /* We need to reset the locations at the beginning of each
28482 function. We can't do this in the end_function hook, because the
28483 declarations that use the locations won't have been output when
28484 that hook is called. Also compute have_multiple_function_sections here. */
28487 dwarf2out_begin_function (tree fun
)
28489 section
*sec
= function_section (fun
);
28491 if (sec
!= text_section
)
28492 have_multiple_function_sections
= true;
28494 if (crtl
->has_bb_partition
&& !cold_text_section
)
28496 gcc_assert (current_function_decl
== fun
);
28497 cold_text_section
= unlikely_text_section ();
28498 switch_to_section (cold_text_section
);
28499 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
28500 switch_to_section (sec
);
28503 call_site_count
= 0;
28504 tail_call_site_count
= 0;
28506 set_cur_line_info_table (sec
);
28507 FORCE_RESET_NEXT_VIEW (cur_line_info_table
->view
);
28510 /* Helper function of dwarf2out_end_function, called only after emitting
28511 the very first function into assembly. Check if some .debug_loc range
28512 might end with a .LVL* label that could be equal to .Ltext0.
28513 In that case we must force using absolute addresses in .debug_loc ranges,
28514 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
28515 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
28517 Set have_multiple_function_sections to true in that case and
28518 terminate htab traversal. */
28521 find_empty_loc_ranges_at_text_label (var_loc_list
**slot
, int)
28523 var_loc_list
*entry
= *slot
;
28524 struct var_loc_node
*node
;
28526 node
= entry
->first
;
28527 if (node
&& node
->next
&& node
->next
->label
)
28530 const char *label
= node
->next
->label
;
28531 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
28533 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
28535 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
28536 if (strcmp (label
, loclabel
) == 0)
28538 have_multiple_function_sections
= true;
28546 /* Hook called after emitting a function into assembly.
28547 This does something only for the very first function emitted. */
28550 dwarf2out_end_function (unsigned int)
28552 if (in_first_function_p
28553 && !have_multiple_function_sections
28554 && first_loclabel_num_not_at_text_label
28556 decl_loc_table
->traverse
<int, find_empty_loc_ranges_at_text_label
> (0);
28557 in_first_function_p
= false;
28558 maybe_at_text_label_p
= false;
28561 /* Temporary holder for dwarf2out_register_main_translation_unit. Used to let
28562 front-ends register a translation unit even before dwarf2out_init is
28564 static tree main_translation_unit
= NULL_TREE
;
28566 /* Hook called by front-ends after they built their main translation unit.
28567 Associate comp_unit_die to UNIT. */
28570 dwarf2out_register_main_translation_unit (tree unit
)
28572 gcc_assert (TREE_CODE (unit
) == TRANSLATION_UNIT_DECL
28573 && main_translation_unit
== NULL_TREE
);
28574 main_translation_unit
= unit
;
28575 /* If dwarf2out_init has not been called yet, it will perform the association
28576 itself looking at main_translation_unit. */
28577 if (decl_die_table
!= NULL
)
28578 equate_decl_number_to_die (unit
, comp_unit_die ());
28581 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
28584 push_dw_line_info_entry (dw_line_info_table
*table
,
28585 enum dw_line_info_opcode opcode
, unsigned int val
)
28587 dw_line_info_entry e
;
28590 vec_safe_push (table
->entries
, e
);
28593 /* Output a label to mark the beginning of a source code line entry
28594 and record information relating to this source line, in
28595 'line_info_table' for later output of the .debug_line section. */
28596 /* ??? The discriminator parameter ought to be unsigned. */
28599 dwarf2out_source_line (unsigned int line
, unsigned int column
,
28600 const char *filename
,
28601 int discriminator
, bool is_stmt
)
28603 unsigned int file_num
;
28604 dw_line_info_table
*table
;
28605 static var_loc_view lvugid
;
28607 /* 'line_info_table' information gathering is not needed when the debug
28608 info level is set to the lowest value. Also, the current DWARF-based
28609 debug formats do not use this info. */
28610 if (debug_info_level
< DINFO_LEVEL_TERSE
|| !dwarf_debuginfo_p ())
28613 table
= cur_line_info_table
;
28617 if (debug_variable_location_views
28618 && output_asm_line_debug_info ()
28619 && table
&& !RESETTING_VIEW_P (table
->view
))
28621 /* If we're using the assembler to compute view numbers, we
28622 can't issue a .loc directive for line zero, so we can't
28623 get a view number at this point. We might attempt to
28624 compute it from the previous view, or equate it to a
28625 subsequent view (though it might not be there!), but
28626 since we're omitting the line number entry, we might as
28627 well omit the view number as well. That means pretending
28628 it's a view number zero, which might very well turn out
28629 to be correct. ??? Extend the assembler so that the
28630 compiler could emit e.g. ".locview .LVU#", to output a
28631 view without changing line number information. We'd then
28632 have to count it in symviews_since_reset; when it's omitted,
28633 it doesn't count. */
28635 zero_view_p
= BITMAP_GGC_ALLOC ();
28636 bitmap_set_bit (zero_view_p
, table
->view
);
28637 if (flag_debug_asm
)
28639 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28640 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", table
->view
);
28641 fprintf (asm_out_file
, "\t%s line 0, omitted view ",
28642 ASM_COMMENT_START
);
28643 assemble_name (asm_out_file
, label
);
28644 putc ('\n', asm_out_file
);
28646 table
->view
= ++lvugid
;
28651 /* The discriminator column was added in dwarf4. Simplify the below
28652 by simply removing it if we're not supposed to output it. */
28653 if (dwarf_version
< 4 && dwarf_strict
)
28656 if (!debug_column_info
)
28659 file_num
= maybe_emit_file (lookup_filename (filename
));
28661 /* ??? TODO: Elide duplicate line number entries. Traditionally,
28662 the debugger has used the second (possibly duplicate) line number
28663 at the beginning of the function to mark the end of the prologue.
28664 We could eliminate any other duplicates within the function. For
28665 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
28666 that second line number entry. */
28667 /* Recall that this end-of-prologue indication is *not* the same thing
28668 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
28669 to which the hook corresponds, follows the last insn that was
28670 emitted by gen_prologue. What we need is to precede the first insn
28671 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
28672 insn that corresponds to something the user wrote. These may be
28673 very different locations once scheduling is enabled. */
28675 if (0 && file_num
== table
->file_num
28676 && line
== table
->line_num
28677 && column
== table
->column_num
28678 && discriminator
== table
->discrim_num
28679 && is_stmt
== table
->is_stmt
)
28682 switch_to_section (current_function_section ());
28684 /* If requested, emit something human-readable. */
28685 if (flag_debug_asm
)
28687 if (debug_column_info
)
28688 fprintf (asm_out_file
, "\t%s %s:%d:%d\n", ASM_COMMENT_START
,
28689 filename
, line
, column
);
28691 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
28695 if (output_asm_line_debug_info ())
28697 /* Emit the .loc directive understood by GNU as. */
28698 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
28699 file_num, line, is_stmt, discriminator */
28700 fputs ("\t.loc ", asm_out_file
);
28701 fprint_ul (asm_out_file
, file_num
);
28702 putc (' ', asm_out_file
);
28703 fprint_ul (asm_out_file
, line
);
28704 putc (' ', asm_out_file
);
28705 fprint_ul (asm_out_file
, column
);
28707 if (is_stmt
!= table
->is_stmt
)
28709 #if HAVE_GAS_LOC_STMT
28710 fputs (" is_stmt ", asm_out_file
);
28711 putc (is_stmt
? '1' : '0', asm_out_file
);
28714 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
28716 gcc_assert (discriminator
> 0);
28717 fputs (" discriminator ", asm_out_file
);
28718 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
28720 if (debug_variable_location_views
)
28722 if (!RESETTING_VIEW_P (table
->view
))
28724 table
->symviews_since_reset
++;
28725 if (table
->symviews_since_reset
> symview_upper_bound
)
28726 symview_upper_bound
= table
->symviews_since_reset
;
28727 /* When we're using the assembler to compute view
28728 numbers, we output symbolic labels after "view" in
28729 .loc directives, and the assembler will set them for
28730 us, so that we can refer to the view numbers in
28731 location lists. The only exceptions are when we know
28732 a view will be zero: "-0" is a forced reset, used
28733 e.g. in the beginning of functions, whereas "0" tells
28734 the assembler to check that there was a PC change
28735 since the previous view, in a way that implicitly
28736 resets the next view. */
28737 fputs (" view ", asm_out_file
);
28738 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28739 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", table
->view
);
28740 assemble_name (asm_out_file
, label
);
28741 table
->view
= ++lvugid
;
28745 table
->symviews_since_reset
= 0;
28746 if (FORCE_RESETTING_VIEW_P (table
->view
))
28747 fputs (" view -0", asm_out_file
);
28749 fputs (" view 0", asm_out_file
);
28750 /* Mark the present view as a zero view. Earlier debug
28751 binds may have already added its id to loclists to be
28752 emitted later, so we can't reuse the id for something
28753 else. However, it's good to know whether a view is
28754 known to be zero, because then we may be able to
28755 optimize out locviews that are all zeros, so take
28756 note of it in zero_view_p. */
28758 zero_view_p
= BITMAP_GGC_ALLOC ();
28759 bitmap_set_bit (zero_view_p
, lvugid
);
28760 table
->view
= ++lvugid
;
28763 putc ('\n', asm_out_file
);
28767 unsigned int label_num
= ++line_info_label_num
;
28769 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
28771 if (debug_variable_location_views
&& !RESETTING_VIEW_P (table
->view
))
28772 push_dw_line_info_entry (table
, LI_adv_address
, label_num
);
28774 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
28775 if (debug_variable_location_views
)
28777 bool resetting
= FORCE_RESETTING_VIEW_P (table
->view
);
28781 if (flag_debug_asm
)
28782 fprintf (asm_out_file
, "\t%s view %s%d\n",
28784 resetting
? "-" : "",
28789 if (file_num
!= table
->file_num
)
28790 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
28791 if (discriminator
!= table
->discrim_num
)
28792 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
28793 if (is_stmt
!= table
->is_stmt
)
28794 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
28795 push_dw_line_info_entry (table
, LI_set_line
, line
);
28796 if (debug_column_info
)
28797 push_dw_line_info_entry (table
, LI_set_column
, column
);
28800 table
->file_num
= file_num
;
28801 table
->line_num
= line
;
28802 table
->column_num
= column
;
28803 table
->discrim_num
= discriminator
;
28804 table
->is_stmt
= is_stmt
;
28805 table
->in_use
= true;
28808 /* Record a source file location for a DECL_IGNORED_P function. */
28811 dwarf2out_set_ignored_loc (unsigned int line
, unsigned int column
,
28812 const char *filename
)
28814 dw_fde_ref fde
= cfun
->fde
;
28816 fde
->ignored_debug
= false;
28817 set_cur_line_info_table (function_section (fde
->decl
));
28819 dwarf2out_source_line (line
, column
, filename
, 0, true);
28822 /* Record the beginning of a new source file. */
28825 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
28827 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28830 e
.code
= DW_MACINFO_start_file
;
28832 e
.info
= ggc_strdup (filename
);
28833 vec_safe_push (macinfo_table
, e
);
28837 /* Record the end of a source file. */
28840 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
28842 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28845 e
.code
= DW_MACINFO_end_file
;
28848 vec_safe_push (macinfo_table
, e
);
28852 /* Called from debug_define in toplev.cc. The `buffer' parameter contains
28853 the tail part of the directive line, i.e. the part which is past the
28854 initial whitespace, #, whitespace, directive-name, whitespace part. */
28857 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
28858 const char *buffer ATTRIBUTE_UNUSED
)
28860 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28863 /* Insert a dummy first entry to be able to optimize the whole
28864 predefined macro block using DW_MACRO_import. */
28865 if (macinfo_table
->is_empty () && lineno
<= 1)
28870 vec_safe_push (macinfo_table
, e
);
28872 e
.code
= DW_MACINFO_define
;
28874 e
.info
= ggc_strdup (buffer
);
28875 vec_safe_push (macinfo_table
, e
);
28879 /* Called from debug_undef in toplev.cc. The `buffer' parameter contains
28880 the tail part of the directive line, i.e. the part which is past the
28881 initial whitespace, #, whitespace, directive-name, whitespace part. */
28884 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
28885 const char *buffer ATTRIBUTE_UNUSED
)
28887 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28890 /* Insert a dummy first entry to be able to optimize the whole
28891 predefined macro block using DW_MACRO_import. */
28892 if (macinfo_table
->is_empty () && lineno
<= 1)
28897 vec_safe_push (macinfo_table
, e
);
28899 e
.code
= DW_MACINFO_undef
;
28901 e
.info
= ggc_strdup (buffer
);
28902 vec_safe_push (macinfo_table
, e
);
28906 /* Helpers to manipulate hash table of CUs. */
28908 struct macinfo_entry_hasher
: nofree_ptr_hash
<macinfo_entry
>
28910 static inline hashval_t
hash (const macinfo_entry
*);
28911 static inline bool equal (const macinfo_entry
*, const macinfo_entry
*);
28915 macinfo_entry_hasher::hash (const macinfo_entry
*entry
)
28917 return htab_hash_string (entry
->info
);
28921 macinfo_entry_hasher::equal (const macinfo_entry
*entry1
,
28922 const macinfo_entry
*entry2
)
28924 return !strcmp (entry1
->info
, entry2
->info
);
28927 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
28929 /* Output a single .debug_macinfo entry. */
28932 output_macinfo_op (macinfo_entry
*ref
)
28936 struct indirect_string_node
*node
;
28937 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28938 struct dwarf_file_data
*fd
;
28942 case DW_MACINFO_start_file
:
28943 fd
= lookup_filename (ref
->info
);
28944 file_num
= maybe_emit_file (fd
);
28945 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
28946 dw2_asm_output_data_uleb128 (ref
->lineno
,
28947 "Included from line number %lu",
28948 (unsigned long) ref
->lineno
);
28949 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
28951 case DW_MACINFO_end_file
:
28952 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
28954 case DW_MACINFO_define
:
28955 case DW_MACINFO_undef
:
28956 len
= strlen (ref
->info
) + 1;
28957 if ((!dwarf_strict
|| dwarf_version
>= 5)
28958 && len
> (size_t) dwarf_offset_size
28959 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
28960 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
28962 if (dwarf_split_debug_info
&& dwarf_version
>= 5)
28963 ref
->code
= ref
->code
== DW_MACINFO_define
28964 ? DW_MACRO_define_strx
: DW_MACRO_undef_strx
;
28966 ref
->code
= ref
->code
== DW_MACINFO_define
28967 ? DW_MACRO_define_strp
: DW_MACRO_undef_strp
;
28968 output_macinfo_op (ref
);
28971 dw2_asm_output_data (1, ref
->code
,
28972 ref
->code
== DW_MACINFO_define
28973 ? "Define macro" : "Undefine macro");
28974 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
28975 (unsigned long) ref
->lineno
);
28976 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
28978 case DW_MACRO_define_strp
:
28979 dw2_asm_output_data (1, ref
->code
, "Define macro strp");
28980 goto do_DW_MACRO_define_strpx
;
28981 case DW_MACRO_undef_strp
:
28982 dw2_asm_output_data (1, ref
->code
, "Undefine macro strp");
28983 goto do_DW_MACRO_define_strpx
;
28984 case DW_MACRO_define_strx
:
28985 dw2_asm_output_data (1, ref
->code
, "Define macro strx");
28986 goto do_DW_MACRO_define_strpx
;
28987 case DW_MACRO_undef_strx
:
28988 dw2_asm_output_data (1, ref
->code
, "Undefine macro strx");
28990 do_DW_MACRO_define_strpx
:
28991 /* NB: dwarf2out_finish performs:
28992 1. save_macinfo_strings
28993 2. hash table traverse of index_string
28994 3. output_macinfo -> output_macinfo_op
28995 4. output_indirect_strings
28996 -> hash table traverse of output_index_string
28998 When output_macinfo_op is called, all index strings have been
28999 added to hash table by save_macinfo_strings and we can't pass
29000 INSERT to find_slot_with_hash which may expand hash table, even
29001 if no insertion is needed, and change hash table traverse order
29002 between index_string and output_index_string. */
29003 node
= find_AT_string (ref
->info
, NO_INSERT
);
29005 && (node
->form
== DW_FORM_strp
29006 || node
->form
== dwarf_FORM (DW_FORM_strx
)));
29007 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
29008 (unsigned long) ref
->lineno
);
29009 if (node
->form
== DW_FORM_strp
)
29010 dw2_asm_output_offset (dwarf_offset_size
, node
->label
,
29011 debug_str_section
, "The macro: \"%s\"",
29014 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
29017 case DW_MACRO_import
:
29018 dw2_asm_output_data (1, ref
->code
, "Import");
29019 ASM_GENERATE_INTERNAL_LABEL (label
,
29020 DEBUG_MACRO_SECTION_LABEL
,
29021 ref
->lineno
+ macinfo_label_base
);
29022 dw2_asm_output_offset (dwarf_offset_size
, label
, NULL
, NULL
);
29025 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
29026 ASM_COMMENT_START
, (unsigned long) ref
->code
);
29031 /* Attempt to make a sequence of define/undef macinfo ops shareable with
29032 other compilation unit .debug_macinfo sections. IDX is the first
29033 index of a define/undef, return the number of ops that should be
29034 emitted in a comdat .debug_macinfo section and emit
29035 a DW_MACRO_import entry referencing it.
29036 If the define/undef entry should be emitted normally, return 0. */
29039 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
29040 macinfo_hash_type
**macinfo_htab
)
29042 macinfo_entry
*first
, *second
, *cur
, *inc
;
29043 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
29044 unsigned char checksum
[16];
29045 struct md5_ctx ctx
;
29046 char *grp_name
, *tail
;
29048 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
29049 macinfo_entry
**slot
;
29051 first
= &(*macinfo_table
)[idx
];
29052 second
= &(*macinfo_table
)[idx
+ 1];
29054 /* Optimize only if there are at least two consecutive define/undef ops,
29055 and either all of them are before first DW_MACINFO_start_file
29056 with lineno {0,1} (i.e. predefined macro block), or all of them are
29057 in some included header file. */
29058 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
29060 if (vec_safe_is_empty (files
))
29062 if (first
->lineno
> 1 || second
->lineno
> 1)
29065 else if (first
->lineno
== 0)
29068 /* Find the last define/undef entry that can be grouped together
29069 with first and at the same time compute md5 checksum of their
29070 codes, linenumbers and strings. */
29071 md5_init_ctx (&ctx
);
29072 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
29073 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
29075 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
29079 unsigned char code
= cur
->code
;
29080 md5_process_bytes (&code
, 1, &ctx
);
29081 checksum_uleb128 (cur
->lineno
, &ctx
);
29082 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
29084 md5_finish_ctx (&ctx
, checksum
);
29087 /* From the containing include filename (if any) pick up just
29088 usable characters from its basename. */
29089 if (vec_safe_is_empty (files
))
29092 base
= lbasename (files
->last ().info
);
29093 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
29094 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
29095 encoded_filename_len
++;
29096 /* Count . at the end. */
29097 if (encoded_filename_len
)
29098 encoded_filename_len
++;
29100 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
29101 linebuf_len
= strlen (linebuf
);
29103 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
29104 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
29106 memcpy (grp_name
, dwarf_offset_size
== 4 ? "wm4." : "wm8.", 4);
29107 tail
= grp_name
+ 4;
29108 if (encoded_filename_len
)
29110 for (i
= 0; base
[i
]; i
++)
29111 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
29115 memcpy (tail
, linebuf
, linebuf_len
);
29116 tail
+= linebuf_len
;
29118 for (i
= 0; i
< 16; i
++)
29119 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
29121 /* Construct a macinfo_entry for DW_MACRO_import
29122 in the empty vector entry before the first define/undef. */
29123 inc
= &(*macinfo_table
)[idx
- 1];
29124 inc
->code
= DW_MACRO_import
;
29126 inc
->info
= ggc_strdup (grp_name
);
29127 if (!*macinfo_htab
)
29128 *macinfo_htab
= new macinfo_hash_type (10);
29129 /* Avoid emitting duplicates. */
29130 slot
= (*macinfo_htab
)->find_slot (inc
, INSERT
);
29135 /* If such an entry has been used before, just emit
29136 a DW_MACRO_import op. */
29138 output_macinfo_op (inc
);
29139 /* And clear all macinfo_entry in the range to avoid emitting them
29140 in the second pass. */
29141 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
29150 inc
->lineno
= (*macinfo_htab
)->elements ();
29151 output_macinfo_op (inc
);
29156 /* Save any strings needed by the macinfo table in the debug str
29157 table. All strings must be collected into the table by the time
29158 index_string is called. */
29161 save_macinfo_strings (void)
29165 macinfo_entry
*ref
;
29167 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
29171 /* Match the logic in output_macinfo_op to decide on
29172 indirect strings. */
29173 case DW_MACINFO_define
:
29174 case DW_MACINFO_undef
:
29175 len
= strlen (ref
->info
) + 1;
29176 if ((!dwarf_strict
|| dwarf_version
>= 5)
29177 && len
> (unsigned) dwarf_offset_size
29178 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
29179 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
29180 set_indirect_string (find_AT_string (ref
->info
));
29182 case DW_MACINFO_start_file
:
29183 /* -gsplit-dwarf -g3 will also output filename as indirect
29185 if (!dwarf_split_debug_info
)
29187 /* Fall through. */
29188 case DW_MACRO_define_strp
:
29189 case DW_MACRO_undef_strp
:
29190 case DW_MACRO_define_strx
:
29191 case DW_MACRO_undef_strx
:
29192 set_indirect_string (find_AT_string (ref
->info
));
29200 /* Output macinfo section(s). */
29203 output_macinfo (const char *debug_line_label
, bool early_lto_debug
)
29206 unsigned long length
= vec_safe_length (macinfo_table
);
29207 macinfo_entry
*ref
;
29208 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
29209 macinfo_hash_type
*macinfo_htab
= NULL
;
29210 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
29215 /* output_macinfo* uses these interchangeably. */
29216 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_define
29217 && (int) DW_MACINFO_undef
== (int) DW_MACRO_undef
29218 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_start_file
29219 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_end_file
);
29221 /* AIX Assembler inserts the length, so adjust the reference to match the
29222 offset expected by debuggers. */
29223 strcpy (dl_section_ref
, debug_line_label
);
29224 if (XCOFF_DEBUGGING_INFO
)
29225 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
29227 /* For .debug_macro emit the section header. */
29228 if (!dwarf_strict
|| dwarf_version
>= 5)
29230 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
29231 "DWARF macro version number");
29232 if (dwarf_offset_size
== 8)
29233 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
29235 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
29236 dw2_asm_output_offset (dwarf_offset_size
, debug_line_label
,
29237 debug_line_section
, NULL
);
29240 /* In the first loop, it emits the primary .debug_macinfo section
29241 and after each emitted op the macinfo_entry is cleared.
29242 If a longer range of define/undef ops can be optimized using
29243 DW_MACRO_import, the DW_MACRO_import op is emitted and kept in
29244 the vector before the first define/undef in the range and the
29245 whole range of define/undef ops is not emitted and kept. */
29246 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
29250 case DW_MACINFO_start_file
:
29251 vec_safe_push (files
, *ref
);
29253 case DW_MACINFO_end_file
:
29254 if (!vec_safe_is_empty (files
))
29257 case DW_MACINFO_define
:
29258 case DW_MACINFO_undef
:
29259 if ((!dwarf_strict
|| dwarf_version
>= 5)
29260 && !dwarf_split_debug_info
29261 && HAVE_COMDAT_GROUP
29262 && vec_safe_length (files
) != 1
29265 && (*macinfo_table
)[i
- 1].code
== 0)
29267 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
29276 /* A dummy entry may be inserted at the beginning to be able
29277 to optimize the whole block of predefined macros. */
29283 output_macinfo_op (ref
);
29291 /* Save the number of transparent includes so we can adjust the
29292 label number for the fat LTO object DWARF. */
29293 unsigned macinfo_label_base_adj
= macinfo_htab
->elements ();
29295 delete macinfo_htab
;
29296 macinfo_htab
= NULL
;
29298 /* If any DW_MACRO_import were used, on those DW_MACRO_import entries
29299 terminate the current chain and switch to a new comdat .debug_macinfo
29300 section and emit the define/undef entries within it. */
29301 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
29306 case DW_MACRO_import
:
29308 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
29309 tree comdat_key
= get_identifier (ref
->info
);
29310 /* Terminate the previous .debug_macinfo section. */
29311 dw2_asm_output_data (1, 0, "End compilation unit");
29312 targetm
.asm_out
.named_section (debug_macinfo_section_name
,
29316 ? SECTION_EXCLUDE
: 0),
29318 ASM_GENERATE_INTERNAL_LABEL (label
,
29319 DEBUG_MACRO_SECTION_LABEL
,
29320 ref
->lineno
+ macinfo_label_base
);
29321 ASM_OUTPUT_LABEL (asm_out_file
, label
);
29324 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
29325 "DWARF macro version number");
29326 if (dwarf_offset_size
== 8)
29327 dw2_asm_output_data (1, 1, "Flags: 64-bit");
29329 dw2_asm_output_data (1, 0, "Flags: 32-bit");
29332 case DW_MACINFO_define
:
29333 case DW_MACINFO_undef
:
29334 output_macinfo_op (ref
);
29339 gcc_unreachable ();
29342 macinfo_label_base
+= macinfo_label_base_adj
;
29345 /* As init_sections_and_labels may get called multiple times, have a
29346 generation count for labels. */
29347 static unsigned init_sections_and_labels_generation
;
29349 /* Initialize the various sections and labels for dwarf output and prefix
29350 them with PREFIX if non-NULL. Returns the generation (zero based
29351 number of times function was called). */
29354 init_sections_and_labels (bool early_lto_debug
)
29356 if (early_lto_debug
)
29358 if (!dwarf_split_debug_info
)
29360 debug_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
29361 SECTION_DEBUG
| SECTION_EXCLUDE
,
29363 debug_abbrev_section
= get_section (DEBUG_LTO_ABBREV_SECTION
,
29364 SECTION_DEBUG
| SECTION_EXCLUDE
,
29366 debug_macinfo_section_name
29367 = ((dwarf_strict
&& dwarf_version
< 5)
29368 ? DEBUG_LTO_MACINFO_SECTION
: DEBUG_LTO_MACRO_SECTION
);
29369 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
29371 | SECTION_EXCLUDE
, NULL
);
29375 /* ??? Which of the following do we need early? */
29376 debug_info_section
= get_section (DEBUG_LTO_DWO_INFO_SECTION
,
29377 SECTION_DEBUG
| SECTION_EXCLUDE
,
29379 debug_abbrev_section
= get_section (DEBUG_LTO_DWO_ABBREV_SECTION
,
29380 SECTION_DEBUG
| SECTION_EXCLUDE
,
29382 debug_skeleton_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
29384 | SECTION_EXCLUDE
, NULL
);
29385 debug_skeleton_abbrev_section
29386 = get_section (DEBUG_LTO_ABBREV_SECTION
,
29387 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
29388 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
29389 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
29390 init_sections_and_labels_generation
);
29392 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
29393 stay in the main .o, but the skeleton_line goes into the split
29395 debug_skeleton_line_section
29396 = get_section (DEBUG_LTO_LINE_SECTION
,
29397 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
29398 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
29399 DEBUG_SKELETON_LINE_SECTION_LABEL
,
29400 init_sections_and_labels_generation
);
29401 debug_str_offsets_section
29402 = get_section (DEBUG_LTO_DWO_STR_OFFSETS_SECTION
,
29403 SECTION_DEBUG
| SECTION_EXCLUDE
,
29405 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
29406 DEBUG_SKELETON_INFO_SECTION_LABEL
,
29407 init_sections_and_labels_generation
);
29408 debug_str_dwo_section
= get_section (DEBUG_LTO_STR_DWO_SECTION
,
29409 DEBUG_STR_DWO_SECTION_FLAGS
,
29411 debug_macinfo_section_name
29412 = ((dwarf_strict
&& dwarf_version
< 5)
29413 ? DEBUG_LTO_DWO_MACINFO_SECTION
: DEBUG_LTO_DWO_MACRO_SECTION
);
29414 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
29415 SECTION_DEBUG
| SECTION_EXCLUDE
,
29418 /* For macro info and the file table we have to refer to a
29419 debug_line section. */
29420 debug_line_section
= get_section (DEBUG_LTO_LINE_SECTION
,
29421 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
29422 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
29423 DEBUG_LINE_SECTION_LABEL
,
29424 init_sections_and_labels_generation
);
29426 debug_str_section
= get_section (DEBUG_LTO_STR_SECTION
,
29427 DEBUG_STR_SECTION_FLAGS
29428 | SECTION_EXCLUDE
, NULL
);
29429 if (!dwarf_split_debug_info
)
29430 debug_line_str_section
29431 = get_section (DEBUG_LTO_LINE_STR_SECTION
,
29432 DEBUG_STR_SECTION_FLAGS
| SECTION_EXCLUDE
, NULL
);
29436 if (!dwarf_split_debug_info
)
29438 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
29439 SECTION_DEBUG
, NULL
);
29440 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
29441 SECTION_DEBUG
, NULL
);
29442 debug_loc_section
= get_section (dwarf_version
>= 5
29443 ? DEBUG_LOCLISTS_SECTION
29444 : DEBUG_LOC_SECTION
,
29445 SECTION_DEBUG
, NULL
);
29446 debug_macinfo_section_name
29447 = ((dwarf_strict
&& dwarf_version
< 5)
29448 ? DEBUG_MACINFO_SECTION
: DEBUG_MACRO_SECTION
);
29449 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
29450 SECTION_DEBUG
, NULL
);
29454 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
29455 SECTION_DEBUG
| SECTION_EXCLUDE
,
29457 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
29458 SECTION_DEBUG
| SECTION_EXCLUDE
,
29460 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
29461 SECTION_DEBUG
, NULL
);
29462 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
29463 SECTION_DEBUG
, NULL
);
29464 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
29465 SECTION_DEBUG
, NULL
);
29466 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
29467 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
29468 init_sections_and_labels_generation
);
29470 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
29471 stay in the main .o, but the skeleton_line goes into the
29473 debug_skeleton_line_section
29474 = get_section (DEBUG_DWO_LINE_SECTION
,
29475 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
29476 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
29477 DEBUG_SKELETON_LINE_SECTION_LABEL
,
29478 init_sections_and_labels_generation
);
29479 debug_str_offsets_section
29480 = get_section (DEBUG_DWO_STR_OFFSETS_SECTION
,
29481 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
29482 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
29483 DEBUG_SKELETON_INFO_SECTION_LABEL
,
29484 init_sections_and_labels_generation
);
29485 debug_loc_section
= get_section (dwarf_version
>= 5
29486 ? DEBUG_DWO_LOCLISTS_SECTION
29487 : DEBUG_DWO_LOC_SECTION
,
29488 SECTION_DEBUG
| SECTION_EXCLUDE
,
29490 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
29491 DEBUG_STR_DWO_SECTION_FLAGS
,
29493 debug_macinfo_section_name
29494 = ((dwarf_strict
&& dwarf_version
< 5)
29495 ? DEBUG_DWO_MACINFO_SECTION
: DEBUG_DWO_MACRO_SECTION
);
29496 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
29497 SECTION_DEBUG
| SECTION_EXCLUDE
,
29499 if (dwarf_version
>= 5)
29500 debug_ranges_dwo_section
29501 = get_section (DEBUG_DWO_RNGLISTS_SECTION
,
29502 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
29504 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
29505 SECTION_DEBUG
, NULL
);
29506 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
29507 SECTION_DEBUG
, NULL
);
29508 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
29509 SECTION_DEBUG
, NULL
);
29510 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
29511 SECTION_DEBUG
, NULL
);
29512 debug_str_section
= get_section (DEBUG_STR_SECTION
,
29513 DEBUG_STR_SECTION_FLAGS
, NULL
);
29514 if ((!dwarf_split_debug_info
&& !output_asm_line_debug_info ())
29515 || asm_outputs_debug_line_str ())
29516 debug_line_str_section
= get_section (DEBUG_LINE_STR_SECTION
,
29517 DEBUG_STR_SECTION_FLAGS
, NULL
);
29519 debug_ranges_section
= get_section (dwarf_version
>= 5
29520 ? DEBUG_RNGLISTS_SECTION
29521 : DEBUG_RANGES_SECTION
,
29522 SECTION_DEBUG
, NULL
);
29523 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
29524 SECTION_DEBUG
, NULL
);
29527 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
29528 DEBUG_ABBREV_SECTION_LABEL
,
29529 init_sections_and_labels_generation
);
29530 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
29531 DEBUG_INFO_SECTION_LABEL
,
29532 init_sections_and_labels_generation
);
29533 info_section_emitted
= false;
29534 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
29535 DEBUG_LINE_SECTION_LABEL
,
29536 init_sections_and_labels_generation
);
29537 /* There are up to 6 unique ranges labels per generation.
29538 See also output_rnglists. */
29539 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
29540 DEBUG_RANGES_SECTION_LABEL
,
29541 init_sections_and_labels_generation
* 6);
29542 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
29543 ASM_GENERATE_INTERNAL_LABEL (ranges_base_label
,
29544 DEBUG_RANGES_SECTION_LABEL
,
29545 1 + init_sections_and_labels_generation
* 6);
29546 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
29547 DEBUG_ADDR_SECTION_LABEL
,
29548 init_sections_and_labels_generation
);
29549 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
29550 (dwarf_strict
&& dwarf_version
< 5)
29551 ? DEBUG_MACINFO_SECTION_LABEL
29552 : DEBUG_MACRO_SECTION_LABEL
,
29553 init_sections_and_labels_generation
);
29554 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
,
29555 init_sections_and_labels_generation
);
29557 ++init_sections_and_labels_generation
;
29558 return init_sections_and_labels_generation
- 1;
29561 /* Set up for Dwarf output at the start of compilation. */
29564 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
29566 /* Allocate the file_table. */
29567 file_table
= hash_table
<dwarf_file_hasher
>::create_ggc (50);
29569 #ifndef DWARF2_LINENO_DEBUGGING_INFO
29570 /* Allocate the decl_die_table. */
29571 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (10);
29573 /* Allocate the decl_loc_table. */
29574 decl_loc_table
= hash_table
<decl_loc_hasher
>::create_ggc (10);
29576 /* Allocate the cached_dw_loc_list_table. */
29577 cached_dw_loc_list_table
= hash_table
<dw_loc_list_hasher
>::create_ggc (10);
29579 /* Allocate the initial hunk of the abbrev_die_table. */
29580 vec_alloc (abbrev_die_table
, 256);
29581 /* Zero-th entry is allocated, but unused. */
29582 abbrev_die_table
->quick_push (NULL
);
29584 /* Allocate the dwarf_proc_stack_usage_map. */
29585 dwarf_proc_stack_usage_map
= new hash_map
<dw_die_ref
, int>;
29587 /* Allocate the pubtypes and pubnames vectors. */
29588 vec_alloc (pubname_table
, 32);
29589 vec_alloc (pubtype_table
, 32);
29591 vec_alloc (incomplete_types
, 64);
29593 vec_alloc (used_rtx_array
, 32);
29595 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
29596 vec_alloc (macinfo_table
, 64);
29599 /* If front-ends already registered a main translation unit but we were not
29600 ready to perform the association, do this now. */
29601 if (main_translation_unit
!= NULL_TREE
)
29602 equate_decl_number_to_die (main_translation_unit
, comp_unit_die ());
29605 /* Called before compile () starts outputtting functions, variables
29606 and toplevel asms into assembly. */
29609 dwarf2out_assembly_start (void)
29611 if (text_section_line_info
)
29614 #ifndef DWARF2_LINENO_DEBUGGING_INFO
29615 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
29616 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
29617 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
29618 COLD_TEXT_SECTION_LABEL
, 0);
29619 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
29621 switch_to_section (text_section
);
29622 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
29625 /* Make sure the line number table for .text always exists. */
29626 text_section_line_info
= new_line_info_table ();
29627 text_section_line_info
->end_label
= text_end_label
;
29629 #ifdef DWARF2_LINENO_DEBUGGING_INFO
29630 cur_line_info_table
= text_section_line_info
;
29633 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
29634 && dwarf2out_do_cfi_asm ()
29635 && !dwarf2out_do_eh_frame ())
29636 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
29638 #if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
29639 if (output_asm_line_debug_info () && dwarf_version
>= 5)
29641 /* When gas outputs DWARF5 .debug_line[_str] then we have to
29642 tell it the comp_dir and main file name for the zero entry
29644 const char *comp_dir
, *filename0
;
29646 comp_dir
= comp_dir_string ();
29647 if (comp_dir
== NULL
)
29650 filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
29651 if (filename0
== NULL
)
29654 fprintf (asm_out_file
, "\t.file 0 ");
29655 output_quoted_string (asm_out_file
, remap_debug_filename (comp_dir
));
29656 fputc (' ', asm_out_file
);
29657 output_quoted_string (asm_out_file
, remap_debug_filename (filename0
));
29658 fputc ('\n', asm_out_file
);
29662 /* Work around for PR101575: output a dummy .file directive. */
29663 if (!last_emitted_file
&& dwarf_debuginfo_p ()
29664 && debug_info_level
>= DINFO_LEVEL_TERSE
)
29666 const char *filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
29668 if (filename0
== NULL
)
29669 filename0
= "<dummy>";
29670 maybe_emit_file (lookup_filename (filename0
));
29674 /* A helper function for dwarf2out_finish called through
29675 htab_traverse. Assign a string its index. All strings must be
29676 collected into the table by the time index_string is called,
29677 because the indexing code relies on htab_traverse to traverse nodes
29678 in the same order for each run. */
29681 index_string (indirect_string_node
**h
, unsigned int *index
)
29683 indirect_string_node
*node
= *h
;
29685 find_string_form (node
);
29686 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
29688 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
29689 node
->index
= *index
;
29695 /* A helper function for output_indirect_strings called through
29696 htab_traverse. Output the offset to a string and update the
29700 output_index_string_offset (indirect_string_node
**h
, unsigned int *offset
)
29702 indirect_string_node
*node
= *h
;
29704 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
29706 /* Assert that this node has been assigned an index. */
29707 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
29708 && node
->index
!= NOT_INDEXED
);
29709 dw2_asm_output_data (dwarf_offset_size
, *offset
,
29710 "indexed string 0x%x: %s", node
->index
, node
->str
);
29711 *offset
+= strlen (node
->str
) + 1;
29716 /* A helper function for dwarf2out_finish called through
29717 htab_traverse. Output the indexed string. */
29720 output_index_string (indirect_string_node
**h
, unsigned int *cur_idx
)
29722 struct indirect_string_node
*node
= *h
;
29724 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
29726 /* Assert that the strings are output in the same order as their
29727 indexes were assigned. */
29728 gcc_assert (*cur_idx
== node
->index
);
29729 assemble_string (node
->str
, strlen (node
->str
) + 1);
29735 /* A helper function for output_indirect_strings. Counts the number
29736 of index strings offsets. Must match the logic of the functions
29737 output_index_string[_offsets] above. */
29739 count_index_strings (indirect_string_node
**h
, unsigned int *last_idx
)
29741 struct indirect_string_node
*node
= *h
;
29743 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
29748 /* A helper function for dwarf2out_finish called through
29749 htab_traverse. Emit one queued .debug_str string. */
29752 output_indirect_string (indirect_string_node
**h
, enum dwarf_form form
)
29754 struct indirect_string_node
*node
= *h
;
29756 node
->form
= find_string_form (node
);
29757 if (node
->form
== form
&& node
->refcount
> 0)
29759 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
29760 assemble_string (node
->str
, strlen (node
->str
) + 1);
29766 /* Output the indexed string table. */
29769 output_indirect_strings (void)
29771 switch_to_section (debug_str_section
);
29772 if (!dwarf_split_debug_info
)
29773 debug_str_hash
->traverse
<enum dwarf_form
,
29774 output_indirect_string
> (DW_FORM_strp
);
29777 unsigned int offset
= 0;
29778 unsigned int cur_idx
= 0;
29780 if (skeleton_debug_str_hash
)
29781 skeleton_debug_str_hash
->traverse
<enum dwarf_form
,
29782 output_indirect_string
> (DW_FORM_strp
);
29784 switch_to_section (debug_str_offsets_section
);
29785 /* For DWARF5 the .debug_str_offsets[.dwo] section needs a unit
29786 header. Note that we don't need to generate a label to the
29787 actual index table following the header here, because this is
29788 for the split dwarf case only. In an .dwo file there is only
29789 one string offsets table (and one debug info section). But
29790 if we would start using string offset tables for the main (or
29791 skeleton) unit, then we have to add a DW_AT_str_offsets_base
29792 pointing to the actual index after the header. Split dwarf
29793 units will never have a string offsets base attribute. When
29794 a split unit is moved into a .dwp file the string offsets can
29795 be found through the .debug_cu_index section table. */
29796 if (dwarf_version
>= 5)
29798 unsigned int last_idx
= 0;
29799 unsigned long str_offsets_length
;
29801 debug_str_hash
->traverse_noresize
29802 <unsigned int *, count_index_strings
> (&last_idx
);
29803 str_offsets_length
= last_idx
* dwarf_offset_size
+ 4;
29804 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
29805 dw2_asm_output_data (4, 0xffffffff,
29806 "Escape value for 64-bit DWARF extension");
29807 dw2_asm_output_data (dwarf_offset_size
, str_offsets_length
,
29808 "Length of string offsets unit");
29809 dw2_asm_output_data (2, 5, "DWARF string offsets version");
29810 dw2_asm_output_data (2, 0, "Header zero padding");
29812 debug_str_hash
->traverse_noresize
29813 <unsigned int *, output_index_string_offset
> (&offset
);
29814 switch_to_section (debug_str_dwo_section
);
29815 debug_str_hash
->traverse_noresize
<unsigned int *, output_index_string
>
29820 /* Callback for htab_traverse to assign an index to an entry in the
29821 table, and to write that entry to the .debug_addr section. */
29824 output_addr_table_entry (addr_table_entry
**slot
, unsigned int *cur_index
)
29826 addr_table_entry
*entry
= *slot
;
29828 if (entry
->refcount
== 0)
29830 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
29831 || entry
->index
== NOT_INDEXED
);
29835 gcc_assert (entry
->index
== *cur_index
);
29838 switch (entry
->kind
)
29841 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
29842 "0x%x", entry
->index
);
29844 case ate_kind_rtx_dtprel
:
29845 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
29846 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
29849 fputc ('\n', asm_out_file
);
29851 case ate_kind_label
:
29852 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
29853 "0x%x", entry
->index
);
29856 gcc_unreachable ();
29861 /* A helper function for dwarf2out_finish. Counts the number
29862 of indexed addresses. Must match the logic of the functions
29863 output_addr_table_entry above. */
29865 count_index_addrs (addr_table_entry
**slot
, unsigned int *last_idx
)
29867 addr_table_entry
*entry
= *slot
;
29869 if (entry
->refcount
> 0)
29874 /* Produce the .debug_addr section. */
29877 output_addr_table (void)
29879 unsigned int index
= 0;
29880 if (addr_index_table
== NULL
|| addr_index_table
->size () == 0)
29883 switch_to_section (debug_addr_section
);
29884 /* GNU DebugFission https://gcc.gnu.org/wiki/DebugFission
29885 which GCC uses to implement -gsplit-dwarf as DWARF GNU extension
29886 before DWARF5, didn't have a header for .debug_addr units.
29887 DWARF5 specifies a small header when address tables are used. */
29888 if (dwarf_version
>= 5)
29890 unsigned int last_idx
= 0;
29891 unsigned long addrs_length
;
29893 addr_index_table
->traverse_noresize
29894 <unsigned int *, count_index_addrs
> (&last_idx
);
29895 addrs_length
= last_idx
* DWARF2_ADDR_SIZE
+ 4;
29897 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
29898 dw2_asm_output_data (4, 0xffffffff,
29899 "Escape value for 64-bit DWARF extension");
29900 dw2_asm_output_data (dwarf_offset_size
, addrs_length
,
29901 "Length of Address Unit");
29902 dw2_asm_output_data (2, 5, "DWARF addr version");
29903 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
29904 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
29906 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
29909 ->traverse_noresize
<unsigned int *, output_addr_table_entry
> (&index
);
29912 #if ENABLE_ASSERT_CHECKING
29913 /* Verify that all marks are clear. */
29916 verify_marks_clear (dw_die_ref die
)
29920 gcc_assert (! die
->die_mark
);
29921 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
29923 #endif /* ENABLE_ASSERT_CHECKING */
29925 /* Clear the marks for a die and its children.
29926 Be cool if the mark isn't set. */
29929 prune_unmark_dies (dw_die_ref die
)
29935 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
29938 /* Given LOC that is referenced by a DIE we're marking as used, find all
29939 referenced DWARF procedures it references and mark them as used. */
29942 prune_unused_types_walk_loc_descr (dw_loc_descr_ref loc
)
29944 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
29945 switch (loc
->dw_loc_opc
)
29947 case DW_OP_implicit_pointer
:
29948 case DW_OP_convert
:
29949 case DW_OP_reinterpret
:
29950 case DW_OP_GNU_implicit_pointer
:
29951 case DW_OP_GNU_convert
:
29952 case DW_OP_GNU_reinterpret
:
29953 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
)
29954 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
29956 case DW_OP_GNU_variable_value
:
29957 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
29960 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
29963 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
29964 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
29965 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29970 case DW_OP_call_ref
:
29971 case DW_OP_const_type
:
29972 case DW_OP_GNU_const_type
:
29973 case DW_OP_GNU_parameter_ref
:
29974 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
);
29975 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
29977 case DW_OP_regval_type
:
29978 case DW_OP_deref_type
:
29979 case DW_OP_GNU_regval_type
:
29980 case DW_OP_GNU_deref_type
:
29981 gcc_assert (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_die_ref
);
29982 prune_unused_types_mark (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
, 1);
29984 case DW_OP_entry_value
:
29985 case DW_OP_GNU_entry_value
:
29986 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
);
29987 prune_unused_types_walk_loc_descr (loc
->dw_loc_oprnd1
.v
.val_loc
);
29994 /* Given DIE that we're marking as used, find any other dies
29995 it references as attributes and mark them as used. */
29998 prune_unused_types_walk_attribs (dw_die_ref die
)
30003 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30005 switch (AT_class (a
))
30007 /* Make sure DWARF procedures referenced by location descriptions will
30009 case dw_val_class_loc
:
30010 prune_unused_types_walk_loc_descr (AT_loc (a
));
30012 case dw_val_class_loc_list
:
30013 for (dw_loc_list_ref list
= AT_loc_list (a
);
30015 list
= list
->dw_loc_next
)
30016 prune_unused_types_walk_loc_descr (list
->expr
);
30019 case dw_val_class_view_list
:
30020 /* This points to a loc_list in another attribute, so it's
30021 already covered. */
30024 case dw_val_class_die_ref
:
30025 /* A reference to another DIE.
30026 Make sure that it will get emitted.
30027 If it was broken out into a comdat group, don't follow it. */
30028 if (! AT_ref (a
)->comdat_type_p
30029 || a
->dw_attr
== DW_AT_specification
)
30030 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
30033 case dw_val_class_str
:
30034 /* Set the string's refcount to 0 so that prune_unused_types_mark
30035 accounts properly for it. */
30036 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
30045 /* Mark the generic parameters and arguments children DIEs of DIE. */
30048 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
30052 if (die
== NULL
|| die
->die_child
== NULL
)
30054 c
= die
->die_child
;
30057 if (is_template_parameter (c
))
30058 prune_unused_types_mark (c
, 1);
30060 } while (c
&& c
!= die
->die_child
);
30063 /* Mark DIE as being used. If DOKIDS is true, then walk down
30064 to DIE's children. */
30067 prune_unused_types_mark (dw_die_ref die
, int dokids
)
30071 if (die
->die_mark
== 0)
30073 /* We haven't done this node yet. Mark it as used. */
30075 /* If this is the DIE of a generic type instantiation,
30076 mark the children DIEs that describe its generic parms and
30078 prune_unused_types_mark_generic_parms_dies (die
);
30080 /* We also have to mark its parents as used.
30081 (But we don't want to mark our parent's kids due to this,
30082 unless it is a class.) */
30083 if (die
->die_parent
)
30084 prune_unused_types_mark (die
->die_parent
,
30085 class_scope_p (die
->die_parent
));
30087 /* Mark any referenced nodes. */
30088 prune_unused_types_walk_attribs (die
);
30090 /* If this node is a specification,
30091 also mark the definition, if it exists. */
30092 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
30093 prune_unused_types_mark (die
->die_definition
, 1);
30096 if (dokids
&& die
->die_mark
!= 2)
30098 /* We need to walk the children, but haven't done so yet.
30099 Remember that we've walked the kids. */
30102 /* If this is an array type, we need to make sure our
30103 kids get marked, even if they're types. If we're
30104 breaking out types into comdat sections, do this
30105 for all type definitions. */
30106 if (die
->die_tag
== DW_TAG_array_type
30107 || (use_debug_types
30108 && is_type_die (die
) && ! is_declaration_die (die
)))
30109 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
30111 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
30115 /* For local classes, look if any static member functions were emitted
30116 and if so, mark them. */
30119 prune_unused_types_walk_local_classes (dw_die_ref die
)
30123 if (die
->die_mark
== 2)
30126 switch (die
->die_tag
)
30128 case DW_TAG_structure_type
:
30129 case DW_TAG_union_type
:
30130 case DW_TAG_class_type
:
30131 case DW_TAG_interface_type
:
30134 case DW_TAG_subprogram
:
30135 if (!get_AT_flag (die
, DW_AT_declaration
)
30136 || die
->die_definition
!= NULL
)
30137 prune_unused_types_mark (die
, 1);
30144 /* Mark children. */
30145 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
30148 /* Walk the tree DIE and mark types that we actually use. */
30151 prune_unused_types_walk (dw_die_ref die
)
30155 /* Don't do anything if this node is already marked and
30156 children have been marked as well. */
30157 if (die
->die_mark
== 2)
30160 switch (die
->die_tag
)
30162 case DW_TAG_structure_type
:
30163 case DW_TAG_union_type
:
30164 case DW_TAG_class_type
:
30165 case DW_TAG_interface_type
:
30166 if (die
->die_perennial_p
)
30169 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
30170 if (c
->die_tag
== DW_TAG_subprogram
)
30173 /* Finding used static member functions inside of classes
30174 is needed just for local classes, because for other classes
30175 static member function DIEs with DW_AT_specification
30176 are emitted outside of the DW_TAG_*_type. If we ever change
30177 it, we'd need to call this even for non-local classes. */
30179 prune_unused_types_walk_local_classes (die
);
30181 /* It's a type node --- don't mark it. */
30184 case DW_TAG_const_type
:
30185 case DW_TAG_packed_type
:
30186 case DW_TAG_pointer_type
:
30187 case DW_TAG_reference_type
:
30188 case DW_TAG_rvalue_reference_type
:
30189 case DW_TAG_volatile_type
:
30190 case DW_TAG_restrict_type
:
30191 case DW_TAG_shared_type
:
30192 case DW_TAG_atomic_type
:
30193 case DW_TAG_immutable_type
:
30194 case DW_TAG_typedef
:
30195 case DW_TAG_array_type
:
30196 case DW_TAG_coarray_type
:
30197 case DW_TAG_friend
:
30198 case DW_TAG_enumeration_type
:
30199 case DW_TAG_subroutine_type
:
30200 case DW_TAG_string_type
:
30201 case DW_TAG_set_type
:
30202 case DW_TAG_subrange_type
:
30203 case DW_TAG_ptr_to_member_type
:
30204 case DW_TAG_file_type
:
30205 case DW_TAG_unspecified_type
:
30206 case DW_TAG_dynamic_type
:
30207 /* Type nodes are useful only when other DIEs reference them --- don't
30211 case DW_TAG_dwarf_procedure
:
30212 /* Likewise for DWARF procedures. */
30214 if (die
->die_perennial_p
)
30219 case DW_TAG_variable
:
30220 if (flag_debug_only_used_symbols
)
30222 if (die
->die_perennial_p
)
30225 /* For static data members, the declaration in the class is supposed
30226 to have DW_TAG_member tag in DWARF{3,4} but DW_TAG_variable in
30227 DWARF5. DW_TAG_member will be marked, so mark even such
30228 DW_TAG_variables in DWARF5, as long as it has DW_AT_const_value
30230 if (dwarf_version
>= 5
30231 && class_scope_p (die
->die_parent
)
30232 && get_AT (die
, DW_AT_const_value
))
30235 /* premark_used_variables marks external variables --- don't mark
30236 them here. But function-local externals are always considered
30238 if (get_AT (die
, DW_AT_external
))
30240 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
30241 if (c
->die_tag
== DW_TAG_subprogram
)
30250 /* Mark everything else. */
30254 if (die
->die_mark
== 0)
30258 /* Now, mark any dies referenced from here. */
30259 prune_unused_types_walk_attribs (die
);
30264 /* Mark children. */
30265 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
30268 /* Increment the string counts on strings referred to from DIE's
30272 prune_unused_types_update_strings (dw_die_ref die
)
30277 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30278 if (AT_class (a
) == dw_val_class_str
)
30280 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
30282 /* Avoid unnecessarily putting strings that are used less than
30283 twice in the hash table. */
30284 if (s
->form
!= DW_FORM_line_strp
30286 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2)))
30288 indirect_string_node
**slot
30289 = debug_str_hash
->find_slot_with_hash (s
->str
,
30290 htab_hash_string (s
->str
),
30292 gcc_assert (*slot
== NULL
);
30298 /* Mark DIE and its children as removed. */
30301 mark_removed (dw_die_ref die
)
30304 die
->removed
= true;
30305 FOR_EACH_CHILD (die
, c
, mark_removed (c
));
30308 /* Remove from the tree DIE any dies that aren't marked. */
30311 prune_unused_types_prune (dw_die_ref die
)
30315 gcc_assert (die
->die_mark
);
30316 prune_unused_types_update_strings (die
);
30318 if (! die
->die_child
)
30321 c
= die
->die_child
;
30323 dw_die_ref prev
= c
, next
;
30324 for (c
= c
->die_sib
; ! c
->die_mark
; c
= next
)
30325 if (c
== die
->die_child
)
30327 /* No marked children between 'prev' and the end of the list. */
30329 /* No marked children at all. */
30330 die
->die_child
= NULL
;
30333 prev
->die_sib
= c
->die_sib
;
30334 die
->die_child
= prev
;
30347 if (c
!= prev
->die_sib
)
30349 prune_unused_types_prune (c
);
30350 } while (c
!= die
->die_child
);
30353 /* Remove dies representing declarations that we never use. */
30356 prune_unused_types (void)
30359 limbo_die_node
*node
;
30360 comdat_type_node
*ctnode
;
30361 pubname_entry
*pub
;
30362 dw_die_ref base_type
;
30364 #if ENABLE_ASSERT_CHECKING
30365 /* All the marks should already be clear. */
30366 verify_marks_clear (comp_unit_die ());
30367 for (node
= limbo_die_list
; node
; node
= node
->next
)
30368 verify_marks_clear (node
->die
);
30369 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
30370 verify_marks_clear (ctnode
->root_die
);
30371 #endif /* ENABLE_ASSERT_CHECKING */
30373 /* Mark types that are used in global variables. */
30374 premark_types_used_by_global_vars ();
30376 /* Mark variables used in the symtab. */
30377 if (flag_debug_only_used_symbols
)
30378 premark_used_variables ();
30380 /* Set the mark on nodes that are actually used. */
30381 prune_unused_types_walk (comp_unit_die ());
30382 for (node
= limbo_die_list
; node
; node
= node
->next
)
30383 prune_unused_types_walk (node
->die
);
30384 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
30386 prune_unused_types_walk (ctnode
->root_die
);
30387 prune_unused_types_mark (ctnode
->type_die
, 1);
30390 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
30391 are unusual in that they are pubnames that are the children of pubtypes.
30392 They should only be marked via their parent DW_TAG_enumeration_type die,
30393 not as roots in themselves. */
30394 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
30395 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
30396 prune_unused_types_mark (pub
->die
, 1);
30397 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
30398 prune_unused_types_mark (base_type
, 1);
30400 /* Also set the mark on nodes that could be referenced by
30401 DW_TAG_call_site DW_AT_call_origin (i.e. direct call callees) or
30402 by DW_TAG_inlined_subroutine origins. */
30403 cgraph_node
*cnode
;
30404 FOR_EACH_FUNCTION (cnode
)
30405 if (cnode
->referred_to_p (false))
30407 dw_die_ref die
= lookup_decl_die (cnode
->decl
);
30408 if (die
== NULL
|| die
->die_mark
)
30410 for (cgraph_edge
*e
= cnode
->callers
; e
; e
= e
->next_caller
)
30411 if (e
->caller
!= cnode
)
30413 prune_unused_types_mark (die
, 1);
30418 if (debug_str_hash
)
30419 debug_str_hash
->empty ();
30420 if (skeleton_debug_str_hash
)
30421 skeleton_debug_str_hash
->empty ();
30422 prune_unused_types_prune (comp_unit_die ());
30423 for (limbo_die_node
**pnode
= &limbo_die_list
; *pnode
; )
30426 if (!node
->die
->die_mark
)
30427 *pnode
= node
->next
;
30430 prune_unused_types_prune (node
->die
);
30431 pnode
= &node
->next
;
30434 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
30435 prune_unused_types_prune (ctnode
->root_die
);
30437 /* Leave the marks clear. */
30438 prune_unmark_dies (comp_unit_die ());
30439 for (node
= limbo_die_list
; node
; node
= node
->next
)
30440 prune_unmark_dies (node
->die
);
30441 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
30442 prune_unmark_dies (ctnode
->root_die
);
30445 /* Helpers to manipulate hash table of comdat type units. */
30447 struct comdat_type_hasher
: nofree_ptr_hash
<comdat_type_node
>
30449 static inline hashval_t
hash (const comdat_type_node
*);
30450 static inline bool equal (const comdat_type_node
*, const comdat_type_node
*);
30454 comdat_type_hasher::hash (const comdat_type_node
*type_node
)
30457 memcpy (&h
, type_node
->signature
, sizeof (h
));
30462 comdat_type_hasher::equal (const comdat_type_node
*type_node_1
,
30463 const comdat_type_node
*type_node_2
)
30465 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
30466 DWARF_TYPE_SIGNATURE_SIZE
));
30469 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
30470 to the location it would have been added, should we know its
30471 DECL_ASSEMBLER_NAME when we added other attributes. This will
30472 probably improve compactness of debug info, removing equivalent
30473 abbrevs, and hide any differences caused by deferring the
30474 computation of the assembler name, triggered by e.g. PCH. */
30477 move_linkage_attr (dw_die_ref die
)
30479 unsigned ix
= vec_safe_length (die
->die_attr
);
30480 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
30482 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
30483 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
30487 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
30489 if (prev
->dw_attr
== DW_AT_decl_line
30490 || prev
->dw_attr
== DW_AT_decl_column
30491 || prev
->dw_attr
== DW_AT_name
)
30495 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
30497 die
->die_attr
->pop ();
30498 die
->die_attr
->quick_insert (ix
, linkage
);
30502 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
30503 referenced from typed stack ops and count how often they are used. */
30506 mark_base_types (dw_loc_descr_ref loc
)
30508 dw_die_ref base_type
= NULL
;
30510 for (; loc
; loc
= loc
->dw_loc_next
)
30512 switch (loc
->dw_loc_opc
)
30514 case DW_OP_regval_type
:
30515 case DW_OP_deref_type
:
30516 case DW_OP_GNU_regval_type
:
30517 case DW_OP_GNU_deref_type
:
30518 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
30520 case DW_OP_convert
:
30521 case DW_OP_reinterpret
:
30522 case DW_OP_GNU_convert
:
30523 case DW_OP_GNU_reinterpret
:
30524 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
30527 case DW_OP_const_type
:
30528 case DW_OP_GNU_const_type
:
30529 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30531 case DW_OP_entry_value
:
30532 case DW_OP_GNU_entry_value
:
30533 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
30538 gcc_assert (base_type
->die_parent
== comp_unit_die ());
30539 if (base_type
->die_mark
)
30540 base_type
->die_mark
++;
30543 base_types
.safe_push (base_type
);
30544 base_type
->die_mark
= 1;
30549 /* Stripped-down variant of resolve_addr, mark DW_TAG_base_type nodes
30550 referenced from typed stack ops and count how often they are used. */
30553 mark_base_types (dw_die_ref die
)
30557 dw_loc_list_ref
*curr
;
30560 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30561 switch (AT_class (a
))
30563 case dw_val_class_loc_list
:
30564 curr
= AT_loc_list_ptr (a
);
30567 mark_base_types ((*curr
)->expr
);
30568 curr
= &(*curr
)->dw_loc_next
;
30572 case dw_val_class_loc
:
30573 mark_base_types (AT_loc (a
));
30580 FOR_EACH_CHILD (die
, c
, mark_base_types (c
));
30583 /* Comparison function for sorting marked base types. */
30586 base_type_cmp (const void *x
, const void *y
)
30588 dw_die_ref dx
= *(const dw_die_ref
*) x
;
30589 dw_die_ref dy
= *(const dw_die_ref
*) y
;
30590 unsigned int byte_size1
, byte_size2
;
30591 unsigned int encoding1
, encoding2
;
30592 unsigned int align1
, align2
;
30593 if (dx
->die_mark
> dy
->die_mark
)
30595 if (dx
->die_mark
< dy
->die_mark
)
30597 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
30598 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
30599 if (byte_size1
< byte_size2
)
30601 if (byte_size1
> byte_size2
)
30603 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
30604 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
30605 if (encoding1
< encoding2
)
30607 if (encoding1
> encoding2
)
30609 align1
= get_AT_unsigned (dx
, DW_AT_alignment
);
30610 align2
= get_AT_unsigned (dy
, DW_AT_alignment
);
30611 if (align1
< align2
)
30613 if (align1
> align2
)
30618 /* Move base types marked by mark_base_types as early as possible
30619 in the CU, sorted by decreasing usage count both to make the
30620 uleb128 references as small as possible and to make sure they
30621 will have die_offset already computed by calc_die_sizes when
30622 sizes of typed stack loc ops is computed. */
30625 move_marked_base_types (void)
30628 dw_die_ref base_type
, die
, c
;
30630 if (base_types
.is_empty ())
30633 /* Sort by decreasing usage count, they will be added again in that
30635 base_types
.qsort (base_type_cmp
);
30636 die
= comp_unit_die ();
30637 c
= die
->die_child
;
30640 dw_die_ref prev
= c
;
30642 while (c
->die_mark
)
30644 remove_child_with_prev (c
, prev
);
30645 /* As base types got marked, there must be at least
30646 one node other than DW_TAG_base_type. */
30647 gcc_assert (die
->die_child
!= NULL
);
30651 while (c
!= die
->die_child
);
30652 gcc_assert (die
->die_child
);
30653 c
= die
->die_child
;
30654 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
30656 base_type
->die_mark
= 0;
30657 base_type
->die_sib
= c
->die_sib
;
30658 c
->die_sib
= base_type
;
30663 /* Helper function for resolve_addr, attempt to resolve
30664 one CONST_STRING, return true if successful. Similarly verify that
30665 SYMBOL_REFs refer to variables emitted in the current CU. */
30668 resolve_one_addr (rtx
*addr
)
30672 if (GET_CODE (rtl
) == CONST_STRING
)
30674 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
30675 tree t
= build_string (len
, XSTR (rtl
, 0));
30676 tree tlen
= size_int (len
- 1);
30678 = build_array_type (char_type_node
, build_index_type (tlen
));
30679 rtl
= lookup_constant_def (t
);
30680 if (!rtl
|| !MEM_P (rtl
))
30682 rtl
= XEXP (rtl
, 0);
30683 if (GET_CODE (rtl
) == SYMBOL_REF
30684 && SYMBOL_REF_DECL (rtl
)
30685 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
30687 vec_safe_push (used_rtx_array
, rtl
);
30692 if (GET_CODE (rtl
) == SYMBOL_REF
30693 && SYMBOL_REF_DECL (rtl
))
30695 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
30697 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
30700 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
30704 if (GET_CODE (rtl
) == CONST
)
30706 subrtx_ptr_iterator::array_type array
;
30707 FOR_EACH_SUBRTX_PTR (iter
, array
, &XEXP (rtl
, 0), ALL
)
30708 if (!resolve_one_addr (*iter
))
30715 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
30716 if possible, and create DW_TAG_dwarf_procedure that can be referenced
30717 from DW_OP_implicit_pointer if the string hasn't been seen yet. */
30720 string_cst_pool_decl (tree t
)
30722 rtx rtl
= output_constant_def (t
, 1);
30723 unsigned char *array
;
30724 dw_loc_descr_ref l
;
30729 if (!rtl
|| !MEM_P (rtl
))
30731 rtl
= XEXP (rtl
, 0);
30732 if (GET_CODE (rtl
) != SYMBOL_REF
30733 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
30736 decl
= SYMBOL_REF_DECL (rtl
);
30737 if (!lookup_decl_die (decl
))
30739 len
= TREE_STRING_LENGTH (t
);
30740 vec_safe_push (used_rtx_array
, rtl
);
30741 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
30742 array
= ggc_vec_alloc
<unsigned char> (len
);
30743 memcpy (array
, TREE_STRING_POINTER (t
), len
);
30744 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
30745 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
30746 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
30747 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
30748 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
30749 add_AT_loc (ref
, DW_AT_location
, l
);
30750 equate_decl_number_to_die (decl
, ref
);
30755 /* Helper function of resolve_addr_in_expr. LOC is
30756 a DW_OP_addr followed by DW_OP_stack_value, either at the start
30757 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
30758 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
30759 with DW_OP_implicit_pointer if possible
30760 and return true, if unsuccessful, return false. */
30763 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
30765 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
30766 HOST_WIDE_INT offset
= 0;
30767 dw_die_ref ref
= NULL
;
30770 if (GET_CODE (rtl
) == CONST
30771 && GET_CODE (XEXP (rtl
, 0)) == PLUS
30772 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
30774 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
30775 rtl
= XEXP (XEXP (rtl
, 0), 0);
30777 if (GET_CODE (rtl
) == CONST_STRING
)
30779 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
30780 tree t
= build_string (len
, XSTR (rtl
, 0));
30781 tree tlen
= size_int (len
- 1);
30784 = build_array_type (char_type_node
, build_index_type (tlen
));
30785 rtl
= string_cst_pool_decl (t
);
30789 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
30791 decl
= SYMBOL_REF_DECL (rtl
);
30792 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
30794 ref
= lookup_decl_die (decl
);
30795 if (ref
&& (get_AT (ref
, DW_AT_location
)
30796 || get_AT (ref
, DW_AT_const_value
)))
30798 loc
->dw_loc_opc
= dwarf_OP (DW_OP_implicit_pointer
);
30799 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30800 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
30801 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30802 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30803 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
30804 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
30812 /* Helper function for resolve_addr, handle one location
30813 expression, return false if at least one CONST_STRING or SYMBOL_REF in
30814 the location list couldn't be resolved. */
30817 resolve_addr_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
30819 dw_loc_descr_ref keep
= NULL
;
30820 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
30821 switch (loc
->dw_loc_opc
)
30824 if (!resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
30827 || prev
->dw_loc_opc
== DW_OP_piece
30828 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
30829 && loc
->dw_loc_next
30830 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
30831 && (!dwarf_strict
|| dwarf_version
>= 5)
30832 && optimize_one_addr_into_implicit_ptr (loc
))
30837 case DW_OP_GNU_addr_index
:
30839 case DW_OP_GNU_const_index
:
30841 if ((loc
->dw_loc_opc
== DW_OP_GNU_addr_index
30842 || loc
->dw_loc_opc
== DW_OP_addrx
)
30843 || ((loc
->dw_loc_opc
== DW_OP_GNU_const_index
30844 || loc
->dw_loc_opc
== DW_OP_constx
)
30847 rtx rtl
= loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
;
30848 if (!resolve_one_addr (&rtl
))
30850 remove_addr_table_entry (loc
->dw_loc_oprnd1
.val_entry
);
30851 loc
->dw_loc_oprnd1
.val_entry
30852 = add_addr_table_entry (rtl
, ate_kind_rtx
);
30855 case DW_OP_const4u
:
30856 case DW_OP_const8u
:
30858 && !resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
30861 case DW_OP_plus_uconst
:
30862 if (size_of_loc_descr (loc
)
30863 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
30865 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
30867 dw_loc_descr_ref repl
30868 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
30869 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
30870 add_loc_descr (&repl
, loc
->dw_loc_next
);
30874 case DW_OP_implicit_value
:
30875 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
30876 && !resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
))
30879 case DW_OP_implicit_pointer
:
30880 case DW_OP_GNU_implicit_pointer
:
30881 case DW_OP_GNU_parameter_ref
:
30882 case DW_OP_GNU_variable_value
:
30883 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
30886 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
30889 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30890 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30891 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30893 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
)
30896 && loc
->dw_loc_next
== NULL
30897 && AT_class (a
) == dw_val_class_loc
)
30898 switch (a
->dw_attr
)
30900 /* Following attributes allow both exprloc and reference,
30901 so if the whole expression is DW_OP_GNU_variable_value
30902 alone we could transform it into reference. */
30903 case DW_AT_byte_size
:
30904 case DW_AT_bit_size
:
30905 case DW_AT_lower_bound
:
30906 case DW_AT_upper_bound
:
30907 case DW_AT_bit_stride
:
30909 case DW_AT_allocated
:
30910 case DW_AT_associated
:
30911 case DW_AT_byte_stride
:
30912 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
30913 a
->dw_attr_val
.val_entry
= NULL
;
30914 a
->dw_attr_val
.v
.val_die_ref
.die
30915 = loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30916 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
30925 case DW_OP_const_type
:
30926 case DW_OP_regval_type
:
30927 case DW_OP_deref_type
:
30928 case DW_OP_convert
:
30929 case DW_OP_reinterpret
:
30930 case DW_OP_GNU_const_type
:
30931 case DW_OP_GNU_regval_type
:
30932 case DW_OP_GNU_deref_type
:
30933 case DW_OP_GNU_convert
:
30934 case DW_OP_GNU_reinterpret
:
30935 while (loc
->dw_loc_next
30936 && (loc
->dw_loc_next
->dw_loc_opc
== DW_OP_convert
30937 || loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
))
30939 dw_die_ref base1
, base2
;
30940 unsigned enc1
, enc2
, size1
, size2
;
30941 if (loc
->dw_loc_opc
== DW_OP_regval_type
30942 || loc
->dw_loc_opc
== DW_OP_deref_type
30943 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
30944 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
30945 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
30946 else if (loc
->dw_loc_oprnd1
.val_class
30947 == dw_val_class_unsigned_const
)
30950 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30951 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
30952 == dw_val_class_unsigned_const
)
30954 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30955 gcc_assert (base1
->die_tag
== DW_TAG_base_type
30956 && base2
->die_tag
== DW_TAG_base_type
);
30957 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
30958 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
30959 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
30960 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
30962 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
30963 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
30967 /* Optimize away next DW_OP_convert after
30968 adjusting LOC's base type die reference. */
30969 if (loc
->dw_loc_opc
== DW_OP_regval_type
30970 || loc
->dw_loc_opc
== DW_OP_deref_type
30971 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
30972 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
30973 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
30975 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
30976 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
30979 /* Don't change integer DW_OP_convert after e.g. floating
30980 point typed stack entry. */
30981 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
30982 keep
= loc
->dw_loc_next
;
30992 /* Helper function of resolve_addr. DIE had DW_AT_location of
30993 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
30994 and DW_OP_addr couldn't be resolved. resolve_addr has already
30995 removed the DW_AT_location attribute. This function attempts to
30996 add a new DW_AT_location attribute with DW_OP_implicit_pointer
30997 to it or DW_AT_const_value attribute, if possible. */
31000 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
31003 || lookup_decl_die (decl
) != die
31004 || DECL_EXTERNAL (decl
)
31005 || !TREE_STATIC (decl
)
31006 || DECL_INITIAL (decl
) == NULL_TREE
31007 || DECL_P (DECL_INITIAL (decl
))
31008 || get_AT (die
, DW_AT_const_value
))
31011 tree init
= DECL_INITIAL (decl
);
31012 HOST_WIDE_INT offset
= 0;
31013 /* For variables that have been optimized away and thus
31014 don't have a memory location, see if we can emit
31015 DW_AT_const_value instead. */
31016 if (tree_add_const_value_attribute (die
, init
))
31018 if (dwarf_strict
&& dwarf_version
< 5)
31020 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
31021 and ADDR_EXPR refers to a decl that has DW_AT_location or
31022 DW_AT_const_value (but isn't addressable, otherwise
31023 resolving the original DW_OP_addr wouldn't fail), see if
31024 we can add DW_OP_implicit_pointer. */
31026 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
31027 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
31029 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
31030 init
= TREE_OPERAND (init
, 0);
31033 if (TREE_CODE (init
) != ADDR_EXPR
)
31035 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
31036 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
31037 || (VAR_P (TREE_OPERAND (init
, 0))
31038 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
31039 && TREE_OPERAND (init
, 0) != decl
))
31042 dw_loc_descr_ref l
;
31044 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
31046 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
31049 decl
= SYMBOL_REF_DECL (rtl
);
31052 decl
= TREE_OPERAND (init
, 0);
31053 ref
= lookup_decl_die (decl
);
31055 || (!get_AT (ref
, DW_AT_location
)
31056 && !get_AT (ref
, DW_AT_const_value
)))
31058 l
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
31059 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31060 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31061 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31062 add_AT_loc (die
, DW_AT_location
, l
);
31066 /* Return NULL if l is a DWARF expression, or first op that is not
31067 valid DWARF expression. */
31069 static dw_loc_descr_ref
31070 non_dwarf_expression (dw_loc_descr_ref l
)
31074 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
31076 switch (l
->dw_loc_opc
)
31079 case DW_OP_implicit_value
:
31080 case DW_OP_stack_value
:
31081 case DW_OP_implicit_pointer
:
31082 case DW_OP_GNU_implicit_pointer
:
31083 case DW_OP_GNU_parameter_ref
:
31085 case DW_OP_bit_piece
:
31090 l
= l
->dw_loc_next
;
31095 /* Return adjusted copy of EXPR:
31096 If it is empty DWARF expression, return it.
31097 If it is valid non-empty DWARF expression,
31098 return copy of EXPR with DW_OP_deref appended to it.
31099 If it is DWARF expression followed by DW_OP_reg{N,x}, return
31100 copy of the DWARF expression with DW_OP_breg{N,x} <0> appended.
31101 If it is DWARF expression followed by DW_OP_stack_value, return
31102 copy of the DWARF expression without anything appended.
31103 Otherwise, return NULL. */
31105 static dw_loc_descr_ref
31106 copy_deref_exprloc (dw_loc_descr_ref expr
)
31108 dw_loc_descr_ref tail
= NULL
;
31113 dw_loc_descr_ref l
= non_dwarf_expression (expr
);
31114 if (l
&& l
->dw_loc_next
)
31119 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
31120 tail
= new_loc_descr ((enum dwarf_location_atom
)
31121 (DW_OP_breg0
+ (l
->dw_loc_opc
- DW_OP_reg0
)),
31124 switch (l
->dw_loc_opc
)
31127 tail
= new_loc_descr (DW_OP_bregx
,
31128 l
->dw_loc_oprnd1
.v
.val_unsigned
, 0);
31130 case DW_OP_stack_value
:
31137 tail
= new_loc_descr (DW_OP_deref
, 0, 0);
31139 dw_loc_descr_ref ret
= NULL
, *p
= &ret
;
31142 *p
= new_loc_descr (expr
->dw_loc_opc
, 0, 0);
31143 (*p
)->dw_loc_oprnd1
= expr
->dw_loc_oprnd1
;
31144 (*p
)->dw_loc_oprnd2
= expr
->dw_loc_oprnd2
;
31145 p
= &(*p
)->dw_loc_next
;
31146 expr
= expr
->dw_loc_next
;
31152 /* For DW_AT_string_length attribute with DW_OP_GNU_variable_value
31153 reference to a variable or argument, adjust it if needed and return:
31154 -1 if the DW_AT_string_length attribute and DW_AT_{string_length_,}byte_size
31155 attribute if present should be removed
31156 0 keep the attribute perhaps with minor modifications, no need to rescan
31157 1 if the attribute has been successfully adjusted. */
31160 optimize_string_length (dw_attr_node
*a
)
31162 dw_loc_descr_ref l
= AT_loc (a
), lv
;
31164 if (l
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
31166 tree decl
= l
->dw_loc_oprnd1
.v
.val_decl_ref
;
31167 die
= lookup_decl_die (decl
);
31170 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31171 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= die
;
31172 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31178 die
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
31180 /* DWARF5 allows reference class, so we can then reference the DIE.
31181 Only do this for DW_OP_GNU_variable_value DW_OP_stack_value. */
31182 if (l
->dw_loc_next
!= NULL
&& dwarf_version
>= 5)
31184 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
31185 a
->dw_attr_val
.val_entry
= NULL
;
31186 a
->dw_attr_val
.v
.val_die_ref
.die
= die
;
31187 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
31191 dw_attr_node
*av
= get_AT (die
, DW_AT_location
);
31193 bool non_dwarf_expr
= false;
31196 return dwarf_strict
? -1 : 0;
31197 switch (AT_class (av
))
31199 case dw_val_class_loc_list
:
31200 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
31201 if (d
->expr
&& non_dwarf_expression (d
->expr
))
31202 non_dwarf_expr
= true;
31204 case dw_val_class_view_list
:
31205 gcc_unreachable ();
31206 case dw_val_class_loc
:
31209 return dwarf_strict
? -1 : 0;
31210 if (non_dwarf_expression (lv
))
31211 non_dwarf_expr
= true;
31214 return dwarf_strict
? -1 : 0;
31217 /* If it is safe to transform DW_OP_GNU_variable_value DW_OP_stack_value
31218 into DW_OP_call4 or DW_OP_GNU_variable_value into
31219 DW_OP_call4 DW_OP_deref, do so. */
31220 if (!non_dwarf_expr
31221 && (l
->dw_loc_next
!= NULL
|| AT_class (av
) == dw_val_class_loc
))
31223 l
->dw_loc_opc
= DW_OP_call4
;
31224 if (l
->dw_loc_next
)
31225 l
->dw_loc_next
= NULL
;
31227 l
->dw_loc_next
= new_loc_descr (DW_OP_deref
, 0, 0);
31231 /* For DW_OP_GNU_variable_value DW_OP_stack_value, we can just
31232 copy over the DW_AT_location attribute from die to a. */
31233 if (l
->dw_loc_next
!= NULL
)
31235 a
->dw_attr_val
= av
->dw_attr_val
;
31239 dw_loc_list_ref list
, *p
;
31240 switch (AT_class (av
))
31242 case dw_val_class_loc_list
:
31245 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
31247 lv
= copy_deref_exprloc (d
->expr
);
31250 *p
= new_loc_list (lv
, d
->begin
, d
->vbegin
, d
->end
, d
->vend
, d
->section
);
31251 p
= &(*p
)->dw_loc_next
;
31253 else if (!dwarf_strict
&& d
->expr
)
31257 return dwarf_strict
? -1 : 0;
31258 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
31260 *AT_loc_list_ptr (a
) = list
;
31262 case dw_val_class_loc
:
31263 lv
= copy_deref_exprloc (AT_loc (av
));
31265 return dwarf_strict
? -1 : 0;
31266 a
->dw_attr_val
.v
.val_loc
= lv
;
31269 gcc_unreachable ();
31273 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
31274 an address in .rodata section if the string literal is emitted there,
31275 or remove the containing location list or replace DW_AT_const_value
31276 with DW_AT_location and empty location expression, if it isn't found
31277 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
31278 to something that has been emitted in the current CU. */
31281 resolve_addr (dw_die_ref die
)
31285 dw_loc_list_ref
*curr
, *start
, loc
;
31287 bool remove_AT_byte_size
= false;
31289 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31290 switch (AT_class (a
))
31292 case dw_val_class_loc_list
:
31293 start
= curr
= AT_loc_list_ptr (a
);
31296 /* The same list can be referenced more than once. See if we have
31297 already recorded the result from a previous pass. */
31299 *curr
= loc
->dw_loc_next
;
31300 else if (!loc
->resolved_addr
)
31302 /* As things stand, we do not expect or allow one die to
31303 reference a suffix of another die's location list chain.
31304 References must be identical or completely separate.
31305 There is therefore no need to cache the result of this
31306 pass on any list other than the first; doing so
31307 would lead to unnecessary writes. */
31310 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
31311 if (!resolve_addr_in_expr (a
, (*curr
)->expr
))
31313 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
31314 dw_loc_descr_ref l
= (*curr
)->expr
;
31316 if (next
&& (*curr
)->ll_symbol
)
31318 gcc_assert (!next
->ll_symbol
);
31319 next
->ll_symbol
= (*curr
)->ll_symbol
;
31320 next
->vl_symbol
= (*curr
)->vl_symbol
;
31322 if (dwarf_split_debug_info
)
31323 remove_loc_list_addr_table_entries (l
);
31328 mark_base_types ((*curr
)->expr
);
31329 curr
= &(*curr
)->dw_loc_next
;
31333 loc
->resolved_addr
= 1;
31337 loc
->dw_loc_next
= *start
;
31342 remove_AT (die
, a
->dw_attr
);
31346 case dw_val_class_view_list
:
31348 gcc_checking_assert (a
->dw_attr
== DW_AT_GNU_locviews
);
31349 gcc_checking_assert (dwarf2out_locviews_in_attribute ());
31350 dw_val_node
*llnode
31351 = view_list_to_loc_list_val_node (&a
->dw_attr_val
);
31352 /* If we no longer have a loclist, or it no longer needs
31353 views, drop this attribute. */
31354 if (!llnode
|| !llnode
->v
.val_loc_list
->vl_symbol
)
31356 remove_AT (die
, a
->dw_attr
);
31361 case dw_val_class_loc
:
31363 dw_loc_descr_ref l
= AT_loc (a
);
31364 /* DW_OP_GNU_variable_value DW_OP_stack_value or
31365 DW_OP_GNU_variable_value in DW_AT_string_length can be converted
31366 into DW_OP_call4 or DW_OP_call4 DW_OP_deref, which is standard
31367 DWARF4 unlike DW_OP_GNU_variable_value. Or for DWARF5
31368 DW_OP_GNU_variable_value DW_OP_stack_value can be replaced
31369 with DW_FORM_ref referencing the same DIE as
31370 DW_OP_GNU_variable_value used to reference. */
31371 if (a
->dw_attr
== DW_AT_string_length
31373 && l
->dw_loc_opc
== DW_OP_GNU_variable_value
31374 && (l
->dw_loc_next
== NULL
31375 || (l
->dw_loc_next
->dw_loc_next
== NULL
31376 && l
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
)))
31378 switch (optimize_string_length (a
))
31381 remove_AT (die
, a
->dw_attr
);
31383 /* If we drop DW_AT_string_length, we need to drop also
31384 DW_AT_{string_length_,}byte_size. */
31385 remove_AT_byte_size
= true;
31390 /* Even if we keep the optimized DW_AT_string_length,
31391 it might have changed AT_class, so process it again. */
31396 /* For -gdwarf-2 don't attempt to optimize
31397 DW_AT_data_member_location containing
31398 DW_OP_plus_uconst - older consumers might
31399 rely on it being that op instead of a more complex,
31400 but shorter, location description. */
31401 if ((dwarf_version
> 2
31402 || a
->dw_attr
!= DW_AT_data_member_location
31404 || l
->dw_loc_opc
!= DW_OP_plus_uconst
31405 || l
->dw_loc_next
!= NULL
)
31406 && !resolve_addr_in_expr (a
, l
))
31408 if (dwarf_split_debug_info
)
31409 remove_loc_list_addr_table_entries (l
);
31411 && l
->dw_loc_next
== NULL
31412 && l
->dw_loc_opc
== DW_OP_addr
31413 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
31414 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
31415 && a
->dw_attr
== DW_AT_location
)
31417 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
31418 remove_AT (die
, a
->dw_attr
);
31420 optimize_location_into_implicit_ptr (die
, decl
);
31423 if (a
->dw_attr
== DW_AT_string_length
)
31424 /* If we drop DW_AT_string_length, we need to drop also
31425 DW_AT_{string_length_,}byte_size. */
31426 remove_AT_byte_size
= true;
31427 remove_AT (die
, a
->dw_attr
);
31431 mark_base_types (l
);
31434 case dw_val_class_addr
:
31435 if (a
->dw_attr
== DW_AT_const_value
31436 && !resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
))
31438 if (AT_index (a
) != NOT_INDEXED
)
31439 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
31440 remove_AT (die
, a
->dw_attr
);
31443 if ((die
->die_tag
== DW_TAG_call_site
31444 && a
->dw_attr
== DW_AT_call_origin
)
31445 || (die
->die_tag
== DW_TAG_GNU_call_site
31446 && a
->dw_attr
== DW_AT_abstract_origin
))
31448 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
31449 dw_die_ref tdie
= lookup_decl_die (tdecl
);
31452 && DECL_EXTERNAL (tdecl
)
31453 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
31454 && (cdie
= lookup_context_die (DECL_CONTEXT (tdecl
))))
31456 dw_die_ref pdie
= cdie
;
31457 /* Make sure we don't add these DIEs into type units.
31458 We could emit skeleton DIEs for context (namespaces,
31459 outer structs/classes) and a skeleton DIE for the
31460 innermost context with DW_AT_signature pointing to the
31461 type unit. See PR78835. */
31462 while (pdie
&& pdie
->die_tag
!= DW_TAG_type_unit
)
31463 pdie
= pdie
->die_parent
;
31466 /* Creating a full DIE for tdecl is overly expensive and
31467 at this point even wrong when in the LTO phase
31468 as it can end up generating new type DIEs we didn't
31469 output and thus optimize_external_refs will crash. */
31470 tdie
= new_die (DW_TAG_subprogram
, cdie
, NULL_TREE
);
31471 add_AT_flag (tdie
, DW_AT_external
, 1);
31472 add_AT_flag (tdie
, DW_AT_declaration
, 1);
31473 add_linkage_attr (tdie
, tdecl
);
31474 add_name_and_src_coords_attributes (tdie
, tdecl
, true);
31475 equate_decl_number_to_die (tdecl
, tdie
);
31480 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
31481 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
31482 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
31486 if (AT_index (a
) != NOT_INDEXED
)
31487 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
31488 remove_AT (die
, a
->dw_attr
);
31497 if (remove_AT_byte_size
)
31498 remove_AT (die
, dwarf_version
>= 5
31499 ? DW_AT_string_length_byte_size
31500 : DW_AT_byte_size
);
31502 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
31505 /* Helper routines for optimize_location_lists.
31506 This pass tries to share identical local lists in .debug_loc
31509 /* Iteratively hash operands of LOC opcode into HSTATE. */
31512 hash_loc_operands (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
31514 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
31515 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
31517 switch (loc
->dw_loc_opc
)
31519 case DW_OP_const4u
:
31520 case DW_OP_const8u
:
31524 case DW_OP_const1u
:
31525 case DW_OP_const1s
:
31526 case DW_OP_const2u
:
31527 case DW_OP_const2s
:
31528 case DW_OP_const4s
:
31529 case DW_OP_const8s
:
31533 case DW_OP_plus_uconst
:
31569 case DW_OP_deref_size
:
31570 case DW_OP_xderef_size
:
31571 hstate
.add_object (val1
->v
.val_int
);
31578 gcc_assert (val1
->val_class
== dw_val_class_loc
);
31579 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
31580 hstate
.add_object (offset
);
31583 case DW_OP_implicit_value
:
31584 hstate
.add_object (val1
->v
.val_unsigned
);
31585 switch (val2
->val_class
)
31587 case dw_val_class_const
:
31588 hstate
.add_object (val2
->v
.val_int
);
31590 case dw_val_class_vec
:
31592 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
31593 unsigned int len
= val2
->v
.val_vec
.length
;
31595 hstate
.add_int (elt_size
);
31596 hstate
.add_int (len
);
31597 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
31600 case dw_val_class_const_double
:
31601 hstate
.add_object (val2
->v
.val_double
.low
);
31602 hstate
.add_object (val2
->v
.val_double
.high
);
31604 case dw_val_class_wide_int
:
31605 hstate
.add (val2
->v
.val_wide
->get_val (),
31606 get_full_len (*val2
->v
.val_wide
)
31607 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
31609 case dw_val_class_addr
:
31610 inchash::add_rtx (val2
->v
.val_addr
, hstate
);
31613 gcc_unreachable ();
31617 case DW_OP_bit_piece
:
31618 hstate
.add_object (val1
->v
.val_int
);
31619 hstate
.add_object (val2
->v
.val_int
);
31625 unsigned char dtprel
= 0xd1;
31626 hstate
.add_object (dtprel
);
31628 inchash::add_rtx (val1
->v
.val_addr
, hstate
);
31630 case DW_OP_GNU_addr_index
:
31632 case DW_OP_GNU_const_index
:
31637 unsigned char dtprel
= 0xd1;
31638 hstate
.add_object (dtprel
);
31640 inchash::add_rtx (val1
->val_entry
->addr
.rtl
, hstate
);
31643 case DW_OP_implicit_pointer
:
31644 case DW_OP_GNU_implicit_pointer
:
31645 hstate
.add_int (val2
->v
.val_int
);
31647 case DW_OP_entry_value
:
31648 case DW_OP_GNU_entry_value
:
31649 hstate
.add_object (val1
->v
.val_loc
);
31651 case DW_OP_regval_type
:
31652 case DW_OP_deref_type
:
31653 case DW_OP_GNU_regval_type
:
31654 case DW_OP_GNU_deref_type
:
31656 unsigned int byte_size
31657 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
31658 unsigned int encoding
31659 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
31660 hstate
.add_object (val1
->v
.val_int
);
31661 hstate
.add_object (byte_size
);
31662 hstate
.add_object (encoding
);
31665 case DW_OP_convert
:
31666 case DW_OP_reinterpret
:
31667 case DW_OP_GNU_convert
:
31668 case DW_OP_GNU_reinterpret
:
31669 if (val1
->val_class
== dw_val_class_unsigned_const
)
31671 hstate
.add_object (val1
->v
.val_unsigned
);
31675 case DW_OP_const_type
:
31676 case DW_OP_GNU_const_type
:
31678 unsigned int byte_size
31679 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
31680 unsigned int encoding
31681 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
31682 hstate
.add_object (byte_size
);
31683 hstate
.add_object (encoding
);
31684 if (loc
->dw_loc_opc
!= DW_OP_const_type
31685 && loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
31687 hstate
.add_object (val2
->val_class
);
31688 switch (val2
->val_class
)
31690 case dw_val_class_const
:
31691 hstate
.add_object (val2
->v
.val_int
);
31693 case dw_val_class_vec
:
31695 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
31696 unsigned int len
= val2
->v
.val_vec
.length
;
31698 hstate
.add_object (elt_size
);
31699 hstate
.add_object (len
);
31700 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
31703 case dw_val_class_const_double
:
31704 hstate
.add_object (val2
->v
.val_double
.low
);
31705 hstate
.add_object (val2
->v
.val_double
.high
);
31707 case dw_val_class_wide_int
:
31708 hstate
.add (val2
->v
.val_wide
->get_val (),
31709 get_full_len (*val2
->v
.val_wide
)
31710 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
31713 gcc_unreachable ();
31719 /* Other codes have no operands. */
31724 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
31727 hash_locs (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
31729 dw_loc_descr_ref l
;
31730 bool sizes_computed
= false;
31731 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
31732 size_of_locs (loc
);
31734 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
31736 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
31737 hstate
.add_object (opc
);
31738 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
31740 size_of_locs (loc
);
31741 sizes_computed
= true;
31743 hash_loc_operands (l
, hstate
);
31747 /* Compute hash of the whole location list LIST_HEAD. */
31750 hash_loc_list (dw_loc_list_ref list_head
)
31752 dw_loc_list_ref curr
= list_head
;
31753 inchash::hash hstate
;
31755 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
31757 hstate
.add (curr
->begin
, strlen (curr
->begin
) + 1);
31758 hstate
.add (curr
->end
, strlen (curr
->end
) + 1);
31759 hstate
.add_object (curr
->vbegin
);
31760 hstate
.add_object (curr
->vend
);
31762 hstate
.add (curr
->section
, strlen (curr
->section
) + 1);
31763 hash_locs (curr
->expr
, hstate
);
31765 list_head
->hash
= hstate
.end ();
31768 /* Return true if X and Y opcodes have the same operands. */
31771 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
31773 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
31774 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
31775 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
31776 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
31778 switch (x
->dw_loc_opc
)
31780 case DW_OP_const4u
:
31781 case DW_OP_const8u
:
31785 case DW_OP_const1u
:
31786 case DW_OP_const1s
:
31787 case DW_OP_const2u
:
31788 case DW_OP_const2s
:
31789 case DW_OP_const4s
:
31790 case DW_OP_const8s
:
31794 case DW_OP_plus_uconst
:
31830 case DW_OP_deref_size
:
31831 case DW_OP_xderef_size
:
31832 return valx1
->v
.val_int
== valy1
->v
.val_int
;
31835 /* If splitting debug info, the use of DW_OP_GNU_addr_index
31836 can cause irrelevant differences in dw_loc_addr. */
31837 gcc_assert (valx1
->val_class
== dw_val_class_loc
31838 && valy1
->val_class
== dw_val_class_loc
31839 && (dwarf_split_debug_info
31840 || x
->dw_loc_addr
== y
->dw_loc_addr
));
31841 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
31842 case DW_OP_implicit_value
:
31843 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
31844 || valx2
->val_class
!= valy2
->val_class
)
31846 switch (valx2
->val_class
)
31848 case dw_val_class_const
:
31849 return valx2
->v
.val_int
== valy2
->v
.val_int
;
31850 case dw_val_class_vec
:
31851 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
31852 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
31853 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
31854 valx2
->v
.val_vec
.elt_size
31855 * valx2
->v
.val_vec
.length
) == 0;
31856 case dw_val_class_const_double
:
31857 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
31858 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
31859 case dw_val_class_wide_int
:
31860 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
31861 case dw_val_class_addr
:
31862 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
31864 gcc_unreachable ();
31867 case DW_OP_bit_piece
:
31868 return valx1
->v
.val_int
== valy1
->v
.val_int
31869 && valx2
->v
.val_int
== valy2
->v
.val_int
;
31872 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
31873 case DW_OP_GNU_addr_index
:
31875 case DW_OP_GNU_const_index
:
31878 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
31879 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
31880 return rtx_equal_p (ax1
, ay1
);
31882 case DW_OP_implicit_pointer
:
31883 case DW_OP_GNU_implicit_pointer
:
31884 return valx1
->val_class
== dw_val_class_die_ref
31885 && valx1
->val_class
== valy1
->val_class
31886 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
31887 && valx2
->v
.val_int
== valy2
->v
.val_int
;
31888 case DW_OP_entry_value
:
31889 case DW_OP_GNU_entry_value
:
31890 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
31891 case DW_OP_const_type
:
31892 case DW_OP_GNU_const_type
:
31893 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
31894 || valx2
->val_class
!= valy2
->val_class
)
31896 switch (valx2
->val_class
)
31898 case dw_val_class_const
:
31899 return valx2
->v
.val_int
== valy2
->v
.val_int
;
31900 case dw_val_class_vec
:
31901 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
31902 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
31903 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
31904 valx2
->v
.val_vec
.elt_size
31905 * valx2
->v
.val_vec
.length
) == 0;
31906 case dw_val_class_const_double
:
31907 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
31908 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
31909 case dw_val_class_wide_int
:
31910 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
31912 gcc_unreachable ();
31914 case DW_OP_regval_type
:
31915 case DW_OP_deref_type
:
31916 case DW_OP_GNU_regval_type
:
31917 case DW_OP_GNU_deref_type
:
31918 return valx1
->v
.val_int
== valy1
->v
.val_int
31919 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
31920 case DW_OP_convert
:
31921 case DW_OP_reinterpret
:
31922 case DW_OP_GNU_convert
:
31923 case DW_OP_GNU_reinterpret
:
31924 if (valx1
->val_class
!= valy1
->val_class
)
31926 if (valx1
->val_class
== dw_val_class_unsigned_const
)
31927 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
31928 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
31929 case DW_OP_GNU_parameter_ref
:
31930 return valx1
->val_class
== dw_val_class_die_ref
31931 && valx1
->val_class
== valy1
->val_class
31932 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
31934 /* Other codes have no operands. */
31939 /* Return true if DWARF location expressions X and Y are the same. */
31942 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
31944 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
31945 if (x
->dw_loc_opc
!= y
->dw_loc_opc
31946 || x
->dtprel
!= y
->dtprel
31947 || !compare_loc_operands (x
, y
))
31949 return x
== NULL
&& y
== NULL
;
31952 /* Hashtable helpers. */
31954 struct loc_list_hasher
: nofree_ptr_hash
<dw_loc_list_struct
>
31956 static inline hashval_t
hash (const dw_loc_list_struct
*);
31957 static inline bool equal (const dw_loc_list_struct
*,
31958 const dw_loc_list_struct
*);
31961 /* Return precomputed hash of location list X. */
31964 loc_list_hasher::hash (const dw_loc_list_struct
*x
)
31969 /* Return true if location lists A and B are the same. */
31972 loc_list_hasher::equal (const dw_loc_list_struct
*a
,
31973 const dw_loc_list_struct
*b
)
31977 if (a
->hash
!= b
->hash
)
31979 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
31980 if (strcmp (a
->begin
, b
->begin
) != 0
31981 || strcmp (a
->end
, b
->end
) != 0
31982 || (a
->section
== NULL
) != (b
->section
== NULL
)
31983 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
31984 || a
->vbegin
!= b
->vbegin
|| a
->vend
!= b
->vend
31985 || !compare_locs (a
->expr
, b
->expr
))
31987 return a
== NULL
&& b
== NULL
;
31990 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
31993 /* Recursively optimize location lists referenced from DIE
31994 children and share them whenever possible. */
31997 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type
*htab
)
32002 dw_loc_list_struct
**slot
;
32003 bool drop_locviews
= false;
32004 bool has_locviews
= false;
32006 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
32007 if (AT_class (a
) == dw_val_class_loc_list
)
32009 dw_loc_list_ref list
= AT_loc_list (a
);
32010 /* TODO: perform some optimizations here, before hashing
32011 it and storing into the hash table. */
32012 hash_loc_list (list
);
32013 slot
= htab
->find_slot_with_hash (list
, list
->hash
, INSERT
);
32017 if (loc_list_has_views (list
))
32018 gcc_assert (list
->vl_symbol
);
32019 else if (list
->vl_symbol
)
32021 drop_locviews
= true;
32022 list
->vl_symbol
= NULL
;
32027 if (list
->vl_symbol
&& !(*slot
)->vl_symbol
)
32028 drop_locviews
= true;
32029 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
32032 else if (AT_class (a
) == dw_val_class_view_list
)
32034 gcc_checking_assert (a
->dw_attr
== DW_AT_GNU_locviews
);
32035 has_locviews
= true;
32039 if (drop_locviews
&& has_locviews
)
32040 remove_AT (die
, DW_AT_GNU_locviews
);
32042 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
32046 /* Recursively assign each location list a unique index into the debug_addr
32050 index_location_lists (dw_die_ref die
)
32056 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
32057 if (AT_class (a
) == dw_val_class_loc_list
)
32059 dw_loc_list_ref list
= AT_loc_list (a
);
32060 dw_loc_list_ref curr
;
32061 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
32063 /* Don't index an entry that has already been indexed
32064 or won't be output. Make sure skip_loc_list_entry doesn't
32065 call size_of_locs, because that might cause circular dependency,
32066 index_location_lists requiring address table indexes to be
32067 computed, but adding new indexes through add_addr_table_entry
32068 and address table index computation requiring no new additions
32069 to the hash table. In the rare case of DWARF[234] >= 64KB
32070 location expression, we'll just waste unused address table entry
32072 if (curr
->begin_entry
!= NULL
|| skip_loc_list_entry (curr
))
32076 = add_addr_table_entry (xstrdup (curr
->begin
), ate_kind_label
);
32077 if (dwarf_version
>= 5 && !HAVE_AS_LEB128
)
32079 = add_addr_table_entry (xstrdup (curr
->end
), ate_kind_label
);
32083 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
32086 /* Optimize location lists referenced from DIE
32087 children and share them whenever possible. */
32090 optimize_location_lists (dw_die_ref die
)
32092 loc_list_hash_type
htab (500);
32093 optimize_location_lists_1 (die
, &htab
);
32096 /* Traverse the limbo die list, and add parent/child links. The only
32097 dies without parents that should be here are concrete instances of
32098 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
32099 For concrete instances, we can get the parent die from the abstract
32103 flush_limbo_die_list (void)
32105 limbo_die_node
*node
;
32107 /* get_context_die calls force_decl_die, which can put new DIEs on the
32108 limbo list in LTO mode when nested functions are put in a different
32109 partition than that of their parent function. */
32110 while ((node
= limbo_die_list
))
32112 dw_die_ref die
= node
->die
;
32113 limbo_die_list
= node
->next
;
32115 if (die
->die_parent
== NULL
)
32117 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
32119 if (origin
&& origin
->die_parent
)
32120 add_child_die (origin
->die_parent
, die
);
32121 else if (is_cu_die (die
))
32123 else if (seen_error ())
32124 /* It's OK to be confused by errors in the input. */
32125 add_child_die (comp_unit_die (), die
);
32128 /* In certain situations, the lexical block containing a
32129 nested function can be optimized away, which results
32130 in the nested function die being orphaned. Likewise
32131 with the return type of that nested function. Force
32132 this to be a child of the containing function.
32134 It may happen that even the containing function got fully
32135 inlined and optimized out. In that case we are lost and
32136 assign the empty child. This should not be big issue as
32137 the function is likely unreachable too. */
32138 gcc_assert (node
->created_for
);
32140 if (DECL_P (node
->created_for
))
32141 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
32142 else if (TYPE_P (node
->created_for
))
32143 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
32145 origin
= comp_unit_die ();
32147 add_child_die (origin
, die
);
32153 /* Reset DIEs so we can output them again. */
32156 reset_dies (dw_die_ref die
)
32160 /* Remove stuff we re-generate. */
32162 die
->die_offset
= 0;
32163 die
->die_abbrev
= 0;
32164 remove_AT (die
, DW_AT_sibling
);
32166 FOR_EACH_CHILD (die
, c
, reset_dies (c
));
32169 /* reset_indirect_string removed the references coming from DW_AT_name
32170 and DW_AT_comp_dir attributes on compilation unit DIEs. Readd them as
32171 .debug_line_str strings again. */
32174 adjust_name_comp_dir (dw_die_ref die
)
32176 for (int i
= 0; i
< 2; i
++)
32178 dwarf_attribute attr_kind
= i
? DW_AT_comp_dir
: DW_AT_name
;
32179 dw_attr_node
*a
= get_AT (die
, attr_kind
);
32180 if (a
== NULL
|| a
->dw_attr_val
.val_class
!= dw_val_class_str
)
32183 if (!debug_line_str_hash
)
32184 debug_line_str_hash
32185 = hash_table
<indirect_string_hasher
>::create_ggc (10);
32187 struct indirect_string_node
*node
32188 = find_AT_string_in_table (a
->dw_attr_val
.v
.val_str
->str
,
32189 debug_line_str_hash
);
32190 set_indirect_string (node
);
32191 node
->form
= DW_FORM_line_strp
;
32192 a
->dw_attr_val
.v
.val_str
= node
;
32196 /* Output stuff that dwarf requires at the end of every file,
32197 and generate the DWARF-2 debugging info. */
32200 dwarf2out_finish (const char *filename
)
32202 comdat_type_node
*ctnode
;
32203 dw_die_ref main_comp_unit_die
;
32204 unsigned char checksum
[16];
32205 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
32207 /* Generate CTF/BTF debug info. */
32208 if ((ctf_debug_info_level
> CTFINFO_LEVEL_NONE
32209 || btf_debuginfo_p ()) && lang_GNU_C ())
32210 ctf_debug_finish (filename
);
32212 /* Skip emitting DWARF if not required. */
32213 if (!dwarf_debuginfo_p ())
32216 /* Flush out any latecomers to the limbo party. */
32217 flush_limbo_die_list ();
32219 if (inline_entry_data_table
)
32220 gcc_assert (inline_entry_data_table
->is_empty ());
32224 verify_die (comp_unit_die ());
32225 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
32226 verify_die (node
->die
);
32229 /* We shouldn't have any symbols with delayed asm names for
32230 DIEs generated after early finish. */
32231 gcc_assert (deferred_asm_name
== NULL
);
32233 gen_remaining_tmpl_value_param_die_attribute ();
32235 if (flag_generate_lto
|| flag_generate_offload
)
32237 gcc_assert (flag_fat_lto_objects
|| flag_generate_offload
);
32239 /* Prune stuff so that dwarf2out_finish runs successfully
32240 for the fat part of the object. */
32241 reset_dies (comp_unit_die ());
32242 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
32243 reset_dies (node
->die
);
32245 hash_table
<comdat_type_hasher
> comdat_type_table (100);
32246 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
32248 comdat_type_node
**slot
32249 = comdat_type_table
.find_slot (ctnode
, INSERT
);
32251 /* Don't reset types twice. */
32252 if (*slot
!= HTAB_EMPTY_ENTRY
)
32255 /* Remove the pointer to the line table. */
32256 remove_AT (ctnode
->root_die
, DW_AT_stmt_list
);
32258 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32259 reset_dies (ctnode
->root_die
);
32264 /* Reset die CU symbol so we don't output it twice. */
32265 comp_unit_die ()->die_id
.die_symbol
= NULL
;
32267 /* Remove DW_AT_macro and DW_AT_stmt_list from the early output. */
32268 remove_AT (comp_unit_die (), DW_AT_stmt_list
);
32270 remove_AT (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
);
32272 /* Remove indirect string decisions. */
32273 debug_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
32274 if (debug_line_str_hash
)
32276 debug_line_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
32277 debug_line_str_hash
= NULL
;
32278 if (asm_outputs_debug_line_str ())
32280 adjust_name_comp_dir (comp_unit_die ());
32281 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
32282 adjust_name_comp_dir (node
->die
);
32287 #if ENABLE_ASSERT_CHECKING
32289 dw_die_ref die
= comp_unit_die (), c
;
32290 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
32293 base_types
.truncate (0);
32294 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
32295 resolve_addr (ctnode
->root_die
);
32296 resolve_addr (comp_unit_die ());
32297 move_marked_base_types ();
32301 fprintf (dump_file
, "DWARF for %s\n", filename
);
32302 print_die (comp_unit_die (), dump_file
);
32305 /* Initialize sections and labels used for actual assembler output. */
32306 unsigned generation
= init_sections_and_labels (false);
32308 /* Traverse the DIE's and add sibling attributes to those DIE's that
32310 add_sibling_attributes (comp_unit_die ());
32311 limbo_die_node
*node
;
32312 for (node
= cu_die_list
; node
; node
= node
->next
)
32313 add_sibling_attributes (node
->die
);
32314 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
32315 add_sibling_attributes (ctnode
->root_die
);
32317 /* When splitting DWARF info, we put some attributes in the
32318 skeleton compile_unit DIE that remains in the .o, while
32319 most attributes go in the DWO compile_unit_die. */
32320 if (dwarf_split_debug_info
)
32322 limbo_die_node
*cu
;
32323 main_comp_unit_die
= gen_compile_unit_die (NULL
);
32324 if (dwarf_version
>= 5)
32325 main_comp_unit_die
->die_tag
= DW_TAG_skeleton_unit
;
32326 cu
= limbo_die_list
;
32327 gcc_assert (cu
->die
== main_comp_unit_die
);
32328 limbo_die_list
= limbo_die_list
->next
;
32329 cu
->next
= cu_die_list
;
32333 main_comp_unit_die
= comp_unit_die ();
32335 /* Output a terminator label for the .text section. */
32336 switch_to_section (text_section
);
32337 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
32338 if (cold_text_section
)
32340 switch_to_section (cold_text_section
);
32341 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
32344 /* We can only use the low/high_pc attributes if all of the code was
32346 if ((!have_multiple_function_sections
32347 && vec_safe_length (switch_text_ranges
) < 2)
32348 || (dwarf_version
< 3 && dwarf_strict
))
32350 const char *end_label
= text_end_label
;
32351 if (vec_safe_length (switch_text_ranges
) == 1)
32352 end_label
= (*switch_text_ranges
)[0];
32353 /* Don't add if the CU has no associated code. */
32354 if (switch_text_ranges
)
32355 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
32362 bool range_list_added
= false;
32363 if (switch_text_ranges
)
32365 const char *prev_loc
= text_section_label
;
32369 FOR_EACH_VEC_ELT (*switch_text_ranges
, idx
, loc
)
32372 add_ranges_by_labels (main_comp_unit_die
, prev_loc
,
32373 loc
, &range_list_added
, true);
32380 add_ranges_by_labels (main_comp_unit_die
, prev_loc
,
32381 text_end_label
, &range_list_added
, true);
32384 if (switch_cold_ranges
)
32386 const char *prev_loc
= cold_text_section_label
;
32390 FOR_EACH_VEC_ELT (*switch_cold_ranges
, idx
, loc
)
32393 add_ranges_by_labels (main_comp_unit_die
, prev_loc
,
32394 loc
, &range_list_added
, true);
32401 add_ranges_by_labels (main_comp_unit_die
, prev_loc
,
32402 cold_end_label
, &range_list_added
, true);
32405 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
32407 if (fde
->ignored_debug
)
32409 if (!fde
->in_std_section
)
32410 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
32411 fde
->dw_fde_end
, &range_list_added
,
32413 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
32414 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
32415 fde
->dw_fde_second_end
, &range_list_added
,
32419 if (range_list_added
)
32421 /* We need to give .debug_loc and .debug_ranges an appropriate
32422 "base address". Use zero so that these addresses become
32423 absolute. Historically, we've emitted the unexpected
32424 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
32425 Emit both to give time for other tools to adapt. */
32426 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
32427 if (! dwarf_strict
&& dwarf_version
< 4)
32428 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
32431 have_multiple_function_sections
= true;
32435 /* AIX Assembler inserts the length, so adjust the reference to match the
32436 offset expected by debuggers. */
32437 strcpy (dl_section_ref
, debug_line_section_label
);
32438 if (XCOFF_DEBUGGING_INFO
)
32439 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
32441 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32442 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
32446 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
32447 macinfo_section_label
);
32449 if (dwarf_split_debug_info
)
32451 if (have_location_lists
)
32453 /* Since we generate the loclists in the split DWARF .dwo
32454 file itself, we don't need to generate a loclists_base
32455 attribute for the split compile unit DIE. That attribute
32456 (and using relocatable sec_offset FORMs) isn't allowed
32457 for a split compile unit. Only if the .debug_loclists
32458 section was in the main file, would we need to generate a
32459 loclists_base attribute here (for the full or skeleton
32462 /* optimize_location_lists calculates the size of the lists,
32463 so index them first, and assign indices to the entries.
32464 Although optimize_location_lists will remove entries from
32465 the table, it only does so for duplicates, and therefore
32466 only reduces ref_counts to 1. */
32467 index_location_lists (comp_unit_die ());
32470 if (dwarf_version
>= 5 && !vec_safe_is_empty (ranges_table
))
32473 if (addr_index_table
!= NULL
)
32475 unsigned int index
= 0;
32477 ->traverse_noresize
<unsigned int *, index_addr_table_entry
>
32483 if (have_location_lists
)
32485 optimize_location_lists (comp_unit_die ());
32486 /* And finally assign indexes to the entries for -gsplit-dwarf. */
32487 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
32488 assign_location_list_indexes (comp_unit_die ());
32491 save_macinfo_strings ();
32493 if (dwarf_split_debug_info
)
32495 unsigned int index
= 0;
32497 /* Add attributes common to skeleton compile_units and
32498 type_units. Because these attributes include strings, it
32499 must be done before freezing the string table. Top-level
32500 skeleton die attrs are added when the skeleton type unit is
32501 created, so ensure it is created by this point. */
32502 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
32503 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
32506 /* Output all of the compilation units. We put the main one last so that
32507 the offsets are available to output_pubnames. */
32508 for (node
= cu_die_list
; node
; node
= node
->next
)
32509 output_comp_unit (node
->die
, 0, NULL
);
32511 hash_table
<comdat_type_hasher
> comdat_type_table (100);
32512 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
32514 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
32516 /* Don't output duplicate types. */
32517 if (*slot
!= HTAB_EMPTY_ENTRY
)
32520 /* Add a pointer to the line table for the main compilation unit
32521 so that the debugger can make sense of DW_AT_decl_file
32523 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32524 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
32525 (!dwarf_split_debug_info
32527 : debug_skeleton_line_section_label
));
32529 output_comdat_type_unit (ctnode
, false);
32533 if (dwarf_split_debug_info
)
32536 struct md5_ctx ctx
;
32538 /* Compute a checksum of the comp_unit to use as the dwo_id. */
32539 md5_init_ctx (&ctx
);
32541 die_checksum (comp_unit_die (), &ctx
, &mark
);
32542 unmark_all_dies (comp_unit_die ());
32543 md5_finish_ctx (&ctx
, checksum
);
32545 if (dwarf_version
< 5)
32547 /* Use the first 8 bytes of the checksum as the dwo_id,
32548 and add it to both comp-unit DIEs. */
32549 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
32550 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
32553 /* Add the base offset of the ranges table to the skeleton
32555 if (!vec_safe_is_empty (ranges_table
))
32557 if (dwarf_version
< 5)
32558 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
32559 ranges_section_label
);
32562 output_addr_table ();
32565 /* Output the main compilation unit if non-empty or if .debug_macinfo
32566 or .debug_macro will be emitted. */
32567 output_comp_unit (comp_unit_die (), have_macinfo
,
32568 dwarf_split_debug_info
? checksum
: NULL
);
32570 if (dwarf_split_debug_info
&& info_section_emitted
)
32571 output_skeleton_debug_sections (main_comp_unit_die
, checksum
);
32573 /* Output the abbreviation table. */
32574 if (vec_safe_length (abbrev_die_table
) != 1)
32576 switch_to_section (debug_abbrev_section
);
32577 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
32578 output_abbrev_section ();
32581 /* Output location list section if necessary. */
32582 if (have_location_lists
)
32584 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
32585 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
32586 /* Output the location lists info. */
32587 switch_to_section (debug_loc_section
);
32588 if (dwarf_version
>= 5)
32590 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_LOC_SECTION_LABEL
, 2);
32591 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_LOC_SECTION_LABEL
, 3);
32592 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
32593 dw2_asm_output_data (4, 0xffffffff,
32594 "Initial length escape value indicating "
32595 "64-bit DWARF extension");
32596 dw2_asm_output_delta (dwarf_offset_size
, l2
, l1
,
32597 "Length of Location Lists");
32598 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
32599 output_dwarf_version ();
32600 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
32601 dw2_asm_output_data (1, 0, "Segment Size");
32602 dw2_asm_output_data (4, dwarf_split_debug_info
? loc_list_idx
: 0,
32603 "Offset Entry Count");
32605 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
32606 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
32608 unsigned int save_loc_list_idx
= loc_list_idx
;
32610 output_loclists_offsets (comp_unit_die ());
32611 gcc_assert (save_loc_list_idx
== loc_list_idx
);
32613 output_location_lists (comp_unit_die ());
32614 if (dwarf_version
>= 5)
32615 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
32618 output_pubtables ();
32620 /* Output the address range information if a CU (.debug_info section)
32621 was emitted. We output an empty table even if we had no functions
32622 to put in it. This because the consumer has no way to tell the
32623 difference between an empty table that we omitted and failure to
32624 generate a table that would have contained data. */
32625 if (info_section_emitted
)
32627 switch_to_section (debug_aranges_section
);
32631 /* Output ranges section if necessary. */
32632 if (!vec_safe_is_empty (ranges_table
))
32634 if (dwarf_version
>= 5)
32636 if (dwarf_split_debug_info
)
32638 /* We don't know right now whether there are any
32639 ranges for .debug_rnglists and any for .debug_rnglists.dwo.
32640 Depending on into which of those two belongs the first
32641 ranges_table entry, emit that section first and that
32642 output_rnglists call will return true if the other kind of
32643 ranges needs to be emitted as well. */
32644 bool dwo
= (*ranges_table
)[0].idx
!= DW_RANGES_IDX_SKELETON
;
32645 if (output_rnglists (generation
, dwo
))
32646 output_rnglists (generation
, !dwo
);
32649 output_rnglists (generation
, false);
32655 /* Have to end the macro section. */
32658 switch_to_section (debug_macinfo_section
);
32659 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
32660 output_macinfo (!dwarf_split_debug_info
? debug_line_section_label
32661 : debug_skeleton_line_section_label
, false);
32662 dw2_asm_output_data (1, 0, "End compilation unit");
32665 /* Output the source line correspondence table. We must do this
32666 even if there is no line information. Otherwise, on an empty
32667 translation unit, we will generate a present, but empty,
32668 .debug_info section. IRIX 6.5 `nm' will then complain when
32669 examining the file. This is done late so that any filenames
32670 used by the debug_info section are marked as 'used'. */
32671 switch_to_section (debug_line_section
);
32672 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
32673 if (! output_asm_line_debug_info ())
32674 output_line_info (false);
32676 if (dwarf_split_debug_info
&& info_section_emitted
)
32678 switch_to_section (debug_skeleton_line_section
);
32679 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
32680 output_line_info (true);
32683 /* If we emitted any indirect strings, output the string table too. */
32684 if (debug_str_hash
|| skeleton_debug_str_hash
)
32685 output_indirect_strings ();
32686 if (debug_line_str_hash
)
32688 switch_to_section (debug_line_str_section
);
32689 const enum dwarf_form form
= DW_FORM_line_strp
;
32690 debug_line_str_hash
->traverse
<enum dwarf_form
,
32691 output_indirect_string
> (form
);
32694 /* ??? Move lvugid out of dwarf2out_source_line and reset it too? */
32695 symview_upper_bound
= 0;
32697 bitmap_clear (zero_view_p
);
32700 /* Returns a hash value for X (which really is a variable_value_struct). */
32703 variable_value_hasher::hash (variable_value_struct
*x
)
32705 return (hashval_t
) x
->decl_id
;
32708 /* Return true if decl_id of variable_value_struct X is the same as
32712 variable_value_hasher::equal (variable_value_struct
*x
, tree y
)
32714 return x
->decl_id
== DECL_UID (y
);
32717 /* Helper function for resolve_variable_value, handle
32718 DW_OP_GNU_variable_value in one location expression.
32719 Return true if exprloc has been changed into loclist. */
32722 resolve_variable_value_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
32724 dw_loc_descr_ref next
;
32725 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= next
)
32727 next
= loc
->dw_loc_next
;
32728 if (loc
->dw_loc_opc
!= DW_OP_GNU_variable_value
32729 || loc
->dw_loc_oprnd1
.val_class
!= dw_val_class_decl_ref
)
32732 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
32733 if (DECL_CONTEXT (decl
) != current_function_decl
)
32736 dw_die_ref ref
= lookup_decl_die (decl
);
32739 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
32740 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
32741 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
32744 dw_loc_list_ref l
= loc_list_from_tree (decl
, 0, NULL
);
32747 if (l
->dw_loc_next
)
32749 if (AT_class (a
) != dw_val_class_loc
)
32751 switch (a
->dw_attr
)
32753 /* Following attributes allow both exprloc and loclist
32754 classes, so we can change them into a loclist. */
32755 case DW_AT_location
:
32756 case DW_AT_string_length
:
32757 case DW_AT_return_addr
:
32758 case DW_AT_data_member_location
:
32759 case DW_AT_frame_base
:
32760 case DW_AT_segment
:
32761 case DW_AT_static_link
:
32762 case DW_AT_use_location
:
32763 case DW_AT_vtable_elem_location
:
32766 prev
->dw_loc_next
= NULL
;
32767 prepend_loc_descr_to_each (l
, AT_loc (a
));
32770 add_loc_descr_to_each (l
, next
);
32771 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
32772 a
->dw_attr_val
.val_entry
= NULL
;
32773 a
->dw_attr_val
.v
.val_loc_list
= l
;
32774 have_location_lists
= true;
32776 /* Following attributes allow both exprloc and reference,
32777 so if the whole expression is DW_OP_GNU_variable_value alone
32778 we could transform it into reference. */
32779 case DW_AT_byte_size
:
32780 case DW_AT_bit_size
:
32781 case DW_AT_lower_bound
:
32782 case DW_AT_upper_bound
:
32783 case DW_AT_bit_stride
:
32785 case DW_AT_allocated
:
32786 case DW_AT_associated
:
32787 case DW_AT_byte_stride
:
32788 if (prev
== NULL
&& next
== NULL
)
32796 /* Create DW_TAG_variable that we can refer to. */
32797 gen_decl_die (decl
, NULL_TREE
, NULL
,
32798 lookup_decl_die (current_function_decl
));
32799 ref
= lookup_decl_die (decl
);
32802 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
32803 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
32804 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
32810 prev
->dw_loc_next
= l
->expr
;
32811 add_loc_descr (&prev
->dw_loc_next
, next
);
32812 free_loc_descr (loc
, NULL
);
32813 next
= prev
->dw_loc_next
;
32817 memcpy (loc
, l
->expr
, sizeof (dw_loc_descr_node
));
32818 add_loc_descr (&loc
, next
);
32826 /* Attempt to resolve DW_OP_GNU_variable_value using loc_list_from_tree. */
32829 resolve_variable_value (dw_die_ref die
)
32832 dw_loc_list_ref loc
;
32835 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
32836 switch (AT_class (a
))
32838 case dw_val_class_loc
:
32839 if (!resolve_variable_value_in_expr (a
, AT_loc (a
)))
32842 case dw_val_class_loc_list
:
32843 loc
= AT_loc_list (a
);
32845 for (; loc
; loc
= loc
->dw_loc_next
)
32846 resolve_variable_value_in_expr (a
, loc
->expr
);
32853 /* Attempt to optimize DW_OP_GNU_variable_value refering to
32854 temporaries in the current function. */
32857 resolve_variable_values (void)
32859 if (!variable_value_hash
|| !current_function_decl
)
32862 struct variable_value_struct
*node
32863 = variable_value_hash
->find_with_hash (current_function_decl
,
32864 DECL_UID (current_function_decl
));
32871 FOR_EACH_VEC_SAFE_ELT (node
->dies
, i
, die
)
32872 resolve_variable_value (die
);
32875 /* Helper function for note_variable_value, handle one location
32879 note_variable_value_in_expr (dw_die_ref die
, dw_loc_descr_ref loc
)
32881 for (; loc
; loc
= loc
->dw_loc_next
)
32882 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
32883 && loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
32885 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
32886 dw_die_ref ref
= lookup_decl_die (decl
);
32887 if (! ref
&& (flag_generate_lto
|| flag_generate_offload
))
32889 /* ??? This is somewhat a hack because we do not create DIEs
32890 for variables not in BLOCK trees early but when generating
32891 early LTO output we need the dw_val_class_decl_ref to be
32892 fully resolved. For fat LTO objects we'd also like to
32893 undo this after LTO dwarf output. */
32894 gcc_assert (DECL_CONTEXT (decl
));
32895 dw_die_ref ctx
= lookup_decl_die (DECL_CONTEXT (decl
));
32896 gcc_assert (ctx
!= NULL
);
32897 gen_decl_die (decl
, NULL_TREE
, NULL
, ctx
);
32898 ref
= lookup_decl_die (decl
);
32899 gcc_assert (ref
!= NULL
);
32903 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
32904 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
32905 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
32909 && DECL_CONTEXT (decl
)
32910 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
32911 && lookup_decl_die (DECL_CONTEXT (decl
)))
32913 if (!variable_value_hash
)
32914 variable_value_hash
32915 = hash_table
<variable_value_hasher
>::create_ggc (10);
32917 tree fndecl
= DECL_CONTEXT (decl
);
32918 struct variable_value_struct
*node
;
32919 struct variable_value_struct
**slot
32920 = variable_value_hash
->find_slot_with_hash (fndecl
,
32925 node
= ggc_cleared_alloc
<variable_value_struct
> ();
32926 node
->decl_id
= DECL_UID (fndecl
);
32932 vec_safe_push (node
->dies
, die
);
32937 /* Walk the tree DIE and note DIEs with DW_OP_GNU_variable_value still
32938 with dw_val_class_decl_ref operand. */
32941 note_variable_value (dw_die_ref die
)
32945 dw_loc_list_ref loc
;
32948 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
32949 switch (AT_class (a
))
32951 case dw_val_class_loc_list
:
32952 loc
= AT_loc_list (a
);
32954 if (!loc
->noted_variable_value
)
32956 loc
->noted_variable_value
= 1;
32957 for (; loc
; loc
= loc
->dw_loc_next
)
32958 note_variable_value_in_expr (die
, loc
->expr
);
32961 case dw_val_class_loc
:
32962 note_variable_value_in_expr (die
, AT_loc (a
));
32968 /* Mark children. */
32969 FOR_EACH_CHILD (die
, c
, note_variable_value (c
));
32972 /* Process DWARF dies for CTF generation. */
32975 ctf_debug_do_cu (dw_die_ref die
)
32979 if (!ctf_do_die (die
))
32982 FOR_EACH_CHILD (die
, c
, ctf_do_die (c
));
32985 /* Perform any cleanups needed after the early debug generation pass
32989 dwarf2out_early_finish (const char *filename
)
32991 comdat_type_node
*ctnode
;
32993 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
32995 /* PCH might result in DW_AT_producer string being restored from the
32996 header compilation, so always fill it with empty string initially
32997 and overwrite only here. */
32998 dw_attr_node
*producer
= get_AT (comp_unit_die (), DW_AT_producer
);
33000 if (dwarf_record_gcc_switches
)
33001 producer_string
= gen_producer_string (lang_hooks
.name
,
33002 save_decoded_options
,
33003 save_decoded_options_count
);
33005 producer_string
= concat (lang_hooks
.name
, " ", version_string
, NULL
);
33007 producer
->dw_attr_val
.v
.val_str
->refcount
--;
33008 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
33010 /* Add the name for the main input file now. We delayed this from
33011 dwarf2out_init to avoid complications with PCH. */
33012 add_filename_attribute (comp_unit_die (), remap_debug_filename (filename
));
33013 add_comp_dir_attribute (comp_unit_die ());
33015 /* With LTO early dwarf was really finished at compile-time, so make
33016 sure to adjust the phase after annotating the LTRANS CU DIE. */
33019 early_dwarf_finished
= true;
33022 fprintf (dump_file
, "LTO EARLY DWARF for %s\n", filename
);
33023 print_die (comp_unit_die (), dump_file
);
33028 /* Walk through the list of incomplete types again, trying once more to
33029 emit full debugging info for them. */
33030 retry_incomplete_types ();
33032 gen_scheduled_generic_parms_dies ();
33033 gen_remaining_tmpl_value_param_die_attribute ();
33035 /* The point here is to flush out the limbo list so that it is empty
33036 and we don't need to stream it for LTO. */
33037 flush_limbo_die_list ();
33039 /* Add DW_AT_linkage_name for all deferred DIEs. */
33040 for (limbo_die_node
*node
= deferred_asm_name
; node
; node
= node
->next
)
33042 tree decl
= node
->created_for
;
33043 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
33044 /* A missing DECL_ASSEMBLER_NAME can be a constant DIE that
33045 ended up in deferred_asm_name before we knew it was
33046 constant and never written to disk. */
33047 && DECL_ASSEMBLER_NAME (decl
))
33049 add_linkage_attr (node
->die
, decl
);
33050 move_linkage_attr (node
->die
);
33053 deferred_asm_name
= NULL
;
33055 if (flag_eliminate_unused_debug_types
)
33056 prune_unused_types ();
33058 /* Generate separate COMDAT sections for type DIEs. */
33059 if (use_debug_types
)
33061 break_out_comdat_types (comp_unit_die ());
33063 /* Each new type_unit DIE was added to the limbo die list when created.
33064 Since these have all been added to comdat_type_list, clear the
33066 limbo_die_list
= NULL
;
33068 /* For each new comdat type unit, copy declarations for incomplete
33069 types to make the new unit self-contained (i.e., no direct
33070 references to the main compile unit). */
33071 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
33072 copy_decls_for_unworthy_types (ctnode
->root_die
);
33073 copy_decls_for_unworthy_types (comp_unit_die ());
33075 /* In the process of copying declarations from one unit to another,
33076 we may have left some declarations behind that are no longer
33077 referenced. Prune them. */
33078 prune_unused_types ();
33081 /* Traverse the DIE's and note DIEs with DW_OP_GNU_variable_value still
33082 with dw_val_class_decl_ref operand. */
33083 note_variable_value (comp_unit_die ());
33084 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
33085 note_variable_value (node
->die
);
33086 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
33087 note_variable_value (ctnode
->root_die
);
33088 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
33089 note_variable_value (node
->die
);
33091 /* The AT_pubnames attribute needs to go in all skeleton dies, including
33092 both the main_cu and all skeleton TUs. Making this call unconditional
33093 would end up either adding a second copy of the AT_pubnames attribute, or
33094 requiring a special case in add_top_level_skeleton_die_attrs. */
33095 if (!dwarf_split_debug_info
)
33096 add_AT_pubnames (comp_unit_die ());
33098 /* The early debug phase is now finished. */
33099 early_dwarf_finished
= true;
33102 fprintf (dump_file
, "EARLY DWARF for %s\n", filename
);
33103 print_die (comp_unit_die (), dump_file
);
33106 /* Generate CTF/BTF debug info. */
33107 if ((ctf_debug_info_level
> CTFINFO_LEVEL_NONE
33108 || btf_debuginfo_p ()) && lang_GNU_C ())
33111 ctf_debug_do_cu (comp_unit_die ());
33112 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
33113 ctf_debug_do_cu (node
->die
);
33114 /* Post process the debug data in the CTF container if necessary. */
33115 ctf_debug_init_postprocess (btf_debuginfo_p ());
33117 ctf_debug_early_finish (filename
);
33120 /* Do not generate DWARF assembler now when not producing LTO bytecode. */
33121 if ((!flag_generate_lto
&& !flag_generate_offload
)
33122 /* FIXME: Disable debug info generation for (PE-)COFF targets since the
33123 copy_lto_debug_sections operation of the simple object support in
33124 libiberty is not implemented for them yet. */
33125 || TARGET_PECOFF
|| TARGET_COFF
)
33128 /* Now as we are going to output for LTO initialize sections and labels
33129 to the LTO variants. We don't need a random-seed postfix as other
33130 LTO sections as linking the LTO debug sections into one in a partial
33132 init_sections_and_labels (true);
33134 /* The output below is modeled after dwarf2out_finish with all
33135 location related output removed and some LTO specific changes.
33136 Some refactoring might make both smaller and easier to match up. */
33138 base_types
.truncate (0);
33139 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
33140 mark_base_types (ctnode
->root_die
);
33141 mark_base_types (comp_unit_die ());
33142 move_marked_base_types ();
33144 /* Traverse the DIE's and add sibling attributes to those DIE's
33145 that have children. */
33146 add_sibling_attributes (comp_unit_die ());
33147 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
33148 add_sibling_attributes (node
->die
);
33149 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
33150 add_sibling_attributes (ctnode
->root_die
);
33152 /* AIX Assembler inserts the length, so adjust the reference to match the
33153 offset expected by debuggers. */
33154 strcpy (dl_section_ref
, debug_line_section_label
);
33155 if (XCOFF_DEBUGGING_INFO
)
33156 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
33158 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
33159 add_AT_lineptr (comp_unit_die (), DW_AT_stmt_list
, dl_section_ref
);
33162 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
33163 macinfo_section_label
);
33165 save_macinfo_strings ();
33167 if (dwarf_split_debug_info
)
33169 unsigned int index
= 0;
33170 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
33173 /* Output all of the compilation units. We put the main one last so that
33174 the offsets are available to output_pubnames. */
33175 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
33176 output_comp_unit (node
->die
, 0, NULL
);
33178 hash_table
<comdat_type_hasher
> comdat_type_table (100);
33179 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
33181 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
33183 /* Don't output duplicate types. */
33184 if (*slot
!= HTAB_EMPTY_ENTRY
)
33187 /* Add a pointer to the line table for the main compilation unit
33188 so that the debugger can make sense of DW_AT_decl_file
33190 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
33191 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
33192 (!dwarf_split_debug_info
33193 ? debug_line_section_label
33194 : debug_skeleton_line_section_label
));
33196 output_comdat_type_unit (ctnode
, true);
33200 /* Stick a unique symbol to the main debuginfo section. */
33201 compute_comp_unit_symbol (comp_unit_die ());
33203 /* Output the main compilation unit. We always need it if only for
33205 output_comp_unit (comp_unit_die (), true, NULL
);
33207 /* Output the abbreviation table. */
33208 if (vec_safe_length (abbrev_die_table
) != 1)
33210 switch_to_section (debug_abbrev_section
);
33211 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
33212 output_abbrev_section ();
33215 /* Have to end the macro section. */
33218 /* We have to save macinfo state if we need to output it again
33219 for the FAT part of the object. */
33220 vec
<macinfo_entry
, va_gc
> *saved_macinfo_table
= macinfo_table
;
33221 if (flag_fat_lto_objects
)
33222 macinfo_table
= macinfo_table
->copy ();
33224 switch_to_section (debug_macinfo_section
);
33225 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
33226 output_macinfo (debug_line_section_label
, true);
33227 dw2_asm_output_data (1, 0, "End compilation unit");
33229 if (flag_fat_lto_objects
)
33231 vec_free (macinfo_table
);
33232 macinfo_table
= saved_macinfo_table
;
33236 /* Emit a skeleton debug_line section. */
33237 switch_to_section (debug_line_section
);
33238 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
33239 output_line_info (true);
33241 /* If we emitted any indirect strings, output the string table too. */
33242 if (debug_str_hash
|| skeleton_debug_str_hash
)
33243 output_indirect_strings ();
33244 if (debug_line_str_hash
)
33246 switch_to_section (debug_line_str_section
);
33247 const enum dwarf_form form
= DW_FORM_line_strp
;
33248 debug_line_str_hash
->traverse
<enum dwarf_form
,
33249 output_indirect_string
> (form
);
33252 /* Switch back to the text section. */
33253 switch_to_section (text_section
);
33256 /* Reset all state within dwarf2out.cc so that we can rerun the compiler
33257 within the same process. For use by toplev::finalize. */
33260 dwarf2out_cc_finalize (void)
33262 last_var_location_insn
= NULL
;
33263 cached_next_real_insn
= NULL
;
33264 used_rtx_array
= NULL
;
33265 incomplete_types
= NULL
;
33266 debug_info_section
= NULL
;
33267 debug_skeleton_info_section
= NULL
;
33268 debug_abbrev_section
= NULL
;
33269 debug_skeleton_abbrev_section
= NULL
;
33270 debug_aranges_section
= NULL
;
33271 debug_addr_section
= NULL
;
33272 debug_macinfo_section
= NULL
;
33273 debug_line_section
= NULL
;
33274 debug_skeleton_line_section
= NULL
;
33275 debug_loc_section
= NULL
;
33276 debug_pubnames_section
= NULL
;
33277 debug_pubtypes_section
= NULL
;
33278 debug_str_section
= NULL
;
33279 debug_line_str_section
= NULL
;
33280 debug_str_dwo_section
= NULL
;
33281 debug_str_offsets_section
= NULL
;
33282 debug_ranges_section
= NULL
;
33283 debug_ranges_dwo_section
= NULL
;
33284 debug_frame_section
= NULL
;
33286 debug_str_hash
= NULL
;
33287 debug_line_str_hash
= NULL
;
33288 skeleton_debug_str_hash
= NULL
;
33289 dw2_string_counter
= 0;
33290 have_multiple_function_sections
= false;
33291 in_text_section_p
= false;
33292 cold_text_section
= NULL
;
33293 last_text_label
= NULL
;
33294 last_cold_label
= NULL
;
33295 switch_text_ranges
= NULL
;
33296 switch_cold_ranges
= NULL
;
33297 current_unit_personality
= NULL
;
33299 early_dwarf
= false;
33300 early_dwarf_finished
= false;
33302 next_die_offset
= 0;
33303 single_comp_unit_die
= NULL
;
33304 comdat_type_list
= NULL
;
33305 limbo_die_list
= NULL
;
33307 decl_die_table
= NULL
;
33308 common_block_die_table
= NULL
;
33309 decl_loc_table
= NULL
;
33310 call_arg_locations
= NULL
;
33311 call_arg_loc_last
= NULL
;
33312 call_site_count
= -1;
33313 tail_call_site_count
= -1;
33314 cached_dw_loc_list_table
= NULL
;
33315 abbrev_die_table
= NULL
;
33316 delete dwarf_proc_stack_usage_map
;
33317 dwarf_proc_stack_usage_map
= NULL
;
33318 line_info_label_num
= 0;
33319 cur_line_info_table
= NULL
;
33320 text_section_line_info
= NULL
;
33321 cold_text_section_line_info
= NULL
;
33322 separate_line_info
= NULL
;
33323 info_section_emitted
= false;
33324 pubname_table
= NULL
;
33325 pubtype_table
= NULL
;
33326 macinfo_table
= NULL
;
33327 ranges_table
= NULL
;
33328 ranges_by_label
= NULL
;
33330 have_location_lists
= false;
33333 last_emitted_file
= NULL
;
33335 tmpl_value_parm_die_table
= NULL
;
33336 generic_type_instances
= NULL
;
33337 frame_pointer_fb_offset
= 0;
33338 frame_pointer_fb_offset_valid
= false;
33339 base_types
.release ();
33340 XDELETEVEC (producer_string
);
33341 producer_string
= NULL
;
33342 output_line_info_generation
= 0;
33343 init_sections_and_labels_generation
= 0;
33346 #include "gt-dwarf2out.h"