1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992-2022 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 int last_match
= 0;
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 int matches
, int 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 wide_int
&op
)
402 int prec
= wi::get_precision (op
);
403 return ((prec
+ HOST_BITS_PER_WIDE_INT
- 1)
404 / HOST_BITS_PER_WIDE_INT
);
408 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
410 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
413 enum debug_struct_file criterion
;
415 bool generic
= lang_hooks
.types
.generic_p (type
);
418 criterion
= debug_struct_generic
[usage
];
420 criterion
= debug_struct_ordinary
[usage
];
422 if (criterion
== DINFO_STRUCT_FILE_NONE
)
423 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
424 if (criterion
== DINFO_STRUCT_FILE_ANY
)
425 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
427 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
429 if (type_decl
!= NULL
)
431 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
432 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
434 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
435 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
438 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
441 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
442 switch to the data section instead, and write out a synthetic start label
443 for collect2 the first time around. */
446 switch_to_eh_frame_section (bool back ATTRIBUTE_UNUSED
)
448 if (eh_frame_section
== 0)
452 if (EH_TABLES_CAN_BE_READ_ONLY
)
458 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
460 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
462 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
465 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
466 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
467 && (per_encoding
& 0x70) != DW_EH_PE_absptr
468 && (per_encoding
& 0x70) != DW_EH_PE_aligned
469 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
470 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
471 ? 0 : SECTION_WRITE
);
474 flags
= SECTION_WRITE
;
476 #ifdef EH_FRAME_SECTION_NAME
477 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
479 eh_frame_section
= ((flags
== SECTION_WRITE
)
480 ? data_section
: readonly_data_section
);
481 #endif /* EH_FRAME_SECTION_NAME */
484 switch_to_section (eh_frame_section
);
486 #ifdef EH_FRAME_THROUGH_COLLECT2
487 /* We have no special eh_frame section. Emit special labels to guide
491 tree label
= get_file_function_name ("F");
492 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
493 targetm
.asm_out
.globalize_label (asm_out_file
,
494 IDENTIFIER_POINTER (label
));
495 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
500 /* Switch [BACK] to the eh or debug frame table section, depending on
504 switch_to_frame_table_section (int for_eh
, bool back
)
507 switch_to_eh_frame_section (back
);
510 if (!debug_frame_section
)
511 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
512 SECTION_DEBUG
, NULL
);
513 switch_to_section (debug_frame_section
);
517 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
519 enum dw_cfi_oprnd_type
520 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
525 case DW_CFA_GNU_window_save
:
526 case DW_CFA_remember_state
:
527 case DW_CFA_restore_state
:
528 return dw_cfi_oprnd_unused
;
531 case DW_CFA_advance_loc1
:
532 case DW_CFA_advance_loc2
:
533 case DW_CFA_advance_loc4
:
534 case DW_CFA_MIPS_advance_loc8
:
535 return dw_cfi_oprnd_addr
;
538 case DW_CFA_offset_extended
:
540 case DW_CFA_offset_extended_sf
:
541 case DW_CFA_def_cfa_sf
:
543 case DW_CFA_restore_extended
:
544 case DW_CFA_undefined
:
545 case DW_CFA_same_value
:
546 case DW_CFA_def_cfa_register
:
547 case DW_CFA_register
:
548 case DW_CFA_expression
:
549 case DW_CFA_val_expression
:
550 return dw_cfi_oprnd_reg_num
;
552 case DW_CFA_def_cfa_offset
:
553 case DW_CFA_GNU_args_size
:
554 case DW_CFA_def_cfa_offset_sf
:
555 return dw_cfi_oprnd_offset
;
557 case DW_CFA_def_cfa_expression
:
558 return dw_cfi_oprnd_loc
;
565 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
567 enum dw_cfi_oprnd_type
568 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
573 case DW_CFA_def_cfa_sf
:
575 case DW_CFA_offset_extended_sf
:
576 case DW_CFA_offset_extended
:
577 return dw_cfi_oprnd_offset
;
579 case DW_CFA_register
:
580 return dw_cfi_oprnd_reg_num
;
582 case DW_CFA_expression
:
583 case DW_CFA_val_expression
:
584 return dw_cfi_oprnd_loc
;
586 case DW_CFA_def_cfa_expression
:
587 return dw_cfi_oprnd_cfa_loc
;
590 return dw_cfi_oprnd_unused
;
594 /* Output one FDE. */
597 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
598 char *section_start_label
, int fde_encoding
, char *augmentation
,
599 bool any_lsda_needed
, int lsda_encoding
)
601 const char *begin
, *end
;
602 static unsigned int j
;
603 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
605 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
607 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
609 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
610 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
611 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
613 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4 && !for_eh
)
614 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
615 " indicating 64-bit DWARF extension");
616 dw2_asm_output_delta (for_eh
? 4 : dwarf_offset_size
, l2
, l1
,
619 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
622 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
624 dw2_asm_output_offset (dwarf_offset_size
, section_start_label
,
625 debug_frame_section
, "FDE CIE offset");
627 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
628 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
632 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
633 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
634 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
635 "FDE initial location");
636 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
637 end
, begin
, "FDE address range");
641 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
642 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
649 int size
= size_of_encoded_value (lsda_encoding
);
651 if (lsda_encoding
== DW_EH_PE_aligned
)
653 int offset
= ( 4 /* Length */
655 + 2 * size_of_encoded_value (fde_encoding
)
656 + 1 /* Augmentation size */ );
657 int pad
= -offset
& (PTR_SIZE
- 1);
660 gcc_assert (size_of_uleb128 (size
) == 1);
663 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
665 if (fde
->uses_eh_lsda
)
667 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
668 fde
->funcdef_number
);
669 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
670 gen_rtx_SYMBOL_REF (Pmode
, l1
),
672 "Language Specific Data Area");
676 if (lsda_encoding
== DW_EH_PE_aligned
)
677 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
678 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
679 "Language Specific Data Area (none)");
683 dw2_asm_output_data_uleb128 (0, "Augmentation size");
686 /* Loop through the Call Frame Instructions associated with this FDE. */
687 fde
->dw_fde_current_label
= begin
;
689 size_t from
, until
, i
;
692 until
= vec_safe_length (fde
->dw_fde_cfi
);
694 if (fde
->dw_fde_second_begin
== NULL
)
697 until
= fde
->dw_fde_switch_cfi_index
;
699 from
= fde
->dw_fde_switch_cfi_index
;
701 for (i
= from
; i
< until
; i
++)
702 output_cfi ((*fde
->dw_fde_cfi
)[i
], fde
, for_eh
);
705 /* If we are to emit a ref/link from function bodies to their frame tables,
706 do it now. This is typically performed to make sure that tables
707 associated with functions are dragged with them and not discarded in
708 garbage collecting links. We need to do this on a per function basis to
709 cope with -ffunction-sections. */
711 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
712 /* Switch to the function section, emit the ref to the tables, and
713 switch *back* into the table section. */
714 switch_to_section (function_section (fde
->decl
));
715 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
716 switch_to_frame_table_section (for_eh
, true);
719 /* Pad the FDE out to an address sized boundary. */
720 ASM_OUTPUT_ALIGN (asm_out_file
,
721 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
722 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
727 /* Return true if frame description entry FDE is needed for EH. */
730 fde_needed_for_eh_p (dw_fde_ref fde
)
732 if (flag_asynchronous_unwind_tables
)
735 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
738 if (fde
->uses_eh_lsda
)
741 /* If exceptions are enabled, we have collected nothrow info. */
742 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
748 /* Output the call frame information used to record information
749 that relates to calculating the frame pointer, and records the
750 location of saved registers. */
753 output_call_frame_info (int for_eh
)
758 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
759 char section_start_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
760 bool any_lsda_needed
= false;
761 char augmentation
[6];
762 int augmentation_size
;
763 int fde_encoding
= DW_EH_PE_absptr
;
764 int per_encoding
= DW_EH_PE_absptr
;
765 int lsda_encoding
= DW_EH_PE_absptr
;
767 rtx personality
= NULL
;
770 /* Don't emit a CIE if there won't be any FDEs. */
774 /* Nothing to do if the assembler's doing it all. */
775 if (dwarf2out_do_cfi_asm ())
778 /* If we don't have any functions we'll want to unwind out of, don't emit
779 any EH unwind information. If we make FDEs linkonce, we may have to
780 emit an empty label for an FDE that wouldn't otherwise be emitted. We
781 want to avoid having an FDE kept around when the function it refers to
782 is discarded. Example where this matters: a primary function template
783 in C++ requires EH information, an explicit specialization doesn't. */
786 bool any_eh_needed
= false;
788 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
790 if (fde
->uses_eh_lsda
)
791 any_eh_needed
= any_lsda_needed
= true;
792 else if (fde_needed_for_eh_p (fde
))
793 any_eh_needed
= true;
794 else if (TARGET_USES_WEAK_UNWIND_INFO
)
795 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, 1, 1);
802 /* We're going to be generating comments, so turn on app. */
806 /* Switch to the proper frame section, first time. */
807 switch_to_frame_table_section (for_eh
, false);
809 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
810 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
812 /* Output the CIE. */
813 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
814 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
815 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
817 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4 && !for_eh
)
818 dw2_asm_output_data (4, 0xffffffff,
819 "Initial length escape value indicating 64-bit DWARF extension");
820 dw2_asm_output_delta (for_eh
? 4 : dwarf_offset_size
, l2
, l1
,
821 "Length of Common Information Entry");
823 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
825 /* Now that the CIE pointer is PC-relative for EH,
826 use 0 to identify the CIE. */
827 dw2_asm_output_data ((for_eh
? 4 : dwarf_offset_size
),
828 (for_eh
? 0 : DWARF_CIE_ID
),
829 "CIE Identifier Tag");
831 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
832 use CIE version 1, unless that would produce incorrect results
833 due to overflowing the return register column. */
834 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
836 if (return_reg
>= 256 || dwarf_version
> 2)
838 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
841 augmentation_size
= 0;
843 personality
= current_unit_personality
;
849 z Indicates that a uleb128 is present to size the
850 augmentation section.
851 L Indicates the encoding (and thus presence) of
852 an LSDA pointer in the FDE augmentation.
853 R Indicates a non-default pointer encoding for
855 P Indicates the presence of an encoding + language
856 personality routine in the CIE augmentation. */
858 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
859 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
860 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
862 p
= augmentation
+ 1;
866 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
867 assemble_external_libcall (personality
);
872 augmentation_size
+= 1;
874 if (fde_encoding
!= DW_EH_PE_absptr
)
877 augmentation_size
+= 1;
879 if (p
> augmentation
+ 1)
881 augmentation
[0] = 'z';
885 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
886 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
888 int offset
= ( 4 /* Length */
890 + 1 /* CIE version */
891 + strlen (augmentation
) + 1 /* Augmentation */
892 + size_of_uleb128 (1) /* Code alignment */
893 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
895 + 1 /* Augmentation size */
896 + 1 /* Personality encoding */ );
897 int pad
= -offset
& (PTR_SIZE
- 1);
899 augmentation_size
+= pad
;
901 /* Augmentations should be small, so there's scarce need to
902 iterate for a solution. Die if we exceed one uleb128 byte. */
903 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
907 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
908 if (dw_cie_version
>= 4)
910 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
911 dw2_asm_output_data (1, 0, "CIE Segment Size");
913 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
914 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
915 "CIE Data Alignment Factor");
917 if (dw_cie_version
== 1)
918 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
920 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
924 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
927 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
928 eh_data_format_name (per_encoding
));
929 dw2_asm_output_encoded_addr_rtx (per_encoding
,
935 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
936 eh_data_format_name (lsda_encoding
));
938 if (fde_encoding
!= DW_EH_PE_absptr
)
939 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
940 eh_data_format_name (fde_encoding
));
943 FOR_EACH_VEC_ELT (*cie_cfi_vec
, i
, cfi
)
944 output_cfi (cfi
, NULL
, for_eh
);
946 /* Pad the CIE out to an address sized boundary. */
947 ASM_OUTPUT_ALIGN (asm_out_file
,
948 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
949 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
951 /* Loop through all of the FDE's. */
952 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
956 /* Don't emit EH unwind info for leaf functions that don't need it. */
957 if (for_eh
&& !fde_needed_for_eh_p (fde
))
960 for (k
= 0; k
< (fde
->dw_fde_second_begin
? 2 : 1); k
++)
961 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
962 augmentation
, any_lsda_needed
, lsda_encoding
);
965 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
966 dw2_asm_output_data (4, 0, "End of Table");
968 /* Turn off app to make assembly quicker. */
973 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
976 dwarf2out_do_cfi_startproc (bool second
)
981 fprintf (asm_out_file
, "\t.cfi_startproc\n");
983 targetm
.asm_out
.post_cfi_startproc (asm_out_file
, current_function_decl
);
985 /* .cfi_personality and .cfi_lsda are only relevant to DWARF2
987 if (targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
)
990 rtx personality
= get_personality_function (current_function_decl
);
994 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
997 /* ??? The GAS support isn't entirely consistent. We have to
998 handle indirect support ourselves, but PC-relative is done
999 in the assembler. Further, the assembler can't handle any
1000 of the weirder relocation types. */
1001 if (enc
& DW_EH_PE_indirect
)
1003 if (targetm
.asm_out
.make_eh_symbol_indirect
!= NULL
)
1004 ref
= targetm
.asm_out
.make_eh_symbol_indirect (ref
, true);
1006 ref
= dw2_force_const_mem (ref
, true);
1009 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
1010 output_addr_const (asm_out_file
, ref
);
1011 fputc ('\n', asm_out_file
);
1014 if (crtl
->uses_eh_lsda
)
1016 char lab
[MAX_ARTIFICIAL_LABEL_BYTES
];
1018 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1019 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
1020 current_function_funcdef_no
);
1021 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
1022 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
1024 if (enc
& DW_EH_PE_indirect
)
1026 if (targetm
.asm_out
.make_eh_symbol_indirect
!= NULL
)
1027 ref
= targetm
.asm_out
.make_eh_symbol_indirect (ref
, true);
1029 ref
= dw2_force_const_mem (ref
, true);
1032 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
1033 output_addr_const (asm_out_file
, ref
);
1034 fputc ('\n', asm_out_file
);
1038 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
1039 this allocation may be done before pass_final. */
1042 dwarf2out_alloc_current_fde (void)
1046 fde
= ggc_cleared_alloc
<dw_fde_node
> ();
1047 fde
->decl
= current_function_decl
;
1048 fde
->funcdef_number
= current_function_funcdef_no
;
1049 fde
->fde_index
= vec_safe_length (fde_vec
);
1050 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
1051 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
1052 fde
->nothrow
= crtl
->nothrow
;
1053 fde
->drap_reg
= INVALID_REGNUM
;
1054 fde
->vdrap_reg
= INVALID_REGNUM
;
1056 /* Record the FDE associated with this function. */
1058 vec_safe_push (fde_vec
, fde
);
1063 /* Output a marker (i.e. a label) for the beginning of a function, before
1067 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1068 unsigned int column ATTRIBUTE_UNUSED
,
1069 const char *file ATTRIBUTE_UNUSED
)
1071 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1077 current_function_func_begin_label
= NULL
;
1079 do_frame
= dwarf2out_do_frame ();
1081 /* ??? current_function_func_begin_label is also used by except.cc for
1082 call-site information. We must emit this label if it might be used. */
1084 && (!flag_exceptions
1085 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1088 fnsec
= function_section (current_function_decl
);
1089 switch_to_section (fnsec
);
1090 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1091 current_function_funcdef_no
);
1092 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1093 current_function_funcdef_no
);
1094 dup_label
= xstrdup (label
);
1095 current_function_func_begin_label
= dup_label
;
1097 /* We can elide FDE allocation if we're not emitting frame unwind info. */
1101 /* Unlike the debug version, the EH version of frame unwind info is a per-
1102 function setting so we need to record whether we need it for the unit. */
1103 do_eh_frame
|= dwarf2out_do_eh_frame ();
1105 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1106 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1107 would include pass_dwarf2_frame. If we've not created the FDE yet,
1111 fde
= dwarf2out_alloc_current_fde ();
1113 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1114 fde
->dw_fde_begin
= dup_label
;
1115 fde
->dw_fde_current_label
= dup_label
;
1116 fde
->in_std_section
= (fnsec
== text_section
1117 || (cold_text_section
&& fnsec
== cold_text_section
));
1118 fde
->ignored_debug
= DECL_IGNORED_P (current_function_decl
);
1119 in_text_section_p
= fnsec
== text_section
;
1121 /* We only want to output line number information for the genuine dwarf2
1122 prologue case, not the eh frame case. */
1123 #ifdef DWARF2_DEBUGGING_INFO
1125 dwarf2out_source_line (line
, column
, file
, 0, true);
1128 if (dwarf2out_do_cfi_asm ())
1129 dwarf2out_do_cfi_startproc (false);
1132 rtx personality
= get_personality_function (current_function_decl
);
1133 if (!current_unit_personality
)
1134 current_unit_personality
= personality
;
1136 /* We cannot keep a current personality per function as without CFI
1137 asm, at the point where we emit the CFI data, there is no current
1138 function anymore. */
1139 if (personality
&& current_unit_personality
!= personality
)
1140 sorry ("multiple EH personalities are supported only with assemblers "
1141 "supporting %<.cfi_personality%> directive");
1145 /* Output a marker (i.e. a label) for the end of the generated code
1146 for a function prologue. This gets called *after* the prologue code has
1150 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1151 const char *file ATTRIBUTE_UNUSED
)
1153 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1155 /* Output a label to mark the endpoint of the code generated for this
1157 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1158 current_function_funcdef_no
);
1159 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1160 current_function_funcdef_no
);
1161 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1164 /* Output a marker (i.e. a label) for the beginning of the generated code
1165 for a function epilogue. This gets called *before* the prologue code has
1169 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1170 const char *file ATTRIBUTE_UNUSED
)
1172 dw_fde_ref fde
= cfun
->fde
;
1173 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1175 if (fde
->dw_fde_vms_begin_epilogue
)
1178 /* Output a label to mark the endpoint of the code generated for this
1180 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1181 current_function_funcdef_no
);
1182 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1183 current_function_funcdef_no
);
1184 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1187 /* Mark the ranges of non-debug subsections in the std text sections. */
1190 mark_ignored_debug_section (dw_fde_ref fde
, bool second
)
1193 const char *begin_label
, *end_label
;
1194 const char **last_end_label
;
1195 vec
<const char *, va_gc
> **switch_ranges
;
1199 std_section
= fde
->second_in_std_section
;
1200 begin_label
= fde
->dw_fde_second_begin
;
1201 end_label
= fde
->dw_fde_second_end
;
1205 std_section
= fde
->in_std_section
;
1206 begin_label
= fde
->dw_fde_begin
;
1207 end_label
= fde
->dw_fde_end
;
1213 if (in_text_section_p
)
1215 last_end_label
= &last_text_label
;
1216 switch_ranges
= &switch_text_ranges
;
1220 last_end_label
= &last_cold_label
;
1221 switch_ranges
= &switch_cold_ranges
;
1224 if (fde
->ignored_debug
)
1226 if (*switch_ranges
&& !(vec_safe_length (*switch_ranges
) & 1))
1227 vec_safe_push (*switch_ranges
, *last_end_label
);
1231 *last_end_label
= end_label
;
1233 if (!*switch_ranges
)
1234 vec_alloc (*switch_ranges
, 16);
1235 else if (vec_safe_length (*switch_ranges
) & 1)
1236 vec_safe_push (*switch_ranges
, begin_label
);
1240 /* Output a marker (i.e. a label) for the absolute end of the generated code
1241 for a function definition. This gets called *after* the epilogue code has
1245 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1246 const char *file ATTRIBUTE_UNUSED
)
1249 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1251 last_var_location_insn
= NULL
;
1252 cached_next_real_insn
= NULL
;
1254 if (dwarf2out_do_cfi_asm ())
1255 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1257 /* Output a label to mark the endpoint of the code generated for this
1259 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1260 current_function_funcdef_no
);
1261 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1263 gcc_assert (fde
!= NULL
);
1264 if (fde
->dw_fde_second_begin
== NULL
)
1265 fde
->dw_fde_end
= xstrdup (label
);
1267 mark_ignored_debug_section (fde
, fde
->dw_fde_second_begin
!= NULL
);
1271 dwarf2out_frame_finish (void)
1273 /* Output call frame information. */
1274 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1275 output_call_frame_info (0);
1277 /* Output another copy for the unwinder. */
1279 output_call_frame_info (1);
1282 static void var_location_switch_text_section (void);
1283 static void set_cur_line_info_table (section
*);
1286 dwarf2out_switch_text_section (void)
1288 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1290 dw_fde_ref fde
= cfun
->fde
;
1292 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1294 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_SECOND_SECT_LABEL
,
1295 current_function_funcdef_no
);
1297 fde
->dw_fde_second_begin
= ggc_strdup (label
);
1298 if (!in_cold_section_p
)
1300 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1301 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1305 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1306 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1308 have_multiple_function_sections
= true;
1310 if (dwarf2out_do_cfi_asm ())
1311 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1313 mark_ignored_debug_section (fde
, false);
1315 /* Now do the real section switch. */
1316 sect
= current_function_section ();
1317 switch_to_section (sect
);
1319 fde
->second_in_std_section
1320 = (sect
== text_section
1321 || (cold_text_section
&& sect
== cold_text_section
));
1322 in_text_section_p
= sect
== text_section
;
1324 if (dwarf2out_do_cfi_asm ())
1325 dwarf2out_do_cfi_startproc (true);
1327 var_location_switch_text_section ();
1329 if (cold_text_section
!= NULL
)
1330 set_cur_line_info_table (sect
);
1333 /* And now, the subset of the debugging information support code necessary
1334 for emitting location expressions. */
1336 /* Describe an entry into the .debug_addr section. */
1340 ate_kind_rtx_dtprel
,
1344 struct GTY((for_user
)) addr_table_entry
{
1346 unsigned int refcount
;
1348 union addr_table_entry_struct_union
1350 rtx
GTY ((tag ("0"))) rtl
;
1351 char * GTY ((tag ("1"))) label
;
1353 GTY ((desc ("%1.kind"))) addr
;
1356 typedef unsigned int var_loc_view
;
1358 /* Location lists are ranges + location descriptions for that range,
1359 so you can track variables that are in different places over
1360 their entire life. */
1361 typedef struct GTY(()) dw_loc_list_struct
{
1362 dw_loc_list_ref dw_loc_next
;
1363 const char *begin
; /* Label and addr_entry for start of range */
1364 addr_table_entry
*begin_entry
;
1365 const char *end
; /* Label for end of range */
1366 addr_table_entry
*end_entry
;
1367 char *ll_symbol
; /* Label for beginning of location list.
1368 Only on head of list. */
1369 char *vl_symbol
; /* Label for beginning of view list. Ditto. */
1370 const char *section
; /* Section this loclist is relative to */
1371 dw_loc_descr_ref expr
;
1372 var_loc_view vbegin
, vend
;
1374 /* True if all addresses in this and subsequent lists are known to be
1377 /* True if this list has been replaced by dw_loc_next. */
1379 /* True if it has been emitted into .debug_loc* / .debug_loclists*
1381 unsigned char emitted
: 1;
1382 /* True if hash field is index rather than hash value. */
1383 unsigned char num_assigned
: 1;
1384 /* True if .debug_loclists.dwo offset has been emitted for it already. */
1385 unsigned char offset_emitted
: 1;
1386 /* True if note_variable_value_in_expr has been called on it. */
1387 unsigned char noted_variable_value
: 1;
1388 /* True if the range should be emitted even if begin and end
1393 static dw_loc_descr_ref
int_loc_descriptor (poly_int64
);
1394 static dw_loc_descr_ref
uint_loc_descriptor (unsigned HOST_WIDE_INT
);
1396 /* Convert a DWARF stack opcode into its string name. */
1399 dwarf_stack_op_name (unsigned int op
)
1401 const char *name
= get_DW_OP_name (op
);
1406 return "OP_<unknown>";
1409 /* Return TRUE iff we're to output location view lists as a separate
1410 attribute next to the location lists, as an extension compatible
1411 with DWARF 2 and above. */
1414 dwarf2out_locviews_in_attribute ()
1416 return debug_variable_location_views
== 1;
1419 /* Return TRUE iff we're to output location view lists as part of the
1420 location lists, as proposed for standardization after DWARF 5. */
1423 dwarf2out_locviews_in_loclist ()
1425 #ifndef DW_LLE_view_pair
1428 return debug_variable_location_views
== -1;
1432 /* Return a pointer to a newly allocated location description. Location
1433 descriptions are simple expression terms that can be strung
1434 together to form more complicated location (address) descriptions. */
1436 static inline dw_loc_descr_ref
1437 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1438 unsigned HOST_WIDE_INT oprnd2
)
1440 dw_loc_descr_ref descr
= ggc_cleared_alloc
<dw_loc_descr_node
> ();
1442 descr
->dw_loc_opc
= op
;
1443 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1444 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1445 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1446 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1447 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1448 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1453 /* Add a location description term to a location description expression. */
1456 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1458 dw_loc_descr_ref
*d
;
1460 /* Find the end of the chain. */
1461 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1467 /* Compare two location operands for exact equality. */
1470 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1472 if (a
->val_class
!= b
->val_class
)
1474 switch (a
->val_class
)
1476 case dw_val_class_none
:
1478 case dw_val_class_addr
:
1479 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1481 case dw_val_class_offset
:
1482 case dw_val_class_unsigned_const
:
1483 case dw_val_class_const
:
1484 case dw_val_class_unsigned_const_implicit
:
1485 case dw_val_class_const_implicit
:
1486 case dw_val_class_range_list
:
1487 /* These are all HOST_WIDE_INT, signed or unsigned. */
1488 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1490 case dw_val_class_loc
:
1491 return a
->v
.val_loc
== b
->v
.val_loc
;
1492 case dw_val_class_loc_list
:
1493 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1494 case dw_val_class_view_list
:
1495 return a
->v
.val_view_list
== b
->v
.val_view_list
;
1496 case dw_val_class_die_ref
:
1497 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1498 case dw_val_class_fde_ref
:
1499 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1500 case dw_val_class_symview
:
1501 return strcmp (a
->v
.val_symbolic_view
, b
->v
.val_symbolic_view
) == 0;
1502 case dw_val_class_lbl_id
:
1503 case dw_val_class_lineptr
:
1504 case dw_val_class_macptr
:
1505 case dw_val_class_loclistsptr
:
1506 case dw_val_class_high_pc
:
1507 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1508 case dw_val_class_str
:
1509 return a
->v
.val_str
== b
->v
.val_str
;
1510 case dw_val_class_flag
:
1511 return a
->v
.val_flag
== b
->v
.val_flag
;
1512 case dw_val_class_file
:
1513 case dw_val_class_file_implicit
:
1514 return a
->v
.val_file
== b
->v
.val_file
;
1515 case dw_val_class_decl_ref
:
1516 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1518 case dw_val_class_const_double
:
1519 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1520 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1522 case dw_val_class_wide_int
:
1523 return *a
->v
.val_wide
== *b
->v
.val_wide
;
1525 case dw_val_class_vec
:
1527 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1528 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1530 return (a_len
== b_len
1531 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1534 case dw_val_class_data8
:
1535 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1537 case dw_val_class_vms_delta
:
1538 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1539 && !strcmp (a
->v
.val_vms_delta
.lbl2
, b
->v
.val_vms_delta
.lbl2
));
1541 case dw_val_class_discr_value
:
1542 return (a
->v
.val_discr_value
.pos
== b
->v
.val_discr_value
.pos
1543 && a
->v
.val_discr_value
.v
.uval
== b
->v
.val_discr_value
.v
.uval
);
1544 case dw_val_class_discr_list
:
1545 /* It makes no sense comparing two discriminant value lists. */
1551 /* Compare two location atoms for exact equality. */
1554 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1556 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1559 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1560 address size, but since we always allocate cleared storage it
1561 should be zero for other types of locations. */
1562 if (a
->dtprel
!= b
->dtprel
)
1565 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1566 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1569 /* Compare two complete location expressions for exact equality. */
1572 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1578 if (a
== NULL
|| b
== NULL
)
1580 if (!loc_descr_equal_p_1 (a
, b
))
1589 /* Add a constant POLY_OFFSET to a location expression. */
1592 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, poly_int64 poly_offset
)
1594 dw_loc_descr_ref loc
;
1597 gcc_assert (*list_head
!= NULL
);
1599 if (known_eq (poly_offset
, 0))
1602 /* Find the end of the chain. */
1603 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1606 HOST_WIDE_INT offset
;
1607 if (!poly_offset
.is_constant (&offset
))
1609 loc
->dw_loc_next
= int_loc_descriptor (poly_offset
);
1610 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_plus
, 0, 0));
1615 if (loc
->dw_loc_opc
== DW_OP_fbreg
1616 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1617 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1618 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1619 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1621 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1622 offset. Don't optimize if an signed integer overflow would happen. */
1624 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1625 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1628 else if (offset
> 0)
1629 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1634 = uint_loc_descriptor (-(unsigned HOST_WIDE_INT
) offset
);
1635 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1639 /* Return a pointer to a newly allocated location description for
1642 static inline dw_loc_descr_ref
1643 new_reg_loc_descr (unsigned int reg
, poly_int64 offset
)
1645 HOST_WIDE_INT const_offset
;
1646 if (offset
.is_constant (&const_offset
))
1649 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1652 return new_loc_descr (DW_OP_bregx
, reg
, const_offset
);
1656 dw_loc_descr_ref ret
= new_reg_loc_descr (reg
, 0);
1657 loc_descr_plus_const (&ret
, offset
);
1662 /* Add a constant OFFSET to a location list. */
1665 loc_list_plus_const (dw_loc_list_ref list_head
, poly_int64 offset
)
1668 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1669 loc_descr_plus_const (&d
->expr
, offset
);
1672 #define DWARF_REF_SIZE \
1673 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : dwarf_offset_size)
1675 /* The number of bits that can be encoded by largest DW_FORM_dataN.
1676 In DWARF4 and earlier it is DW_FORM_data8 with 64 bits, in DWARF5
1677 DW_FORM_data16 with 128 bits. */
1678 #define DWARF_LARGEST_DATA_FORM_BITS \
1679 (dwarf_version >= 5 ? 128 : 64)
1681 /* Utility inline function for construction of ops that were GNU extension
1683 static inline enum dwarf_location_atom
1684 dwarf_OP (enum dwarf_location_atom op
)
1688 case DW_OP_implicit_pointer
:
1689 if (dwarf_version
< 5)
1690 return DW_OP_GNU_implicit_pointer
;
1693 case DW_OP_entry_value
:
1694 if (dwarf_version
< 5)
1695 return DW_OP_GNU_entry_value
;
1698 case DW_OP_const_type
:
1699 if (dwarf_version
< 5)
1700 return DW_OP_GNU_const_type
;
1703 case DW_OP_regval_type
:
1704 if (dwarf_version
< 5)
1705 return DW_OP_GNU_regval_type
;
1708 case DW_OP_deref_type
:
1709 if (dwarf_version
< 5)
1710 return DW_OP_GNU_deref_type
;
1714 if (dwarf_version
< 5)
1715 return DW_OP_GNU_convert
;
1718 case DW_OP_reinterpret
:
1719 if (dwarf_version
< 5)
1720 return DW_OP_GNU_reinterpret
;
1724 if (dwarf_version
< 5)
1725 return DW_OP_GNU_addr_index
;
1729 if (dwarf_version
< 5)
1730 return DW_OP_GNU_const_index
;
1739 /* Similarly for attributes. */
1740 static inline enum dwarf_attribute
1741 dwarf_AT (enum dwarf_attribute at
)
1745 case DW_AT_call_return_pc
:
1746 if (dwarf_version
< 5)
1747 return DW_AT_low_pc
;
1750 case DW_AT_call_tail_call
:
1751 if (dwarf_version
< 5)
1752 return DW_AT_GNU_tail_call
;
1755 case DW_AT_call_origin
:
1756 if (dwarf_version
< 5)
1757 return DW_AT_abstract_origin
;
1760 case DW_AT_call_target
:
1761 if (dwarf_version
< 5)
1762 return DW_AT_GNU_call_site_target
;
1765 case DW_AT_call_target_clobbered
:
1766 if (dwarf_version
< 5)
1767 return DW_AT_GNU_call_site_target_clobbered
;
1770 case DW_AT_call_parameter
:
1771 if (dwarf_version
< 5)
1772 return DW_AT_abstract_origin
;
1775 case DW_AT_call_value
:
1776 if (dwarf_version
< 5)
1777 return DW_AT_GNU_call_site_value
;
1780 case DW_AT_call_data_value
:
1781 if (dwarf_version
< 5)
1782 return DW_AT_GNU_call_site_data_value
;
1785 case DW_AT_call_all_calls
:
1786 if (dwarf_version
< 5)
1787 return DW_AT_GNU_all_call_sites
;
1790 case DW_AT_call_all_tail_calls
:
1791 if (dwarf_version
< 5)
1792 return DW_AT_GNU_all_tail_call_sites
;
1795 case DW_AT_dwo_name
:
1796 if (dwarf_version
< 5)
1797 return DW_AT_GNU_dwo_name
;
1800 case DW_AT_addr_base
:
1801 if (dwarf_version
< 5)
1802 return DW_AT_GNU_addr_base
;
1811 /* And similarly for tags. */
1812 static inline enum dwarf_tag
1813 dwarf_TAG (enum dwarf_tag tag
)
1817 case DW_TAG_call_site
:
1818 if (dwarf_version
< 5)
1819 return DW_TAG_GNU_call_site
;
1822 case DW_TAG_call_site_parameter
:
1823 if (dwarf_version
< 5)
1824 return DW_TAG_GNU_call_site_parameter
;
1833 /* And similarly for forms. */
1834 static inline enum dwarf_form
1835 dwarf_FORM (enum dwarf_form form
)
1840 if (dwarf_version
< 5)
1841 return DW_FORM_GNU_addr_index
;
1845 if (dwarf_version
< 5)
1846 return DW_FORM_GNU_str_index
;
1855 static unsigned long int get_base_type_offset (dw_die_ref
);
1857 /* Return the size of a location descriptor. */
1859 static unsigned long
1860 size_of_loc_descr (dw_loc_descr_ref loc
)
1862 unsigned long size
= 1;
1864 switch (loc
->dw_loc_opc
)
1867 size
+= DWARF2_ADDR_SIZE
;
1869 case DW_OP_GNU_addr_index
:
1871 case DW_OP_GNU_const_index
:
1873 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1874 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1893 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1896 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1901 case DW_OP_plus_uconst
:
1902 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1940 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1943 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1946 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1949 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1950 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1953 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1955 case DW_OP_bit_piece
:
1956 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1957 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1959 case DW_OP_deref_size
:
1960 case DW_OP_xderef_size
:
1969 case DW_OP_call_ref
:
1970 case DW_OP_GNU_variable_value
:
1971 size
+= DWARF_REF_SIZE
;
1973 case DW_OP_implicit_value
:
1974 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1975 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1977 case DW_OP_implicit_pointer
:
1978 case DW_OP_GNU_implicit_pointer
:
1979 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1981 case DW_OP_entry_value
:
1982 case DW_OP_GNU_entry_value
:
1984 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1985 size
+= size_of_uleb128 (op_size
) + op_size
;
1988 case DW_OP_const_type
:
1989 case DW_OP_GNU_const_type
:
1992 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1993 size
+= size_of_uleb128 (o
) + 1;
1994 switch (loc
->dw_loc_oprnd2
.val_class
)
1996 case dw_val_class_vec
:
1997 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1998 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
2000 case dw_val_class_const
:
2001 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
2003 case dw_val_class_const_double
:
2004 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
2006 case dw_val_class_wide_int
:
2007 size
+= (get_full_len (*loc
->dw_loc_oprnd2
.v
.val_wide
)
2008 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
2015 case DW_OP_regval_type
:
2016 case DW_OP_GNU_regval_type
:
2019 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
2020 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
2021 + size_of_uleb128 (o
);
2024 case DW_OP_deref_type
:
2025 case DW_OP_GNU_deref_type
:
2028 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
2029 size
+= 1 + size_of_uleb128 (o
);
2033 case DW_OP_reinterpret
:
2034 case DW_OP_GNU_convert
:
2035 case DW_OP_GNU_reinterpret
:
2036 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2037 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2041 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
2042 size
+= size_of_uleb128 (o
);
2045 case DW_OP_GNU_parameter_ref
:
2055 /* Return the size of a series of location descriptors. */
2058 size_of_locs (dw_loc_descr_ref loc
)
2063 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
2064 field, to avoid writing to a PCH file. */
2065 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
2067 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
2069 size
+= size_of_loc_descr (l
);
2074 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
2076 l
->dw_loc_addr
= size
;
2077 size
+= size_of_loc_descr (l
);
2083 /* Return the size of the value in a DW_AT_discr_value attribute. */
2086 size_of_discr_value (dw_discr_value
*discr_value
)
2088 if (discr_value
->pos
)
2089 return size_of_uleb128 (discr_value
->v
.uval
);
2091 return size_of_sleb128 (discr_value
->v
.sval
);
2094 /* Return the size of the value in a DW_AT_discr_list attribute. */
2097 size_of_discr_list (dw_discr_list_ref discr_list
)
2101 for (dw_discr_list_ref list
= discr_list
;
2103 list
= list
->dw_discr_next
)
2105 /* One byte for the discriminant value descriptor, and then one or two
2106 LEB128 numbers, depending on whether it's a single case label or a
2109 size
+= size_of_discr_value (&list
->dw_discr_lower_bound
);
2110 if (list
->dw_discr_range
!= 0)
2111 size
+= size_of_discr_value (&list
->dw_discr_upper_bound
);
2116 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
2117 static void get_ref_die_offset_label (char *, dw_die_ref
);
2118 static unsigned long int get_ref_die_offset (dw_die_ref
);
2120 /* Output location description stack opcode's operands (if any).
2121 The for_eh_or_skip parameter controls whether register numbers are
2122 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2123 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2124 info). This should be suppressed for the cases that have not been converted
2125 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2128 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2130 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2131 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2133 switch (loc
->dw_loc_opc
)
2135 #ifdef DWARF2_DEBUGGING_INFO
2138 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
2143 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2144 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
2146 fputc ('\n', asm_out_file
);
2151 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
2156 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2157 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
2159 fputc ('\n', asm_out_file
);
2164 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2165 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
2172 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2173 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2175 dw2_asm_output_data (2, offset
, NULL
);
2178 case DW_OP_implicit_value
:
2179 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2180 switch (val2
->val_class
)
2182 case dw_val_class_const
:
2183 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
2185 case dw_val_class_vec
:
2187 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2188 unsigned int len
= val2
->v
.val_vec
.length
;
2192 if (elt_size
> sizeof (HOST_WIDE_INT
))
2197 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2200 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2201 "fp or vector constant word %u", i
);
2204 case dw_val_class_const_double
:
2206 unsigned HOST_WIDE_INT first
, second
;
2208 if (WORDS_BIG_ENDIAN
)
2210 first
= val2
->v
.val_double
.high
;
2211 second
= val2
->v
.val_double
.low
;
2215 first
= val2
->v
.val_double
.low
;
2216 second
= val2
->v
.val_double
.high
;
2218 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2220 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2224 case dw_val_class_wide_int
:
2227 int len
= get_full_len (*val2
->v
.val_wide
);
2228 if (WORDS_BIG_ENDIAN
)
2229 for (i
= len
- 1; i
>= 0; --i
)
2230 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2231 val2
->v
.val_wide
->elt (i
), NULL
);
2233 for (i
= 0; i
< len
; ++i
)
2234 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2235 val2
->v
.val_wide
->elt (i
), NULL
);
2238 case dw_val_class_addr
:
2239 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
2240 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
2255 case DW_OP_implicit_value
:
2256 /* We currently don't make any attempt to make sure these are
2257 aligned properly like we do for the main unwind info, so
2258 don't support emitting things larger than a byte if we're
2259 only doing unwinding. */
2264 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2267 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2270 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2273 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2275 case DW_OP_plus_uconst
:
2276 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2310 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2314 unsigned r
= val1
->v
.val_unsigned
;
2315 if (for_eh_or_skip
>= 0)
2316 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2317 gcc_assert (size_of_uleb128 (r
)
2318 == size_of_uleb128 (val1
->v
.val_unsigned
));
2319 dw2_asm_output_data_uleb128 (r
, NULL
);
2323 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2327 unsigned r
= val1
->v
.val_unsigned
;
2328 if (for_eh_or_skip
>= 0)
2329 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2330 gcc_assert (size_of_uleb128 (r
)
2331 == size_of_uleb128 (val1
->v
.val_unsigned
));
2332 dw2_asm_output_data_uleb128 (r
, NULL
);
2333 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2337 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2339 case DW_OP_bit_piece
:
2340 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2341 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
2343 case DW_OP_deref_size
:
2344 case DW_OP_xderef_size
:
2345 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2351 if (targetm
.asm_out
.output_dwarf_dtprel
)
2353 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
2356 fputc ('\n', asm_out_file
);
2363 #ifdef DWARF2_DEBUGGING_INFO
2364 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
2371 case DW_OP_GNU_addr_index
:
2373 case DW_OP_GNU_const_index
:
2375 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
2376 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
2377 "(index into .debug_addr)");
2383 unsigned long die_offset
2384 = get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2385 /* Make sure the offset has been computed and that we can encode it as
2387 gcc_assert (die_offset
> 0
2388 && die_offset
<= (loc
->dw_loc_opc
== DW_OP_call2
2391 dw2_asm_output_data ((loc
->dw_loc_opc
== DW_OP_call2
) ? 2 : 4,
2396 case DW_OP_call_ref
:
2397 case DW_OP_GNU_variable_value
:
2399 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2400 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2401 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2402 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2403 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2407 case DW_OP_implicit_pointer
:
2408 case DW_OP_GNU_implicit_pointer
:
2410 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2411 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2412 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2413 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2414 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2415 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2419 case DW_OP_entry_value
:
2420 case DW_OP_GNU_entry_value
:
2421 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
2422 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
2425 case DW_OP_const_type
:
2426 case DW_OP_GNU_const_type
:
2428 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
2430 dw2_asm_output_data_uleb128 (o
, NULL
);
2431 switch (val2
->val_class
)
2433 case dw_val_class_const
:
2434 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2435 dw2_asm_output_data (1, l
, NULL
);
2436 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
2438 case dw_val_class_vec
:
2440 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2441 unsigned int len
= val2
->v
.val_vec
.length
;
2446 dw2_asm_output_data (1, l
, NULL
);
2447 if (elt_size
> sizeof (HOST_WIDE_INT
))
2452 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2455 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2456 "fp or vector constant word %u", i
);
2459 case dw_val_class_const_double
:
2461 unsigned HOST_WIDE_INT first
, second
;
2462 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2464 dw2_asm_output_data (1, 2 * l
, NULL
);
2465 if (WORDS_BIG_ENDIAN
)
2467 first
= val2
->v
.val_double
.high
;
2468 second
= val2
->v
.val_double
.low
;
2472 first
= val2
->v
.val_double
.low
;
2473 second
= val2
->v
.val_double
.high
;
2475 dw2_asm_output_data (l
, first
, NULL
);
2476 dw2_asm_output_data (l
, second
, NULL
);
2479 case dw_val_class_wide_int
:
2482 int len
= get_full_len (*val2
->v
.val_wide
);
2483 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2485 dw2_asm_output_data (1, len
* l
, NULL
);
2486 if (WORDS_BIG_ENDIAN
)
2487 for (i
= len
- 1; i
>= 0; --i
)
2488 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2490 for (i
= 0; i
< len
; ++i
)
2491 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2499 case DW_OP_regval_type
:
2500 case DW_OP_GNU_regval_type
:
2502 unsigned r
= val1
->v
.val_unsigned
;
2503 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2505 if (for_eh_or_skip
>= 0)
2507 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2508 gcc_assert (size_of_uleb128 (r
)
2509 == size_of_uleb128 (val1
->v
.val_unsigned
));
2511 dw2_asm_output_data_uleb128 (r
, NULL
);
2512 dw2_asm_output_data_uleb128 (o
, NULL
);
2515 case DW_OP_deref_type
:
2516 case DW_OP_GNU_deref_type
:
2518 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2520 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2521 dw2_asm_output_data_uleb128 (o
, NULL
);
2525 case DW_OP_reinterpret
:
2526 case DW_OP_GNU_convert
:
2527 case DW_OP_GNU_reinterpret
:
2528 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2529 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2532 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2534 dw2_asm_output_data_uleb128 (o
, NULL
);
2538 case DW_OP_GNU_parameter_ref
:
2541 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2542 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2543 dw2_asm_output_data (4, o
, NULL
);
2548 /* Other codes have no operands. */
2553 /* Output a sequence of location operations.
2554 The for_eh_or_skip parameter controls whether register numbers are
2555 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2556 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2557 info). This should be suppressed for the cases that have not been converted
2558 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2561 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2563 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2565 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2566 /* Output the opcode. */
2567 if (for_eh_or_skip
>= 0
2568 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2570 unsigned r
= (opc
- DW_OP_breg0
);
2571 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2572 gcc_assert (r
<= 31);
2573 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2575 else if (for_eh_or_skip
>= 0
2576 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2578 unsigned r
= (opc
- DW_OP_reg0
);
2579 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2580 gcc_assert (r
<= 31);
2581 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2584 dw2_asm_output_data (1, opc
,
2585 "%s", dwarf_stack_op_name (opc
));
2587 /* Output the operand(s) (if any). */
2588 output_loc_operands (loc
, for_eh_or_skip
);
2592 /* Output location description stack opcode's operands (if any).
2593 The output is single bytes on a line, suitable for .cfi_escape. */
2596 output_loc_operands_raw (dw_loc_descr_ref loc
)
2598 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2599 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2601 switch (loc
->dw_loc_opc
)
2604 case DW_OP_GNU_addr_index
:
2606 case DW_OP_GNU_const_index
:
2608 case DW_OP_implicit_value
:
2609 /* We cannot output addresses in .cfi_escape, only bytes. */
2615 case DW_OP_deref_size
:
2616 case DW_OP_xderef_size
:
2617 fputc (',', asm_out_file
);
2618 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2623 fputc (',', asm_out_file
);
2624 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2629 fputc (',', asm_out_file
);
2630 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2635 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2636 fputc (',', asm_out_file
);
2637 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2645 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2646 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2648 fputc (',', asm_out_file
);
2649 dw2_asm_output_data_raw (2, offset
);
2655 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2656 gcc_assert (size_of_uleb128 (r
)
2657 == size_of_uleb128 (val1
->v
.val_unsigned
));
2658 fputc (',', asm_out_file
);
2659 dw2_asm_output_data_uleb128_raw (r
);
2664 case DW_OP_plus_uconst
:
2666 fputc (',', asm_out_file
);
2667 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2670 case DW_OP_bit_piece
:
2671 fputc (',', asm_out_file
);
2672 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2673 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2710 fputc (',', asm_out_file
);
2711 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2716 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2717 gcc_assert (size_of_uleb128 (r
)
2718 == size_of_uleb128 (val1
->v
.val_unsigned
));
2719 fputc (',', asm_out_file
);
2720 dw2_asm_output_data_uleb128_raw (r
);
2721 fputc (',', asm_out_file
);
2722 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2726 case DW_OP_implicit_pointer
:
2727 case DW_OP_entry_value
:
2728 case DW_OP_const_type
:
2729 case DW_OP_regval_type
:
2730 case DW_OP_deref_type
:
2732 case DW_OP_reinterpret
:
2733 case DW_OP_GNU_implicit_pointer
:
2734 case DW_OP_GNU_entry_value
:
2735 case DW_OP_GNU_const_type
:
2736 case DW_OP_GNU_regval_type
:
2737 case DW_OP_GNU_deref_type
:
2738 case DW_OP_GNU_convert
:
2739 case DW_OP_GNU_reinterpret
:
2740 case DW_OP_GNU_parameter_ref
:
2745 /* Other codes have no operands. */
2751 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2755 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2756 /* Output the opcode. */
2757 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2759 unsigned r
= (opc
- DW_OP_breg0
);
2760 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2761 gcc_assert (r
<= 31);
2762 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2764 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2766 unsigned r
= (opc
- DW_OP_reg0
);
2767 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2768 gcc_assert (r
<= 31);
2769 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2771 /* Output the opcode. */
2772 fprintf (asm_out_file
, "%#x", opc
);
2773 output_loc_operands_raw (loc
);
2775 if (!loc
->dw_loc_next
)
2777 loc
= loc
->dw_loc_next
;
2779 fputc (',', asm_out_file
);
2784 build_breg_loc (struct dw_loc_descr_node
**head
, unsigned int regno
)
2787 add_loc_descr (head
, new_loc_descr ((enum dwarf_location_atom
)
2788 (DW_OP_breg0
+ regno
), 0, 0));
2790 add_loc_descr (head
, new_loc_descr (DW_OP_bregx
, regno
, 0));
2793 /* Build a dwarf location for a cfa_reg spanning multiple
2794 consecutive registers. */
2796 struct dw_loc_descr_node
*
2797 build_span_loc (struct cfa_reg reg
)
2799 struct dw_loc_descr_node
*head
= NULL
;
2801 gcc_assert (reg
.span_width
> 0);
2802 gcc_assert (reg
.span
> 1);
2804 /* Start from the highest number register as it goes in the upper bits. */
2805 unsigned int regno
= reg
.reg
+ reg
.span
- 1;
2806 build_breg_loc (&head
, regno
);
2808 /* Deal with the remaining registers in the span. */
2809 for (int i
= reg
.span
- 2; i
>= 0; i
--)
2811 add_loc_descr (&head
, int_loc_descriptor (reg
.span_width
* 8));
2812 add_loc_descr (&head
, new_loc_descr (DW_OP_shl
, 0, 0));
2814 build_breg_loc (&head
, regno
);
2815 add_loc_descr (&head
, new_loc_descr (DW_OP_plus
, 0, 0));
2820 /* This function builds a dwarf location descriptor sequence from a
2821 dw_cfa_location, adding the given OFFSET to the result of the
2824 struct dw_loc_descr_node
*
2825 build_cfa_loc (dw_cfa_location
*cfa
, poly_int64 offset
)
2827 struct dw_loc_descr_node
*head
, *tmp
;
2829 offset
+= cfa
->offset
;
2831 if (cfa
->reg
.span
> 1)
2833 head
= build_span_loc (cfa
->reg
);
2835 if (maybe_ne (offset
, 0))
2836 loc_descr_plus_const (&head
, offset
);
2838 else if (cfa
->indirect
)
2840 head
= new_reg_loc_descr (cfa
->reg
.reg
, cfa
->base_offset
);
2841 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2842 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2843 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2844 add_loc_descr (&head
, tmp
);
2845 loc_descr_plus_const (&head
, offset
);
2848 head
= new_reg_loc_descr (cfa
->reg
.reg
, offset
);
2853 /* This function builds a dwarf location descriptor sequence for
2854 the address at OFFSET from the CFA when stack is aligned to
2857 struct dw_loc_descr_node
*
2858 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2859 poly_int64 offset
, HOST_WIDE_INT alignment
)
2861 struct dw_loc_descr_node
*head
;
2862 unsigned int dwarf_fp
2863 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2865 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2866 if (cfa
->reg
.reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2868 head
= new_reg_loc_descr (dwarf_fp
, 0);
2869 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2870 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2871 loc_descr_plus_const (&head
, offset
);
2874 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2878 /* And now, the support for symbolic debugging information. */
2880 /* .debug_str support. */
2882 static void dwarf2out_init (const char *);
2883 static void dwarf2out_finish (const char *);
2884 static void dwarf2out_early_finish (const char *);
2885 static void dwarf2out_assembly_start (void);
2886 static void dwarf2out_define (unsigned int, const char *);
2887 static void dwarf2out_undef (unsigned int, const char *);
2888 static void dwarf2out_start_source_file (unsigned, const char *);
2889 static void dwarf2out_end_source_file (unsigned);
2890 static void dwarf2out_function_decl (tree
);
2891 static void dwarf2out_begin_block (unsigned, unsigned);
2892 static void dwarf2out_end_block (unsigned, unsigned);
2893 static bool dwarf2out_ignore_block (const_tree
);
2894 static void dwarf2out_set_ignored_loc (unsigned, unsigned, const char *);
2895 static void dwarf2out_early_global_decl (tree
);
2896 static void dwarf2out_late_global_decl (tree
);
2897 static void dwarf2out_type_decl (tree
, int);
2898 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool, bool);
2899 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2901 static void dwarf2out_abstract_function (tree
);
2902 static void dwarf2out_var_location (rtx_insn
*);
2903 static void dwarf2out_inline_entry (tree
);
2904 static void dwarf2out_size_function (tree
);
2905 static void dwarf2out_begin_function (tree
);
2906 static void dwarf2out_end_function (unsigned int);
2907 static void dwarf2out_register_main_translation_unit (tree unit
);
2908 static void dwarf2out_set_name (tree
, tree
);
2909 static void dwarf2out_register_external_die (tree decl
, const char *sym
,
2910 unsigned HOST_WIDE_INT off
);
2911 static bool dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
2912 unsigned HOST_WIDE_INT
*off
);
2914 /* The debug hooks structure. */
2916 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2920 dwarf2out_early_finish
,
2921 dwarf2out_assembly_start
,
2924 dwarf2out_start_source_file
,
2925 dwarf2out_end_source_file
,
2926 dwarf2out_begin_block
,
2927 dwarf2out_end_block
,
2928 dwarf2out_ignore_block
,
2929 dwarf2out_source_line
,
2930 dwarf2out_set_ignored_loc
,
2931 dwarf2out_begin_prologue
,
2932 #if VMS_DEBUGGING_INFO
2933 dwarf2out_vms_end_prologue
,
2934 dwarf2out_vms_begin_epilogue
,
2936 debug_nothing_int_charstar
,
2937 debug_nothing_int_charstar
,
2939 dwarf2out_end_epilogue
,
2940 dwarf2out_begin_function
,
2941 dwarf2out_end_function
, /* end_function */
2942 dwarf2out_register_main_translation_unit
,
2943 dwarf2out_function_decl
, /* function_decl */
2944 dwarf2out_early_global_decl
,
2945 dwarf2out_late_global_decl
,
2946 dwarf2out_type_decl
, /* type_decl */
2947 dwarf2out_imported_module_or_decl
,
2948 dwarf2out_die_ref_for_decl
,
2949 dwarf2out_register_external_die
,
2950 debug_nothing_tree
, /* deferred_inline_function */
2951 /* The DWARF 2 backend tries to reduce debugging bloat by not
2952 emitting the abstract description of inline functions until
2953 something tries to reference them. */
2954 dwarf2out_abstract_function
, /* outlining_inline_function */
2955 debug_nothing_rtx_code_label
, /* label */
2956 debug_nothing_int
, /* handle_pch */
2957 dwarf2out_var_location
,
2958 dwarf2out_inline_entry
, /* inline_entry */
2959 dwarf2out_size_function
, /* size_function */
2960 dwarf2out_switch_text_section
,
2962 1, /* start_end_main_source_file */
2963 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2966 const struct gcc_debug_hooks dwarf2_lineno_debug_hooks
=
2969 debug_nothing_charstar
,
2970 debug_nothing_charstar
,
2971 dwarf2out_assembly_start
,
2972 debug_nothing_int_charstar
,
2973 debug_nothing_int_charstar
,
2974 debug_nothing_int_charstar
,
2976 debug_nothing_int_int
, /* begin_block */
2977 debug_nothing_int_int
, /* end_block */
2978 debug_true_const_tree
, /* ignore_block */
2979 dwarf2out_source_line
, /* source_line */
2980 debug_nothing_int_int_charstar
, /* set_ignored_loc */
2981 debug_nothing_int_int_charstar
, /* begin_prologue */
2982 debug_nothing_int_charstar
, /* end_prologue */
2983 debug_nothing_int_charstar
, /* begin_epilogue */
2984 debug_nothing_int_charstar
, /* end_epilogue */
2985 debug_nothing_tree
, /* begin_function */
2986 debug_nothing_int
, /* end_function */
2987 debug_nothing_tree
, /* register_main_translation_unit */
2988 debug_nothing_tree
, /* function_decl */
2989 debug_nothing_tree
, /* early_global_decl */
2990 debug_nothing_tree
, /* late_global_decl */
2991 debug_nothing_tree_int
, /* type_decl */
2992 debug_nothing_tree_tree_tree_bool_bool
,/* imported_module_or_decl */
2993 debug_false_tree_charstarstar_uhwistar
,/* die_ref_for_decl */
2994 debug_nothing_tree_charstar_uhwi
, /* register_external_die */
2995 debug_nothing_tree
, /* deferred_inline_function */
2996 debug_nothing_tree
, /* outlining_inline_function */
2997 debug_nothing_rtx_code_label
, /* label */
2998 debug_nothing_int
, /* handle_pch */
2999 debug_nothing_rtx_insn
, /* var_location */
3000 debug_nothing_tree
, /* inline_entry */
3001 debug_nothing_tree
, /* size_function */
3002 debug_nothing_void
, /* switch_text_section */
3003 debug_nothing_tree_tree
, /* set_name */
3004 0, /* start_end_main_source_file */
3005 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
3008 /* NOTE: In the comments in this file, many references are made to
3009 "Debugging Information Entries". This term is abbreviated as `DIE'
3010 throughout the remainder of this file. */
3012 /* An internal representation of the DWARF output is built, and then
3013 walked to generate the DWARF debugging info. The walk of the internal
3014 representation is done after the entire program has been compiled.
3015 The types below are used to describe the internal representation. */
3017 /* Whether to put type DIEs into their own section .debug_types instead
3018 of making them part of the .debug_info section. Only supported for
3019 Dwarf V4 or higher and the user didn't disable them through
3020 -fno-debug-types-section. It is more efficient to put them in a
3021 separate comdat sections since the linker will then be able to
3022 remove duplicates. But not all tools support .debug_types sections
3023 yet. For Dwarf V5 or higher .debug_types doesn't exist any more,
3024 it is DW_UT_type unit type in .debug_info section. For late LTO
3025 debug there should be almost no types emitted so avoid enabling
3026 -fdebug-types-section there. */
3028 #define use_debug_types (dwarf_version >= 4 \
3029 && flag_debug_types_section \
3032 /* Various DIE's use offsets relative to the beginning of the
3033 .debug_info section to refer to each other. */
3035 typedef long int dw_offset
;
3037 struct comdat_type_node
;
3039 /* The entries in the line_info table more-or-less mirror the opcodes
3040 that are used in the real dwarf line table. Arrays of these entries
3041 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
3044 enum dw_line_info_opcode
{
3045 /* Emit DW_LNE_set_address; the operand is the label index. */
3048 /* Emit a row to the matrix with the given line. This may be done
3049 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
3053 /* Emit a DW_LNS_set_file. */
3056 /* Emit a DW_LNS_set_column. */
3059 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
3062 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
3063 LI_set_prologue_end
,
3064 LI_set_epilogue_begin
,
3066 /* Emit a DW_LNE_set_discriminator. */
3067 LI_set_discriminator
,
3069 /* Output a Fixed Advance PC; the target PC is the label index; the
3070 base PC is the previous LI_adv_address or LI_set_address entry.
3071 We only use this when emitting debug views without assembler
3072 support, at explicit user request. Ideally, we should only use
3073 it when the offset might be zero but we can't tell: it's the only
3074 way to maybe change the PC without resetting the view number. */
3078 typedef struct GTY(()) dw_line_info_struct
{
3079 enum dw_line_info_opcode opcode
;
3081 } dw_line_info_entry
;
3084 struct GTY(()) dw_line_info_table
{
3085 /* The label that marks the end of this section. */
3086 const char *end_label
;
3088 /* The values for the last row of the matrix, as collected in the table.
3089 These are used to minimize the changes to the next row. */
3090 unsigned int file_num
;
3091 unsigned int line_num
;
3092 unsigned int column_num
;
3097 /* This denotes the NEXT view number.
3099 If it is 0, it is known that the NEXT view will be the first view
3102 If it is -1, we're forcing the view number to be reset, e.g. at a
3105 The meaning of other nonzero values depends on whether we're
3106 computing views internally or leaving it for the assembler to do
3107 so. If we're emitting them internally, view denotes the view
3108 number since the last known advance of PC. If we're leaving it
3109 for the assembler, it denotes the LVU label number that we're
3110 going to ask the assembler to assign. */
3113 /* This counts the number of symbolic views emitted in this table
3114 since the latest view reset. Its max value, over all tables,
3115 sets symview_upper_bound. */
3116 var_loc_view symviews_since_reset
;
3118 #define FORCE_RESET_NEXT_VIEW(x) ((x) = (var_loc_view)-1)
3119 #define RESET_NEXT_VIEW(x) ((x) = (var_loc_view)0)
3120 #define FORCE_RESETTING_VIEW_P(x) ((x) == (var_loc_view)-1)
3121 #define RESETTING_VIEW_P(x) ((x) == (var_loc_view)0 || FORCE_RESETTING_VIEW_P (x))
3123 vec
<dw_line_info_entry
, va_gc
> *entries
;
3126 /* This is an upper bound for view numbers that the assembler may
3127 assign to symbolic views output in this translation. It is used to
3128 decide how big a field to use to represent view numbers in
3129 symview-classed attributes. */
3131 static var_loc_view symview_upper_bound
;
3133 /* If we're keep track of location views and their reset points, and
3134 INSN is a reset point (i.e., it necessarily advances the PC), mark
3135 the next view in TABLE as reset. */
3138 maybe_reset_location_view (rtx_insn
*insn
, dw_line_info_table
*table
)
3140 if (!debug_internal_reset_location_views
)
3143 /* Maybe turn (part of?) this test into a default target hook. */
3146 if (targetm
.reset_location_view
)
3147 reset
= targetm
.reset_location_view (insn
);
3151 else if (JUMP_TABLE_DATA_P (insn
))
3153 else if (GET_CODE (insn
) == USE
3154 || GET_CODE (insn
) == CLOBBER
3155 || GET_CODE (insn
) == ASM_INPUT
3156 || asm_noperands (insn
) >= 0)
3158 else if (get_attr_min_length (insn
) > 0)
3161 if (reset
> 0 && !RESETTING_VIEW_P (table
->view
))
3162 RESET_NEXT_VIEW (table
->view
);
3165 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
3166 The children of each node form a circular list linked by
3167 die_sib. die_child points to the node *before* the "first" child node. */
3169 typedef struct GTY((chain_circular ("%h.die_sib"), for_user
)) die_struct
{
3170 union die_symbol_or_type_node
3172 const char * GTY ((tag ("0"))) die_symbol
;
3173 comdat_type_node
*GTY ((tag ("1"))) die_type_node
;
3175 GTY ((desc ("%0.comdat_type_p"))) die_id
;
3176 vec
<dw_attr_node
, va_gc
> *die_attr
;
3177 dw_die_ref die_parent
;
3178 dw_die_ref die_child
;
3180 dw_die_ref die_definition
; /* ref from a specification to its definition */
3181 dw_offset die_offset
;
3182 unsigned long die_abbrev
;
3184 unsigned int decl_id
;
3185 enum dwarf_tag die_tag
;
3186 /* Die is used and must not be pruned as unused. */
3187 BOOL_BITFIELD die_perennial_p
: 1;
3188 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
3189 /* For an external ref to die_symbol if die_offset contains an extra
3190 offset to that symbol. */
3191 BOOL_BITFIELD with_offset
: 1;
3192 /* Whether this DIE was removed from the DIE tree, for example via
3193 prune_unused_types. We don't consider those present from the
3194 DIE lookup routines. */
3195 BOOL_BITFIELD removed
: 1;
3196 /* Lots of spare bits. */
3200 /* Set to TRUE while dwarf2out_early_global_decl is running. */
3201 static bool early_dwarf
;
3202 static bool early_dwarf_finished
;
3203 class set_early_dwarf
{
3206 set_early_dwarf () : saved(early_dwarf
)
3208 gcc_assert (! early_dwarf_finished
);
3211 ~set_early_dwarf () { early_dwarf
= saved
; }
3214 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
3215 #define FOR_EACH_CHILD(die, c, expr) do { \
3216 c = die->die_child; \
3220 } while (c != die->die_child); \
3223 /* The pubname structure */
3225 typedef struct GTY(()) pubname_struct
{
3232 struct GTY(()) dw_ranges
{
3234 /* If this is positive, it's a block number, otherwise it's a
3235 bitwise-negated index into dw_ranges_by_label. */
3237 /* If idx is equal to DW_RANGES_IDX_SKELETON, it should be emitted
3238 into .debug_rnglists section rather than .debug_rnglists.dwo
3239 for -gsplit-dwarf and DWARF >= 5. */
3240 #define DW_RANGES_IDX_SKELETON ((1U << 31) - 1)
3241 /* Index for the range list for DW_FORM_rnglistx. */
3242 unsigned int idx
: 31;
3243 /* True if this range might be possibly in a different section
3244 from previous entry. */
3245 unsigned int maybe_new_sec
: 1;
3246 addr_table_entry
*begin_entry
;
3247 addr_table_entry
*end_entry
;
3250 /* A structure to hold a macinfo entry. */
3252 typedef struct GTY(()) macinfo_struct
{
3254 unsigned HOST_WIDE_INT lineno
;
3260 struct GTY(()) dw_ranges_by_label
{
3265 /* The comdat type node structure. */
3266 struct GTY(()) comdat_type_node
3268 dw_die_ref root_die
;
3269 dw_die_ref type_die
;
3270 dw_die_ref skeleton_die
;
3271 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
3272 comdat_type_node
*next
;
3275 /* A list of DIEs for which we can't determine ancestry (parent_die
3276 field) just yet. Later in dwarf2out_finish we will fill in the
3278 typedef struct GTY(()) limbo_die_struct
{
3280 /* The tree for which this DIE was created. We use this to
3281 determine ancestry later. */
3283 struct limbo_die_struct
*next
;
3287 typedef struct skeleton_chain_struct
3291 struct skeleton_chain_struct
*parent
;
3293 skeleton_chain_node
;
3295 /* Define a macro which returns nonzero for a TYPE_DECL which was
3296 implicitly generated for a type.
3298 Note that, unlike the C front-end (which generates a NULL named
3299 TYPE_DECL node for each complete tagged type, each array type,
3300 and each function type node created) the C++ front-end generates
3301 a _named_ TYPE_DECL node for each tagged type node created.
3302 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3303 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
3304 front-end, but for each type, tagged or not. */
3306 #define TYPE_DECL_IS_STUB(decl) \
3307 (DECL_NAME (decl) == NULL_TREE \
3308 || (DECL_ARTIFICIAL (decl) \
3309 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3310 /* This is necessary for stub decls that \
3311 appear in nested inline functions. */ \
3312 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3313 && (decl_ultimate_origin (decl) \
3314 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3316 /* Information concerning the compilation unit's programming
3317 language, and compiler version. */
3319 /* Fixed size portion of the DWARF compilation unit header. */
3320 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3321 (DWARF_INITIAL_LENGTH_SIZE + dwarf_offset_size \
3322 + (dwarf_version >= 5 ? 4 : 3))
3324 /* Fixed size portion of the DWARF comdat type unit header. */
3325 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
3326 (DWARF_COMPILE_UNIT_HEADER_SIZE \
3327 + DWARF_TYPE_SIGNATURE_SIZE + dwarf_offset_size)
3329 /* Fixed size portion of the DWARF skeleton compilation unit header. */
3330 #define DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE \
3331 (DWARF_COMPILE_UNIT_HEADER_SIZE + (dwarf_version >= 5 ? 8 : 0))
3333 /* Fixed size portion of public names info. */
3334 #define DWARF_PUBNAMES_HEADER_SIZE (2 * dwarf_offset_size + 2)
3336 /* Fixed size portion of the address range info. */
3337 #define DWARF_ARANGES_HEADER_SIZE \
3338 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + dwarf_offset_size + 4, \
3339 DWARF2_ADDR_SIZE * 2) \
3340 - DWARF_INITIAL_LENGTH_SIZE)
3342 /* Size of padding portion in the address range info. It must be
3343 aligned to twice the pointer size. */
3344 #define DWARF_ARANGES_PAD_SIZE \
3345 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + dwarf_offset_size + 4, \
3346 DWARF2_ADDR_SIZE * 2) \
3347 - (DWARF_INITIAL_LENGTH_SIZE + dwarf_offset_size + 4))
3349 /* Use assembler line directives if available. */
3350 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3351 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3352 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3354 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3358 /* Use assembler views in line directives if available. */
3359 #ifndef DWARF2_ASM_VIEW_DEBUG_INFO
3360 #ifdef HAVE_AS_DWARF2_DEBUG_VIEW
3361 #define DWARF2_ASM_VIEW_DEBUG_INFO 1
3363 #define DWARF2_ASM_VIEW_DEBUG_INFO 0
3367 /* Return true if GCC configure detected assembler support for .loc. */
3370 dwarf2out_default_as_loc_support (void)
3372 return DWARF2_ASM_LINE_DEBUG_INFO
;
3373 #if (GCC_VERSION >= 3000)
3374 # undef DWARF2_ASM_LINE_DEBUG_INFO
3375 # pragma GCC poison DWARF2_ASM_LINE_DEBUG_INFO
3379 /* Return true if GCC configure detected assembler support for views
3380 in .loc directives. */
3383 dwarf2out_default_as_locview_support (void)
3385 return DWARF2_ASM_VIEW_DEBUG_INFO
;
3386 #if (GCC_VERSION >= 3000)
3387 # undef DWARF2_ASM_VIEW_DEBUG_INFO
3388 # pragma GCC poison DWARF2_ASM_VIEW_DEBUG_INFO
3392 /* A bit is set in ZERO_VIEW_P if we are using the assembler-supported
3393 view computation, and it refers to a view identifier for which we
3394 will not emit a label because it is known to map to a view number
3395 zero. We won't allocate the bitmap if we're not using assembler
3396 support for location views, but we have to make the variable
3397 visible for GGC and for code that will be optimized out for lack of
3398 support but that's still parsed and compiled. We could abstract it
3399 out with macros, but it's not worth it. */
3400 static GTY(()) bitmap zero_view_p
;
3402 /* Evaluate to TRUE iff N is known to identify the first location view
3403 at its PC. When not using assembler location view computation,
3404 that must be view number zero. Otherwise, ZERO_VIEW_P is allocated
3405 and views label numbers recorded in it are the ones known to be
3407 #define ZERO_VIEW_P(N) ((N) == (var_loc_view)0 \
3408 || (N) == (var_loc_view)-1 \
3410 && bitmap_bit_p (zero_view_p, (N))))
3412 /* Return true iff we're to emit .loc directives for the assembler to
3413 generate line number sections.
3415 When we're not emitting views, all we need from the assembler is
3416 support for .loc directives.
3418 If we are emitting views, we can only use the assembler's .loc
3419 support if it also supports views.
3421 When the compiler is emitting the line number programs and
3422 computing view numbers itself, it resets view numbers at known PC
3423 changes and counts from that, and then it emits view numbers as
3424 literal constants in locviewlists. There are cases in which the
3425 compiler is not sure about PC changes, e.g. when extra alignment is
3426 requested for a label. In these cases, the compiler may not reset
3427 the view counter, and the potential PC advance in the line number
3428 program will use an opcode that does not reset the view counter
3429 even if the PC actually changes, so that compiler and debug info
3430 consumer can keep view numbers in sync.
3432 When the compiler defers view computation to the assembler, it
3433 emits symbolic view numbers in locviewlists, with the exception of
3434 views known to be zero (forced resets, or reset after
3435 compiler-visible PC changes): instead of emitting symbols for
3436 these, we emit literal zero and assert the assembler agrees with
3437 the compiler's assessment. We could use symbolic views everywhere,
3438 instead of special-casing zero views, but then we'd be unable to
3439 optimize out locviewlists that contain only zeros. */
3442 output_asm_line_debug_info (void)
3444 return (dwarf2out_as_loc_support
3445 && (dwarf2out_as_locview_support
3446 || !debug_variable_location_views
));
3449 static bool asm_outputs_debug_line_str (void);
3451 /* Minimum line offset in a special line info. opcode.
3452 This value was chosen to give a reasonable range of values. */
3453 #define DWARF_LINE_BASE -10
3455 /* First special line opcode - leave room for the standard opcodes. */
3456 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
3458 /* Range of line offsets in a special line info. opcode. */
3459 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3461 /* Flag that indicates the initial value of the is_stmt_start flag.
3462 In the present implementation, we do not mark any lines as
3463 the beginning of a source statement, because that information
3464 is not made available by the GCC front-end. */
3465 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3467 /* Maximum number of operations per instruction bundle. */
3468 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
3469 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
3472 /* This location is used by calc_die_sizes() to keep track
3473 the offset of each DIE within the .debug_info section. */
3474 static unsigned long next_die_offset
;
3476 /* Record the root of the DIE's built for the current compilation unit. */
3477 static GTY(()) dw_die_ref single_comp_unit_die
;
3479 /* A list of type DIEs that have been separated into comdat sections. */
3480 static GTY(()) comdat_type_node
*comdat_type_list
;
3482 /* A list of CU DIEs that have been separated. */
3483 static GTY(()) limbo_die_node
*cu_die_list
;
3485 /* A list of DIEs with a NULL parent waiting to be relocated. */
3486 static GTY(()) limbo_die_node
*limbo_die_list
;
3488 /* A list of DIEs for which we may have to generate
3489 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
3490 static GTY(()) limbo_die_node
*deferred_asm_name
;
3492 struct dwarf_file_hasher
: ggc_ptr_hash
<dwarf_file_data
>
3494 typedef const char *compare_type
;
3496 static hashval_t
hash (dwarf_file_data
*);
3497 static bool equal (dwarf_file_data
*, const char *);
3500 /* Filenames referenced by this compilation unit. */
3501 static GTY(()) hash_table
<dwarf_file_hasher
> *file_table
;
3503 struct decl_die_hasher
: ggc_ptr_hash
<die_node
>
3505 typedef tree compare_type
;
3507 static hashval_t
hash (die_node
*);
3508 static bool equal (die_node
*, tree
);
3510 /* A hash table of references to DIE's that describe declarations.
3511 The key is a DECL_UID() which is a unique number identifying each decl. */
3512 static GTY (()) hash_table
<decl_die_hasher
> *decl_die_table
;
3514 struct GTY ((for_user
)) variable_value_struct
{
3515 unsigned int decl_id
;
3516 vec
<dw_die_ref
, va_gc
> *dies
;
3519 struct variable_value_hasher
: ggc_ptr_hash
<variable_value_struct
>
3521 typedef tree compare_type
;
3523 static hashval_t
hash (variable_value_struct
*);
3524 static bool equal (variable_value_struct
*, tree
);
3526 /* A hash table of DIEs that contain DW_OP_GNU_variable_value with
3527 dw_val_class_decl_ref class, indexed by FUNCTION_DECLs which is
3528 DECL_CONTEXT of the referenced VAR_DECLs. */
3529 static GTY (()) hash_table
<variable_value_hasher
> *variable_value_hash
;
3531 struct block_die_hasher
: ggc_ptr_hash
<die_struct
>
3533 static hashval_t
hash (die_struct
*);
3534 static bool equal (die_struct
*, die_struct
*);
3537 /* A hash table of references to DIE's that describe COMMON blocks.
3538 The key is DECL_UID() ^ die_parent. */
3539 static GTY (()) hash_table
<block_die_hasher
> *common_block_die_table
;
3541 typedef struct GTY(()) die_arg_entry_struct
{
3547 /* Node of the variable location list. */
3548 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
3549 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
3550 EXPR_LIST chain. For small bitsizes, bitsize is encoded
3551 in mode of the EXPR_LIST node and first EXPR_LIST operand
3552 is either NOTE_INSN_VAR_LOCATION for a piece with a known
3553 location or NULL for padding. For larger bitsizes,
3554 mode is 0 and first operand is a CONCAT with bitsize
3555 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
3556 NULL as second operand. */
3558 const char * GTY (()) label
;
3559 struct var_loc_node
* GTY (()) next
;
3563 /* Variable location list. */
3564 struct GTY ((for_user
)) var_loc_list_def
{
3565 struct var_loc_node
* GTY (()) first
;
3567 /* Pointer to the last but one or last element of the
3568 chained list. If the list is empty, both first and
3569 last are NULL, if the list contains just one node
3570 or the last node certainly is not redundant, it points
3571 to the last node, otherwise points to the last but one.
3572 Do not mark it for GC because it is marked through the chain. */
3573 struct var_loc_node
* GTY ((skip ("%h"))) last
;
3575 /* Pointer to the last element before section switch,
3576 if NULL, either sections weren't switched or first
3577 is after section switch. */
3578 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
3580 /* DECL_UID of the variable decl. */
3581 unsigned int decl_id
;
3583 typedef struct var_loc_list_def var_loc_list
;
3585 /* Call argument location list. */
3586 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
3587 rtx
GTY (()) call_arg_loc_note
;
3588 const char * GTY (()) label
;
3589 tree
GTY (()) block
;
3591 rtx
GTY (()) symbol_ref
;
3592 struct call_arg_loc_node
* GTY (()) next
;
3596 struct decl_loc_hasher
: ggc_ptr_hash
<var_loc_list
>
3598 typedef const_tree compare_type
;
3600 static hashval_t
hash (var_loc_list
*);
3601 static bool equal (var_loc_list
*, const_tree
);
3604 /* Table of decl location linked lists. */
3605 static GTY (()) hash_table
<decl_loc_hasher
> *decl_loc_table
;
3607 /* Head and tail of call_arg_loc chain. */
3608 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
3609 static struct call_arg_loc_node
*call_arg_loc_last
;
3611 /* Number of call sites in the current function. */
3612 static int call_site_count
= -1;
3613 /* Number of tail call sites in the current function. */
3614 static int tail_call_site_count
= -1;
3616 /* A cached location list. */
3617 struct GTY ((for_user
)) cached_dw_loc_list_def
{
3618 /* The DECL_UID of the decl that this entry describes. */
3619 unsigned int decl_id
;
3621 /* The cached location list. */
3622 dw_loc_list_ref loc_list
;
3624 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
3626 struct dw_loc_list_hasher
: ggc_ptr_hash
<cached_dw_loc_list
>
3629 typedef const_tree compare_type
;
3631 static hashval_t
hash (cached_dw_loc_list
*);
3632 static bool equal (cached_dw_loc_list
*, const_tree
);
3635 /* Table of cached location lists. */
3636 static GTY (()) hash_table
<dw_loc_list_hasher
> *cached_dw_loc_list_table
;
3638 /* A vector of references to DIE's that are uniquely identified by their tag,
3639 presence/absence of children DIE's, and list of attribute/value pairs. */
3640 static GTY(()) vec
<dw_die_ref
, va_gc
> *abbrev_die_table
;
3642 /* A hash map to remember the stack usage for DWARF procedures. The value
3643 stored is the stack size difference between before the DWARF procedure
3644 invokation and after it returned. In other words, for a DWARF procedure
3645 that consumes N stack slots and that pushes M ones, this stores M - N. */
3646 static hash_map
<dw_die_ref
, int> *dwarf_proc_stack_usage_map
;
3648 /* A global counter for generating labels for line number data. */
3649 static unsigned int line_info_label_num
;
3651 /* The current table to which we should emit line number information
3652 for the current function. This will be set up at the beginning of
3653 assembly for the function. */
3654 static GTY(()) dw_line_info_table
*cur_line_info_table
;
3656 /* The two default tables of line number info. */
3657 static GTY(()) dw_line_info_table
*text_section_line_info
;
3658 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
3660 /* The set of all non-default tables of line number info. */
3661 static GTY(()) vec
<dw_line_info_table
*, va_gc
> *separate_line_info
;
3663 /* A flag to tell pubnames/types export if there is an info section to
3665 static bool info_section_emitted
;
3667 /* A pointer to the base of a table that contains a list of publicly
3668 accessible names. */
3669 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
3671 /* A pointer to the base of a table that contains a list of publicly
3672 accessible types. */
3673 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
3675 /* A pointer to the base of a table that contains a list of macro
3676 defines/undefines (and file start/end markers). */
3677 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
3679 /* True if .debug_macinfo or .debug_macros section is going to be
3681 #define have_macinfo \
3682 ((!XCOFF_DEBUGGING_INFO || HAVE_XCOFF_DWARF_EXTRAS) \
3683 && debug_info_level >= DINFO_LEVEL_VERBOSE \
3684 && !macinfo_table->is_empty ())
3686 /* Vector of dies for which we should generate .debug_ranges info. */
3687 static GTY (()) vec
<dw_ranges
, va_gc
> *ranges_table
;
3689 /* Vector of pairs of labels referenced in ranges_table. */
3690 static GTY (()) vec
<dw_ranges_by_label
, va_gc
> *ranges_by_label
;
3692 /* Whether we have location lists that need outputting */
3693 static GTY(()) bool have_location_lists
;
3695 /* Unique label counter. */
3696 static GTY(()) unsigned int loclabel_num
;
3698 /* Unique label counter for point-of-call tables. */
3699 static GTY(()) unsigned int poc_label_num
;
3701 /* The last file entry emitted by maybe_emit_file(). */
3702 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
3704 /* Number of internal labels generated by gen_internal_sym(). */
3705 static GTY(()) int label_num
;
3707 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
3709 /* Instances of generic types for which we need to generate debug
3710 info that describe their generic parameters and arguments. That
3711 generation needs to happen once all types are properly laid out so
3712 we do it at the end of compilation. */
3713 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
3715 /* Offset from the "steady-state frame pointer" to the frame base,
3716 within the current function. */
3717 static poly_int64 frame_pointer_fb_offset
;
3718 static bool frame_pointer_fb_offset_valid
;
3720 static vec
<dw_die_ref
> base_types
;
3722 /* Flags to represent a set of attribute classes for attributes that represent
3723 a scalar value (bounds, pointers, ...). */
3726 dw_scalar_form_constant
= 0x01,
3727 dw_scalar_form_exprloc
= 0x02,
3728 dw_scalar_form_reference
= 0x04
3731 /* Forward declarations for functions defined in this file. */
3733 static int is_pseudo_reg (const_rtx
);
3734 static tree
type_main_variant (tree
);
3735 static int is_tagged_type (const_tree
);
3736 static const char *dwarf_tag_name (unsigned);
3737 static const char *dwarf_attr_name (unsigned);
3738 static const char *dwarf_form_name (unsigned);
3739 static tree
decl_ultimate_origin (const_tree
);
3740 static tree
decl_class_context (tree
);
3741 static void add_dwarf_attr (dw_die_ref
, dw_attr_node
*);
3742 static inline unsigned int AT_index (dw_attr_node
*);
3743 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3744 static inline unsigned AT_flag (dw_attr_node
*);
3745 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3746 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3747 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
3748 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
3749 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3750 unsigned int, unsigned char *);
3751 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
3752 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3753 static inline const char *AT_string (dw_attr_node
*);
3754 static enum dwarf_form
AT_string_form (dw_attr_node
*);
3755 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3756 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3757 static inline dw_die_ref
AT_ref (dw_attr_node
*);
3758 static inline int AT_ref_external (dw_attr_node
*);
3759 static inline void set_AT_ref_external (dw_attr_node
*, int);
3760 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3761 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3763 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3764 static void add_AT_view_list (dw_die_ref
, enum dwarf_attribute
);
3765 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3766 static addr_table_entry
*add_addr_table_entry (void *, enum ate_kind
);
3767 static void remove_addr_table_entry (addr_table_entry
*);
3768 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
, bool);
3769 static inline rtx
AT_addr (dw_attr_node
*);
3770 static void add_AT_symview (dw_die_ref
, enum dwarf_attribute
, const char *);
3771 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3772 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3773 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3774 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3775 unsigned long, bool);
3776 static inline const char *AT_lbl (dw_attr_node
*);
3777 static const char *get_AT_low_pc (dw_die_ref
);
3778 static bool is_c (void);
3779 static bool is_cxx (void);
3780 static bool is_cxx (const_tree
);
3781 static bool is_fortran (void);
3782 static bool is_ada (void);
3783 static bool remove_AT (dw_die_ref
, enum dwarf_attribute
);
3784 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3785 static void add_child_die (dw_die_ref
, dw_die_ref
);
3786 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3787 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3788 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3789 static void equate_type_number_to_die (tree
, dw_die_ref
);
3790 static var_loc_list
*lookup_decl_loc (const_tree
);
3791 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3792 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *, var_loc_view
);
3793 static void print_spaces (FILE *);
3794 static void print_die (dw_die_ref
, FILE *);
3795 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3796 static void attr_checksum (dw_attr_node
*, struct md5_ctx
*, int *);
3797 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3798 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3799 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3800 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3801 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_node
*,
3802 struct md5_ctx
*, int *);
3803 struct checksum_attributes
;
3804 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3805 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3806 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3807 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3808 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3809 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3810 static int same_attr_p (dw_attr_node
*, dw_attr_node
*, int *);
3811 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3812 static int is_type_die (dw_die_ref
);
3813 static inline bool is_template_instantiation (dw_die_ref
);
3814 static int is_declaration_die (dw_die_ref
);
3815 static int should_move_die_to_comdat (dw_die_ref
);
3816 static dw_die_ref
clone_as_declaration (dw_die_ref
);
3817 static dw_die_ref
clone_die (dw_die_ref
);
3818 static dw_die_ref
clone_tree (dw_die_ref
);
3819 static dw_die_ref
copy_declaration_context (dw_die_ref
, dw_die_ref
);
3820 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
3821 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
3822 static dw_die_ref
generate_skeleton (dw_die_ref
);
3823 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
3826 static void break_out_comdat_types (dw_die_ref
);
3827 static void copy_decls_for_unworthy_types (dw_die_ref
);
3829 static void add_sibling_attributes (dw_die_ref
);
3830 static void output_location_lists (dw_die_ref
);
3831 static int constant_size (unsigned HOST_WIDE_INT
);
3832 static unsigned long size_of_die (dw_die_ref
);
3833 static void calc_die_sizes (dw_die_ref
);
3834 static void calc_base_type_die_sizes (void);
3835 static void mark_dies (dw_die_ref
);
3836 static void unmark_dies (dw_die_ref
);
3837 static void unmark_all_dies (dw_die_ref
);
3838 static unsigned long size_of_pubnames (vec
<pubname_entry
, va_gc
> *);
3839 static unsigned long size_of_aranges (void);
3840 static enum dwarf_form
value_format (dw_attr_node
*);
3841 static void output_value_format (dw_attr_node
*);
3842 static void output_abbrev_section (void);
3843 static void output_die_abbrevs (unsigned long, dw_die_ref
);
3844 static void output_die (dw_die_ref
);
3845 static void output_compilation_unit_header (enum dwarf_unit_type
);
3846 static void output_comp_unit (dw_die_ref
, int, const unsigned char *);
3847 static void output_comdat_type_unit (comdat_type_node
*, bool);
3848 static const char *dwarf2_name (tree
, int);
3849 static void add_pubname (tree
, dw_die_ref
);
3850 static void add_enumerator_pubname (const char *, dw_die_ref
);
3851 static void add_pubname_string (const char *, dw_die_ref
);
3852 static void add_pubtype (tree
, dw_die_ref
);
3853 static void output_pubnames (vec
<pubname_entry
, va_gc
> *);
3854 static void output_aranges (void);
3855 static unsigned int add_ranges (const_tree
, bool = false);
3856 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
3858 static void output_ranges (void);
3859 static dw_line_info_table
*new_line_info_table (void);
3860 static void output_line_info (bool);
3861 static void output_file_names (void);
3862 static int is_base_type (tree
);
3863 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, tree
, dw_die_ref
);
3864 static int decl_quals (const_tree
);
3865 static dw_die_ref
modified_type_die (tree
, int, bool, dw_die_ref
);
3866 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
3867 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
3868 static unsigned int dbx_reg_number (const_rtx
);
3869 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3870 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3871 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3872 enum var_init_status
);
3873 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3874 enum var_init_status
);
3875 static dw_loc_descr_ref
based_loc_descr (rtx
, poly_int64
,
3876 enum var_init_status
);
3877 static int is_based_loc (const_rtx
);
3878 static bool resolve_one_addr (rtx
*);
3879 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3880 enum var_init_status
);
3881 static dw_loc_descr_ref
loc_descriptor (rtx
, machine_mode mode
,
3882 enum var_init_status
);
3883 struct loc_descr_context
;
3884 static void add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
);
3885 static void add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
);
3886 static dw_loc_list_ref
loc_list_from_tree (tree
, int,
3887 struct loc_descr_context
*);
3888 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int,
3889 struct loc_descr_context
*);
3890 static tree
field_type (const_tree
);
3891 static unsigned int simple_type_align_in_bits (const_tree
);
3892 static unsigned int simple_decl_align_in_bits (const_tree
);
3893 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3895 static dw_loc_descr_ref
field_byte_offset (const_tree
, struct vlr_context
*,
3897 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3899 static void add_data_member_location_attribute (dw_die_ref
, tree
,
3900 struct vlr_context
*);
3901 static bool add_const_value_attribute (dw_die_ref
, machine_mode
, rtx
);
3902 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3903 static void insert_wide_int (const wide_int
&, unsigned char *, int);
3904 static unsigned insert_float (const_rtx
, unsigned char *);
3905 static rtx
rtl_for_decl_location (tree
);
3906 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool);
3907 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3908 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3909 static void add_desc_attribute (dw_die_ref
, tree
);
3910 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3911 static void add_comp_dir_attribute (dw_die_ref
);
3912 static void add_scalar_info (dw_die_ref
, enum dwarf_attribute
, tree
, int,
3913 struct loc_descr_context
*);
3914 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
,
3915 struct loc_descr_context
*);
3916 static void add_subscript_info (dw_die_ref
, tree
, bool);
3917 static void add_byte_size_attribute (dw_die_ref
, tree
);
3918 static void add_alignment_attribute (dw_die_ref
, tree
);
3919 static void add_bit_offset_attribute (dw_die_ref
, tree
);
3920 static void add_bit_size_attribute (dw_die_ref
, tree
);
3921 static void add_prototyped_attribute (dw_die_ref
, tree
);
3922 static void add_abstract_origin_attribute (dw_die_ref
, tree
);
3923 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3924 static void add_src_coords_attributes (dw_die_ref
, tree
);
3925 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
, bool = false);
3926 static void add_discr_value (dw_die_ref
, dw_discr_value
*);
3927 static void add_discr_list (dw_die_ref
, dw_discr_list_ref
);
3928 static inline dw_discr_list_ref
AT_discr_list (dw_attr_node
*);
3929 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3930 static inline int local_scope_p (dw_die_ref
);
3931 static inline int class_scope_p (dw_die_ref
);
3932 static inline int class_or_namespace_scope_p (dw_die_ref
);
3933 static void add_type_attribute (dw_die_ref
, tree
, int, bool, dw_die_ref
);
3934 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3935 static const char *type_tag (const_tree
);
3936 static tree
member_declared_type (const_tree
);
3938 static const char *decl_start_label (tree
);
3940 static void gen_array_type_die (tree
, dw_die_ref
);
3941 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3943 static void gen_entry_point_die (tree
, dw_die_ref
);
3945 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3946 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3947 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3948 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3949 static void gen_formal_types_die (tree
, dw_die_ref
);
3950 static void gen_subprogram_die (tree
, dw_die_ref
);
3951 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3952 static void gen_const_die (tree
, dw_die_ref
);
3953 static void gen_label_die (tree
, dw_die_ref
);
3954 static void gen_lexical_block_die (tree
, dw_die_ref
);
3955 static void gen_inlined_subroutine_die (tree
, dw_die_ref
);
3956 static void gen_field_die (tree
, struct vlr_context
*, dw_die_ref
);
3957 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3958 static dw_die_ref
gen_compile_unit_die (const char *);
3959 static void gen_inheritance_die (tree
, tree
, tree
, dw_die_ref
);
3960 static void gen_member_die (tree
, dw_die_ref
);
3961 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3962 enum debug_info_usage
);
3963 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3964 static void gen_typedef_die (tree
, dw_die_ref
);
3965 static void gen_type_die (tree
, dw_die_ref
);
3966 static void gen_block_die (tree
, dw_die_ref
);
3967 static void decls_for_scope (tree
, dw_die_ref
, bool = true);
3968 static bool is_naming_typedef_decl (const_tree
);
3969 static inline dw_die_ref
get_context_die (tree
);
3970 static void gen_namespace_die (tree
, dw_die_ref
);
3971 static dw_die_ref
gen_namelist_decl (tree
, dw_die_ref
, tree
);
3972 static dw_die_ref
gen_decl_die (tree
, tree
, struct vlr_context
*, dw_die_ref
);
3973 static dw_die_ref
force_decl_die (tree
);
3974 static dw_die_ref
force_type_die (tree
);
3975 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3976 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3977 static struct dwarf_file_data
* lookup_filename (const char *);
3978 static void retry_incomplete_types (void);
3979 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3980 static void gen_generic_params_dies (tree
);
3981 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3982 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3983 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3984 static int file_info_cmp (const void *, const void *);
3985 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *, var_loc_view
,
3986 const char *, var_loc_view
, const char *);
3987 static void output_loc_list (dw_loc_list_ref
);
3988 static char *gen_internal_sym (const char *);
3989 static bool want_pubnames (void);
3991 static void prune_unmark_dies (dw_die_ref
);
3992 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3993 static void prune_unused_types_mark (dw_die_ref
, int);
3994 static void prune_unused_types_walk (dw_die_ref
);
3995 static void prune_unused_types_walk_attribs (dw_die_ref
);
3996 static void prune_unused_types_prune (dw_die_ref
);
3997 static void prune_unused_types (void);
3998 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3999 static inline const char *AT_vms_delta1 (dw_attr_node
*);
4000 static inline const char *AT_vms_delta2 (dw_attr_node
*);
4001 #if VMS_DEBUGGING_INFO
4002 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
4003 const char *, const char *);
4005 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
4006 static void gen_remaining_tmpl_value_param_die_attribute (void);
4007 static bool generic_type_p (tree
);
4008 static void schedule_generic_params_dies_gen (tree t
);
4009 static void gen_scheduled_generic_parms_dies (void);
4010 static void resolve_variable_values (void);
4012 static const char *comp_dir_string (void);
4014 static void hash_loc_operands (dw_loc_descr_ref
, inchash::hash
&);
4016 /* enum for tracking thread-local variables whose address is really an offset
4017 relative to the TLS pointer, which will need link-time relocation, but will
4018 not need relocation by the DWARF consumer. */
4026 /* Return the operator to use for an address of a variable. For dtprel_true, we
4027 use DW_OP_const*. For regular variables, which need both link-time
4028 relocation and consumer-level relocation (e.g., to account for shared objects
4029 loaded at a random address), we use DW_OP_addr*. */
4031 static inline enum dwarf_location_atom
4032 dw_addr_op (enum dtprel_bool dtprel
)
4034 if (dtprel
== dtprel_true
)
4035 return (dwarf_split_debug_info
? dwarf_OP (DW_OP_constx
)
4036 : (DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
));
4038 return dwarf_split_debug_info
? dwarf_OP (DW_OP_addrx
) : DW_OP_addr
;
4041 /* Return a pointer to a newly allocated address location description. If
4042 dwarf_split_debug_info is true, then record the address with the appropriate
4044 static inline dw_loc_descr_ref
4045 new_addr_loc_descr (rtx addr
, enum dtprel_bool dtprel
)
4047 dw_loc_descr_ref ref
= new_loc_descr (dw_addr_op (dtprel
), 0, 0);
4049 ref
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
4050 ref
->dw_loc_oprnd1
.v
.val_addr
= addr
;
4051 ref
->dtprel
= dtprel
;
4052 if (dwarf_split_debug_info
)
4053 ref
->dw_loc_oprnd1
.val_entry
4054 = add_addr_table_entry (addr
,
4055 dtprel
? ate_kind_rtx_dtprel
: ate_kind_rtx
);
4057 ref
->dw_loc_oprnd1
.val_entry
= NULL
;
4062 /* Section names used to hold DWARF debugging information. */
4064 #ifndef DEBUG_INFO_SECTION
4065 #define DEBUG_INFO_SECTION ".debug_info"
4067 #ifndef DEBUG_DWO_INFO_SECTION
4068 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
4070 #ifndef DEBUG_LTO_INFO_SECTION
4071 #define DEBUG_LTO_INFO_SECTION ".gnu.debuglto_.debug_info"
4073 #ifndef DEBUG_LTO_DWO_INFO_SECTION
4074 #define DEBUG_LTO_DWO_INFO_SECTION ".gnu.debuglto_.debug_info.dwo"
4076 #ifndef DEBUG_ABBREV_SECTION
4077 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
4079 #ifndef DEBUG_LTO_ABBREV_SECTION
4080 #define DEBUG_LTO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev"
4082 #ifndef DEBUG_DWO_ABBREV_SECTION
4083 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
4085 #ifndef DEBUG_LTO_DWO_ABBREV_SECTION
4086 #define DEBUG_LTO_DWO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev.dwo"
4088 #ifndef DEBUG_ARANGES_SECTION
4089 #define DEBUG_ARANGES_SECTION ".debug_aranges"
4091 #ifndef DEBUG_ADDR_SECTION
4092 #define DEBUG_ADDR_SECTION ".debug_addr"
4094 #ifndef DEBUG_MACINFO_SECTION
4095 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
4097 #ifndef DEBUG_LTO_MACINFO_SECTION
4098 #define DEBUG_LTO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo"
4100 #ifndef DEBUG_DWO_MACINFO_SECTION
4101 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
4103 #ifndef DEBUG_LTO_DWO_MACINFO_SECTION
4104 #define DEBUG_LTO_DWO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo.dwo"
4106 #ifndef DEBUG_MACRO_SECTION
4107 #define DEBUG_MACRO_SECTION ".debug_macro"
4109 #ifndef DEBUG_LTO_MACRO_SECTION
4110 #define DEBUG_LTO_MACRO_SECTION ".gnu.debuglto_.debug_macro"
4112 #ifndef DEBUG_DWO_MACRO_SECTION
4113 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
4115 #ifndef DEBUG_LTO_DWO_MACRO_SECTION
4116 #define DEBUG_LTO_DWO_MACRO_SECTION ".gnu.debuglto_.debug_macro.dwo"
4118 #ifndef DEBUG_LINE_SECTION
4119 #define DEBUG_LINE_SECTION ".debug_line"
4121 #ifndef DEBUG_LTO_LINE_SECTION
4122 #define DEBUG_LTO_LINE_SECTION ".gnu.debuglto_.debug_line"
4124 #ifndef DEBUG_DWO_LINE_SECTION
4125 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
4127 #ifndef DEBUG_LTO_DWO_LINE_SECTION
4128 #define DEBUG_LTO_DWO_LINE_SECTION ".gnu.debuglto_.debug_line.dwo"
4130 #ifndef DEBUG_LOC_SECTION
4131 #define DEBUG_LOC_SECTION ".debug_loc"
4133 #ifndef DEBUG_DWO_LOC_SECTION
4134 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
4136 #ifndef DEBUG_LOCLISTS_SECTION
4137 #define DEBUG_LOCLISTS_SECTION ".debug_loclists"
4139 #ifndef DEBUG_DWO_LOCLISTS_SECTION
4140 #define DEBUG_DWO_LOCLISTS_SECTION ".debug_loclists.dwo"
4142 #ifndef DEBUG_PUBNAMES_SECTION
4143 #define DEBUG_PUBNAMES_SECTION \
4144 ((debug_generate_pub_sections == 2) \
4145 ? ".debug_gnu_pubnames" : ".debug_pubnames")
4147 #ifndef DEBUG_PUBTYPES_SECTION
4148 #define DEBUG_PUBTYPES_SECTION \
4149 ((debug_generate_pub_sections == 2) \
4150 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
4152 #ifndef DEBUG_STR_OFFSETS_SECTION
4153 #define DEBUG_STR_OFFSETS_SECTION ".debug_str_offsets"
4155 #ifndef DEBUG_DWO_STR_OFFSETS_SECTION
4156 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
4158 #ifndef DEBUG_LTO_DWO_STR_OFFSETS_SECTION
4159 #define DEBUG_LTO_DWO_STR_OFFSETS_SECTION ".gnu.debuglto_.debug_str_offsets.dwo"
4161 #ifndef DEBUG_STR_SECTION
4162 #define DEBUG_STR_SECTION ".debug_str"
4164 #ifndef DEBUG_LTO_STR_SECTION
4165 #define DEBUG_LTO_STR_SECTION ".gnu.debuglto_.debug_str"
4167 #ifndef DEBUG_STR_DWO_SECTION
4168 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
4170 #ifndef DEBUG_LTO_STR_DWO_SECTION
4171 #define DEBUG_LTO_STR_DWO_SECTION ".gnu.debuglto_.debug_str.dwo"
4173 #ifndef DEBUG_RANGES_SECTION
4174 #define DEBUG_RANGES_SECTION ".debug_ranges"
4176 #ifndef DEBUG_RNGLISTS_SECTION
4177 #define DEBUG_RNGLISTS_SECTION ".debug_rnglists"
4179 #ifndef DEBUG_DWO_RNGLISTS_SECTION
4180 #define DEBUG_DWO_RNGLISTS_SECTION ".debug_rnglists.dwo"
4182 #ifndef DEBUG_LINE_STR_SECTION
4183 #define DEBUG_LINE_STR_SECTION ".debug_line_str"
4185 #ifndef DEBUG_LTO_LINE_STR_SECTION
4186 #define DEBUG_LTO_LINE_STR_SECTION ".gnu.debuglto_.debug_line_str"
4189 /* Section flags for .debug_str section. */
4190 #define DEBUG_STR_SECTION_FLAGS \
4191 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
4192 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4195 /* Section flags for .debug_str.dwo section. */
4196 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
4198 /* Attribute used to refer to the macro section. */
4199 #define DEBUG_MACRO_ATTRIBUTE (dwarf_version >= 5 ? DW_AT_macros \
4200 : dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros)
4202 /* Labels we insert at beginning sections we can reference instead of
4203 the section names themselves. */
4205 #ifndef TEXT_SECTION_LABEL
4206 #define TEXT_SECTION_LABEL "Ltext"
4208 #ifndef COLD_TEXT_SECTION_LABEL
4209 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
4211 #ifndef DEBUG_LINE_SECTION_LABEL
4212 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4214 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
4215 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
4217 #ifndef DEBUG_INFO_SECTION_LABEL
4218 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4220 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
4221 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
4223 #ifndef DEBUG_ABBREV_SECTION_LABEL
4224 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4226 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
4227 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
4229 #ifndef DEBUG_ADDR_SECTION_LABEL
4230 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
4232 #ifndef DEBUG_LOC_SECTION_LABEL
4233 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4235 #ifndef DEBUG_RANGES_SECTION_LABEL
4236 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4238 #ifndef DEBUG_MACINFO_SECTION_LABEL
4239 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4241 #ifndef DEBUG_MACRO_SECTION_LABEL
4242 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
4244 #define SKELETON_COMP_DIE_ABBREV 1
4245 #define SKELETON_TYPE_DIE_ABBREV 2
4247 /* Definitions of defaults for formats and names of various special
4248 (artificial) labels which may be generated within this file (when the -g
4249 options is used and DWARF2_DEBUGGING_INFO is in effect.
4250 If necessary, these may be overridden from within the tm.h file, but
4251 typically, overriding these defaults is unnecessary. */
4253 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4254 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4255 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4256 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4257 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4258 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4259 static char debug_skeleton_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4260 static char debug_skeleton_abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4261 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4262 static char debug_addr_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4263 static char debug_skeleton_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4264 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4265 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4266 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4267 static char ranges_base_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4269 #ifndef TEXT_END_LABEL
4270 #define TEXT_END_LABEL "Letext"
4272 #ifndef COLD_END_LABEL
4273 #define COLD_END_LABEL "Letext_cold"
4275 #ifndef BLOCK_BEGIN_LABEL
4276 #define BLOCK_BEGIN_LABEL "LBB"
4278 #ifndef BLOCK_INLINE_ENTRY_LABEL
4279 #define BLOCK_INLINE_ENTRY_LABEL "LBI"
4281 #ifndef BLOCK_END_LABEL
4282 #define BLOCK_END_LABEL "LBE"
4284 #ifndef LINE_CODE_LABEL
4285 #define LINE_CODE_LABEL "LM"
4289 /* Return the root of the DIE's built for the current compilation unit. */
4291 comp_unit_die (void)
4293 if (!single_comp_unit_die
)
4294 single_comp_unit_die
= gen_compile_unit_die (NULL
);
4295 return single_comp_unit_die
;
4298 /* We allow a language front-end to designate a function that is to be
4299 called to "demangle" any name before it is put into a DIE. */
4301 static const char *(*demangle_name_func
) (const char *);
4304 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
4306 demangle_name_func
= func
;
4309 /* Test if rtl node points to a pseudo register. */
4312 is_pseudo_reg (const_rtx rtl
)
4314 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
4315 || (GET_CODE (rtl
) == SUBREG
4316 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
4319 /* Return a reference to a type, with its const and volatile qualifiers
4323 type_main_variant (tree type
)
4325 type
= TYPE_MAIN_VARIANT (type
);
4327 /* ??? There really should be only one main variant among any group of
4328 variants of a given type (and all of the MAIN_VARIANT values for all
4329 members of the group should point to that one type) but sometimes the C
4330 front-end messes this up for array types, so we work around that bug
4332 if (TREE_CODE (type
) == ARRAY_TYPE
)
4333 while (type
!= TYPE_MAIN_VARIANT (type
))
4334 type
= TYPE_MAIN_VARIANT (type
);
4339 /* Return nonzero if the given type node represents a tagged type. */
4342 is_tagged_type (const_tree type
)
4344 enum tree_code code
= TREE_CODE (type
);
4346 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
4347 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
4350 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
4353 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
4355 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
4358 /* Return die_offset of a DIE reference to a base type. */
4360 static unsigned long int
4361 get_base_type_offset (dw_die_ref ref
)
4363 if (ref
->die_offset
)
4364 return ref
->die_offset
;
4365 if (comp_unit_die ()->die_abbrev
)
4367 calc_base_type_die_sizes ();
4368 gcc_assert (ref
->die_offset
);
4370 return ref
->die_offset
;
4373 /* Return die_offset of a DIE reference other than base type. */
4375 static unsigned long int
4376 get_ref_die_offset (dw_die_ref ref
)
4378 gcc_assert (ref
->die_offset
);
4379 return ref
->die_offset
;
4382 /* Convert a DIE tag into its string name. */
4385 dwarf_tag_name (unsigned int tag
)
4387 const char *name
= get_DW_TAG_name (tag
);
4392 return "DW_TAG_<unknown>";
4395 /* Convert a DWARF attribute code into its string name. */
4398 dwarf_attr_name (unsigned int attr
)
4404 #if VMS_DEBUGGING_INFO
4405 case DW_AT_HP_prologue
:
4406 return "DW_AT_HP_prologue";
4408 case DW_AT_MIPS_loop_unroll_factor
:
4409 return "DW_AT_MIPS_loop_unroll_factor";
4412 #if VMS_DEBUGGING_INFO
4413 case DW_AT_HP_epilogue
:
4414 return "DW_AT_HP_epilogue";
4416 case DW_AT_MIPS_stride
:
4417 return "DW_AT_MIPS_stride";
4421 name
= get_DW_AT_name (attr
);
4426 return "DW_AT_<unknown>";
4429 /* Convert a DWARF value form code into its string name. */
4432 dwarf_form_name (unsigned int form
)
4434 const char *name
= get_DW_FORM_name (form
);
4439 return "DW_FORM_<unknown>";
4442 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4443 instance of an inlined instance of a decl which is local to an inline
4444 function, so we have to trace all of the way back through the origin chain
4445 to find out what sort of node actually served as the original seed for the
4449 decl_ultimate_origin (const_tree decl
)
4451 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
4454 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
4455 we're trying to output the abstract instance of this function. */
4456 if (DECL_ABSTRACT_P (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
4459 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4460 most distant ancestor, this should never happen. */
4461 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
4463 return DECL_ABSTRACT_ORIGIN (decl
);
4466 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4467 of a virtual function may refer to a base class, so we check the 'this'
4471 decl_class_context (tree decl
)
4473 tree context
= NULL_TREE
;
4475 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
4476 context
= DECL_CONTEXT (decl
);
4478 context
= TYPE_MAIN_VARIANT
4479 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
4481 if (context
&& !TYPE_P (context
))
4482 context
= NULL_TREE
;
4487 /* Add an attribute/value pair to a DIE. */
4490 add_dwarf_attr (dw_die_ref die
, dw_attr_node
*attr
)
4492 /* Maybe this should be an assert? */
4498 /* Check we do not add duplicate attrs. Can't use get_AT here
4499 because that recurses to the specification/abstract origin DIE. */
4502 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4503 gcc_assert (a
->dw_attr
!= attr
->dw_attr
);
4506 vec_safe_reserve (die
->die_attr
, 1);
4507 vec_safe_push (die
->die_attr
, *attr
);
4511 AT_class (dw_attr_node
*a
)
4513 return a
->dw_attr_val
.val_class
;
4516 /* Return the index for any attribute that will be referenced with a
4517 DW_FORM_addrx/GNU_addr_index or DW_FORM_strx/GNU_str_index. String
4518 indices are stored in dw_attr_val.v.val_str for reference counting
4521 static inline unsigned int
4522 AT_index (dw_attr_node
*a
)
4524 if (AT_class (a
) == dw_val_class_str
)
4525 return a
->dw_attr_val
.v
.val_str
->index
;
4526 else if (a
->dw_attr_val
.val_entry
!= NULL
)
4527 return a
->dw_attr_val
.val_entry
->index
;
4531 /* Add a flag value attribute to a DIE. */
4534 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
4538 attr
.dw_attr
= attr_kind
;
4539 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
4540 attr
.dw_attr_val
.val_entry
= NULL
;
4541 attr
.dw_attr_val
.v
.val_flag
= flag
;
4542 add_dwarf_attr (die
, &attr
);
4545 static inline unsigned
4546 AT_flag (dw_attr_node
*a
)
4548 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
4549 return a
->dw_attr_val
.v
.val_flag
;
4552 /* Add a signed integer attribute value to a DIE. */
4555 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
4559 attr
.dw_attr
= attr_kind
;
4560 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
4561 attr
.dw_attr_val
.val_entry
= NULL
;
4562 attr
.dw_attr_val
.v
.val_int
= int_val
;
4563 add_dwarf_attr (die
, &attr
);
4567 AT_int (dw_attr_node
*a
)
4569 gcc_assert (a
&& (AT_class (a
) == dw_val_class_const
4570 || AT_class (a
) == dw_val_class_const_implicit
));
4571 return a
->dw_attr_val
.v
.val_int
;
4574 /* Add an unsigned integer attribute value to a DIE. */
4577 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4578 unsigned HOST_WIDE_INT unsigned_val
)
4582 attr
.dw_attr
= attr_kind
;
4583 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
4584 attr
.dw_attr_val
.val_entry
= NULL
;
4585 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
4586 add_dwarf_attr (die
, &attr
);
4589 unsigned HOST_WIDE_INT
4590 AT_unsigned (dw_attr_node
*a
)
4592 gcc_assert (a
&& (AT_class (a
) == dw_val_class_unsigned_const
4593 || AT_class (a
) == dw_val_class_unsigned_const_implicit
));
4594 return a
->dw_attr_val
.v
.val_unsigned
;
4597 /* Add an unsigned wide integer attribute value to a DIE. */
4600 add_AT_wide (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4605 attr
.dw_attr
= attr_kind
;
4606 attr
.dw_attr_val
.val_class
= dw_val_class_wide_int
;
4607 attr
.dw_attr_val
.val_entry
= NULL
;
4608 attr
.dw_attr_val
.v
.val_wide
= ggc_alloc
<wide_int
> ();
4609 *attr
.dw_attr_val
.v
.val_wide
= w
;
4610 add_dwarf_attr (die
, &attr
);
4613 /* Add an unsigned double integer attribute value to a DIE. */
4616 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4617 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
4621 attr
.dw_attr
= attr_kind
;
4622 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
4623 attr
.dw_attr_val
.val_entry
= NULL
;
4624 attr
.dw_attr_val
.v
.val_double
.high
= high
;
4625 attr
.dw_attr_val
.v
.val_double
.low
= low
;
4626 add_dwarf_attr (die
, &attr
);
4629 /* Add a floating point attribute value to a DIE and return it. */
4632 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4633 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
4637 attr
.dw_attr
= attr_kind
;
4638 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
4639 attr
.dw_attr_val
.val_entry
= NULL
;
4640 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
4641 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
4642 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
4643 add_dwarf_attr (die
, &attr
);
4646 /* Add an 8-byte data attribute value to a DIE. */
4649 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4650 unsigned char data8
[8])
4654 attr
.dw_attr
= attr_kind
;
4655 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
4656 attr
.dw_attr_val
.val_entry
= NULL
;
4657 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
4658 add_dwarf_attr (die
, &attr
);
4661 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
4662 dwarf_split_debug_info, address attributes in dies destined for the
4663 final executable have force_direct set to avoid using indexed
4667 add_AT_low_high_pc (dw_die_ref die
, const char *lbl_low
, const char *lbl_high
,
4673 lbl_id
= xstrdup (lbl_low
);
4674 attr
.dw_attr
= DW_AT_low_pc
;
4675 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4676 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4677 if (dwarf_split_debug_info
&& !force_direct
)
4678 attr
.dw_attr_val
.val_entry
4679 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4681 attr
.dw_attr_val
.val_entry
= NULL
;
4682 add_dwarf_attr (die
, &attr
);
4684 attr
.dw_attr
= DW_AT_high_pc
;
4685 if (dwarf_version
< 4)
4686 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4688 attr
.dw_attr_val
.val_class
= dw_val_class_high_pc
;
4689 lbl_id
= xstrdup (lbl_high
);
4690 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4691 if (attr
.dw_attr_val
.val_class
== dw_val_class_lbl_id
4692 && dwarf_split_debug_info
&& !force_direct
)
4693 attr
.dw_attr_val
.val_entry
4694 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4696 attr
.dw_attr_val
.val_entry
= NULL
;
4697 add_dwarf_attr (die
, &attr
);
4700 /* Hash and equality functions for debug_str_hash. */
4703 indirect_string_hasher::hash (indirect_string_node
*x
)
4705 return htab_hash_string (x
->str
);
4709 indirect_string_hasher::equal (indirect_string_node
*x1
, const char *x2
)
4711 return strcmp (x1
->str
, x2
) == 0;
4714 /* Add STR to the given string hash table. */
4716 static struct indirect_string_node
*
4717 find_AT_string_in_table (const char *str
,
4718 hash_table
<indirect_string_hasher
> *table
,
4719 enum insert_option insert
= INSERT
)
4721 struct indirect_string_node
*node
;
4723 indirect_string_node
**slot
4724 = table
->find_slot_with_hash (str
, htab_hash_string (str
), insert
);
4727 node
= ggc_cleared_alloc
<indirect_string_node
> ();
4728 node
->str
= ggc_strdup (str
);
4738 /* Add STR to the indirect string hash table. */
4740 static struct indirect_string_node
*
4741 find_AT_string (const char *str
, enum insert_option insert
= INSERT
)
4743 if (! debug_str_hash
)
4744 debug_str_hash
= hash_table
<indirect_string_hasher
>::create_ggc (10);
4746 return find_AT_string_in_table (str
, debug_str_hash
, insert
);
4749 /* Add a string attribute value to a DIE. */
4752 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
4755 struct indirect_string_node
*node
;
4757 node
= find_AT_string (str
);
4759 attr
.dw_attr
= attr_kind
;
4760 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
4761 attr
.dw_attr_val
.val_entry
= NULL
;
4762 attr
.dw_attr_val
.v
.val_str
= node
;
4763 add_dwarf_attr (die
, &attr
);
4766 static inline const char *
4767 AT_string (dw_attr_node
*a
)
4769 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4770 return a
->dw_attr_val
.v
.val_str
->str
;
4773 /* Call this function directly to bypass AT_string_form's logic to put
4774 the string inline in the die. */
4777 set_indirect_string (struct indirect_string_node
*node
)
4779 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4780 /* Already indirect is a no op. */
4781 if (node
->form
== DW_FORM_strp
4782 || node
->form
== DW_FORM_line_strp
4783 || node
->form
== dwarf_FORM (DW_FORM_strx
))
4785 gcc_assert (node
->label
);
4788 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4789 ++dw2_string_counter
;
4790 node
->label
= xstrdup (label
);
4792 if (!dwarf_split_debug_info
)
4794 node
->form
= DW_FORM_strp
;
4795 node
->index
= NOT_INDEXED
;
4799 node
->form
= dwarf_FORM (DW_FORM_strx
);
4800 node
->index
= NO_INDEX_ASSIGNED
;
4804 /* A helper function for dwarf2out_finish, called to reset indirect
4805 string decisions done for early LTO dwarf output before fat object
4809 reset_indirect_string (indirect_string_node
**h
, void *)
4811 struct indirect_string_node
*node
= *h
;
4812 if (node
->form
== DW_FORM_strp
4813 || node
->form
== DW_FORM_line_strp
4814 || node
->form
== dwarf_FORM (DW_FORM_strx
))
4818 node
->form
= (dwarf_form
) 0;
4824 /* Add a string representing a file or filepath attribute value to a DIE. */
4827 add_filepath_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4830 if (! asm_outputs_debug_line_str ())
4831 add_AT_string (die
, attr_kind
, str
);
4835 struct indirect_string_node
*node
;
4837 if (!debug_line_str_hash
)
4839 = hash_table
<indirect_string_hasher
>::create_ggc (10);
4841 node
= find_AT_string_in_table (str
, debug_line_str_hash
);
4842 set_indirect_string (node
);
4843 node
->form
= DW_FORM_line_strp
;
4845 attr
.dw_attr
= attr_kind
;
4846 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
4847 attr
.dw_attr_val
.val_entry
= NULL
;
4848 attr
.dw_attr_val
.v
.val_str
= node
;
4849 add_dwarf_attr (die
, &attr
);
4853 /* Find out whether a string should be output inline in DIE
4854 or out-of-line in .debug_str section. */
4856 static enum dwarf_form
4857 find_string_form (struct indirect_string_node
*node
)
4864 len
= strlen (node
->str
) + 1;
4866 /* If the string is shorter or equal to the size of the reference, it is
4867 always better to put it inline. */
4868 if (len
<= (unsigned) dwarf_offset_size
|| node
->refcount
== 0)
4869 return node
->form
= DW_FORM_string
;
4871 /* If we cannot expect the linker to merge strings in .debug_str
4872 section, only put it into .debug_str if it is worth even in this
4874 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4875 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
4876 && (len
- dwarf_offset_size
) * node
->refcount
<= len
))
4877 return node
->form
= DW_FORM_string
;
4879 set_indirect_string (node
);
4884 /* Find out whether the string referenced from the attribute should be
4885 output inline in DIE or out-of-line in .debug_str section. */
4887 static enum dwarf_form
4888 AT_string_form (dw_attr_node
*a
)
4890 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4891 return find_string_form (a
->dw_attr_val
.v
.val_str
);
4894 /* Add a DIE reference attribute value to a DIE. */
4897 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4900 gcc_checking_assert (targ_die
!= NULL
);
4902 /* With LTO we can end up trying to reference something we didn't create
4903 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4904 if (targ_die
== NULL
)
4907 attr
.dw_attr
= attr_kind
;
4908 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
4909 attr
.dw_attr_val
.val_entry
= NULL
;
4910 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4911 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
4912 add_dwarf_attr (die
, &attr
);
4915 /* Change DIE reference REF to point to NEW_DIE instead. */
4918 change_AT_die_ref (dw_attr_node
*ref
, dw_die_ref new_die
)
4920 gcc_assert (ref
->dw_attr_val
.val_class
== dw_val_class_die_ref
);
4921 ref
->dw_attr_val
.v
.val_die_ref
.die
= new_die
;
4922 ref
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4925 /* Add an AT_specification attribute to a DIE, and also make the back
4926 pointer from the specification to the definition. */
4929 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4931 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4932 gcc_assert (!targ_die
->die_definition
);
4933 targ_die
->die_definition
= die
;
4936 static inline dw_die_ref
4937 AT_ref (dw_attr_node
*a
)
4939 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4940 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4944 AT_ref_external (dw_attr_node
*a
)
4946 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4947 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4953 set_AT_ref_external (dw_attr_node
*a
, int i
)
4955 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4956 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4959 /* Add a location description attribute value to a DIE. */
4962 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4966 attr
.dw_attr
= attr_kind
;
4967 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4968 attr
.dw_attr_val
.val_entry
= NULL
;
4969 attr
.dw_attr_val
.v
.val_loc
= loc
;
4970 add_dwarf_attr (die
, &attr
);
4974 AT_loc (dw_attr_node
*a
)
4976 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4977 return a
->dw_attr_val
.v
.val_loc
;
4981 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4985 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4988 attr
.dw_attr
= attr_kind
;
4989 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
4990 attr
.dw_attr_val
.val_entry
= NULL
;
4991 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
4992 add_dwarf_attr (die
, &attr
);
4993 have_location_lists
= true;
4996 static inline dw_loc_list_ref
4997 AT_loc_list (dw_attr_node
*a
)
4999 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
5000 return a
->dw_attr_val
.v
.val_loc_list
;
5003 /* Add a view list attribute to DIE. It must have a DW_AT_location
5004 attribute, because the view list complements the location list. */
5007 add_AT_view_list (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5011 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
5014 attr
.dw_attr
= attr_kind
;
5015 attr
.dw_attr_val
.val_class
= dw_val_class_view_list
;
5016 attr
.dw_attr_val
.val_entry
= NULL
;
5017 attr
.dw_attr_val
.v
.val_view_list
= die
;
5018 add_dwarf_attr (die
, &attr
);
5019 gcc_checking_assert (get_AT (die
, DW_AT_location
));
5020 gcc_assert (have_location_lists
);
5023 /* Return a pointer to the location list referenced by the attribute.
5024 If the named attribute is a view list, look up the corresponding
5025 DW_AT_location attribute and return its location list. */
5027 static inline dw_loc_list_ref
*
5028 AT_loc_list_ptr (dw_attr_node
*a
)
5031 switch (AT_class (a
))
5033 case dw_val_class_loc_list
:
5034 return &a
->dw_attr_val
.v
.val_loc_list
;
5035 case dw_val_class_view_list
:
5038 l
= get_AT (a
->dw_attr_val
.v
.val_view_list
, DW_AT_location
);
5041 gcc_checking_assert (l
+ 1 == a
);
5042 return AT_loc_list_ptr (l
);
5049 /* Return the location attribute value associated with a view list
5052 static inline dw_val_node
*
5053 view_list_to_loc_list_val_node (dw_val_node
*val
)
5055 gcc_assert (val
->val_class
== dw_val_class_view_list
);
5056 dw_attr_node
*loc
= get_AT (val
->v
.val_view_list
, DW_AT_location
);
5059 gcc_checking_assert (&(loc
+ 1)->dw_attr_val
== val
);
5060 gcc_assert (AT_class (loc
) == dw_val_class_loc_list
);
5061 return &loc
->dw_attr_val
;
5064 struct addr_hasher
: ggc_ptr_hash
<addr_table_entry
>
5066 static hashval_t
hash (addr_table_entry
*);
5067 static bool equal (addr_table_entry
*, addr_table_entry
*);
5070 /* Table of entries into the .debug_addr section. */
5072 static GTY (()) hash_table
<addr_hasher
> *addr_index_table
;
5074 /* Hash an address_table_entry. */
5077 addr_hasher::hash (addr_table_entry
*a
)
5079 inchash::hash hstate
;
5085 case ate_kind_rtx_dtprel
:
5088 case ate_kind_label
:
5089 return htab_hash_string (a
->addr
.label
);
5093 inchash::add_rtx (a
->addr
.rtl
, hstate
);
5094 return hstate
.end ();
5097 /* Determine equality for two address_table_entries. */
5100 addr_hasher::equal (addr_table_entry
*a1
, addr_table_entry
*a2
)
5102 if (a1
->kind
!= a2
->kind
)
5107 case ate_kind_rtx_dtprel
:
5108 return rtx_equal_p (a1
->addr
.rtl
, a2
->addr
.rtl
);
5109 case ate_kind_label
:
5110 return strcmp (a1
->addr
.label
, a2
->addr
.label
) == 0;
5116 /* Initialize an addr_table_entry. */
5119 init_addr_table_entry (addr_table_entry
*e
, enum ate_kind kind
, void *addr
)
5125 case ate_kind_rtx_dtprel
:
5126 e
->addr
.rtl
= (rtx
) addr
;
5128 case ate_kind_label
:
5129 e
->addr
.label
= (char *) addr
;
5133 e
->index
= NO_INDEX_ASSIGNED
;
5136 /* Add attr to the address table entry to the table. Defer setting an
5137 index until output time. */
5139 static addr_table_entry
*
5140 add_addr_table_entry (void *addr
, enum ate_kind kind
)
5142 addr_table_entry
*node
;
5143 addr_table_entry finder
;
5145 gcc_assert (dwarf_split_debug_info
);
5146 if (! addr_index_table
)
5147 addr_index_table
= hash_table
<addr_hasher
>::create_ggc (10);
5148 init_addr_table_entry (&finder
, kind
, addr
);
5149 addr_table_entry
**slot
= addr_index_table
->find_slot (&finder
, INSERT
);
5151 if (*slot
== HTAB_EMPTY_ENTRY
)
5153 node
= ggc_cleared_alloc
<addr_table_entry
> ();
5154 init_addr_table_entry (node
, kind
, addr
);
5164 /* Remove an entry from the addr table by decrementing its refcount.
5165 Strictly, decrementing the refcount would be enough, but the
5166 assertion that the entry is actually in the table has found
5170 remove_addr_table_entry (addr_table_entry
*entry
)
5172 gcc_assert (dwarf_split_debug_info
&& addr_index_table
);
5173 /* After an index is assigned, the table is frozen. */
5174 gcc_assert (entry
->refcount
> 0 && entry
->index
== NO_INDEX_ASSIGNED
);
5178 /* Given a location list, remove all addresses it refers to from the
5182 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr
)
5184 for (; descr
; descr
= descr
->dw_loc_next
)
5185 if (descr
->dw_loc_oprnd1
.val_entry
!= NULL
)
5187 gcc_assert (descr
->dw_loc_oprnd1
.val_entry
->index
== NO_INDEX_ASSIGNED
);
5188 remove_addr_table_entry (descr
->dw_loc_oprnd1
.val_entry
);
5192 /* A helper function for dwarf2out_finish called through
5193 htab_traverse. Assign an addr_table_entry its index. All entries
5194 must be collected into the table when this function is called,
5195 because the indexing code relies on htab_traverse to traverse nodes
5196 in the same order for each run. */
5199 index_addr_table_entry (addr_table_entry
**h
, unsigned int *index
)
5201 addr_table_entry
*node
= *h
;
5203 /* Don't index unreferenced nodes. */
5204 if (node
->refcount
== 0)
5207 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
5208 node
->index
= *index
;
5214 /* Return the tag of a given DIE. */
5217 dw_get_die_tag (dw_die_ref die
)
5219 return die
->die_tag
;
5222 /* Return a reference to the children list of a given DIE. */
5225 dw_get_die_child (dw_die_ref die
)
5227 return die
->die_child
;
5230 /* Return a reference to the sibling of a given DIE. */
5233 dw_get_die_sib (dw_die_ref die
)
5235 return die
->die_sib
;
5238 /* Add an address constant attribute value to a DIE. When using
5239 dwarf_split_debug_info, address attributes in dies destined for the
5240 final executable should be direct references--setting the parameter
5241 force_direct ensures this behavior. */
5244 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
,
5249 attr
.dw_attr
= attr_kind
;
5250 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
5251 attr
.dw_attr_val
.v
.val_addr
= addr
;
5252 if (dwarf_split_debug_info
&& !force_direct
)
5253 attr
.dw_attr_val
.val_entry
= add_addr_table_entry (addr
, ate_kind_rtx
);
5255 attr
.dw_attr_val
.val_entry
= NULL
;
5256 add_dwarf_attr (die
, &attr
);
5259 /* Get the RTX from to an address DIE attribute. */
5262 AT_addr (dw_attr_node
*a
)
5264 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
5265 return a
->dw_attr_val
.v
.val_addr
;
5268 /* Add a file attribute value to a DIE. */
5271 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5272 struct dwarf_file_data
*fd
)
5276 attr
.dw_attr
= attr_kind
;
5277 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
5278 attr
.dw_attr_val
.val_entry
= NULL
;
5279 attr
.dw_attr_val
.v
.val_file
= fd
;
5280 add_dwarf_attr (die
, &attr
);
5283 /* Get the dwarf_file_data from a file DIE attribute. */
5285 static inline struct dwarf_file_data
*
5286 AT_file (dw_attr_node
*a
)
5288 gcc_assert (a
&& (AT_class (a
) == dw_val_class_file
5289 || AT_class (a
) == dw_val_class_file_implicit
));
5290 return a
->dw_attr_val
.v
.val_file
;
5293 #if VMS_DEBUGGING_INFO
5294 /* Add a vms delta attribute value to a DIE. */
5297 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5298 const char *lbl1
, const char *lbl2
)
5302 attr
.dw_attr
= attr_kind
;
5303 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
5304 attr
.dw_attr_val
.val_entry
= NULL
;
5305 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
5306 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
5307 add_dwarf_attr (die
, &attr
);
5311 /* Add a symbolic view identifier attribute value to a DIE. */
5314 add_AT_symview (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5315 const char *view_label
)
5319 attr
.dw_attr
= attr_kind
;
5320 attr
.dw_attr_val
.val_class
= dw_val_class_symview
;
5321 attr
.dw_attr_val
.val_entry
= NULL
;
5322 attr
.dw_attr_val
.v
.val_symbolic_view
= xstrdup (view_label
);
5323 add_dwarf_attr (die
, &attr
);
5326 /* Add a label identifier attribute value to a DIE. */
5329 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5334 attr
.dw_attr
= attr_kind
;
5335 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
5336 attr
.dw_attr_val
.val_entry
= NULL
;
5337 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
5338 if (dwarf_split_debug_info
)
5339 attr
.dw_attr_val
.val_entry
5340 = add_addr_table_entry (attr
.dw_attr_val
.v
.val_lbl_id
,
5342 add_dwarf_attr (die
, &attr
);
5345 /* Add a section offset attribute value to a DIE, an offset into the
5346 debug_line section. */
5349 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5354 attr
.dw_attr
= attr_kind
;
5355 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
5356 attr
.dw_attr_val
.val_entry
= NULL
;
5357 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5358 add_dwarf_attr (die
, &attr
);
5361 /* Add a section offset attribute value to a DIE, an offset into the
5362 debug_macinfo section. */
5365 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5370 attr
.dw_attr
= attr_kind
;
5371 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
5372 attr
.dw_attr_val
.val_entry
= NULL
;
5373 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5374 add_dwarf_attr (die
, &attr
);
5377 /* Add a range_list attribute value to a DIE. When using
5378 dwarf_split_debug_info, address attributes in dies destined for the
5379 final executable should be direct references--setting the parameter
5380 force_direct ensures this behavior. */
5382 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
5383 #define RELOCATED_OFFSET (NULL)
5386 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5387 long unsigned int offset
, bool force_direct
)
5391 attr
.dw_attr
= attr_kind
;
5392 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
5393 /* For the range_list attribute, use val_entry to store whether the
5394 offset should follow split-debug-info or normal semantics. This
5395 value is read in output_range_list_offset. */
5396 if (dwarf_split_debug_info
&& !force_direct
)
5397 attr
.dw_attr_val
.val_entry
= UNRELOCATED_OFFSET
;
5399 attr
.dw_attr_val
.val_entry
= RELOCATED_OFFSET
;
5400 attr
.dw_attr_val
.v
.val_offset
= offset
;
5401 add_dwarf_attr (die
, &attr
);
5404 /* Return the start label of a delta attribute. */
5406 static inline const char *
5407 AT_vms_delta1 (dw_attr_node
*a
)
5409 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5410 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
5413 /* Return the end label of a delta attribute. */
5415 static inline const char *
5416 AT_vms_delta2 (dw_attr_node
*a
)
5418 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5419 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
5422 static inline const char *
5423 AT_lbl (dw_attr_node
*a
)
5425 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
5426 || AT_class (a
) == dw_val_class_lineptr
5427 || AT_class (a
) == dw_val_class_macptr
5428 || AT_class (a
) == dw_val_class_loclistsptr
5429 || AT_class (a
) == dw_val_class_high_pc
));
5430 return a
->dw_attr_val
.v
.val_lbl_id
;
5433 /* Get the attribute of type attr_kind. */
5436 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5440 dw_die_ref spec
= NULL
;
5445 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5446 if (a
->dw_attr
== attr_kind
)
5448 else if (a
->dw_attr
== DW_AT_specification
5449 || a
->dw_attr
== DW_AT_abstract_origin
)
5453 return get_AT (spec
, attr_kind
);
5458 /* Returns the parent of the declaration of DIE. */
5461 get_die_parent (dw_die_ref die
)
5468 if ((t
= get_AT_ref (die
, DW_AT_abstract_origin
))
5469 || (t
= get_AT_ref (die
, DW_AT_specification
)))
5472 return die
->die_parent
;
5475 /* Return the "low pc" attribute value, typically associated with a subprogram
5476 DIE. Return null if the "low pc" attribute is either not present, or if it
5477 cannot be represented as an assembler label identifier. */
5479 static inline const char *
5480 get_AT_low_pc (dw_die_ref die
)
5482 dw_attr_node
*a
= get_AT (die
, DW_AT_low_pc
);
5484 return a
? AT_lbl (a
) : NULL
;
5487 /* Return the value of the string attribute designated by ATTR_KIND, or
5488 NULL if it is not present. */
5491 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5493 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5495 return a
? AT_string (a
) : NULL
;
5498 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5499 if it is not present. */
5502 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5504 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5506 return a
? AT_flag (a
) : 0;
5509 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5510 if it is not present. */
5513 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5515 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5517 return a
? AT_unsigned (a
) : 0;
5521 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5523 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5525 return a
? AT_ref (a
) : NULL
;
5528 struct dwarf_file_data
*
5529 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5531 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5533 return a
? AT_file (a
) : NULL
;
5536 /* Return TRUE if the language is C. */
5541 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5543 return (lang
== DW_LANG_C
|| lang
== DW_LANG_C89
|| lang
== DW_LANG_C99
5544 || lang
== DW_LANG_C11
|| lang
== DW_LANG_ObjC
);
5549 /* Return TRUE if the language is C++. */
5554 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5556 return (lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
5557 || lang
== DW_LANG_C_plus_plus_11
|| lang
== DW_LANG_C_plus_plus_14
);
5560 /* Return TRUE if DECL was created by the C++ frontend. */
5563 is_cxx (const_tree decl
)
5567 const_tree context
= get_ultimate_context (decl
);
5568 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5569 return startswith (TRANSLATION_UNIT_LANGUAGE (context
), "GNU C++");
5574 /* Return TRUE if the language is Fortran. */
5579 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5581 return (lang
== DW_LANG_Fortran77
5582 || lang
== DW_LANG_Fortran90
5583 || lang
== DW_LANG_Fortran95
5584 || lang
== DW_LANG_Fortran03
5585 || lang
== DW_LANG_Fortran08
);
5589 is_fortran (const_tree decl
)
5593 const_tree context
= get_ultimate_context (decl
);
5594 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5595 return (strncmp (TRANSLATION_UNIT_LANGUAGE (context
),
5596 "GNU Fortran", 11) == 0
5597 || strcmp (TRANSLATION_UNIT_LANGUAGE (context
),
5600 return is_fortran ();
5603 /* Return TRUE if the language is Ada. */
5608 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5610 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
5613 /* Return TRUE if the language is D. */
5618 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5620 return lang
== DW_LANG_D
;
5623 /* Remove the specified attribute if present. Return TRUE if removal
5627 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5635 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5636 if (a
->dw_attr
== attr_kind
)
5638 if (AT_class (a
) == dw_val_class_str
)
5639 if (a
->dw_attr_val
.v
.val_str
->refcount
)
5640 a
->dw_attr_val
.v
.val_str
->refcount
--;
5642 /* vec::ordered_remove should help reduce the number of abbrevs
5644 die
->die_attr
->ordered_remove (ix
);
5650 /* Remove CHILD from its parent. PREV must have the property that
5651 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
5654 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
5656 gcc_assert (child
->die_parent
== prev
->die_parent
);
5657 gcc_assert (prev
->die_sib
== child
);
5660 gcc_assert (child
->die_parent
->die_child
== child
);
5664 prev
->die_sib
= child
->die_sib
;
5665 if (child
->die_parent
->die_child
== child
)
5666 child
->die_parent
->die_child
= prev
;
5667 child
->die_sib
= NULL
;
5670 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
5671 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
5674 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
5676 dw_die_ref parent
= old_child
->die_parent
;
5678 gcc_assert (parent
== prev
->die_parent
);
5679 gcc_assert (prev
->die_sib
== old_child
);
5681 new_child
->die_parent
= parent
;
5682 if (prev
== old_child
)
5684 gcc_assert (parent
->die_child
== old_child
);
5685 new_child
->die_sib
= new_child
;
5689 prev
->die_sib
= new_child
;
5690 new_child
->die_sib
= old_child
->die_sib
;
5692 if (old_child
->die_parent
->die_child
== old_child
)
5693 old_child
->die_parent
->die_child
= new_child
;
5694 old_child
->die_sib
= NULL
;
5697 /* Move all children from OLD_PARENT to NEW_PARENT. */
5700 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
5703 new_parent
->die_child
= old_parent
->die_child
;
5704 old_parent
->die_child
= NULL
;
5705 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
5708 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
5712 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
5718 dw_die_ref prev
= c
;
5720 while (c
->die_tag
== tag
)
5722 remove_child_with_prev (c
, prev
);
5723 c
->die_parent
= NULL
;
5724 /* Might have removed every child. */
5725 if (die
->die_child
== NULL
)
5729 } while (c
!= die
->die_child
);
5732 /* Add a CHILD_DIE as the last child of DIE. */
5735 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
5737 /* FIXME this should probably be an assert. */
5738 if (! die
|| ! child_die
)
5740 gcc_assert (die
!= child_die
);
5742 child_die
->die_parent
= die
;
5745 child_die
->die_sib
= die
->die_child
->die_sib
;
5746 die
->die_child
->die_sib
= child_die
;
5749 child_die
->die_sib
= child_die
;
5750 die
->die_child
= child_die
;
5753 /* Like add_child_die, but put CHILD_DIE after AFTER_DIE. */
5756 add_child_die_after (dw_die_ref die
, dw_die_ref child_die
,
5757 dw_die_ref after_die
)
5763 && die
!= child_die
);
5765 child_die
->die_parent
= die
;
5766 child_die
->die_sib
= after_die
->die_sib
;
5767 after_die
->die_sib
= child_die
;
5768 if (die
->die_child
== after_die
)
5769 die
->die_child
= child_die
;
5772 /* Unassociate CHILD from its parent, and make its parent be
5776 reparent_child (dw_die_ref child
, dw_die_ref new_parent
)
5778 for (dw_die_ref p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
5779 if (p
->die_sib
== child
)
5781 remove_child_with_prev (child
, p
);
5784 add_child_die (new_parent
, child
);
5787 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5788 is the specification, to the end of PARENT's list of children.
5789 This is done by removing and re-adding it. */
5792 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
5794 /* We want the declaration DIE from inside the class, not the
5795 specification DIE at toplevel. */
5796 if (child
->die_parent
!= parent
)
5798 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5804 gcc_assert (child
->die_parent
== parent
5805 || (child
->die_parent
5806 == get_AT_ref (parent
, DW_AT_specification
)));
5808 reparent_child (child
, parent
);
5811 /* Create and return a new die with TAG_VALUE as tag. */
5814 new_die_raw (enum dwarf_tag tag_value
)
5816 dw_die_ref die
= ggc_cleared_alloc
<die_node
> ();
5817 die
->die_tag
= tag_value
;
5821 /* Create and return a new die with a parent of PARENT_DIE. If
5822 PARENT_DIE is NULL, the new DIE is placed in limbo and an
5823 associated tree T must be supplied to determine parenthood
5826 static inline dw_die_ref
5827 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5829 dw_die_ref die
= new_die_raw (tag_value
);
5831 if (parent_die
!= NULL
)
5832 add_child_die (parent_die
, die
);
5835 limbo_die_node
*limbo_node
;
5837 /* No DIEs created after early dwarf should end up in limbo,
5838 because the limbo list should not persist past LTO
5840 if (tag_value
!= DW_TAG_compile_unit
5841 /* These are allowed because they're generated while
5842 breaking out COMDAT units late. */
5843 && tag_value
!= DW_TAG_type_unit
5844 && tag_value
!= DW_TAG_skeleton_unit
5846 /* Allow nested functions to live in limbo because they will
5847 only temporarily live there, as decls_for_scope will fix
5849 && (TREE_CODE (t
) != FUNCTION_DECL
5850 || !decl_function_context (t
))
5851 /* Same as nested functions above but for types. Types that
5852 are local to a function will be fixed in
5854 && (!RECORD_OR_UNION_TYPE_P (t
)
5855 || !TYPE_CONTEXT (t
)
5856 || TREE_CODE (TYPE_CONTEXT (t
)) != FUNCTION_DECL
)
5857 /* FIXME debug-early: Allow late limbo DIE creation for LTO,
5858 especially in the ltrans stage, but once we implement LTO
5859 dwarf streaming, we should remove this exception. */
5862 fprintf (stderr
, "symbol ended up in limbo too late:");
5863 debug_generic_stmt (t
);
5867 limbo_node
= ggc_cleared_alloc
<limbo_die_node
> ();
5868 limbo_node
->die
= die
;
5869 limbo_node
->created_for
= t
;
5870 limbo_node
->next
= limbo_die_list
;
5871 limbo_die_list
= limbo_node
;
5877 /* Return the DIE associated with the given type specifier. */
5880 lookup_type_die (tree type
)
5882 dw_die_ref die
= TYPE_SYMTAB_DIE (type
);
5883 if (die
&& die
->removed
)
5885 TYPE_SYMTAB_DIE (type
) = NULL
;
5891 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
5892 anonymous type named by the typedef TYPE_DIE, return the DIE of the
5893 anonymous type instead the one of the naming typedef. */
5895 static inline dw_die_ref
5896 strip_naming_typedef (tree type
, dw_die_ref type_die
)
5899 && TREE_CODE (type
) == RECORD_TYPE
5901 && type_die
->die_tag
== DW_TAG_typedef
5902 && is_naming_typedef_decl (TYPE_NAME (type
)))
5903 type_die
= get_AT_ref (type_die
, DW_AT_type
);
5907 /* Like lookup_type_die, but if type is an anonymous type named by a
5908 typedef[1], return the DIE of the anonymous type instead the one of
5909 the naming typedef. This is because in gen_typedef_die, we did
5910 equate the anonymous struct named by the typedef with the DIE of
5911 the naming typedef. So by default, lookup_type_die on an anonymous
5912 struct yields the DIE of the naming typedef.
5914 [1]: Read the comment of is_naming_typedef_decl to learn about what
5915 a naming typedef is. */
5917 static inline dw_die_ref
5918 lookup_type_die_strip_naming_typedef (tree type
)
5920 dw_die_ref die
= lookup_type_die (type
);
5921 return strip_naming_typedef (type
, die
);
5924 /* Equate a DIE to a given type specifier. */
5927 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5929 TYPE_SYMTAB_DIE (type
) = type_die
;
5932 static dw_die_ref
maybe_create_die_with_external_ref (tree
);
5933 struct GTY(()) sym_off_pair
5935 const char * GTY((skip
)) sym
;
5936 unsigned HOST_WIDE_INT off
;
5938 static GTY(()) hash_map
<tree
, sym_off_pair
> *external_die_map
;
5940 /* Returns a hash value for X (which really is a die_struct). */
5943 decl_die_hasher::hash (die_node
*x
)
5945 return (hashval_t
) x
->decl_id
;
5948 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5951 decl_die_hasher::equal (die_node
*x
, tree y
)
5953 return (x
->decl_id
== DECL_UID (y
));
5956 /* Return the DIE associated with a given declaration. */
5959 lookup_decl_die (tree decl
)
5961 dw_die_ref
*die
= decl_die_table
->find_slot_with_hash (decl
, DECL_UID (decl
),
5966 return maybe_create_die_with_external_ref (decl
);
5969 if ((*die
)->removed
)
5971 decl_die_table
->clear_slot (die
);
5978 /* Return the DIE associated with BLOCK. */
5980 static inline dw_die_ref
5981 lookup_block_die (tree block
)
5983 dw_die_ref die
= BLOCK_DIE (block
);
5984 if (!die
&& in_lto_p
)
5985 return maybe_create_die_with_external_ref (block
);
5989 /* Associate DIE with BLOCK. */
5992 equate_block_to_die (tree block
, dw_die_ref die
)
5994 BLOCK_DIE (block
) = die
;
5999 /* For DECL which might have early dwarf output query a SYMBOL + OFFSET
6000 style reference. Return true if we found one refering to a DIE for
6001 DECL, otherwise return false. */
6004 dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
6005 unsigned HOST_WIDE_INT
*off
)
6011 /* During WPA stage and incremental linking we use a hash-map
6012 to store the decl <-> label + offset map. */
6013 if (!external_die_map
)
6015 sym_off_pair
*desc
= external_die_map
->get (decl
);
6023 if (TREE_CODE (decl
) == BLOCK
)
6024 die
= lookup_block_die (decl
);
6026 die
= lookup_decl_die (decl
);
6030 /* Similar to get_ref_die_offset_label, but using the "correct"
6032 *off
= die
->die_offset
;
6033 while (die
->die_parent
)
6034 die
= die
->die_parent
;
6035 /* For the containing CU DIE we compute a die_symbol in
6036 compute_comp_unit_symbol. */
6037 gcc_assert (die
->die_tag
== DW_TAG_compile_unit
6038 && die
->die_id
.die_symbol
!= NULL
);
6039 *sym
= die
->die_id
.die_symbol
;
6043 /* Add a reference of kind ATTR_KIND to a DIE at SYMBOL + OFFSET to DIE. */
6046 add_AT_external_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
,
6047 const char *symbol
, HOST_WIDE_INT offset
)
6049 /* Create a fake DIE that contains the reference. Don't use
6050 new_die because we don't want to end up in the limbo list. */
6051 /* ??? We probably want to share these, thus put a ref to the DIE
6052 we create here to the external_die_map entry. */
6053 dw_die_ref ref
= new_die_raw (die
->die_tag
);
6054 ref
->die_id
.die_symbol
= symbol
;
6055 ref
->die_offset
= offset
;
6056 ref
->with_offset
= 1;
6057 add_AT_die_ref (die
, attr_kind
, ref
);
6060 /* Create a DIE for DECL if required and add a reference to a DIE
6061 at SYMBOL + OFFSET which contains attributes dumped early. */
6064 dwarf2out_register_external_die (tree decl
, const char *sym
,
6065 unsigned HOST_WIDE_INT off
)
6067 if (debug_info_level
== DINFO_LEVEL_NONE
)
6070 if (!external_die_map
)
6071 external_die_map
= hash_map
<tree
, sym_off_pair
>::create_ggc (1000);
6072 gcc_checking_assert (!external_die_map
->get (decl
));
6073 sym_off_pair p
= { IDENTIFIER_POINTER (get_identifier (sym
)), off
};
6074 external_die_map
->put (decl
, p
);
6077 /* If we have a registered external DIE for DECL return a new DIE for
6078 the concrete instance with an appropriate abstract origin. */
6081 maybe_create_die_with_external_ref (tree decl
)
6083 if (!external_die_map
)
6085 sym_off_pair
*desc
= external_die_map
->get (decl
);
6089 const char *sym
= desc
->sym
;
6090 unsigned HOST_WIDE_INT off
= desc
->off
;
6091 external_die_map
->remove (decl
);
6094 dw_die_ref die
= (TREE_CODE (decl
) == BLOCK
6095 ? lookup_block_die (decl
) : lookup_decl_die (decl
));
6100 dw_die_ref parent
= NULL
;
6101 /* Need to lookup a DIE for the decls context - the containing
6102 function or translation unit. */
6103 if (TREE_CODE (decl
) == BLOCK
)
6105 ctx
= BLOCK_SUPERCONTEXT (decl
);
6106 /* ??? We do not output DIEs for all scopes thus skip as
6107 many DIEs as needed. */
6108 while (TREE_CODE (ctx
) == BLOCK
6109 && !lookup_block_die (ctx
))
6110 ctx
= BLOCK_SUPERCONTEXT (ctx
);
6113 ctx
= DECL_CONTEXT (decl
);
6114 /* Peel types in the context stack. */
6115 while (ctx
&& TYPE_P (ctx
))
6116 ctx
= TYPE_CONTEXT (ctx
);
6117 /* Likewise namespaces in case we do not want to emit DIEs for them. */
6118 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
6119 while (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
6120 ctx
= DECL_CONTEXT (ctx
);
6123 if (TREE_CODE (ctx
) == BLOCK
)
6124 parent
= lookup_block_die (ctx
);
6125 else if (TREE_CODE (ctx
) == TRANSLATION_UNIT_DECL
6126 /* Keep the 1:1 association during WPA. */
6128 && flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
6129 /* Otherwise all late annotations go to the main CU which
6130 imports the original CUs. */
6131 parent
= comp_unit_die ();
6132 else if (TREE_CODE (ctx
) == FUNCTION_DECL
6133 && TREE_CODE (decl
) != FUNCTION_DECL
6134 && TREE_CODE (decl
) != PARM_DECL
6135 && TREE_CODE (decl
) != RESULT_DECL
6136 && TREE_CODE (decl
) != BLOCK
)
6137 /* Leave function local entities parent determination to when
6138 we process scope vars. */
6141 parent
= lookup_decl_die (ctx
);
6144 /* In some cases the FEs fail to set DECL_CONTEXT properly.
6145 Handle this case gracefully by globalizing stuff. */
6146 parent
= comp_unit_die ();
6147 /* Create a DIE "stub". */
6148 switch (TREE_CODE (decl
))
6150 case TRANSLATION_UNIT_DECL
:
6152 die
= comp_unit_die ();
6153 /* We re-target all CU decls to the LTRANS CU DIE, so no need
6154 to create a DIE for the original CUs. */
6157 case NAMESPACE_DECL
:
6158 if (is_fortran (decl
))
6159 die
= new_die (DW_TAG_module
, parent
, decl
);
6161 die
= new_die (DW_TAG_namespace
, parent
, decl
);
6164 die
= new_die (DW_TAG_subprogram
, parent
, decl
);
6167 die
= new_die (DW_TAG_variable
, parent
, decl
);
6170 die
= new_die (DW_TAG_variable
, parent
, decl
);
6173 die
= new_die (DW_TAG_formal_parameter
, parent
, decl
);
6176 die
= new_die (DW_TAG_constant
, parent
, decl
);
6179 die
= new_die (DW_TAG_label
, parent
, decl
);
6182 die
= new_die (DW_TAG_lexical_block
, parent
, decl
);
6187 if (TREE_CODE (decl
) == BLOCK
)
6188 equate_block_to_die (decl
, die
);
6190 equate_decl_number_to_die (decl
, die
);
6192 add_desc_attribute (die
, decl
);
6194 /* Add a reference to the DIE providing early debug at $sym + off. */
6195 add_AT_external_die_ref (die
, DW_AT_abstract_origin
, sym
, off
);
6200 /* Returns a hash value for X (which really is a var_loc_list). */
6203 decl_loc_hasher::hash (var_loc_list
*x
)
6205 return (hashval_t
) x
->decl_id
;
6208 /* Return nonzero if decl_id of var_loc_list X is the same as
6212 decl_loc_hasher::equal (var_loc_list
*x
, const_tree y
)
6214 return (x
->decl_id
== DECL_UID (y
));
6217 /* Return the var_loc list associated with a given declaration. */
6219 static inline var_loc_list
*
6220 lookup_decl_loc (const_tree decl
)
6222 if (!decl_loc_table
)
6224 return decl_loc_table
->find_with_hash (decl
, DECL_UID (decl
));
6227 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
6230 dw_loc_list_hasher::hash (cached_dw_loc_list
*x
)
6232 return (hashval_t
) x
->decl_id
;
6235 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
6239 dw_loc_list_hasher::equal (cached_dw_loc_list
*x
, const_tree y
)
6241 return (x
->decl_id
== DECL_UID (y
));
6244 /* Equate a DIE to a particular declaration. */
6247 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
6249 unsigned int decl_id
= DECL_UID (decl
);
6251 *decl_die_table
->find_slot_with_hash (decl
, decl_id
, INSERT
) = decl_die
;
6252 decl_die
->decl_id
= decl_id
;
6255 /* Return how many bits covers PIECE EXPR_LIST. */
6257 static HOST_WIDE_INT
6258 decl_piece_bitsize (rtx piece
)
6260 int ret
= (int) GET_MODE (piece
);
6263 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
6264 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
6265 return INTVAL (XEXP (XEXP (piece
, 0), 0));
6268 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
6271 decl_piece_varloc_ptr (rtx piece
)
6273 if ((int) GET_MODE (piece
))
6274 return &XEXP (piece
, 0);
6276 return &XEXP (XEXP (piece
, 0), 1);
6279 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
6280 Next is the chain of following piece nodes. */
6282 static rtx_expr_list
*
6283 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
6285 if (bitsize
> 0 && bitsize
<= (int) MAX_MACHINE_MODE
)
6286 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
6288 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
6293 /* Return rtx that should be stored into loc field for
6294 LOC_NOTE and BITPOS/BITSIZE. */
6297 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
6298 HOST_WIDE_INT bitsize
)
6302 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
6304 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
6309 /* This function either modifies location piece list *DEST in
6310 place (if SRC and INNER is NULL), or copies location piece list
6311 *SRC to *DEST while modifying it. Location BITPOS is modified
6312 to contain LOC_NOTE, any pieces overlapping it are removed resp.
6313 not copied and if needed some padding around it is added.
6314 When modifying in place, DEST should point to EXPR_LIST where
6315 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
6316 to the start of the whole list and INNER points to the EXPR_LIST
6317 where earlier pieces cover PIECE_BITPOS bits. */
6320 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
6321 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
6322 HOST_WIDE_INT bitsize
, rtx loc_note
)
6325 bool copy
= inner
!= NULL
;
6329 /* First copy all nodes preceding the current bitpos. */
6330 while (src
!= inner
)
6332 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
6333 decl_piece_bitsize (*src
), NULL_RTX
);
6334 dest
= &XEXP (*dest
, 1);
6335 src
= &XEXP (*src
, 1);
6338 /* Add padding if needed. */
6339 if (bitpos
!= piece_bitpos
)
6341 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
6342 copy
? NULL_RTX
: *dest
);
6343 dest
= &XEXP (*dest
, 1);
6345 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
6348 /* A piece with correct bitpos and bitsize already exist,
6349 just update the location for it and return. */
6350 *decl_piece_varloc_ptr (*dest
) = loc_note
;
6353 /* Add the piece that changed. */
6354 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
6355 dest
= &XEXP (*dest
, 1);
6356 /* Skip over pieces that overlap it. */
6357 diff
= bitpos
- piece_bitpos
+ bitsize
;
6360 while (diff
> 0 && *src
)
6363 diff
-= decl_piece_bitsize (piece
);
6365 src
= &XEXP (piece
, 1);
6368 *src
= XEXP (piece
, 1);
6369 free_EXPR_LIST_node (piece
);
6372 /* Add padding if needed. */
6373 if (diff
< 0 && *src
)
6377 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
6378 dest
= &XEXP (*dest
, 1);
6382 /* Finally copy all nodes following it. */
6385 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
6386 decl_piece_bitsize (*src
), NULL_RTX
);
6387 dest
= &XEXP (*dest
, 1);
6388 src
= &XEXP (*src
, 1);
6392 /* Add a variable location node to the linked list for DECL. */
6394 static struct var_loc_node
*
6395 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
, var_loc_view view
)
6397 unsigned int decl_id
;
6399 struct var_loc_node
*loc
= NULL
;
6400 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
6402 if (VAR_P (decl
) && DECL_HAS_DEBUG_EXPR_P (decl
))
6404 tree realdecl
= DECL_DEBUG_EXPR (decl
);
6405 if (handled_component_p (realdecl
)
6406 || (TREE_CODE (realdecl
) == MEM_REF
6407 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
6410 tree innerdecl
= get_ref_base_and_extent_hwi (realdecl
, &bitpos
,
6411 &bitsize
, &reverse
);
6413 || !DECL_P (innerdecl
)
6414 || DECL_IGNORED_P (innerdecl
)
6415 || TREE_STATIC (innerdecl
)
6417 || bitpos
+ bitsize
> 256)
6423 decl_id
= DECL_UID (decl
);
6425 = decl_loc_table
->find_slot_with_hash (decl
, decl_id
, INSERT
);
6428 temp
= ggc_cleared_alloc
<var_loc_list
> ();
6429 temp
->decl_id
= decl_id
;
6435 /* For PARM_DECLs try to keep around the original incoming value,
6436 even if that means we'll emit a zero-range .debug_loc entry. */
6438 && temp
->first
== temp
->last
6439 && TREE_CODE (decl
) == PARM_DECL
6440 && NOTE_P (temp
->first
->loc
)
6441 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
6442 && DECL_INCOMING_RTL (decl
)
6443 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
6444 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
6445 == GET_CODE (DECL_INCOMING_RTL (decl
))
6446 && prev_real_insn (as_a
<rtx_insn
*> (temp
->first
->loc
)) == NULL_RTX
6448 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
6449 NOTE_VAR_LOCATION_LOC (loc_note
))
6450 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
6451 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
6453 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6454 temp
->first
->next
= loc
;
6456 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6458 else if (temp
->last
)
6460 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
6461 rtx
*piece_loc
= NULL
, last_loc_note
;
6462 HOST_WIDE_INT piece_bitpos
= 0;
6466 gcc_assert (last
->next
== NULL
);
6468 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
6470 piece_loc
= &last
->loc
;
6473 HOST_WIDE_INT cur_bitsize
= decl_piece_bitsize (*piece_loc
);
6474 if (piece_bitpos
+ cur_bitsize
> bitpos
)
6476 piece_bitpos
+= cur_bitsize
;
6477 piece_loc
= &XEXP (*piece_loc
, 1);
6481 /* TEMP->LAST here is either pointer to the last but one or
6482 last element in the chained list, LAST is pointer to the
6484 if (label
&& strcmp (last
->label
, label
) == 0 && last
->view
== view
)
6486 /* For SRA optimized variables if there weren't any real
6487 insns since last note, just modify the last node. */
6488 if (piece_loc
!= NULL
)
6490 adjust_piece_list (piece_loc
, NULL
, NULL
,
6491 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6494 /* If the last note doesn't cover any instructions, remove it. */
6495 if (temp
->last
!= last
)
6497 temp
->last
->next
= NULL
;
6500 gcc_assert (strcmp (last
->label
, label
) != 0 || last
->view
!= view
);
6504 gcc_assert (temp
->first
== temp
->last
6505 || (temp
->first
->next
== temp
->last
6506 && TREE_CODE (decl
) == PARM_DECL
));
6507 memset (temp
->last
, '\0', sizeof (*temp
->last
));
6508 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6512 if (bitsize
== -1 && NOTE_P (last
->loc
))
6513 last_loc_note
= last
->loc
;
6514 else if (piece_loc
!= NULL
6515 && *piece_loc
!= NULL_RTX
6516 && piece_bitpos
== bitpos
6517 && decl_piece_bitsize (*piece_loc
) == bitsize
)
6518 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
6520 last_loc_note
= NULL_RTX
;
6521 /* If the current location is the same as the end of the list,
6522 and either both or neither of the locations is uninitialized,
6523 we have nothing to do. */
6524 if (last_loc_note
== NULL_RTX
6525 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
6526 NOTE_VAR_LOCATION_LOC (loc_note
)))
6527 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6528 != NOTE_VAR_LOCATION_STATUS (loc_note
))
6529 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6530 == VAR_INIT_STATUS_UNINITIALIZED
)
6531 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
6532 == VAR_INIT_STATUS_UNINITIALIZED
))))
6534 /* Add LOC to the end of list and update LAST. If the last
6535 element of the list has been removed above, reuse its
6536 memory for the new node, otherwise allocate a new one. */
6540 memset (loc
, '\0', sizeof (*loc
));
6543 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6544 if (bitsize
== -1 || piece_loc
== NULL
)
6545 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6547 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
6548 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6550 /* Ensure TEMP->LAST will point either to the new last but one
6551 element of the chain, or to the last element in it. */
6552 if (last
!= temp
->last
)
6560 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6563 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6568 /* Keep track of the number of spaces used to indent the
6569 output of the debugging routines that print the structure of
6570 the DIE internal representation. */
6571 static int print_indent
;
6573 /* Indent the line the number of spaces given by print_indent. */
6576 print_spaces (FILE *outfile
)
6578 fprintf (outfile
, "%*s", print_indent
, "");
6581 /* Print a type signature in hex. */
6584 print_signature (FILE *outfile
, char *sig
)
6588 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
6589 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
6593 print_discr_value (FILE *outfile
, dw_discr_value
*discr_value
)
6595 if (discr_value
->pos
)
6596 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, discr_value
->v
.sval
);
6598 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, discr_value
->v
.uval
);
6601 static void print_loc_descr (dw_loc_descr_ref
, FILE *);
6603 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
6604 RECURSE, output location descriptor operations. */
6607 print_dw_val (dw_val_node
*val
, bool recurse
, FILE *outfile
)
6609 switch (val
->val_class
)
6611 case dw_val_class_addr
:
6612 fprintf (outfile
, "address");
6614 case dw_val_class_offset
:
6615 fprintf (outfile
, "offset");
6617 case dw_val_class_loc
:
6618 fprintf (outfile
, "location descriptor");
6619 if (val
->v
.val_loc
== NULL
)
6620 fprintf (outfile
, " -> <null>\n");
6623 fprintf (outfile
, ":\n");
6625 print_loc_descr (val
->v
.val_loc
, outfile
);
6630 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6631 fprintf (outfile
, " #\n");
6633 fprintf (outfile
, " (%p)\n", (void *) val
->v
.val_loc
);
6636 case dw_val_class_loc_list
:
6637 fprintf (outfile
, "location list -> label:%s",
6638 val
->v
.val_loc_list
->ll_symbol
);
6640 case dw_val_class_view_list
:
6641 val
= view_list_to_loc_list_val_node (val
);
6642 fprintf (outfile
, "location list with views -> labels:%s and %s",
6643 val
->v
.val_loc_list
->ll_symbol
,
6644 val
->v
.val_loc_list
->vl_symbol
);
6646 case dw_val_class_range_list
:
6647 fprintf (outfile
, "range list");
6649 case dw_val_class_const
:
6650 case dw_val_class_const_implicit
:
6651 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, val
->v
.val_int
);
6653 case dw_val_class_unsigned_const
:
6654 case dw_val_class_unsigned_const_implicit
:
6655 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, val
->v
.val_unsigned
);
6657 case dw_val_class_const_double
:
6658 fprintf (outfile
, "constant (" HOST_WIDE_INT_PRINT_DEC
","\
6659 HOST_WIDE_INT_PRINT_UNSIGNED
")",
6660 val
->v
.val_double
.high
,
6661 val
->v
.val_double
.low
);
6663 case dw_val_class_wide_int
:
6665 int i
= val
->v
.val_wide
->get_len ();
6666 fprintf (outfile
, "constant (");
6668 if (val
->v
.val_wide
->elt (i
- 1) == 0)
6669 fprintf (outfile
, "0x");
6670 fprintf (outfile
, HOST_WIDE_INT_PRINT_HEX
,
6671 val
->v
.val_wide
->elt (--i
));
6673 fprintf (outfile
, HOST_WIDE_INT_PRINT_PADDED_HEX
,
6674 val
->v
.val_wide
->elt (i
));
6675 fprintf (outfile
, ")");
6678 case dw_val_class_vec
:
6679 fprintf (outfile
, "floating-point or vector constant");
6681 case dw_val_class_flag
:
6682 fprintf (outfile
, "%u", val
->v
.val_flag
);
6684 case dw_val_class_die_ref
:
6685 if (val
->v
.val_die_ref
.die
!= NULL
)
6687 dw_die_ref die
= val
->v
.val_die_ref
.die
;
6689 if (die
->comdat_type_p
)
6691 fprintf (outfile
, "die -> signature: ");
6692 print_signature (outfile
,
6693 die
->die_id
.die_type_node
->signature
);
6695 else if (die
->die_id
.die_symbol
)
6697 fprintf (outfile
, "die -> label: %s", die
->die_id
.die_symbol
);
6698 if (die
->with_offset
)
6699 fprintf (outfile
, " + %ld", die
->die_offset
);
6702 fprintf (outfile
, "die -> %ld", die
->die_offset
);
6703 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6704 fprintf (outfile
, " #");
6706 fprintf (outfile
, " (%p)", (void *) die
);
6709 fprintf (outfile
, "die -> <null>");
6711 case dw_val_class_vms_delta
:
6712 fprintf (outfile
, "delta: @slotcount(%s-%s)",
6713 val
->v
.val_vms_delta
.lbl2
, val
->v
.val_vms_delta
.lbl1
);
6715 case dw_val_class_symview
:
6716 fprintf (outfile
, "view: %s", val
->v
.val_symbolic_view
);
6718 case dw_val_class_lbl_id
:
6719 case dw_val_class_lineptr
:
6720 case dw_val_class_macptr
:
6721 case dw_val_class_loclistsptr
:
6722 case dw_val_class_high_pc
:
6723 fprintf (outfile
, "label: %s", val
->v
.val_lbl_id
);
6725 case dw_val_class_str
:
6726 if (val
->v
.val_str
->str
!= NULL
)
6727 fprintf (outfile
, "\"%s\"", val
->v
.val_str
->str
);
6729 fprintf (outfile
, "<null>");
6731 case dw_val_class_file
:
6732 case dw_val_class_file_implicit
:
6733 fprintf (outfile
, "\"%s\" (%d)", val
->v
.val_file
->filename
,
6734 val
->v
.val_file
->emitted_number
);
6736 case dw_val_class_data8
:
6740 for (i
= 0; i
< 8; i
++)
6741 fprintf (outfile
, "%02x", val
->v
.val_data8
[i
]);
6744 case dw_val_class_discr_value
:
6745 print_discr_value (outfile
, &val
->v
.val_discr_value
);
6747 case dw_val_class_discr_list
:
6748 for (dw_discr_list_ref node
= val
->v
.val_discr_list
;
6750 node
= node
->dw_discr_next
)
6752 if (node
->dw_discr_range
)
6754 fprintf (outfile
, " .. ");
6755 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6756 print_discr_value (outfile
, &node
->dw_discr_upper_bound
);
6759 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6761 if (node
->dw_discr_next
!= NULL
)
6762 fprintf (outfile
, " | ");
6769 /* Likewise, for a DIE attribute. */
6772 print_attribute (dw_attr_node
*a
, bool recurse
, FILE *outfile
)
6774 print_dw_val (&a
->dw_attr_val
, recurse
, outfile
);
6778 /* Print the list of operands in the LOC location description to OUTFILE. This
6779 routine is a debugging aid only. */
6782 print_loc_descr (dw_loc_descr_ref loc
, FILE *outfile
)
6784 dw_loc_descr_ref l
= loc
;
6788 print_spaces (outfile
);
6789 fprintf (outfile
, "<null>\n");
6793 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
6795 print_spaces (outfile
);
6796 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6797 fprintf (outfile
, "#");
6799 fprintf (outfile
, "(%p)", (void *) l
);
6800 fprintf (outfile
, " %s",
6801 dwarf_stack_op_name (l
->dw_loc_opc
));
6802 if (l
->dw_loc_oprnd1
.val_class
!= dw_val_class_none
)
6804 fprintf (outfile
, " ");
6805 print_dw_val (&l
->dw_loc_oprnd1
, false, outfile
);
6807 if (l
->dw_loc_oprnd2
.val_class
!= dw_val_class_none
)
6809 fprintf (outfile
, ", ");
6810 print_dw_val (&l
->dw_loc_oprnd2
, false, outfile
);
6812 fprintf (outfile
, "\n");
6816 /* Print the information associated with a given DIE, and its children.
6817 This routine is a debugging aid only. */
6820 print_die (dw_die_ref die
, FILE *outfile
)
6826 print_spaces (outfile
);
6827 fprintf (outfile
, "DIE %4ld: %s ",
6828 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
6829 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6830 fprintf (outfile
, "#\n");
6832 fprintf (outfile
, "(%p)\n", (void*) die
);
6833 print_spaces (outfile
);
6834 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
6835 fprintf (outfile
, " offset: %ld", die
->die_offset
);
6836 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
6838 if (die
->comdat_type_p
)
6840 print_spaces (outfile
);
6841 fprintf (outfile
, " signature: ");
6842 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
6843 fprintf (outfile
, "\n");
6846 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6848 print_spaces (outfile
);
6849 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
6851 print_attribute (a
, true, outfile
);
6852 fprintf (outfile
, "\n");
6855 if (die
->die_child
!= NULL
)
6858 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
6861 if (print_indent
== 0)
6862 fprintf (outfile
, "\n");
6865 /* Print the list of operations in the LOC location description. */
6868 debug_dwarf_loc_descr (dw_loc_descr_ref loc
)
6870 print_loc_descr (loc
, stderr
);
6873 /* Print the information collected for a given DIE. */
6876 debug_dwarf_die (dw_die_ref die
)
6878 print_die (die
, stderr
);
6882 debug (die_struct
&ref
)
6884 print_die (&ref
, stderr
);
6888 debug (die_struct
*ptr
)
6893 fprintf (stderr
, "<nil>\n");
6897 /* Print all DWARF information collected for the compilation unit.
6898 This routine is a debugging aid only. */
6904 print_die (comp_unit_die (), stderr
);
6907 /* Verify the DIE tree structure. */
6910 verify_die (dw_die_ref die
)
6912 gcc_assert (!die
->die_mark
);
6913 if (die
->die_parent
== NULL
6914 && die
->die_sib
== NULL
)
6916 /* Verify the die_sib list is cyclic. */
6923 while (x
&& !x
->die_mark
);
6924 gcc_assert (x
== die
);
6928 /* Verify all dies have the same parent. */
6929 gcc_assert (x
->die_parent
== die
->die_parent
);
6932 /* Verify the child has the proper parent and recurse. */
6933 gcc_assert (x
->die_child
->die_parent
== x
);
6934 verify_die (x
->die_child
);
6939 while (x
&& x
->die_mark
);
6942 /* Sanity checks on DIEs. */
6945 check_die (dw_die_ref die
)
6949 bool inline_found
= false;
6950 int n_location
= 0, n_low_pc
= 0, n_high_pc
= 0, n_artificial
= 0;
6951 int n_decl_line
= 0, n_decl_column
= 0, n_decl_file
= 0;
6952 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6957 if (a
->dw_attr_val
.v
.val_unsigned
)
6958 inline_found
= true;
6960 case DW_AT_location
:
6969 case DW_AT_artificial
:
6972 case DW_AT_decl_column
:
6975 case DW_AT_decl_line
:
6978 case DW_AT_decl_file
:
6985 if (n_location
> 1 || n_low_pc
> 1 || n_high_pc
> 1 || n_artificial
> 1
6986 || n_decl_column
> 1 || n_decl_line
> 1 || n_decl_file
> 1)
6988 fprintf (stderr
, "Duplicate attributes in DIE:\n");
6989 debug_dwarf_die (die
);
6994 /* A debugging information entry that is a member of an abstract
6995 instance tree [that has DW_AT_inline] should not contain any
6996 attributes which describe aspects of the subroutine which vary
6997 between distinct inlined expansions or distinct out-of-line
6999 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7000 gcc_assert (a
->dw_attr
!= DW_AT_low_pc
7001 && a
->dw_attr
!= DW_AT_high_pc
7002 && a
->dw_attr
!= DW_AT_location
7003 && a
->dw_attr
!= DW_AT_frame_base
7004 && a
->dw_attr
!= DW_AT_call_all_calls
7005 && a
->dw_attr
!= DW_AT_GNU_all_call_sites
);
7009 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
7010 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
7011 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
7013 /* Calculate the checksum of a location expression. */
7016 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
7019 inchash::hash hstate
;
7022 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
7024 hash_loc_operands (loc
, hstate
);
7025 hash
= hstate
.end();
7029 /* Calculate the checksum of an attribute. */
7032 attr_checksum (dw_attr_node
*at
, struct md5_ctx
*ctx
, int *mark
)
7034 dw_loc_descr_ref loc
;
7037 CHECKSUM (at
->dw_attr
);
7039 /* We don't care that this was compiled with a different compiler
7040 snapshot; if the output is the same, that's what matters. */
7041 if (at
->dw_attr
== DW_AT_producer
)
7044 switch (AT_class (at
))
7046 case dw_val_class_const
:
7047 case dw_val_class_const_implicit
:
7048 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
7050 case dw_val_class_unsigned_const
:
7051 case dw_val_class_unsigned_const_implicit
:
7052 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
7054 case dw_val_class_const_double
:
7055 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
7057 case dw_val_class_wide_int
:
7058 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
7059 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7060 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
7062 case dw_val_class_vec
:
7063 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
7064 (at
->dw_attr_val
.v
.val_vec
.length
7065 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
7067 case dw_val_class_flag
:
7068 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
7070 case dw_val_class_str
:
7071 CHECKSUM_STRING (AT_string (at
));
7074 case dw_val_class_addr
:
7076 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
7077 CHECKSUM_STRING (XSTR (r
, 0));
7080 case dw_val_class_offset
:
7081 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
7084 case dw_val_class_loc
:
7085 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
7086 loc_checksum (loc
, ctx
);
7089 case dw_val_class_die_ref
:
7090 die_checksum (AT_ref (at
), ctx
, mark
);
7093 case dw_val_class_fde_ref
:
7094 case dw_val_class_vms_delta
:
7095 case dw_val_class_symview
:
7096 case dw_val_class_lbl_id
:
7097 case dw_val_class_lineptr
:
7098 case dw_val_class_macptr
:
7099 case dw_val_class_loclistsptr
:
7100 case dw_val_class_high_pc
:
7103 case dw_val_class_file
:
7104 case dw_val_class_file_implicit
:
7105 CHECKSUM_STRING (AT_file (at
)->filename
);
7108 case dw_val_class_data8
:
7109 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
7117 /* Calculate the checksum of a DIE. */
7120 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
7126 /* To avoid infinite recursion. */
7129 CHECKSUM (die
->die_mark
);
7132 die
->die_mark
= ++(*mark
);
7134 CHECKSUM (die
->die_tag
);
7136 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7137 attr_checksum (a
, ctx
, mark
);
7139 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
7143 #undef CHECKSUM_BLOCK
7144 #undef CHECKSUM_STRING
7146 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
7147 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
7148 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
7149 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
7150 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
7151 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
7152 #define CHECKSUM_ATTR(FOO) \
7153 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
7155 /* Calculate the checksum of a number in signed LEB128 format. */
7158 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
7165 byte
= (value
& 0x7f);
7167 more
= !((value
== 0 && (byte
& 0x40) == 0)
7168 || (value
== -1 && (byte
& 0x40) != 0));
7177 /* Calculate the checksum of a number in unsigned LEB128 format. */
7180 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
7184 unsigned char byte
= (value
& 0x7f);
7187 /* More bytes to follow. */
7195 /* Checksum the context of the DIE. This adds the names of any
7196 surrounding namespaces or structures to the checksum. */
7199 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
7203 int tag
= die
->die_tag
;
7205 if (tag
!= DW_TAG_namespace
7206 && tag
!= DW_TAG_structure_type
7207 && tag
!= DW_TAG_class_type
)
7210 name
= get_AT_string (die
, DW_AT_name
);
7212 spec
= get_AT_ref (die
, DW_AT_specification
);
7216 if (die
->die_parent
!= NULL
)
7217 checksum_die_context (die
->die_parent
, ctx
);
7219 CHECKSUM_ULEB128 ('C');
7220 CHECKSUM_ULEB128 (tag
);
7222 CHECKSUM_STRING (name
);
7225 /* Calculate the checksum of a location expression. */
7228 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
7230 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
7231 were emitted as a DW_FORM_sdata instead of a location expression. */
7232 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
7234 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7235 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
7239 /* Otherwise, just checksum the raw location expression. */
7242 inchash::hash hstate
;
7245 CHECKSUM_ULEB128 (loc
->dtprel
);
7246 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
7247 hash_loc_operands (loc
, hstate
);
7248 hash
= hstate
.end ();
7250 loc
= loc
->dw_loc_next
;
7254 /* Calculate the checksum of an attribute. */
7257 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_node
*at
,
7258 struct md5_ctx
*ctx
, int *mark
)
7260 dw_loc_descr_ref loc
;
7263 if (AT_class (at
) == dw_val_class_die_ref
)
7265 dw_die_ref target_die
= AT_ref (at
);
7267 /* For pointer and reference types, we checksum only the (qualified)
7268 name of the target type (if there is a name). For friend entries,
7269 we checksum only the (qualified) name of the target type or function.
7270 This allows the checksum to remain the same whether the target type
7271 is complete or not. */
7272 if ((at
->dw_attr
== DW_AT_type
7273 && (tag
== DW_TAG_pointer_type
7274 || tag
== DW_TAG_reference_type
7275 || tag
== DW_TAG_rvalue_reference_type
7276 || tag
== DW_TAG_ptr_to_member_type
))
7277 || (at
->dw_attr
== DW_AT_friend
7278 && tag
== DW_TAG_friend
))
7280 dw_attr_node
*name_attr
= get_AT (target_die
, DW_AT_name
);
7282 if (name_attr
!= NULL
)
7284 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
7288 CHECKSUM_ULEB128 ('N');
7289 CHECKSUM_ULEB128 (at
->dw_attr
);
7290 if (decl
->die_parent
!= NULL
)
7291 checksum_die_context (decl
->die_parent
, ctx
);
7292 CHECKSUM_ULEB128 ('E');
7293 CHECKSUM_STRING (AT_string (name_attr
));
7298 /* For all other references to another DIE, we check to see if the
7299 target DIE has already been visited. If it has, we emit a
7300 backward reference; if not, we descend recursively. */
7301 if (target_die
->die_mark
> 0)
7303 CHECKSUM_ULEB128 ('R');
7304 CHECKSUM_ULEB128 (at
->dw_attr
);
7305 CHECKSUM_ULEB128 (target_die
->die_mark
);
7309 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
7313 target_die
->die_mark
= ++(*mark
);
7314 CHECKSUM_ULEB128 ('T');
7315 CHECKSUM_ULEB128 (at
->dw_attr
);
7316 if (decl
->die_parent
!= NULL
)
7317 checksum_die_context (decl
->die_parent
, ctx
);
7318 die_checksum_ordered (target_die
, ctx
, mark
);
7323 CHECKSUM_ULEB128 ('A');
7324 CHECKSUM_ULEB128 (at
->dw_attr
);
7326 switch (AT_class (at
))
7328 case dw_val_class_const
:
7329 case dw_val_class_const_implicit
:
7330 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7331 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
7334 case dw_val_class_unsigned_const
:
7335 case dw_val_class_unsigned_const_implicit
:
7336 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7337 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
7340 case dw_val_class_const_double
:
7341 CHECKSUM_ULEB128 (DW_FORM_block
);
7342 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
7343 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
7346 case dw_val_class_wide_int
:
7347 CHECKSUM_ULEB128 (DW_FORM_block
);
7348 CHECKSUM_ULEB128 (get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7349 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
7350 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
7351 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7352 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
7355 case dw_val_class_vec
:
7356 CHECKSUM_ULEB128 (DW_FORM_block
);
7357 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_vec
.length
7358 * at
->dw_attr_val
.v
.val_vec
.elt_size
);
7359 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
7360 (at
->dw_attr_val
.v
.val_vec
.length
7361 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
7364 case dw_val_class_flag
:
7365 CHECKSUM_ULEB128 (DW_FORM_flag
);
7366 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
7369 case dw_val_class_str
:
7370 CHECKSUM_ULEB128 (DW_FORM_string
);
7371 CHECKSUM_STRING (AT_string (at
));
7374 case dw_val_class_addr
:
7376 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
7377 CHECKSUM_ULEB128 (DW_FORM_string
);
7378 CHECKSUM_STRING (XSTR (r
, 0));
7381 case dw_val_class_offset
:
7382 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7383 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
7386 case dw_val_class_loc
:
7387 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
7388 loc_checksum_ordered (loc
, ctx
);
7391 case dw_val_class_fde_ref
:
7392 case dw_val_class_symview
:
7393 case dw_val_class_lbl_id
:
7394 case dw_val_class_lineptr
:
7395 case dw_val_class_macptr
:
7396 case dw_val_class_loclistsptr
:
7397 case dw_val_class_high_pc
:
7400 case dw_val_class_file
:
7401 case dw_val_class_file_implicit
:
7402 CHECKSUM_ULEB128 (DW_FORM_string
);
7403 CHECKSUM_STRING (AT_file (at
)->filename
);
7406 case dw_val_class_data8
:
7407 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
7415 struct checksum_attributes
7417 dw_attr_node
*at_name
;
7418 dw_attr_node
*at_type
;
7419 dw_attr_node
*at_friend
;
7420 dw_attr_node
*at_accessibility
;
7421 dw_attr_node
*at_address_class
;
7422 dw_attr_node
*at_alignment
;
7423 dw_attr_node
*at_allocated
;
7424 dw_attr_node
*at_artificial
;
7425 dw_attr_node
*at_associated
;
7426 dw_attr_node
*at_binary_scale
;
7427 dw_attr_node
*at_bit_offset
;
7428 dw_attr_node
*at_bit_size
;
7429 dw_attr_node
*at_bit_stride
;
7430 dw_attr_node
*at_byte_size
;
7431 dw_attr_node
*at_byte_stride
;
7432 dw_attr_node
*at_const_value
;
7433 dw_attr_node
*at_containing_type
;
7434 dw_attr_node
*at_count
;
7435 dw_attr_node
*at_data_location
;
7436 dw_attr_node
*at_data_member_location
;
7437 dw_attr_node
*at_decimal_scale
;
7438 dw_attr_node
*at_decimal_sign
;
7439 dw_attr_node
*at_default_value
;
7440 dw_attr_node
*at_digit_count
;
7441 dw_attr_node
*at_discr
;
7442 dw_attr_node
*at_discr_list
;
7443 dw_attr_node
*at_discr_value
;
7444 dw_attr_node
*at_encoding
;
7445 dw_attr_node
*at_endianity
;
7446 dw_attr_node
*at_explicit
;
7447 dw_attr_node
*at_is_optional
;
7448 dw_attr_node
*at_location
;
7449 dw_attr_node
*at_lower_bound
;
7450 dw_attr_node
*at_mutable
;
7451 dw_attr_node
*at_ordering
;
7452 dw_attr_node
*at_picture_string
;
7453 dw_attr_node
*at_prototyped
;
7454 dw_attr_node
*at_small
;
7455 dw_attr_node
*at_segment
;
7456 dw_attr_node
*at_string_length
;
7457 dw_attr_node
*at_string_length_bit_size
;
7458 dw_attr_node
*at_string_length_byte_size
;
7459 dw_attr_node
*at_threads_scaled
;
7460 dw_attr_node
*at_upper_bound
;
7461 dw_attr_node
*at_use_location
;
7462 dw_attr_node
*at_use_UTF8
;
7463 dw_attr_node
*at_variable_parameter
;
7464 dw_attr_node
*at_virtuality
;
7465 dw_attr_node
*at_visibility
;
7466 dw_attr_node
*at_vtable_elem_location
;
7469 /* Collect the attributes that we will want to use for the checksum. */
7472 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
7477 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7488 attrs
->at_friend
= a
;
7490 case DW_AT_accessibility
:
7491 attrs
->at_accessibility
= a
;
7493 case DW_AT_address_class
:
7494 attrs
->at_address_class
= a
;
7496 case DW_AT_alignment
:
7497 attrs
->at_alignment
= a
;
7499 case DW_AT_allocated
:
7500 attrs
->at_allocated
= a
;
7502 case DW_AT_artificial
:
7503 attrs
->at_artificial
= a
;
7505 case DW_AT_associated
:
7506 attrs
->at_associated
= a
;
7508 case DW_AT_binary_scale
:
7509 attrs
->at_binary_scale
= a
;
7511 case DW_AT_bit_offset
:
7512 attrs
->at_bit_offset
= a
;
7514 case DW_AT_bit_size
:
7515 attrs
->at_bit_size
= a
;
7517 case DW_AT_bit_stride
:
7518 attrs
->at_bit_stride
= a
;
7520 case DW_AT_byte_size
:
7521 attrs
->at_byte_size
= a
;
7523 case DW_AT_byte_stride
:
7524 attrs
->at_byte_stride
= a
;
7526 case DW_AT_const_value
:
7527 attrs
->at_const_value
= a
;
7529 case DW_AT_containing_type
:
7530 attrs
->at_containing_type
= a
;
7533 attrs
->at_count
= a
;
7535 case DW_AT_data_location
:
7536 attrs
->at_data_location
= a
;
7538 case DW_AT_data_member_location
:
7539 attrs
->at_data_member_location
= a
;
7541 case DW_AT_decimal_scale
:
7542 attrs
->at_decimal_scale
= a
;
7544 case DW_AT_decimal_sign
:
7545 attrs
->at_decimal_sign
= a
;
7547 case DW_AT_default_value
:
7548 attrs
->at_default_value
= a
;
7550 case DW_AT_digit_count
:
7551 attrs
->at_digit_count
= a
;
7554 attrs
->at_discr
= a
;
7556 case DW_AT_discr_list
:
7557 attrs
->at_discr_list
= a
;
7559 case DW_AT_discr_value
:
7560 attrs
->at_discr_value
= a
;
7562 case DW_AT_encoding
:
7563 attrs
->at_encoding
= a
;
7565 case DW_AT_endianity
:
7566 attrs
->at_endianity
= a
;
7568 case DW_AT_explicit
:
7569 attrs
->at_explicit
= a
;
7571 case DW_AT_is_optional
:
7572 attrs
->at_is_optional
= a
;
7574 case DW_AT_location
:
7575 attrs
->at_location
= a
;
7577 case DW_AT_lower_bound
:
7578 attrs
->at_lower_bound
= a
;
7581 attrs
->at_mutable
= a
;
7583 case DW_AT_ordering
:
7584 attrs
->at_ordering
= a
;
7586 case DW_AT_picture_string
:
7587 attrs
->at_picture_string
= a
;
7589 case DW_AT_prototyped
:
7590 attrs
->at_prototyped
= a
;
7593 attrs
->at_small
= a
;
7596 attrs
->at_segment
= a
;
7598 case DW_AT_string_length
:
7599 attrs
->at_string_length
= a
;
7601 case DW_AT_string_length_bit_size
:
7602 attrs
->at_string_length_bit_size
= a
;
7604 case DW_AT_string_length_byte_size
:
7605 attrs
->at_string_length_byte_size
= a
;
7607 case DW_AT_threads_scaled
:
7608 attrs
->at_threads_scaled
= a
;
7610 case DW_AT_upper_bound
:
7611 attrs
->at_upper_bound
= a
;
7613 case DW_AT_use_location
:
7614 attrs
->at_use_location
= a
;
7616 case DW_AT_use_UTF8
:
7617 attrs
->at_use_UTF8
= a
;
7619 case DW_AT_variable_parameter
:
7620 attrs
->at_variable_parameter
= a
;
7622 case DW_AT_virtuality
:
7623 attrs
->at_virtuality
= a
;
7625 case DW_AT_visibility
:
7626 attrs
->at_visibility
= a
;
7628 case DW_AT_vtable_elem_location
:
7629 attrs
->at_vtable_elem_location
= a
;
7637 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
7640 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
7644 struct checksum_attributes attrs
;
7646 CHECKSUM_ULEB128 ('D');
7647 CHECKSUM_ULEB128 (die
->die_tag
);
7649 memset (&attrs
, 0, sizeof (attrs
));
7651 decl
= get_AT_ref (die
, DW_AT_specification
);
7653 collect_checksum_attributes (&attrs
, decl
);
7654 collect_checksum_attributes (&attrs
, die
);
7656 CHECKSUM_ATTR (attrs
.at_name
);
7657 CHECKSUM_ATTR (attrs
.at_accessibility
);
7658 CHECKSUM_ATTR (attrs
.at_address_class
);
7659 CHECKSUM_ATTR (attrs
.at_allocated
);
7660 CHECKSUM_ATTR (attrs
.at_artificial
);
7661 CHECKSUM_ATTR (attrs
.at_associated
);
7662 CHECKSUM_ATTR (attrs
.at_binary_scale
);
7663 CHECKSUM_ATTR (attrs
.at_bit_offset
);
7664 CHECKSUM_ATTR (attrs
.at_bit_size
);
7665 CHECKSUM_ATTR (attrs
.at_bit_stride
);
7666 CHECKSUM_ATTR (attrs
.at_byte_size
);
7667 CHECKSUM_ATTR (attrs
.at_byte_stride
);
7668 CHECKSUM_ATTR (attrs
.at_const_value
);
7669 CHECKSUM_ATTR (attrs
.at_containing_type
);
7670 CHECKSUM_ATTR (attrs
.at_count
);
7671 CHECKSUM_ATTR (attrs
.at_data_location
);
7672 CHECKSUM_ATTR (attrs
.at_data_member_location
);
7673 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
7674 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
7675 CHECKSUM_ATTR (attrs
.at_default_value
);
7676 CHECKSUM_ATTR (attrs
.at_digit_count
);
7677 CHECKSUM_ATTR (attrs
.at_discr
);
7678 CHECKSUM_ATTR (attrs
.at_discr_list
);
7679 CHECKSUM_ATTR (attrs
.at_discr_value
);
7680 CHECKSUM_ATTR (attrs
.at_encoding
);
7681 CHECKSUM_ATTR (attrs
.at_endianity
);
7682 CHECKSUM_ATTR (attrs
.at_explicit
);
7683 CHECKSUM_ATTR (attrs
.at_is_optional
);
7684 CHECKSUM_ATTR (attrs
.at_location
);
7685 CHECKSUM_ATTR (attrs
.at_lower_bound
);
7686 CHECKSUM_ATTR (attrs
.at_mutable
);
7687 CHECKSUM_ATTR (attrs
.at_ordering
);
7688 CHECKSUM_ATTR (attrs
.at_picture_string
);
7689 CHECKSUM_ATTR (attrs
.at_prototyped
);
7690 CHECKSUM_ATTR (attrs
.at_small
);
7691 CHECKSUM_ATTR (attrs
.at_segment
);
7692 CHECKSUM_ATTR (attrs
.at_string_length
);
7693 CHECKSUM_ATTR (attrs
.at_string_length_bit_size
);
7694 CHECKSUM_ATTR (attrs
.at_string_length_byte_size
);
7695 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
7696 CHECKSUM_ATTR (attrs
.at_upper_bound
);
7697 CHECKSUM_ATTR (attrs
.at_use_location
);
7698 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
7699 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
7700 CHECKSUM_ATTR (attrs
.at_virtuality
);
7701 CHECKSUM_ATTR (attrs
.at_visibility
);
7702 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
7703 CHECKSUM_ATTR (attrs
.at_type
);
7704 CHECKSUM_ATTR (attrs
.at_friend
);
7705 CHECKSUM_ATTR (attrs
.at_alignment
);
7707 /* Checksum the child DIEs. */
7710 dw_attr_node
*name_attr
;
7713 name_attr
= get_AT (c
, DW_AT_name
);
7714 if (is_template_instantiation (c
))
7716 /* Ignore instantiations of member type and function templates. */
7718 else if (name_attr
!= NULL
7719 && (is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
))
7721 /* Use a shallow checksum for named nested types and member
7723 CHECKSUM_ULEB128 ('S');
7724 CHECKSUM_ULEB128 (c
->die_tag
);
7725 CHECKSUM_STRING (AT_string (name_attr
));
7729 /* Use a deep checksum for other children. */
7730 /* Mark this DIE so it gets processed when unmarking. */
7731 if (c
->die_mark
== 0)
7733 die_checksum_ordered (c
, ctx
, mark
);
7735 } while (c
!= die
->die_child
);
7737 CHECKSUM_ULEB128 (0);
7740 /* Add a type name and tag to a hash. */
7742 die_odr_checksum (int tag
, const char *name
, md5_ctx
*ctx
)
7744 CHECKSUM_ULEB128 (tag
);
7745 CHECKSUM_STRING (name
);
7749 #undef CHECKSUM_STRING
7750 #undef CHECKSUM_ATTR
7751 #undef CHECKSUM_LEB128
7752 #undef CHECKSUM_ULEB128
7754 /* Generate the type signature for DIE. This is computed by generating an
7755 MD5 checksum over the DIE's tag, its relevant attributes, and its
7756 children. Attributes that are references to other DIEs are processed
7757 by recursion, using the MARK field to prevent infinite recursion.
7758 If the DIE is nested inside a namespace or another type, we also
7759 need to include that context in the signature. The lower 64 bits
7760 of the resulting MD5 checksum comprise the signature. */
7763 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
7767 unsigned char checksum
[16];
7772 name
= get_AT_string (die
, DW_AT_name
);
7773 decl
= get_AT_ref (die
, DW_AT_specification
);
7774 parent
= get_die_parent (die
);
7776 /* First, compute a signature for just the type name (and its surrounding
7777 context, if any. This is stored in the type unit DIE for link-time
7778 ODR (one-definition rule) checking. */
7780 if (is_cxx () && name
!= NULL
)
7782 md5_init_ctx (&ctx
);
7784 /* Checksum the names of surrounding namespaces and structures. */
7786 checksum_die_context (parent
, &ctx
);
7788 /* Checksum the current DIE. */
7789 die_odr_checksum (die
->die_tag
, name
, &ctx
);
7790 md5_finish_ctx (&ctx
, checksum
);
7792 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
7795 /* Next, compute the complete type signature. */
7797 md5_init_ctx (&ctx
);
7799 die
->die_mark
= mark
;
7801 /* Checksum the names of surrounding namespaces and structures. */
7803 checksum_die_context (parent
, &ctx
);
7805 /* Checksum the DIE and its children. */
7806 die_checksum_ordered (die
, &ctx
, &mark
);
7807 unmark_all_dies (die
);
7808 md5_finish_ctx (&ctx
, checksum
);
7810 /* Store the signature in the type node and link the type DIE and the
7811 type node together. */
7812 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
7813 DWARF_TYPE_SIGNATURE_SIZE
);
7814 die
->comdat_type_p
= true;
7815 die
->die_id
.die_type_node
= type_node
;
7816 type_node
->type_die
= die
;
7818 /* If the DIE is a specification, link its declaration to the type node
7822 decl
->comdat_type_p
= true;
7823 decl
->die_id
.die_type_node
= type_node
;
7827 /* Do the location expressions look same? */
7829 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
7831 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
7832 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
7833 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
7836 /* Do the values look the same? */
7838 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
7840 dw_loc_descr_ref loc1
, loc2
;
7843 if (v1
->val_class
!= v2
->val_class
)
7846 switch (v1
->val_class
)
7848 case dw_val_class_const
:
7849 case dw_val_class_const_implicit
:
7850 return v1
->v
.val_int
== v2
->v
.val_int
;
7851 case dw_val_class_unsigned_const
:
7852 case dw_val_class_unsigned_const_implicit
:
7853 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
7854 case dw_val_class_const_double
:
7855 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
7856 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
7857 case dw_val_class_wide_int
:
7858 return *v1
->v
.val_wide
== *v2
->v
.val_wide
;
7859 case dw_val_class_vec
:
7860 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
7861 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
7863 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
7864 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
7867 case dw_val_class_flag
:
7868 return v1
->v
.val_flag
== v2
->v
.val_flag
;
7869 case dw_val_class_str
:
7870 return !strcmp (v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
7872 case dw_val_class_addr
:
7873 r1
= v1
->v
.val_addr
;
7874 r2
= v2
->v
.val_addr
;
7875 if (GET_CODE (r1
) != GET_CODE (r2
))
7877 return !rtx_equal_p (r1
, r2
);
7879 case dw_val_class_offset
:
7880 return v1
->v
.val_offset
== v2
->v
.val_offset
;
7882 case dw_val_class_loc
:
7883 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
7885 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
7886 if (!same_loc_p (loc1
, loc2
, mark
))
7888 return !loc1
&& !loc2
;
7890 case dw_val_class_die_ref
:
7891 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
7893 case dw_val_class_symview
:
7894 return strcmp (v1
->v
.val_symbolic_view
, v2
->v
.val_symbolic_view
) == 0;
7896 case dw_val_class_fde_ref
:
7897 case dw_val_class_vms_delta
:
7898 case dw_val_class_lbl_id
:
7899 case dw_val_class_lineptr
:
7900 case dw_val_class_macptr
:
7901 case dw_val_class_loclistsptr
:
7902 case dw_val_class_high_pc
:
7905 case dw_val_class_file
:
7906 case dw_val_class_file_implicit
:
7907 return v1
->v
.val_file
== v2
->v
.val_file
;
7909 case dw_val_class_data8
:
7910 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
7917 /* Do the attributes look the same? */
7920 same_attr_p (dw_attr_node
*at1
, dw_attr_node
*at2
, int *mark
)
7922 if (at1
->dw_attr
!= at2
->dw_attr
)
7925 /* We don't care that this was compiled with a different compiler
7926 snapshot; if the output is the same, that's what matters. */
7927 if (at1
->dw_attr
== DW_AT_producer
)
7930 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
7933 /* Do the dies look the same? */
7936 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
7942 /* To avoid infinite recursion. */
7944 return die1
->die_mark
== die2
->die_mark
;
7945 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
7947 if (die1
->die_tag
!= die2
->die_tag
)
7950 if (vec_safe_length (die1
->die_attr
) != vec_safe_length (die2
->die_attr
))
7953 FOR_EACH_VEC_SAFE_ELT (die1
->die_attr
, ix
, a1
)
7954 if (!same_attr_p (a1
, &(*die2
->die_attr
)[ix
], mark
))
7957 c1
= die1
->die_child
;
7958 c2
= die2
->die_child
;
7967 if (!same_die_p (c1
, c2
, mark
))
7971 if (c1
== die1
->die_child
)
7973 if (c2
== die2
->die_child
)
7983 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7984 children, and set die_symbol. */
7987 compute_comp_unit_symbol (dw_die_ref unit_die
)
7989 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
7990 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
7991 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
7994 unsigned char checksum
[16];
7997 /* Compute the checksum of the DIE, then append part of it as hex digits to
7998 the name filename of the unit. */
8000 md5_init_ctx (&ctx
);
8002 die_checksum (unit_die
, &ctx
, &mark
);
8003 unmark_all_dies (unit_die
);
8004 md5_finish_ctx (&ctx
, checksum
);
8006 /* When we this for comp_unit_die () we have a DW_AT_name that might
8007 not start with a letter but with anything valid for filenames and
8008 clean_symbol_name doesn't fix that up. Prepend 'g' if the first
8009 character is not a letter. */
8010 sprintf (name
, "%s%s.", ISALPHA (*base
) ? "" : "g", base
);
8011 clean_symbol_name (name
);
8013 p
= name
+ strlen (name
);
8014 for (i
= 0; i
< 4; i
++)
8016 sprintf (p
, "%.2x", checksum
[i
]);
8020 unit_die
->die_id
.die_symbol
= xstrdup (name
);
8023 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
8026 is_type_die (dw_die_ref die
)
8028 switch (die
->die_tag
)
8030 case DW_TAG_array_type
:
8031 case DW_TAG_class_type
:
8032 case DW_TAG_interface_type
:
8033 case DW_TAG_enumeration_type
:
8034 case DW_TAG_pointer_type
:
8035 case DW_TAG_reference_type
:
8036 case DW_TAG_rvalue_reference_type
:
8037 case DW_TAG_string_type
:
8038 case DW_TAG_structure_type
:
8039 case DW_TAG_subroutine_type
:
8040 case DW_TAG_union_type
:
8041 case DW_TAG_ptr_to_member_type
:
8042 case DW_TAG_set_type
:
8043 case DW_TAG_subrange_type
:
8044 case DW_TAG_base_type
:
8045 case DW_TAG_const_type
:
8046 case DW_TAG_file_type
:
8047 case DW_TAG_packed_type
:
8048 case DW_TAG_volatile_type
:
8049 case DW_TAG_typedef
:
8056 /* Returns true iff C is a compile-unit DIE. */
8059 is_cu_die (dw_die_ref c
)
8061 return c
&& (c
->die_tag
== DW_TAG_compile_unit
8062 || c
->die_tag
== DW_TAG_skeleton_unit
);
8065 /* Returns true iff C is a unit DIE of some sort. */
8068 is_unit_die (dw_die_ref c
)
8070 return c
&& (c
->die_tag
== DW_TAG_compile_unit
8071 || c
->die_tag
== DW_TAG_partial_unit
8072 || c
->die_tag
== DW_TAG_type_unit
8073 || c
->die_tag
== DW_TAG_skeleton_unit
);
8076 /* Returns true iff C is a namespace DIE. */
8079 is_namespace_die (dw_die_ref c
)
8081 return c
&& c
->die_tag
== DW_TAG_namespace
;
8084 /* Return non-zero if this DIE is a template parameter. */
8087 is_template_parameter (dw_die_ref die
)
8089 switch (die
->die_tag
)
8091 case DW_TAG_template_type_param
:
8092 case DW_TAG_template_value_param
:
8093 case DW_TAG_GNU_template_template_param
:
8094 case DW_TAG_GNU_template_parameter_pack
:
8101 /* Return non-zero if this DIE represents a template instantiation. */
8104 is_template_instantiation (dw_die_ref die
)
8108 if (!is_type_die (die
) && die
->die_tag
!= DW_TAG_subprogram
)
8110 FOR_EACH_CHILD (die
, c
, if (is_template_parameter (c
)) return true);
8115 gen_internal_sym (const char *prefix
)
8117 char buf
[MAX_ARTIFICIAL_LABEL_BYTES
];
8119 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
8120 return xstrdup (buf
);
8123 /* Return non-zero if this DIE is a declaration. */
8126 is_declaration_die (dw_die_ref die
)
8131 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8132 if (a
->dw_attr
== DW_AT_declaration
)
8138 /* Return non-zero if this DIE is nested inside a subprogram. */
8141 is_nested_in_subprogram (dw_die_ref die
)
8143 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
8147 return local_scope_p (decl
);
8150 /* Return non-zero if this DIE contains a defining declaration of a
8154 contains_subprogram_definition (dw_die_ref die
)
8158 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
8160 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
8164 /* Return non-zero if this is a type DIE that should be moved to a
8165 COMDAT .debug_types section or .debug_info section with DW_UT_*type
8169 should_move_die_to_comdat (dw_die_ref die
)
8171 switch (die
->die_tag
)
8173 case DW_TAG_class_type
:
8174 case DW_TAG_structure_type
:
8175 case DW_TAG_enumeration_type
:
8176 case DW_TAG_union_type
:
8177 /* Don't move declarations, inlined instances, types nested in a
8178 subprogram, or types that contain subprogram definitions. */
8179 if (is_declaration_die (die
)
8180 || get_AT (die
, DW_AT_abstract_origin
)
8181 || is_nested_in_subprogram (die
)
8182 || contains_subprogram_definition (die
))
8185 case DW_TAG_array_type
:
8186 case DW_TAG_interface_type
:
8187 case DW_TAG_pointer_type
:
8188 case DW_TAG_reference_type
:
8189 case DW_TAG_rvalue_reference_type
:
8190 case DW_TAG_string_type
:
8191 case DW_TAG_subroutine_type
:
8192 case DW_TAG_ptr_to_member_type
:
8193 case DW_TAG_set_type
:
8194 case DW_TAG_subrange_type
:
8195 case DW_TAG_base_type
:
8196 case DW_TAG_const_type
:
8197 case DW_TAG_file_type
:
8198 case DW_TAG_packed_type
:
8199 case DW_TAG_volatile_type
:
8200 case DW_TAG_typedef
:
8206 /* Make a clone of DIE. */
8209 clone_die (dw_die_ref die
)
8211 dw_die_ref clone
= new_die_raw (die
->die_tag
);
8215 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8216 add_dwarf_attr (clone
, a
);
8221 /* Make a clone of the tree rooted at DIE. */
8224 clone_tree (dw_die_ref die
)
8227 dw_die_ref clone
= clone_die (die
);
8229 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
8234 /* Make a clone of DIE as a declaration. */
8237 clone_as_declaration (dw_die_ref die
)
8244 /* If the DIE is already a declaration, just clone it. */
8245 if (is_declaration_die (die
))
8246 return clone_die (die
);
8248 /* If the DIE is a specification, just clone its declaration DIE. */
8249 decl
= get_AT_ref (die
, DW_AT_specification
);
8252 clone
= clone_die (decl
);
8253 if (die
->comdat_type_p
)
8254 add_AT_die_ref (clone
, DW_AT_signature
, die
);
8258 clone
= new_die_raw (die
->die_tag
);
8260 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8262 /* We don't want to copy over all attributes.
8263 For example we don't want DW_AT_byte_size because otherwise we will no
8264 longer have a declaration and GDB will treat it as a definition. */
8268 case DW_AT_abstract_origin
:
8269 case DW_AT_artificial
:
8270 case DW_AT_containing_type
:
8271 case DW_AT_external
:
8274 case DW_AT_virtuality
:
8275 case DW_AT_linkage_name
:
8276 case DW_AT_MIPS_linkage_name
:
8277 add_dwarf_attr (clone
, a
);
8279 case DW_AT_byte_size
:
8280 case DW_AT_alignment
:
8286 if (die
->comdat_type_p
)
8287 add_AT_die_ref (clone
, DW_AT_signature
, die
);
8289 add_AT_flag (clone
, DW_AT_declaration
, 1);
8294 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
8296 struct decl_table_entry
8302 /* Helpers to manipulate hash table of copied declarations. */
8304 /* Hashtable helpers. */
8306 struct decl_table_entry_hasher
: free_ptr_hash
<decl_table_entry
>
8308 typedef die_struct
*compare_type
;
8309 static inline hashval_t
hash (const decl_table_entry
*);
8310 static inline bool equal (const decl_table_entry
*, const die_struct
*);
8314 decl_table_entry_hasher::hash (const decl_table_entry
*entry
)
8316 return htab_hash_pointer (entry
->orig
);
8320 decl_table_entry_hasher::equal (const decl_table_entry
*entry1
,
8321 const die_struct
*entry2
)
8323 return entry1
->orig
== entry2
;
8326 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
8328 /* Copy DIE and its ancestors, up to, but not including, the compile unit
8329 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
8330 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
8331 to check if the ancestor has already been copied into UNIT. */
8334 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
,
8335 decl_hash_type
*decl_table
)
8337 dw_die_ref parent
= die
->die_parent
;
8338 dw_die_ref new_parent
= unit
;
8340 decl_table_entry
**slot
= NULL
;
8341 struct decl_table_entry
*entry
= NULL
;
8343 /* If DIE refers to a stub unfold that so we get the appropriate
8344 DIE registered as orig in decl_table. */
8345 if (dw_die_ref c
= get_AT_ref (die
, DW_AT_signature
))
8350 /* Check if the entry has already been copied to UNIT. */
8351 slot
= decl_table
->find_slot_with_hash (die
, htab_hash_pointer (die
),
8353 if (*slot
!= HTAB_EMPTY_ENTRY
)
8359 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
8360 entry
= XCNEW (struct decl_table_entry
);
8368 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
8371 if (!is_unit_die (parent
))
8372 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
8375 copy
= clone_as_declaration (die
);
8376 add_child_die (new_parent
, copy
);
8380 /* Record the pointer to the copy. */
8386 /* Copy the declaration context to the new type unit DIE. This includes
8387 any surrounding namespace or type declarations. If the DIE has an
8388 AT_specification attribute, it also includes attributes and children
8389 attached to the specification, and returns a pointer to the original
8390 parent of the declaration DIE. Returns NULL otherwise. */
8393 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
8396 dw_die_ref new_decl
;
8397 dw_die_ref orig_parent
= NULL
;
8399 decl
= get_AT_ref (die
, DW_AT_specification
);
8408 /* The original DIE will be changed to a declaration, and must
8409 be moved to be a child of the original declaration DIE. */
8410 orig_parent
= decl
->die_parent
;
8412 /* Copy the type node pointer from the new DIE to the original
8413 declaration DIE so we can forward references later. */
8414 decl
->comdat_type_p
= true;
8415 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
8417 remove_AT (die
, DW_AT_specification
);
8419 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
8421 if (a
->dw_attr
!= DW_AT_name
8422 && a
->dw_attr
!= DW_AT_declaration
8423 && a
->dw_attr
!= DW_AT_external
)
8424 add_dwarf_attr (die
, a
);
8427 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
8430 if (decl
->die_parent
!= NULL
8431 && !is_unit_die (decl
->die_parent
))
8433 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
8434 if (new_decl
!= NULL
)
8436 remove_AT (new_decl
, DW_AT_signature
);
8437 add_AT_specification (die
, new_decl
);
8444 /* Generate the skeleton ancestor tree for the given NODE, then clone
8445 the DIE and add the clone into the tree. */
8448 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
8450 if (node
->new_die
!= NULL
)
8453 node
->new_die
= clone_as_declaration (node
->old_die
);
8455 if (node
->parent
!= NULL
)
8457 generate_skeleton_ancestor_tree (node
->parent
);
8458 add_child_die (node
->parent
->new_die
, node
->new_die
);
8462 /* Generate a skeleton tree of DIEs containing any declarations that are
8463 found in the original tree. We traverse the tree looking for declaration
8464 DIEs, and construct the skeleton from the bottom up whenever we find one. */
8467 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
8469 skeleton_chain_node node
;
8472 dw_die_ref prev
= NULL
;
8473 dw_die_ref next
= NULL
;
8475 node
.parent
= parent
;
8477 first
= c
= parent
->old_die
->die_child
;
8481 if (prev
== NULL
|| prev
->die_sib
== c
)
8484 next
= (c
== first
? NULL
: c
->die_sib
);
8486 node
.new_die
= NULL
;
8487 if (is_declaration_die (c
))
8489 if (is_template_instantiation (c
))
8491 /* Instantiated templates do not need to be cloned into the
8492 type unit. Just move the DIE and its children back to
8493 the skeleton tree (in the main CU). */
8494 remove_child_with_prev (c
, prev
);
8495 add_child_die (parent
->new_die
, c
);
8498 else if (c
->comdat_type_p
)
8500 /* This is the skeleton of earlier break_out_comdat_types
8501 type. Clone the existing DIE, but keep the children
8502 under the original (which is in the main CU). */
8503 dw_die_ref clone
= clone_die (c
);
8505 replace_child (c
, clone
, prev
);
8506 generate_skeleton_ancestor_tree (parent
);
8507 add_child_die (parent
->new_die
, c
);
8513 /* Clone the existing DIE, move the original to the skeleton
8514 tree (which is in the main CU), and put the clone, with
8515 all the original's children, where the original came from
8516 (which is about to be moved to the type unit). */
8517 dw_die_ref clone
= clone_die (c
);
8518 move_all_children (c
, clone
);
8520 /* If the original has a DW_AT_object_pointer attribute,
8521 it would now point to a child DIE just moved to the
8522 cloned tree, so we need to remove that attribute from
8524 remove_AT (c
, DW_AT_object_pointer
);
8526 replace_child (c
, clone
, prev
);
8527 generate_skeleton_ancestor_tree (parent
);
8528 add_child_die (parent
->new_die
, c
);
8529 node
.old_die
= clone
;
8534 generate_skeleton_bottom_up (&node
);
8535 } while (next
!= NULL
);
8538 /* Wrapper function for generate_skeleton_bottom_up. */
8541 generate_skeleton (dw_die_ref die
)
8543 skeleton_chain_node node
;
8546 node
.new_die
= NULL
;
8549 /* If this type definition is nested inside another type,
8550 and is not an instantiation of a template, always leave
8551 at least a declaration in its place. */
8552 if (die
->die_parent
!= NULL
8553 && is_type_die (die
->die_parent
)
8554 && !is_template_instantiation (die
))
8555 node
.new_die
= clone_as_declaration (die
);
8557 generate_skeleton_bottom_up (&node
);
8558 return node
.new_die
;
8561 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
8562 declaration. The original DIE is moved to a new compile unit so that
8563 existing references to it follow it to the new location. If any of the
8564 original DIE's descendants is a declaration, we need to replace the
8565 original DIE with a skeleton tree and move the declarations back into the
8569 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
8572 dw_die_ref skeleton
, orig_parent
;
8574 /* Copy the declaration context to the type unit DIE. If the returned
8575 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
8577 orig_parent
= copy_declaration_context (unit
, child
);
8579 skeleton
= generate_skeleton (child
);
8580 if (skeleton
== NULL
)
8581 remove_child_with_prev (child
, prev
);
8584 skeleton
->comdat_type_p
= true;
8585 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
8587 /* If the original DIE was a specification, we need to put
8588 the skeleton under the parent DIE of the declaration.
8589 This leaves the original declaration in the tree, but
8590 it will be pruned later since there are no longer any
8591 references to it. */
8592 if (orig_parent
!= NULL
)
8594 remove_child_with_prev (child
, prev
);
8595 add_child_die (orig_parent
, skeleton
);
8598 replace_child (child
, skeleton
, prev
);
8605 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8606 comdat_type_node
*type_node
,
8607 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
);
8609 /* Helper for copy_dwarf_procs_ref_in_dies. Make a copy of the DIE DWARF
8610 procedure, put it under TYPE_NODE and return the copy. Continue looking for
8611 DWARF procedure references in the DW_AT_location attribute. */
8614 copy_dwarf_procedure (dw_die_ref die
,
8615 comdat_type_node
*type_node
,
8616 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8618 gcc_assert (die
->die_tag
== DW_TAG_dwarf_procedure
);
8620 /* DWARF procedures are not supposed to have children... */
8621 gcc_assert (die
->die_child
== NULL
);
8623 /* ... and they are supposed to have only one attribute: DW_AT_location. */
8624 gcc_assert (vec_safe_length (die
->die_attr
) == 1
8625 && ((*die
->die_attr
)[0].dw_attr
== DW_AT_location
));
8627 /* Do not copy more than once DWARF procedures. */
8629 dw_die_ref
&die_copy
= copied_dwarf_procs
.get_or_insert (die
, &existed
);
8633 die_copy
= clone_die (die
);
8634 add_child_die (type_node
->root_die
, die_copy
);
8635 copy_dwarf_procs_ref_in_attrs (die_copy
, type_node
, copied_dwarf_procs
);
8639 /* Helper for copy_dwarf_procs_ref_in_dies. Look for references to DWARF
8640 procedures in DIE's attributes. */
8643 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8644 comdat_type_node
*type_node
,
8645 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8650 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, i
, a
)
8652 dw_loc_descr_ref loc
;
8654 if (a
->dw_attr_val
.val_class
!= dw_val_class_loc
)
8657 for (loc
= a
->dw_attr_val
.v
.val_loc
; loc
!= NULL
; loc
= loc
->dw_loc_next
)
8659 switch (loc
->dw_loc_opc
)
8663 case DW_OP_call_ref
:
8664 gcc_assert (loc
->dw_loc_oprnd1
.val_class
8665 == dw_val_class_die_ref
);
8666 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
8667 = copy_dwarf_procedure (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
,
8669 copied_dwarf_procs
);
8678 /* Copy DWARF procedures that are referenced by the DIE tree to TREE_NODE and
8679 rewrite references to point to the copies.
8681 References are looked for in DIE's attributes and recursively in all its
8682 children attributes that are location descriptions. COPIED_DWARF_PROCS is a
8683 mapping from old DWARF procedures to their copy. It is used not to copy
8684 twice the same DWARF procedure under TYPE_NODE. */
8687 copy_dwarf_procs_ref_in_dies (dw_die_ref die
,
8688 comdat_type_node
*type_node
,
8689 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8693 copy_dwarf_procs_ref_in_attrs (die
, type_node
, copied_dwarf_procs
);
8694 FOR_EACH_CHILD (die
, c
, copy_dwarf_procs_ref_in_dies (c
,
8696 copied_dwarf_procs
));
8699 /* Traverse the DIE and set up additional .debug_types or .debug_info
8700 DW_UT_*type sections for each type worthy of being placed in a COMDAT
8704 break_out_comdat_types (dw_die_ref die
)
8708 dw_die_ref prev
= NULL
;
8709 dw_die_ref next
= NULL
;
8710 dw_die_ref unit
= NULL
;
8712 first
= c
= die
->die_child
;
8716 if (prev
== NULL
|| prev
->die_sib
== c
)
8719 next
= (c
== first
? NULL
: c
->die_sib
);
8720 if (should_move_die_to_comdat (c
))
8722 dw_die_ref replacement
;
8723 comdat_type_node
*type_node
;
8725 /* Break out nested types into their own type units. */
8726 break_out_comdat_types (c
);
8728 /* Create a new type unit DIE as the root for the new tree. */
8729 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
8730 add_AT_unsigned (unit
, DW_AT_language
,
8731 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
8733 /* Add the new unit's type DIE into the comdat type list. */
8734 type_node
= ggc_cleared_alloc
<comdat_type_node
> ();
8735 type_node
->root_die
= unit
;
8736 type_node
->next
= comdat_type_list
;
8737 comdat_type_list
= type_node
;
8739 /* Generate the type signature. */
8740 generate_type_signature (c
, type_node
);
8742 /* Copy the declaration context, attributes, and children of the
8743 declaration into the new type unit DIE, then remove this DIE
8744 from the main CU (or replace it with a skeleton if necessary). */
8745 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
8746 type_node
->skeleton_die
= replacement
;
8748 /* Add the DIE to the new compunit. */
8749 add_child_die (unit
, c
);
8751 /* Types can reference DWARF procedures for type size or data location
8752 expressions. Calls in DWARF expressions cannot target procedures
8753 that are not in the same section. So we must copy DWARF procedures
8754 along with this type and then rewrite references to them. */
8755 hash_map
<dw_die_ref
, dw_die_ref
> copied_dwarf_procs
;
8756 copy_dwarf_procs_ref_in_dies (c
, type_node
, copied_dwarf_procs
);
8758 if (replacement
!= NULL
)
8761 else if (c
->die_tag
== DW_TAG_namespace
8762 || c
->die_tag
== DW_TAG_class_type
8763 || c
->die_tag
== DW_TAG_structure_type
8764 || c
->die_tag
== DW_TAG_union_type
)
8766 /* Look for nested types that can be broken out. */
8767 break_out_comdat_types (c
);
8769 } while (next
!= NULL
);
8772 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
8773 Enter all the cloned children into the hash table decl_table. */
8776 clone_tree_partial (dw_die_ref die
, decl_hash_type
*decl_table
)
8780 struct decl_table_entry
*entry
;
8781 decl_table_entry
**slot
;
8783 if (die
->die_tag
== DW_TAG_subprogram
)
8784 clone
= clone_as_declaration (die
);
8786 clone
= clone_die (die
);
8788 slot
= decl_table
->find_slot_with_hash (die
,
8789 htab_hash_pointer (die
), INSERT
);
8791 /* Assert that DIE isn't in the hash table yet. If it would be there
8792 before, the ancestors would be necessarily there as well, therefore
8793 clone_tree_partial wouldn't be called. */
8794 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
8796 entry
= XCNEW (struct decl_table_entry
);
8798 entry
->copy
= clone
;
8801 if (die
->die_tag
!= DW_TAG_subprogram
)
8802 FOR_EACH_CHILD (die
, c
,
8803 add_child_die (clone
, clone_tree_partial (c
, decl_table
)));
8808 /* Walk the DIE and its children, looking for references to incomplete
8809 or trivial types that are unmarked (i.e., that are not in the current
8813 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type
*decl_table
)
8819 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8821 if (AT_class (a
) == dw_val_class_die_ref
)
8823 dw_die_ref targ
= AT_ref (a
);
8824 decl_table_entry
**slot
;
8825 struct decl_table_entry
*entry
;
8827 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
8830 slot
= decl_table
->find_slot_with_hash (targ
,
8831 htab_hash_pointer (targ
),
8834 if (*slot
!= HTAB_EMPTY_ENTRY
)
8836 /* TARG has already been copied, so we just need to
8837 modify the reference to point to the copy. */
8839 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
8843 dw_die_ref parent
= unit
;
8844 dw_die_ref copy
= clone_die (targ
);
8846 /* Record in DECL_TABLE that TARG has been copied.
8847 Need to do this now, before the recursive call,
8848 because DECL_TABLE may be expanded and SLOT
8849 would no longer be a valid pointer. */
8850 entry
= XCNEW (struct decl_table_entry
);
8855 /* If TARG is not a declaration DIE, we need to copy its
8857 if (!is_declaration_die (targ
))
8861 add_child_die (copy
,
8862 clone_tree_partial (c
, decl_table
)));
8865 /* Make sure the cloned tree is marked as part of the
8869 /* If TARG has surrounding context, copy its ancestor tree
8870 into the new type unit. */
8871 if (targ
->die_parent
!= NULL
8872 && !is_unit_die (targ
->die_parent
))
8873 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
8876 add_child_die (parent
, copy
);
8877 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
8879 /* Make sure the newly-copied DIE is walked. If it was
8880 installed in a previously-added context, it won't
8881 get visited otherwise. */
8884 /* Find the highest point of the newly-added tree,
8885 mark each node along the way, and walk from there. */
8886 parent
->die_mark
= 1;
8887 while (parent
->die_parent
8888 && parent
->die_parent
->die_mark
== 0)
8890 parent
= parent
->die_parent
;
8891 parent
->die_mark
= 1;
8893 copy_decls_walk (unit
, parent
, decl_table
);
8899 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
8902 /* Collect skeleton dies in DIE created by break_out_comdat_types already
8903 and record them in DECL_TABLE. */
8906 collect_skeleton_dies (dw_die_ref die
, decl_hash_type
*decl_table
)
8910 if (dw_attr_node
*a
= get_AT (die
, DW_AT_signature
))
8912 dw_die_ref targ
= AT_ref (a
);
8913 gcc_assert (targ
->die_mark
== 0 && targ
->comdat_type_p
);
8914 decl_table_entry
**slot
8915 = decl_table
->find_slot_with_hash (targ
,
8916 htab_hash_pointer (targ
),
8918 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
8919 /* Record in DECL_TABLE that TARG has been already copied
8920 by remove_child_or_replace_with_skeleton. */
8921 decl_table_entry
*entry
= XCNEW (struct decl_table_entry
);
8926 FOR_EACH_CHILD (die
, c
, collect_skeleton_dies (c
, decl_table
));
8929 /* Copy declarations for "unworthy" types into the new comdat section.
8930 Incomplete types, modified types, and certain other types aren't broken
8931 out into comdat sections of their own, so they don't have a signature,
8932 and we need to copy the declaration into the same section so that we
8933 don't have an external reference. */
8936 copy_decls_for_unworthy_types (dw_die_ref unit
)
8939 decl_hash_type
decl_table (10);
8940 collect_skeleton_dies (unit
, &decl_table
);
8941 copy_decls_walk (unit
, unit
, &decl_table
);
8945 /* Traverse the DIE and add a sibling attribute if it may have the
8946 effect of speeding up access to siblings. To save some space,
8947 avoid generating sibling attributes for DIE's without children. */
8950 add_sibling_attributes (dw_die_ref die
)
8954 if (! die
->die_child
)
8957 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
8958 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
8960 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
8963 /* Output all location lists for the DIE and its children. */
8966 output_location_lists (dw_die_ref die
)
8972 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8973 if (AT_class (a
) == dw_val_class_loc_list
)
8974 output_loc_list (AT_loc_list (a
));
8976 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
8979 /* During assign_location_list_indexes and output_loclists_offset the
8980 current index, after it the number of assigned indexes (i.e. how
8981 large the .debug_loclists* offset table should be). */
8982 static unsigned int loc_list_idx
;
8984 /* Output all location list offsets for the DIE and its children. */
8987 output_loclists_offsets (dw_die_ref die
)
8993 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8994 if (AT_class (a
) == dw_val_class_loc_list
)
8996 dw_loc_list_ref l
= AT_loc_list (a
);
8997 if (l
->offset_emitted
)
8999 dw2_asm_output_delta (dwarf_offset_size
, l
->ll_symbol
,
9000 loc_section_label
, NULL
);
9001 gcc_assert (l
->hash
== loc_list_idx
);
9003 l
->offset_emitted
= true;
9006 FOR_EACH_CHILD (die
, c
, output_loclists_offsets (c
));
9009 /* Recursively set indexes of location lists. */
9012 assign_location_list_indexes (dw_die_ref die
)
9018 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9019 if (AT_class (a
) == dw_val_class_loc_list
)
9021 dw_loc_list_ref list
= AT_loc_list (a
);
9022 if (!list
->num_assigned
)
9024 list
->num_assigned
= true;
9025 list
->hash
= loc_list_idx
++;
9029 FOR_EACH_CHILD (die
, c
, assign_location_list_indexes (c
));
9032 /* We want to limit the number of external references, because they are
9033 larger than local references: a relocation takes multiple words, and
9034 even a sig8 reference is always eight bytes, whereas a local reference
9035 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
9036 So if we encounter multiple external references to the same type DIE, we
9037 make a local typedef stub for it and redirect all references there.
9039 This is the element of the hash table for keeping track of these
9049 /* Hashtable helpers. */
9051 struct external_ref_hasher
: free_ptr_hash
<external_ref
>
9053 static inline hashval_t
hash (const external_ref
*);
9054 static inline bool equal (const external_ref
*, const external_ref
*);
9058 external_ref_hasher::hash (const external_ref
*r
)
9060 dw_die_ref die
= r
->type
;
9063 /* We can't use the address of the DIE for hashing, because
9064 that will make the order of the stub DIEs non-deterministic. */
9065 if (! die
->comdat_type_p
)
9066 /* We have a symbol; use it to compute a hash. */
9067 h
= htab_hash_string (die
->die_id
.die_symbol
);
9070 /* We have a type signature; use a subset of the bits as the hash.
9071 The 8-byte signature is at least as large as hashval_t. */
9072 comdat_type_node
*type_node
= die
->die_id
.die_type_node
;
9073 memcpy (&h
, type_node
->signature
, sizeof (h
));
9079 external_ref_hasher::equal (const external_ref
*r1
, const external_ref
*r2
)
9081 return r1
->type
== r2
->type
;
9084 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
9086 /* Return a pointer to the external_ref for references to DIE. */
9088 static struct external_ref
*
9089 lookup_external_ref (external_ref_hash_type
*map
, dw_die_ref die
)
9091 struct external_ref ref
, *ref_p
;
9092 external_ref
**slot
;
9095 slot
= map
->find_slot (&ref
, INSERT
);
9096 if (*slot
!= HTAB_EMPTY_ENTRY
)
9099 ref_p
= XCNEW (struct external_ref
);
9105 /* Subroutine of optimize_external_refs, below.
9107 If we see a type skeleton, record it as our stub. If we see external
9108 references, remember how many we've seen. */
9111 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type
*map
)
9116 struct external_ref
*ref_p
;
9118 if (is_type_die (die
)
9119 && (c
= get_AT_ref (die
, DW_AT_signature
)))
9121 /* This is a local skeleton; use it for local references. */
9122 ref_p
= lookup_external_ref (map
, c
);
9126 /* Scan the DIE references, and remember any that refer to DIEs from
9127 other CUs (i.e. those which are not marked). */
9128 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9129 if (AT_class (a
) == dw_val_class_die_ref
9130 && (c
= AT_ref (a
))->die_mark
== 0
9133 ref_p
= lookup_external_ref (map
, c
);
9137 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
9140 /* htab_traverse callback function for optimize_external_refs, below. SLOT
9141 points to an external_ref, DATA is the CU we're processing. If we don't
9142 already have a local stub, and we have multiple refs, build a stub. */
9145 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
9147 struct external_ref
*ref_p
= *slot
;
9149 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
9151 /* We have multiple references to this type, so build a small stub.
9152 Both of these forms are a bit dodgy from the perspective of the
9153 DWARF standard, since technically they should have names. */
9154 dw_die_ref cu
= data
;
9155 dw_die_ref type
= ref_p
->type
;
9156 dw_die_ref stub
= NULL
;
9158 if (type
->comdat_type_p
)
9160 /* If we refer to this type via sig8, use AT_signature. */
9161 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
9162 add_AT_die_ref (stub
, DW_AT_signature
, type
);
9166 /* Otherwise, use a typedef with no name. */
9167 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
9168 add_AT_die_ref (stub
, DW_AT_type
, type
);
9177 /* DIE is a unit; look through all the DIE references to see if there are
9178 any external references to types, and if so, create local stubs for
9179 them which will be applied in build_abbrev_table. This is useful because
9180 references to local DIEs are smaller. */
9182 static external_ref_hash_type
*
9183 optimize_external_refs (dw_die_ref die
)
9185 external_ref_hash_type
*map
= new external_ref_hash_type (10);
9186 optimize_external_refs_1 (die
, map
);
9187 map
->traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
9191 /* The following 3 variables are temporaries that are computed only during the
9192 build_abbrev_table call and used and released during the following
9193 optimize_abbrev_table call. */
9195 /* First abbrev_id that can be optimized based on usage. */
9196 static unsigned int abbrev_opt_start
;
9198 /* Maximum abbrev_id of a base type plus one (we can't optimize DIEs with
9199 abbrev_id smaller than this, because they must be already sized
9200 during build_abbrev_table). */
9201 static unsigned int abbrev_opt_base_type_end
;
9203 /* Vector of usage counts during build_abbrev_table. Indexed by
9204 abbrev_id - abbrev_opt_start. */
9205 static vec
<unsigned int> abbrev_usage_count
;
9207 /* Vector of all DIEs added with die_abbrev >= abbrev_opt_start. */
9208 static vec
<dw_die_ref
> sorted_abbrev_dies
;
9210 /* The format of each DIE (and its attribute value pairs) is encoded in an
9211 abbreviation table. This routine builds the abbreviation table and assigns
9212 a unique abbreviation id for each abbreviation entry. The children of each
9213 die are visited recursively. */
9216 build_abbrev_table (dw_die_ref die
, external_ref_hash_type
*extern_map
)
9218 unsigned int abbrev_id
= 0;
9224 /* Scan the DIE references, and replace any that refer to
9225 DIEs from other CUs (i.e. those which are not marked) with
9226 the local stubs we built in optimize_external_refs. */
9227 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9228 if (AT_class (a
) == dw_val_class_die_ref
9229 && (c
= AT_ref (a
))->die_mark
== 0)
9231 struct external_ref
*ref_p
;
9232 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
9235 && (ref_p
= lookup_external_ref (extern_map
, c
))
9236 && ref_p
->stub
&& ref_p
->stub
!= die
)
9238 gcc_assert (a
->dw_attr
!= DW_AT_signature
);
9239 change_AT_die_ref (a
, ref_p
->stub
);
9242 /* We aren't changing this reference, so mark it external. */
9243 set_AT_ref_external (a
, 1);
9246 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
9248 dw_attr_node
*die_a
, *abbrev_a
;
9254 if (abbrev
->die_tag
!= die
->die_tag
)
9256 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
9259 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
9262 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
9264 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
9265 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
9266 || (value_format (abbrev_a
) != value_format (die_a
)))
9276 if (abbrev_id
>= vec_safe_length (abbrev_die_table
))
9278 vec_safe_push (abbrev_die_table
, die
);
9279 if (abbrev_opt_start
)
9280 abbrev_usage_count
.safe_push (0);
9282 if (abbrev_opt_start
&& abbrev_id
>= abbrev_opt_start
)
9284 abbrev_usage_count
[abbrev_id
- abbrev_opt_start
]++;
9285 sorted_abbrev_dies
.safe_push (die
);
9288 die
->die_abbrev
= abbrev_id
;
9289 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
9292 /* Callback function for sorted_abbrev_dies vector sorting. We sort
9293 by die_abbrev's usage count, from the most commonly used
9294 abbreviation to the least. */
9297 die_abbrev_cmp (const void *p1
, const void *p2
)
9299 dw_die_ref die1
= *(const dw_die_ref
*) p1
;
9300 dw_die_ref die2
= *(const dw_die_ref
*) p2
;
9302 gcc_checking_assert (die1
->die_abbrev
>= abbrev_opt_start
);
9303 gcc_checking_assert (die2
->die_abbrev
>= abbrev_opt_start
);
9305 if (die1
->die_abbrev
>= abbrev_opt_base_type_end
9306 && die2
->die_abbrev
>= abbrev_opt_base_type_end
)
9308 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
9309 > abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
9311 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
9312 < abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
9316 /* Stabilize the sort. */
9317 if (die1
->die_abbrev
< die2
->die_abbrev
)
9319 if (die1
->die_abbrev
> die2
->die_abbrev
)
9325 /* Convert dw_val_class_const and dw_val_class_unsigned_const class attributes
9326 of DIEs in between sorted_abbrev_dies[first_id] and abbrev_dies[end_id - 1]
9327 into dw_val_class_const_implicit or
9328 dw_val_class_unsigned_const_implicit. */
9331 optimize_implicit_const (unsigned int first_id
, unsigned int end
,
9332 vec
<bool> &implicit_consts
)
9334 /* It never makes sense if there is just one DIE using the abbreviation. */
9335 if (end
< first_id
+ 2)
9340 dw_die_ref die
= sorted_abbrev_dies
[first_id
];
9341 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9342 if (implicit_consts
[ix
])
9344 enum dw_val_class new_class
= dw_val_class_none
;
9345 switch (AT_class (a
))
9347 case dw_val_class_unsigned_const
:
9348 if ((HOST_WIDE_INT
) AT_unsigned (a
) < 0)
9351 /* The .debug_abbrev section will grow by
9352 size_of_sleb128 (AT_unsigned (a)) and we avoid the constants
9353 in all the DIEs using that abbreviation. */
9354 if (constant_size (AT_unsigned (a
)) * (end
- first_id
)
9355 <= (unsigned) size_of_sleb128 (AT_unsigned (a
)))
9358 new_class
= dw_val_class_unsigned_const_implicit
;
9361 case dw_val_class_const
:
9362 new_class
= dw_val_class_const_implicit
;
9365 case dw_val_class_file
:
9366 new_class
= dw_val_class_file_implicit
;
9372 for (i
= first_id
; i
< end
; i
++)
9373 (*sorted_abbrev_dies
[i
]->die_attr
)[ix
].dw_attr_val
.val_class
9378 /* Attempt to optimize abbreviation table from abbrev_opt_start
9379 abbreviation above. */
9382 optimize_abbrev_table (void)
9384 if (abbrev_opt_start
9385 && vec_safe_length (abbrev_die_table
) > abbrev_opt_start
9386 && (dwarf_version
>= 5 || vec_safe_length (abbrev_die_table
) > 127))
9388 auto_vec
<bool, 32> implicit_consts
;
9389 sorted_abbrev_dies
.qsort (die_abbrev_cmp
);
9391 unsigned int abbrev_id
= abbrev_opt_start
- 1;
9392 unsigned int first_id
= ~0U;
9393 unsigned int last_abbrev_id
= 0;
9396 if (abbrev_opt_base_type_end
> abbrev_opt_start
)
9397 abbrev_id
= abbrev_opt_base_type_end
- 1;
9398 /* Reassign abbreviation ids from abbrev_opt_start above, so that
9399 most commonly used abbreviations come first. */
9400 FOR_EACH_VEC_ELT (sorted_abbrev_dies
, i
, die
)
9405 /* If calc_base_type_die_sizes has been called, the CU and
9406 base types after it can't be optimized, because we've already
9407 calculated their DIE offsets. We've sorted them first. */
9408 if (die
->die_abbrev
< abbrev_opt_base_type_end
)
9410 if (die
->die_abbrev
!= last_abbrev_id
)
9412 last_abbrev_id
= die
->die_abbrev
;
9413 if (dwarf_version
>= 5 && first_id
!= ~0U)
9414 optimize_implicit_const (first_id
, i
, implicit_consts
);
9416 (*abbrev_die_table
)[abbrev_id
] = die
;
9417 if (dwarf_version
>= 5)
9420 implicit_consts
.truncate (0);
9422 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9423 switch (AT_class (a
))
9425 case dw_val_class_const
:
9426 case dw_val_class_unsigned_const
:
9427 case dw_val_class_file
:
9428 implicit_consts
.safe_push (true);
9431 implicit_consts
.safe_push (false);
9436 else if (dwarf_version
>= 5)
9438 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9439 if (!implicit_consts
[ix
])
9443 dw_attr_node
*other_a
9444 = &(*(*abbrev_die_table
)[abbrev_id
]->die_attr
)[ix
];
9445 if (!dw_val_equal_p (&a
->dw_attr_val
,
9446 &other_a
->dw_attr_val
))
9447 implicit_consts
[ix
] = false;
9450 die
->die_abbrev
= abbrev_id
;
9452 gcc_assert (abbrev_id
== vec_safe_length (abbrev_die_table
) - 1);
9453 if (dwarf_version
>= 5 && first_id
!= ~0U)
9454 optimize_implicit_const (first_id
, i
, implicit_consts
);
9457 abbrev_opt_start
= 0;
9458 abbrev_opt_base_type_end
= 0;
9459 abbrev_usage_count
.release ();
9460 sorted_abbrev_dies
.release ();
9463 /* Return the power-of-two number of bytes necessary to represent VALUE. */
9466 constant_size (unsigned HOST_WIDE_INT value
)
9473 log
= floor_log2 (value
);
9476 log
= 1 << (floor_log2 (log
) + 1);
9481 /* Return the size of a DIE as it is represented in the
9482 .debug_info section. */
9484 static unsigned long
9485 size_of_die (dw_die_ref die
)
9487 unsigned long size
= 0;
9490 enum dwarf_form form
;
9492 size
+= size_of_uleb128 (die
->die_abbrev
);
9493 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9495 switch (AT_class (a
))
9497 case dw_val_class_addr
:
9498 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9500 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9501 size
+= size_of_uleb128 (AT_index (a
));
9504 size
+= DWARF2_ADDR_SIZE
;
9506 case dw_val_class_offset
:
9507 size
+= dwarf_offset_size
;
9509 case dw_val_class_loc
:
9511 unsigned long lsize
= size_of_locs (AT_loc (a
));
9514 if (dwarf_version
>= 4)
9515 size
+= size_of_uleb128 (lsize
);
9517 size
+= constant_size (lsize
);
9521 case dw_val_class_loc_list
:
9522 if (dwarf_split_debug_info
&& dwarf_version
>= 5)
9524 gcc_assert (AT_loc_list (a
)->num_assigned
);
9525 size
+= size_of_uleb128 (AT_loc_list (a
)->hash
);
9528 size
+= dwarf_offset_size
;
9530 case dw_val_class_view_list
:
9531 size
+= dwarf_offset_size
;
9533 case dw_val_class_range_list
:
9534 if (value_format (a
) == DW_FORM_rnglistx
)
9536 gcc_assert (rnglist_idx
);
9537 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
9538 size
+= size_of_uleb128 (r
->idx
);
9541 size
+= dwarf_offset_size
;
9543 case dw_val_class_const
:
9544 size
+= size_of_sleb128 (AT_int (a
));
9546 case dw_val_class_unsigned_const
:
9548 int csize
= constant_size (AT_unsigned (a
));
9549 if (dwarf_version
== 3
9550 && a
->dw_attr
== DW_AT_data_member_location
9552 size
+= size_of_uleb128 (AT_unsigned (a
));
9557 case dw_val_class_symview
:
9558 if (symview_upper_bound
<= 0xff)
9560 else if (symview_upper_bound
<= 0xffff)
9562 else if (symview_upper_bound
<= 0xffffffff)
9567 case dw_val_class_const_implicit
:
9568 case dw_val_class_unsigned_const_implicit
:
9569 case dw_val_class_file_implicit
:
9570 /* These occupy no size in the DIE, just an extra sleb128 in
9573 case dw_val_class_const_double
:
9574 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
9575 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
9578 case dw_val_class_wide_int
:
9579 size
+= (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9580 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
9581 if (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9582 * HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
9585 case dw_val_class_vec
:
9586 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
9587 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
9588 + a
->dw_attr_val
.v
.val_vec
.length
9589 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
9591 case dw_val_class_flag
:
9592 if (dwarf_version
>= 4)
9593 /* Currently all add_AT_flag calls pass in 1 as last argument,
9594 so DW_FORM_flag_present can be used. If that ever changes,
9595 we'll need to use DW_FORM_flag and have some optimization
9596 in build_abbrev_table that will change those to
9597 DW_FORM_flag_present if it is set to 1 in all DIEs using
9598 the same abbrev entry. */
9599 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9603 case dw_val_class_die_ref
:
9604 if (AT_ref_external (a
))
9606 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
9607 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
9608 is sized by target address length, whereas in DWARF3
9609 it's always sized as an offset. */
9610 if (AT_ref (a
)->comdat_type_p
)
9611 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
9612 else if (dwarf_version
== 2)
9613 size
+= DWARF2_ADDR_SIZE
;
9615 size
+= dwarf_offset_size
;
9618 size
+= dwarf_offset_size
;
9620 case dw_val_class_fde_ref
:
9621 size
+= dwarf_offset_size
;
9623 case dw_val_class_lbl_id
:
9624 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9626 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9627 size
+= size_of_uleb128 (AT_index (a
));
9630 size
+= DWARF2_ADDR_SIZE
;
9632 case dw_val_class_lineptr
:
9633 case dw_val_class_macptr
:
9634 case dw_val_class_loclistsptr
:
9635 size
+= dwarf_offset_size
;
9637 case dw_val_class_str
:
9638 form
= AT_string_form (a
);
9639 if (form
== DW_FORM_strp
|| form
== DW_FORM_line_strp
)
9640 size
+= dwarf_offset_size
;
9641 else if (form
== dwarf_FORM (DW_FORM_strx
))
9642 size
+= size_of_uleb128 (AT_index (a
));
9644 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
9646 case dw_val_class_file
:
9647 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
9649 case dw_val_class_data8
:
9652 case dw_val_class_vms_delta
:
9653 size
+= dwarf_offset_size
;
9655 case dw_val_class_high_pc
:
9656 size
+= DWARF2_ADDR_SIZE
;
9658 case dw_val_class_discr_value
:
9659 size
+= size_of_discr_value (&a
->dw_attr_val
.v
.val_discr_value
);
9661 case dw_val_class_discr_list
:
9663 unsigned block_size
= size_of_discr_list (AT_discr_list (a
));
9665 /* This is a block, so we have the block length and then its
9667 size
+= constant_size (block_size
) + block_size
;
9678 /* Size the debugging information associated with a given DIE. Visits the
9679 DIE's children recursively. Updates the global variable next_die_offset, on
9680 each time through. Uses the current value of next_die_offset to update the
9681 die_offset field in each DIE. */
9684 calc_die_sizes (dw_die_ref die
)
9688 gcc_assert (die
->die_offset
== 0
9689 || (unsigned long int) die
->die_offset
== next_die_offset
);
9690 die
->die_offset
= next_die_offset
;
9691 next_die_offset
+= size_of_die (die
);
9693 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
9695 if (die
->die_child
!= NULL
)
9696 /* Count the null byte used to terminate sibling lists. */
9697 next_die_offset
+= 1;
9700 /* Size just the base type children at the start of the CU.
9701 This is needed because build_abbrev needs to size locs
9702 and sizing of type based stack ops needs to know die_offset
9703 values for the base types. */
9706 calc_base_type_die_sizes (void)
9708 unsigned long die_offset
= (dwarf_split_debug_info
9709 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
9710 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
9712 dw_die_ref base_type
;
9713 #if ENABLE_ASSERT_CHECKING
9714 dw_die_ref prev
= comp_unit_die ()->die_child
;
9717 die_offset
+= size_of_die (comp_unit_die ());
9718 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
9720 #if ENABLE_ASSERT_CHECKING
9721 gcc_assert (base_type
->die_offset
== 0
9722 && prev
->die_sib
== base_type
9723 && base_type
->die_child
== NULL
9724 && base_type
->die_abbrev
);
9727 if (abbrev_opt_start
9728 && base_type
->die_abbrev
>= abbrev_opt_base_type_end
)
9729 abbrev_opt_base_type_end
= base_type
->die_abbrev
+ 1;
9730 base_type
->die_offset
= die_offset
;
9731 die_offset
+= size_of_die (base_type
);
9735 /* Set the marks for a die and its children. We do this so
9736 that we know whether or not a reference needs to use FORM_ref_addr; only
9737 DIEs in the same CU will be marked. We used to clear out the offset
9738 and use that as the flag, but ran into ordering problems. */
9741 mark_dies (dw_die_ref die
)
9745 gcc_assert (!die
->die_mark
);
9748 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
9751 /* Clear the marks for a die and its children. */
9754 unmark_dies (dw_die_ref die
)
9758 if (! use_debug_types
)
9759 gcc_assert (die
->die_mark
);
9762 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
9765 /* Clear the marks for a die, its children and referred dies. */
9768 unmark_all_dies (dw_die_ref die
)
9778 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
9780 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9781 if (AT_class (a
) == dw_val_class_die_ref
)
9782 unmark_all_dies (AT_ref (a
));
9785 /* Calculate if the entry should appear in the final output file. It may be
9786 from a pruned a type. */
9789 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
9791 /* By limiting gnu pubnames to definitions only, gold can generate a
9792 gdb index without entries for declarations, which don't include
9793 enough information to be useful. */
9794 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
9797 if (table
== pubname_table
)
9799 /* Enumerator names are part of the pubname table, but the
9800 parent DW_TAG_enumeration_type die may have been pruned.
9801 Don't output them if that is the case. */
9802 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
9803 (p
->die
->die_parent
== NULL
9804 || !p
->die
->die_parent
->die_perennial_p
))
9807 /* Everything else in the pubname table is included. */
9811 /* The pubtypes table shouldn't include types that have been
9813 return (p
->die
->die_offset
!= 0
9814 || !flag_eliminate_unused_debug_types
);
9817 /* Return the size of the .debug_pubnames or .debug_pubtypes table
9818 generated for the compilation unit. */
9820 static unsigned long
9821 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9826 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
9828 size
= DWARF_PUBNAMES_HEADER_SIZE
;
9829 FOR_EACH_VEC_ELT (*names
, i
, p
)
9830 if (include_pubname_in_output (names
, p
))
9831 size
+= strlen (p
->name
) + dwarf_offset_size
+ 1 + space_for_flags
;
9833 size
+= dwarf_offset_size
;
9837 /* Return the size of the information in the .debug_aranges section. */
9839 static unsigned long
9840 size_of_aranges (void)
9844 size
= DWARF_ARANGES_HEADER_SIZE
;
9846 /* Count the address/length pair for this compilation unit. */
9847 if (switch_text_ranges
)
9848 size
+= 2 * DWARF2_ADDR_SIZE
9849 * (vec_safe_length (switch_text_ranges
) / 2 + 1);
9850 if (switch_cold_ranges
)
9851 size
+= 2 * DWARF2_ADDR_SIZE
9852 * (vec_safe_length (switch_cold_ranges
) / 2 + 1);
9853 if (have_multiple_function_sections
)
9858 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
9860 if (fde
->ignored_debug
)
9862 if (!fde
->in_std_section
)
9863 size
+= 2 * DWARF2_ADDR_SIZE
;
9864 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
9865 size
+= 2 * DWARF2_ADDR_SIZE
;
9869 /* Count the two zero words used to terminated the address range table. */
9870 size
+= 2 * DWARF2_ADDR_SIZE
;
9874 /* Select the encoding of an attribute value. */
9876 static enum dwarf_form
9877 value_format (dw_attr_node
*a
)
9879 switch (AT_class (a
))
9881 case dw_val_class_addr
:
9882 /* Only very few attributes allow DW_FORM_addr. */
9887 case DW_AT_entry_pc
:
9888 case DW_AT_trampoline
:
9889 return (AT_index (a
) == NOT_INDEXED
9890 ? DW_FORM_addr
: dwarf_FORM (DW_FORM_addrx
));
9894 switch (DWARF2_ADDR_SIZE
)
9897 return DW_FORM_data1
;
9899 return DW_FORM_data2
;
9901 return DW_FORM_data4
;
9903 return DW_FORM_data8
;
9907 case dw_val_class_loc_list
:
9908 if (dwarf_split_debug_info
9909 && dwarf_version
>= 5
9910 && AT_loc_list (a
)->num_assigned
)
9911 return DW_FORM_loclistx
;
9913 case dw_val_class_view_list
:
9914 case dw_val_class_range_list
:
9915 /* For range lists in DWARF 5, use DW_FORM_rnglistx from .debug_info.dwo
9916 but in .debug_info use DW_FORM_sec_offset, which is shorter if we
9917 care about sizes of .debug* sections in shared libraries and
9918 executables and don't take into account relocations that affect just
9919 relocatable objects - for DW_FORM_rnglistx we'd have to emit offset
9920 table in the .debug_rnglists section. */
9921 if (dwarf_split_debug_info
9922 && dwarf_version
>= 5
9923 && AT_class (a
) == dw_val_class_range_list
9925 && a
->dw_attr_val
.val_entry
!= RELOCATED_OFFSET
)
9926 return DW_FORM_rnglistx
;
9927 if (dwarf_version
>= 4)
9928 return DW_FORM_sec_offset
;
9930 case dw_val_class_vms_delta
:
9931 case dw_val_class_offset
:
9932 switch (dwarf_offset_size
)
9935 return DW_FORM_data4
;
9937 return DW_FORM_data8
;
9941 case dw_val_class_loc
:
9942 if (dwarf_version
>= 4)
9943 return DW_FORM_exprloc
;
9944 switch (constant_size (size_of_locs (AT_loc (a
))))
9947 return DW_FORM_block1
;
9949 return DW_FORM_block2
;
9951 return DW_FORM_block4
;
9955 case dw_val_class_const
:
9956 return DW_FORM_sdata
;
9957 case dw_val_class_unsigned_const
:
9958 switch (constant_size (AT_unsigned (a
)))
9961 return DW_FORM_data1
;
9963 return DW_FORM_data2
;
9965 /* In DWARF3 DW_AT_data_member_location with
9966 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
9967 constant, so we need to use DW_FORM_udata if we need
9968 a large constant. */
9969 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9970 return DW_FORM_udata
;
9971 return DW_FORM_data4
;
9973 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9974 return DW_FORM_udata
;
9975 return DW_FORM_data8
;
9979 case dw_val_class_const_implicit
:
9980 case dw_val_class_unsigned_const_implicit
:
9981 case dw_val_class_file_implicit
:
9982 return DW_FORM_implicit_const
;
9983 case dw_val_class_const_double
:
9984 switch (HOST_BITS_PER_WIDE_INT
)
9987 return DW_FORM_data2
;
9989 return DW_FORM_data4
;
9991 return DW_FORM_data8
;
9993 if (dwarf_version
>= 5)
9994 return DW_FORM_data16
;
9997 return DW_FORM_block1
;
9999 case dw_val_class_wide_int
:
10000 switch (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
)
10003 return DW_FORM_data1
;
10005 return DW_FORM_data2
;
10007 return DW_FORM_data4
;
10009 return DW_FORM_data8
;
10011 if (dwarf_version
>= 5)
10012 return DW_FORM_data16
;
10015 return DW_FORM_block1
;
10017 case dw_val_class_symview
:
10018 /* ??? We might use uleb128, but then we'd have to compute
10019 .debug_info offsets in the assembler. */
10020 if (symview_upper_bound
<= 0xff)
10021 return DW_FORM_data1
;
10022 else if (symview_upper_bound
<= 0xffff)
10023 return DW_FORM_data2
;
10024 else if (symview_upper_bound
<= 0xffffffff)
10025 return DW_FORM_data4
;
10027 return DW_FORM_data8
;
10028 case dw_val_class_vec
:
10029 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
10030 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
10033 return DW_FORM_block1
;
10035 return DW_FORM_block2
;
10037 return DW_FORM_block4
;
10039 gcc_unreachable ();
10041 case dw_val_class_flag
:
10042 if (dwarf_version
>= 4)
10044 /* Currently all add_AT_flag calls pass in 1 as last argument,
10045 so DW_FORM_flag_present can be used. If that ever changes,
10046 we'll need to use DW_FORM_flag and have some optimization
10047 in build_abbrev_table that will change those to
10048 DW_FORM_flag_present if it is set to 1 in all DIEs using
10049 the same abbrev entry. */
10050 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
10051 return DW_FORM_flag_present
;
10053 return DW_FORM_flag
;
10054 case dw_val_class_die_ref
:
10055 if (AT_ref_external (a
))
10057 if (AT_ref (a
)->comdat_type_p
)
10058 return DW_FORM_ref_sig8
;
10060 return DW_FORM_ref_addr
;
10063 return DW_FORM_ref
;
10064 case dw_val_class_fde_ref
:
10065 return DW_FORM_data
;
10066 case dw_val_class_lbl_id
:
10067 return (AT_index (a
) == NOT_INDEXED
10068 ? DW_FORM_addr
: dwarf_FORM (DW_FORM_addrx
));
10069 case dw_val_class_lineptr
:
10070 case dw_val_class_macptr
:
10071 case dw_val_class_loclistsptr
:
10072 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
10073 case dw_val_class_str
:
10074 return AT_string_form (a
);
10075 case dw_val_class_file
:
10076 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
10079 return DW_FORM_data1
;
10081 return DW_FORM_data2
;
10083 return DW_FORM_data4
;
10085 gcc_unreachable ();
10088 case dw_val_class_data8
:
10089 return DW_FORM_data8
;
10091 case dw_val_class_high_pc
:
10092 switch (DWARF2_ADDR_SIZE
)
10095 return DW_FORM_data1
;
10097 return DW_FORM_data2
;
10099 return DW_FORM_data4
;
10101 return DW_FORM_data8
;
10103 gcc_unreachable ();
10106 case dw_val_class_discr_value
:
10107 return (a
->dw_attr_val
.v
.val_discr_value
.pos
10110 case dw_val_class_discr_list
:
10111 switch (constant_size (size_of_discr_list (AT_discr_list (a
))))
10114 return DW_FORM_block1
;
10116 return DW_FORM_block2
;
10118 return DW_FORM_block4
;
10120 gcc_unreachable ();
10124 gcc_unreachable ();
10128 /* Output the encoding of an attribute value. */
10131 output_value_format (dw_attr_node
*a
)
10133 enum dwarf_form form
= value_format (a
);
10135 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
10138 /* Given a die and id, produce the appropriate abbreviations. */
10141 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
10144 dw_attr_node
*a_attr
;
10146 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
10147 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
10148 dwarf_tag_name (abbrev
->die_tag
));
10150 if (abbrev
->die_child
!= NULL
)
10151 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
10153 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
10155 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
10157 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
10158 dwarf_attr_name (a_attr
->dw_attr
));
10159 output_value_format (a_attr
);
10160 if (value_format (a_attr
) == DW_FORM_implicit_const
)
10162 if (AT_class (a_attr
) == dw_val_class_file_implicit
)
10164 int f
= maybe_emit_file (a_attr
->dw_attr_val
.v
.val_file
);
10165 const char *filename
= a_attr
->dw_attr_val
.v
.val_file
->filename
;
10166 dw2_asm_output_data_sleb128 (f
, "(%s)", filename
);
10169 dw2_asm_output_data_sleb128 (a_attr
->dw_attr_val
.v
.val_int
, NULL
);
10173 dw2_asm_output_data (1, 0, NULL
);
10174 dw2_asm_output_data (1, 0, NULL
);
10178 /* Output the .debug_abbrev section which defines the DIE abbreviation
10182 output_abbrev_section (void)
10184 unsigned int abbrev_id
;
10187 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
10188 if (abbrev_id
!= 0)
10189 output_die_abbrevs (abbrev_id
, abbrev
);
10191 /* Terminate the table. */
10192 dw2_asm_output_data (1, 0, NULL
);
10195 /* Return a new location list, given the begin and end range, and the
10198 static inline dw_loc_list_ref
10199 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, var_loc_view vbegin
,
10200 const char *end
, var_loc_view vend
,
10201 const char *section
)
10203 dw_loc_list_ref retlist
= ggc_cleared_alloc
<dw_loc_list_node
> ();
10205 retlist
->begin
= begin
;
10206 retlist
->begin_entry
= NULL
;
10207 retlist
->end
= end
;
10208 retlist
->end_entry
= NULL
;
10209 retlist
->expr
= expr
;
10210 retlist
->section
= section
;
10211 retlist
->vbegin
= vbegin
;
10212 retlist
->vend
= vend
;
10217 /* Return true iff there's any nonzero view number in the loc list.
10219 ??? When views are not enabled, we'll often extend a single range
10220 to the entire function, so that we emit a single location
10221 expression rather than a location list. With views, even with a
10222 single range, we'll output a list if start or end have a nonzero
10223 view. If we change this, we may want to stop splitting a single
10224 range in dw_loc_list just because of a nonzero view, even if it
10225 straddles across hot/cold partitions. */
10228 loc_list_has_views (dw_loc_list_ref list
)
10230 if (!debug_variable_location_views
)
10233 for (dw_loc_list_ref loc
= list
;
10234 loc
!= NULL
; loc
= loc
->dw_loc_next
)
10235 if (!ZERO_VIEW_P (loc
->vbegin
) || !ZERO_VIEW_P (loc
->vend
))
10241 /* Generate a new internal symbol for this location list node, if it
10242 hasn't got one yet. */
10245 gen_llsym (dw_loc_list_ref list
)
10247 gcc_assert (!list
->ll_symbol
);
10248 list
->ll_symbol
= gen_internal_sym ("LLST");
10250 if (!loc_list_has_views (list
))
10253 if (dwarf2out_locviews_in_attribute ())
10255 /* Use the same label_num for the view list. */
10257 list
->vl_symbol
= gen_internal_sym ("LVUS");
10260 list
->vl_symbol
= list
->ll_symbol
;
10263 /* Generate a symbol for the list, but only if we really want to emit
10267 maybe_gen_llsym (dw_loc_list_ref list
)
10269 if (!list
|| (!list
->dw_loc_next
&& !loc_list_has_views (list
)))
10275 /* Determine whether or not to skip loc_list entry CURR. If SIZEP is
10276 NULL, don't consider size of the location expression. If we're not
10277 to skip it, and SIZEP is non-null, store the size of CURR->expr's
10278 representation in *SIZEP. */
10281 skip_loc_list_entry (dw_loc_list_ref curr
, unsigned long *sizep
= NULL
)
10283 /* Don't output an entry that starts and ends at the same address. */
10284 if (strcmp (curr
->begin
, curr
->end
) == 0
10285 && curr
->vbegin
== curr
->vend
&& !curr
->force
)
10291 unsigned long size
= size_of_locs (curr
->expr
);
10293 /* If the expression is too large, drop it on the floor. We could
10294 perhaps put it into DW_TAG_dwarf_procedure and refer to that
10295 in the expression, but >= 64KB expressions for a single value
10296 in a single range are unlikely very useful. */
10297 if (dwarf_version
< 5 && size
> 0xffff)
10305 /* Output a view pair loclist entry for CURR, if it requires one. */
10308 dwarf2out_maybe_output_loclist_view_pair (dw_loc_list_ref curr
)
10310 if (!dwarf2out_locviews_in_loclist ())
10313 if (ZERO_VIEW_P (curr
->vbegin
) && ZERO_VIEW_P (curr
->vend
))
10316 #ifdef DW_LLE_view_pair
10317 dw2_asm_output_data (1, DW_LLE_view_pair
, "DW_LLE_view_pair");
10319 if (dwarf2out_as_locview_support
)
10321 if (ZERO_VIEW_P (curr
->vbegin
))
10322 dw2_asm_output_data_uleb128 (0, "Location view begin");
10325 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10326 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vbegin
);
10327 dw2_asm_output_symname_uleb128 (label
, "Location view begin");
10330 if (ZERO_VIEW_P (curr
->vend
))
10331 dw2_asm_output_data_uleb128 (0, "Location view end");
10334 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10335 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vend
);
10336 dw2_asm_output_symname_uleb128 (label
, "Location view end");
10341 dw2_asm_output_data_uleb128 (curr
->vbegin
, "Location view begin");
10342 dw2_asm_output_data_uleb128 (curr
->vend
, "Location view end");
10344 #endif /* DW_LLE_view_pair */
10349 /* Output the location list given to us. */
10352 output_loc_list (dw_loc_list_ref list_head
)
10354 int vcount
= 0, lcount
= 0;
10356 if (list_head
->emitted
)
10358 list_head
->emitted
= true;
10360 if (list_head
->vl_symbol
&& dwarf2out_locviews_in_attribute ())
10362 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->vl_symbol
);
10364 for (dw_loc_list_ref curr
= list_head
; curr
!= NULL
;
10365 curr
= curr
->dw_loc_next
)
10367 unsigned long size
;
10369 if (skip_loc_list_entry (curr
, &size
))
10374 /* ?? dwarf_split_debug_info? */
10375 if (dwarf2out_as_locview_support
)
10377 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10379 if (!ZERO_VIEW_P (curr
->vbegin
))
10381 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vbegin
);
10382 dw2_asm_output_symname_uleb128 (label
,
10383 "View list begin (%s)",
10384 list_head
->vl_symbol
);
10387 dw2_asm_output_data_uleb128 (0,
10388 "View list begin (%s)",
10389 list_head
->vl_symbol
);
10391 if (!ZERO_VIEW_P (curr
->vend
))
10393 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vend
);
10394 dw2_asm_output_symname_uleb128 (label
,
10395 "View list end (%s)",
10396 list_head
->vl_symbol
);
10399 dw2_asm_output_data_uleb128 (0,
10400 "View list end (%s)",
10401 list_head
->vl_symbol
);
10405 dw2_asm_output_data_uleb128 (curr
->vbegin
,
10406 "View list begin (%s)",
10407 list_head
->vl_symbol
);
10408 dw2_asm_output_data_uleb128 (curr
->vend
,
10409 "View list end (%s)",
10410 list_head
->vl_symbol
);
10415 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
10417 const char *last_section
= NULL
;
10418 const char *base_label
= NULL
;
10420 /* Walk the location list, and output each range + expression. */
10421 for (dw_loc_list_ref curr
= list_head
; curr
!= NULL
;
10422 curr
= curr
->dw_loc_next
)
10424 unsigned long size
;
10426 /* Skip this entry? If we skip it here, we must skip it in the
10427 view list above as well. */
10428 if (skip_loc_list_entry (curr
, &size
))
10433 if (dwarf_version
>= 5)
10435 if (dwarf_split_debug_info
&& HAVE_AS_LEB128
)
10437 dwarf2out_maybe_output_loclist_view_pair (curr
);
10438 /* For -gsplit-dwarf, emit DW_LLE_startx_length, which has
10439 uleb128 index into .debug_addr and uleb128 length. */
10440 dw2_asm_output_data (1, DW_LLE_startx_length
,
10441 "DW_LLE_startx_length (%s)",
10442 list_head
->ll_symbol
);
10443 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10444 "Location list range start index "
10445 "(%s)", curr
->begin
);
10446 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
10447 "Location list length (%s)",
10448 list_head
->ll_symbol
);
10450 else if (dwarf_split_debug_info
)
10452 dwarf2out_maybe_output_loclist_view_pair (curr
);
10453 /* For -gsplit-dwarf without usable .uleb128 support, emit
10454 DW_LLE_startx_endx, which has two uleb128 indexes into
10456 dw2_asm_output_data (1, DW_LLE_startx_endx
,
10457 "DW_LLE_startx_endx (%s)",
10458 list_head
->ll_symbol
);
10459 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10460 "Location list range start index "
10461 "(%s)", curr
->begin
);
10462 dw2_asm_output_data_uleb128 (curr
->end_entry
->index
,
10463 "Location list range end index "
10464 "(%s)", curr
->end
);
10466 else if (!have_multiple_function_sections
&& HAVE_AS_LEB128
)
10468 dwarf2out_maybe_output_loclist_view_pair (curr
);
10469 /* If all code is in .text section, the base address is
10470 already provided by the CU attributes. Use
10471 DW_LLE_offset_pair where both addresses are uleb128 encoded
10472 offsets against that base. */
10473 dw2_asm_output_data (1, DW_LLE_offset_pair
,
10474 "DW_LLE_offset_pair (%s)",
10475 list_head
->ll_symbol
);
10476 dw2_asm_output_delta_uleb128 (curr
->begin
, curr
->section
,
10477 "Location list begin address (%s)",
10478 list_head
->ll_symbol
);
10479 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->section
,
10480 "Location list end address (%s)",
10481 list_head
->ll_symbol
);
10483 else if (HAVE_AS_LEB128
)
10485 /* Otherwise, find out how many consecutive entries could share
10486 the same base entry. If just one, emit DW_LLE_start_length,
10487 otherwise emit DW_LLE_base_address for the base address
10488 followed by a series of DW_LLE_offset_pair. */
10489 if (last_section
== NULL
|| curr
->section
!= last_section
)
10491 dw_loc_list_ref curr2
;
10492 for (curr2
= curr
->dw_loc_next
; curr2
!= NULL
;
10493 curr2
= curr2
->dw_loc_next
)
10495 if (strcmp (curr2
->begin
, curr2
->end
) == 0
10500 if (curr2
== NULL
|| curr
->section
!= curr2
->section
)
10501 last_section
= NULL
;
10504 last_section
= curr
->section
;
10505 base_label
= curr
->begin
;
10506 dw2_asm_output_data (1, DW_LLE_base_address
,
10507 "DW_LLE_base_address (%s)",
10508 list_head
->ll_symbol
);
10509 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, base_label
,
10510 "Base address (%s)",
10511 list_head
->ll_symbol
);
10514 /* Only one entry with the same base address. Use
10515 DW_LLE_start_length with absolute address and uleb128
10517 if (last_section
== NULL
)
10519 dwarf2out_maybe_output_loclist_view_pair (curr
);
10520 dw2_asm_output_data (1, DW_LLE_start_length
,
10521 "DW_LLE_start_length (%s)",
10522 list_head
->ll_symbol
);
10523 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10524 "Location list begin address (%s)",
10525 list_head
->ll_symbol
);
10526 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
10527 "Location list length "
10528 "(%s)", list_head
->ll_symbol
);
10530 /* Otherwise emit DW_LLE_offset_pair, relative to above emitted
10531 DW_LLE_base_address. */
10534 dwarf2out_maybe_output_loclist_view_pair (curr
);
10535 dw2_asm_output_data (1, DW_LLE_offset_pair
,
10536 "DW_LLE_offset_pair (%s)",
10537 list_head
->ll_symbol
);
10538 dw2_asm_output_delta_uleb128 (curr
->begin
, base_label
,
10539 "Location list begin address "
10540 "(%s)", list_head
->ll_symbol
);
10541 dw2_asm_output_delta_uleb128 (curr
->end
, base_label
,
10542 "Location list end address "
10543 "(%s)", list_head
->ll_symbol
);
10546 /* The assembler does not support .uleb128 directive. Emit
10547 DW_LLE_start_end with a pair of absolute addresses. */
10550 dwarf2out_maybe_output_loclist_view_pair (curr
);
10551 dw2_asm_output_data (1, DW_LLE_start_end
,
10552 "DW_LLE_start_end (%s)",
10553 list_head
->ll_symbol
);
10554 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10555 "Location list begin address (%s)",
10556 list_head
->ll_symbol
);
10557 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10558 "Location list end address (%s)",
10559 list_head
->ll_symbol
);
10562 else if (dwarf_split_debug_info
)
10564 /* For -gsplit-dwarf -gdwarf-{2,3,4} emit index into .debug_addr
10565 and 4 byte length. */
10566 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
10567 "Location list start/length entry (%s)",
10568 list_head
->ll_symbol
);
10569 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10570 "Location list range start index (%s)",
10572 /* The length field is 4 bytes. If we ever need to support
10573 an 8-byte length, we can add a new DW_LLE code or fall back
10574 to DW_LLE_GNU_start_end_entry. */
10575 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
10576 "Location list range length (%s)",
10577 list_head
->ll_symbol
);
10579 else if (!have_multiple_function_sections
)
10581 /* Pair of relative addresses against start of text section. */
10582 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
10583 "Location list begin address (%s)",
10584 list_head
->ll_symbol
);
10585 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
10586 "Location list end address (%s)",
10587 list_head
->ll_symbol
);
10591 /* Pair of absolute addresses. */
10592 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10593 "Location list begin address (%s)",
10594 list_head
->ll_symbol
);
10595 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10596 "Location list end address (%s)",
10597 list_head
->ll_symbol
);
10600 /* Output the block length for this list of location operations. */
10601 if (dwarf_version
>= 5)
10602 dw2_asm_output_data_uleb128 (size
, "Location expression size");
10605 gcc_assert (size
<= 0xffff);
10606 dw2_asm_output_data (2, size
, "Location expression size");
10609 output_loc_sequence (curr
->expr
, -1);
10612 /* And finally list termination. */
10613 if (dwarf_version
>= 5)
10614 dw2_asm_output_data (1, DW_LLE_end_of_list
,
10615 "DW_LLE_end_of_list (%s)", list_head
->ll_symbol
);
10616 else if (dwarf_split_debug_info
)
10617 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
10618 "Location list terminator (%s)",
10619 list_head
->ll_symbol
);
10622 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10623 "Location list terminator begin (%s)",
10624 list_head
->ll_symbol
);
10625 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10626 "Location list terminator end (%s)",
10627 list_head
->ll_symbol
);
10630 gcc_assert (!list_head
->vl_symbol
10631 || vcount
== lcount
* (dwarf2out_locviews_in_attribute () ? 1 : 0));
10634 /* Output a range_list offset into the .debug_ranges or .debug_rnglists
10635 section. Emit a relocated reference if val_entry is NULL, otherwise,
10636 emit an indirect reference. */
10639 output_range_list_offset (dw_attr_node
*a
)
10641 const char *name
= dwarf_attr_name (a
->dw_attr
);
10643 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
10645 if (dwarf_version
>= 5)
10647 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
10648 dw2_asm_output_offset (dwarf_offset_size
, r
->label
,
10649 debug_ranges_section
, "%s", name
);
10653 char *p
= strchr (ranges_section_label
, '\0');
10654 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
10655 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
);
10656 dw2_asm_output_offset (dwarf_offset_size
, ranges_section_label
,
10657 debug_ranges_section
, "%s", name
);
10661 else if (dwarf_version
>= 5)
10663 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
10664 gcc_assert (rnglist_idx
);
10665 dw2_asm_output_data_uleb128 (r
->idx
, "%s", name
);
10668 dw2_asm_output_data (dwarf_offset_size
,
10669 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
,
10670 "%s (offset from %s)", name
, ranges_section_label
);
10673 /* Output the offset into the debug_loc section. */
10676 output_loc_list_offset (dw_attr_node
*a
)
10678 char *sym
= AT_loc_list (a
)->ll_symbol
;
10681 if (!dwarf_split_debug_info
)
10682 dw2_asm_output_offset (dwarf_offset_size
, sym
, debug_loc_section
,
10683 "%s", dwarf_attr_name (a
->dw_attr
));
10684 else if (dwarf_version
>= 5)
10686 gcc_assert (AT_loc_list (a
)->num_assigned
);
10687 dw2_asm_output_data_uleb128 (AT_loc_list (a
)->hash
, "%s (%s)",
10688 dwarf_attr_name (a
->dw_attr
),
10692 dw2_asm_output_delta (dwarf_offset_size
, sym
, loc_section_label
,
10693 "%s", dwarf_attr_name (a
->dw_attr
));
10696 /* Output the offset into the debug_loc section. */
10699 output_view_list_offset (dw_attr_node
*a
)
10701 char *sym
= (*AT_loc_list_ptr (a
))->vl_symbol
;
10704 if (dwarf_split_debug_info
)
10705 dw2_asm_output_delta (dwarf_offset_size
, sym
, loc_section_label
,
10706 "%s", dwarf_attr_name (a
->dw_attr
));
10708 dw2_asm_output_offset (dwarf_offset_size
, sym
, debug_loc_section
,
10709 "%s", dwarf_attr_name (a
->dw_attr
));
10712 /* Output an attribute's index or value appropriately. */
10715 output_attr_index_or_value (dw_attr_node
*a
)
10717 const char *name
= dwarf_attr_name (a
->dw_attr
);
10719 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
10721 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
10724 switch (AT_class (a
))
10726 case dw_val_class_addr
:
10727 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
10729 case dw_val_class_high_pc
:
10730 case dw_val_class_lbl_id
:
10731 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
10734 gcc_unreachable ();
10738 /* Output a type signature. */
10741 output_signature (const char *sig
, const char *name
)
10745 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
10746 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
10749 /* Output a discriminant value. */
10752 output_discr_value (dw_discr_value
*discr_value
, const char *name
)
10754 if (discr_value
->pos
)
10755 dw2_asm_output_data_uleb128 (discr_value
->v
.uval
, "%s", name
);
10757 dw2_asm_output_data_sleb128 (discr_value
->v
.sval
, "%s", name
);
10760 /* Output the DIE and its attributes. Called recursively to generate
10761 the definitions of each child DIE. */
10764 output_die (dw_die_ref die
)
10768 unsigned long size
;
10771 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
10772 (unsigned long)die
->die_offset
,
10773 dwarf_tag_name (die
->die_tag
));
10775 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
10777 const char *name
= dwarf_attr_name (a
->dw_attr
);
10779 switch (AT_class (a
))
10781 case dw_val_class_addr
:
10782 output_attr_index_or_value (a
);
10785 case dw_val_class_offset
:
10786 dw2_asm_output_data (dwarf_offset_size
, a
->dw_attr_val
.v
.val_offset
,
10790 case dw_val_class_range_list
:
10791 output_range_list_offset (a
);
10794 case dw_val_class_loc
:
10795 size
= size_of_locs (AT_loc (a
));
10797 /* Output the block length for this list of location operations. */
10798 if (dwarf_version
>= 4)
10799 dw2_asm_output_data_uleb128 (size
, "%s", name
);
10801 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
10803 output_loc_sequence (AT_loc (a
), -1);
10806 case dw_val_class_const
:
10807 /* ??? It would be slightly more efficient to use a scheme like is
10808 used for unsigned constants below, but gdb 4.x does not sign
10809 extend. Gdb 5.x does sign extend. */
10810 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
10813 case dw_val_class_unsigned_const
:
10815 int csize
= constant_size (AT_unsigned (a
));
10816 if (dwarf_version
== 3
10817 && a
->dw_attr
== DW_AT_data_member_location
10819 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
10821 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
10825 case dw_val_class_symview
:
10828 if (symview_upper_bound
<= 0xff)
10830 else if (symview_upper_bound
<= 0xffff)
10832 else if (symview_upper_bound
<= 0xffffffff)
10836 dw2_asm_output_addr (vsize
, a
->dw_attr_val
.v
.val_symbolic_view
,
10841 case dw_val_class_const_implicit
:
10842 if (flag_debug_asm
)
10843 fprintf (asm_out_file
, "\t\t\t%s %s ("
10844 HOST_WIDE_INT_PRINT_DEC
")\n",
10845 ASM_COMMENT_START
, name
, AT_int (a
));
10848 case dw_val_class_unsigned_const_implicit
:
10849 if (flag_debug_asm
)
10850 fprintf (asm_out_file
, "\t\t\t%s %s ("
10851 HOST_WIDE_INT_PRINT_HEX
")\n",
10852 ASM_COMMENT_START
, name
, AT_unsigned (a
));
10855 case dw_val_class_const_double
:
10857 unsigned HOST_WIDE_INT first
, second
;
10859 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
10860 dw2_asm_output_data (1,
10861 HOST_BITS_PER_DOUBLE_INT
10862 / HOST_BITS_PER_CHAR
,
10865 if (WORDS_BIG_ENDIAN
)
10867 first
= a
->dw_attr_val
.v
.val_double
.high
;
10868 second
= a
->dw_attr_val
.v
.val_double
.low
;
10872 first
= a
->dw_attr_val
.v
.val_double
.low
;
10873 second
= a
->dw_attr_val
.v
.val_double
.high
;
10876 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10877 first
, "%s", name
);
10878 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10883 case dw_val_class_wide_int
:
10886 int len
= get_full_len (*a
->dw_attr_val
.v
.val_wide
);
10887 int l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
10888 if (len
* HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
10889 dw2_asm_output_data (1, get_full_len (*a
->dw_attr_val
.v
.val_wide
)
10892 if (WORDS_BIG_ENDIAN
)
10893 for (i
= len
- 1; i
>= 0; --i
)
10895 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10900 for (i
= 0; i
< len
; ++i
)
10902 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10909 case dw_val_class_vec
:
10911 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
10912 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
10916 dw2_asm_output_data (constant_size (len
* elt_size
),
10917 len
* elt_size
, "%s", name
);
10918 if (elt_size
> sizeof (HOST_WIDE_INT
))
10923 for (i
= 0, p
= (unsigned char *) a
->dw_attr_val
.v
.val_vec
.array
;
10925 i
++, p
+= elt_size
)
10926 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
10927 "fp or vector constant word %u", i
);
10931 case dw_val_class_flag
:
10932 if (dwarf_version
>= 4)
10934 /* Currently all add_AT_flag calls pass in 1 as last argument,
10935 so DW_FORM_flag_present can be used. If that ever changes,
10936 we'll need to use DW_FORM_flag and have some optimization
10937 in build_abbrev_table that will change those to
10938 DW_FORM_flag_present if it is set to 1 in all DIEs using
10939 the same abbrev entry. */
10940 gcc_assert (AT_flag (a
) == 1);
10941 if (flag_debug_asm
)
10942 fprintf (asm_out_file
, "\t\t\t%s %s\n",
10943 ASM_COMMENT_START
, name
);
10946 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
10949 case dw_val_class_loc_list
:
10950 output_loc_list_offset (a
);
10953 case dw_val_class_view_list
:
10954 output_view_list_offset (a
);
10957 case dw_val_class_die_ref
:
10958 if (AT_ref_external (a
))
10960 if (AT_ref (a
)->comdat_type_p
)
10962 comdat_type_node
*type_node
10963 = AT_ref (a
)->die_id
.die_type_node
;
10965 gcc_assert (type_node
);
10966 output_signature (type_node
->signature
, name
);
10970 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
10974 /* In DWARF2, DW_FORM_ref_addr is sized by target address
10975 length, whereas in DWARF3 it's always sized as an
10977 if (dwarf_version
== 2)
10978 size
= DWARF2_ADDR_SIZE
;
10980 size
= dwarf_offset_size
;
10981 /* ??? We cannot unconditionally output die_offset if
10982 non-zero - others might create references to those
10984 And we do not clear its DIE offset after outputting it
10985 (and the label refers to the actual DIEs, not the
10986 DWARF CU unit header which is when using label + offset
10987 would be the correct thing to do).
10988 ??? This is the reason for the with_offset flag. */
10989 if (AT_ref (a
)->with_offset
)
10990 dw2_asm_output_offset (size
, sym
, AT_ref (a
)->die_offset
,
10991 debug_info_section
, "%s", name
);
10993 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
10999 gcc_assert (AT_ref (a
)->die_offset
);
11000 dw2_asm_output_data (dwarf_offset_size
, AT_ref (a
)->die_offset
,
11005 case dw_val_class_fde_ref
:
11007 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
11009 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
11010 a
->dw_attr_val
.v
.val_fde_index
* 2);
11011 dw2_asm_output_offset (dwarf_offset_size
, l1
, debug_frame_section
,
11016 case dw_val_class_vms_delta
:
11017 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
11018 dw2_asm_output_vms_delta (dwarf_offset_size
,
11019 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
11022 dw2_asm_output_delta (dwarf_offset_size
,
11023 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
11028 case dw_val_class_lbl_id
:
11029 output_attr_index_or_value (a
);
11032 case dw_val_class_lineptr
:
11033 dw2_asm_output_offset (dwarf_offset_size
, AT_lbl (a
),
11034 debug_line_section
, "%s", name
);
11037 case dw_val_class_macptr
:
11038 dw2_asm_output_offset (dwarf_offset_size
, AT_lbl (a
),
11039 debug_macinfo_section
, "%s", name
);
11042 case dw_val_class_loclistsptr
:
11043 dw2_asm_output_offset (dwarf_offset_size
, AT_lbl (a
),
11044 debug_loc_section
, "%s", name
);
11047 case dw_val_class_str
:
11048 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
11049 dw2_asm_output_offset (dwarf_offset_size
,
11050 a
->dw_attr_val
.v
.val_str
->label
,
11052 "%s: \"%s\"", name
, AT_string (a
));
11053 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_line_strp
)
11054 dw2_asm_output_offset (dwarf_offset_size
,
11055 a
->dw_attr_val
.v
.val_str
->label
,
11056 debug_line_str_section
,
11057 "%s: \"%s\"", name
, AT_string (a
));
11058 else if (a
->dw_attr_val
.v
.val_str
->form
== dwarf_FORM (DW_FORM_strx
))
11059 dw2_asm_output_data_uleb128 (AT_index (a
),
11060 "%s: \"%s\"", name
, AT_string (a
));
11062 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
11065 case dw_val_class_file
:
11067 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
11069 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
11070 a
->dw_attr_val
.v
.val_file
->filename
);
11074 case dw_val_class_file_implicit
:
11075 if (flag_debug_asm
)
11076 fprintf (asm_out_file
, "\t\t\t%s %s (%d, %s)\n",
11077 ASM_COMMENT_START
, name
,
11078 maybe_emit_file (a
->dw_attr_val
.v
.val_file
),
11079 a
->dw_attr_val
.v
.val_file
->filename
);
11082 case dw_val_class_data8
:
11086 for (i
= 0; i
< 8; i
++)
11087 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
11088 i
== 0 ? "%s" : NULL
, name
);
11092 case dw_val_class_high_pc
:
11093 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
11094 get_AT_low_pc (die
), "DW_AT_high_pc");
11097 case dw_val_class_discr_value
:
11098 output_discr_value (&a
->dw_attr_val
.v
.val_discr_value
, name
);
11101 case dw_val_class_discr_list
:
11103 dw_discr_list_ref list
= AT_discr_list (a
);
11104 const int size
= size_of_discr_list (list
);
11106 /* This is a block, so output its length first. */
11107 dw2_asm_output_data (constant_size (size
), size
,
11108 "%s: block size", name
);
11110 for (; list
!= NULL
; list
= list
->dw_discr_next
)
11112 /* One byte for the discriminant value descriptor, and then as
11113 many LEB128 numbers as required. */
11114 if (list
->dw_discr_range
)
11115 dw2_asm_output_data (1, DW_DSC_range
,
11116 "%s: DW_DSC_range", name
);
11118 dw2_asm_output_data (1, DW_DSC_label
,
11119 "%s: DW_DSC_label", name
);
11121 output_discr_value (&list
->dw_discr_lower_bound
, name
);
11122 if (list
->dw_discr_range
)
11123 output_discr_value (&list
->dw_discr_upper_bound
, name
);
11129 gcc_unreachable ();
11133 FOR_EACH_CHILD (die
, c
, output_die (c
));
11135 /* Add null byte to terminate sibling list. */
11136 if (die
->die_child
!= NULL
)
11137 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
11138 (unsigned long) die
->die_offset
);
11141 /* Output the dwarf version number. */
11144 output_dwarf_version ()
11146 /* ??? For now, if -gdwarf-6 is specified, we output version 5 with
11147 views in loclist. That will change eventually. */
11148 if (dwarf_version
== 6)
11153 warning (0, "%<-gdwarf-6%> is output as version 5 with "
11154 "incompatibilities");
11157 dw2_asm_output_data (2, 5, "DWARF version number");
11160 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
11163 /* Output the compilation unit that appears at the beginning of the
11164 .debug_info section, and precedes the DIE descriptions. */
11167 output_compilation_unit_header (enum dwarf_unit_type ut
)
11169 if (!XCOFF_DEBUGGING_INFO
)
11171 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
11172 dw2_asm_output_data (4, 0xffffffff,
11173 "Initial length escape value indicating 64-bit DWARF extension");
11174 dw2_asm_output_data (dwarf_offset_size
,
11175 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
11176 "Length of Compilation Unit Info");
11179 output_dwarf_version ();
11180 if (dwarf_version
>= 5)
11185 case DW_UT_compile
: name
= "DW_UT_compile"; break;
11186 case DW_UT_type
: name
= "DW_UT_type"; break;
11187 case DW_UT_split_compile
: name
= "DW_UT_split_compile"; break;
11188 case DW_UT_split_type
: name
= "DW_UT_split_type"; break;
11189 default: gcc_unreachable ();
11191 dw2_asm_output_data (1, ut
, "%s", name
);
11192 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11194 dw2_asm_output_offset (dwarf_offset_size
, abbrev_section_label
,
11195 debug_abbrev_section
,
11196 "Offset Into Abbrev. Section");
11197 if (dwarf_version
< 5)
11198 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11201 /* Output the compilation unit DIE and its children. */
11204 output_comp_unit (dw_die_ref die
, int output_if_empty
,
11205 const unsigned char *dwo_id
)
11207 const char *secname
, *oldsym
;
11210 /* Unless we are outputting main CU, we may throw away empty ones. */
11211 if (!output_if_empty
&& die
->die_child
== NULL
)
11214 /* Even if there are no children of this DIE, we must output the information
11215 about the compilation unit. Otherwise, on an empty translation unit, we
11216 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
11217 will then complain when examining the file. First mark all the DIEs in
11218 this CU so we know which get local refs. */
11221 external_ref_hash_type
*extern_map
= optimize_external_refs (die
);
11223 /* For now, optimize only the main CU, in order to optimize the rest
11224 we'd need to see all of them earlier. Leave the rest for post-linking
11226 if (die
== comp_unit_die ())
11227 abbrev_opt_start
= vec_safe_length (abbrev_die_table
);
11229 build_abbrev_table (die
, extern_map
);
11231 optimize_abbrev_table ();
11235 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11236 next_die_offset
= (dwo_id
11237 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11238 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
11239 calc_die_sizes (die
);
11241 oldsym
= die
->die_id
.die_symbol
;
11242 if (oldsym
&& die
->comdat_type_p
)
11244 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
11246 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
11248 die
->die_id
.die_symbol
= NULL
;
11249 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11253 switch_to_section (debug_info_section
);
11254 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
11255 info_section_emitted
= true;
11258 /* For LTO cross unit DIE refs we want a symbol on the start of the
11259 debuginfo section, not on the CU DIE. */
11260 if ((flag_generate_lto
|| flag_generate_offload
) && oldsym
)
11262 /* ??? No way to get visibility assembled without a decl. */
11263 tree decl
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
11264 get_identifier (oldsym
), char_type_node
);
11265 TREE_PUBLIC (decl
) = true;
11266 TREE_STATIC (decl
) = true;
11267 DECL_ARTIFICIAL (decl
) = true;
11268 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
11269 DECL_VISIBILITY_SPECIFIED (decl
) = true;
11270 targetm
.asm_out
.assemble_visibility (decl
, VISIBILITY_HIDDEN
);
11271 #ifdef ASM_WEAKEN_LABEL
11272 /* We prefer a .weak because that handles duplicates from duplicate
11273 archive members in a graceful way. */
11274 ASM_WEAKEN_LABEL (asm_out_file
, oldsym
);
11276 targetm
.asm_out
.globalize_label (asm_out_file
, oldsym
);
11278 ASM_OUTPUT_LABEL (asm_out_file
, oldsym
);
11281 /* Output debugging information. */
11282 output_compilation_unit_header (dwo_id
11283 ? DW_UT_split_compile
: DW_UT_compile
);
11284 if (dwarf_version
>= 5)
11286 if (dwo_id
!= NULL
)
11287 for (int i
= 0; i
< 8; i
++)
11288 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
11292 /* Leave the marks on the main CU, so we can check them in
11293 output_pubnames. */
11297 die
->die_id
.die_symbol
= oldsym
;
11301 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
11302 and .debug_pubtypes. This is configured per-target, but can be
11303 overridden by the -gpubnames or -gno-pubnames options. */
11306 want_pubnames (void)
11308 if (debug_info_level
<= DINFO_LEVEL_TERSE
11309 /* Names and types go to the early debug part only. */
11312 if (debug_generate_pub_sections
!= -1)
11313 return debug_generate_pub_sections
;
11314 return targetm
.want_debug_pub_sections
;
11317 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
11320 add_AT_pubnames (dw_die_ref die
)
11322 if (want_pubnames ())
11323 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
11326 /* Add a string attribute value to a skeleton DIE. */
11329 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
11333 struct indirect_string_node
*node
;
11335 if (! skeleton_debug_str_hash
)
11336 skeleton_debug_str_hash
11337 = hash_table
<indirect_string_hasher
>::create_ggc (10);
11339 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
11340 find_string_form (node
);
11341 if (node
->form
== dwarf_FORM (DW_FORM_strx
))
11342 node
->form
= DW_FORM_strp
;
11344 attr
.dw_attr
= attr_kind
;
11345 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
11346 attr
.dw_attr_val
.val_entry
= NULL
;
11347 attr
.dw_attr_val
.v
.val_str
= node
;
11348 add_dwarf_attr (die
, &attr
);
11351 /* Helper function to generate top-level dies for skeleton debug_info and
11355 add_top_level_skeleton_die_attrs (dw_die_ref die
)
11357 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
11358 const char *comp_dir
= comp_dir_string ();
11360 add_skeleton_AT_string (die
, dwarf_AT (DW_AT_dwo_name
), dwo_file_name
);
11361 if (comp_dir
!= NULL
)
11362 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
11363 add_AT_pubnames (die
);
11364 if (addr_index_table
!= NULL
&& addr_index_table
->size () > 0)
11365 add_AT_lineptr (die
, dwarf_AT (DW_AT_addr_base
), debug_addr_section_label
);
11368 /* Output skeleton debug sections that point to the dwo file. */
11371 output_skeleton_debug_sections (dw_die_ref comp_unit
,
11372 const unsigned char *dwo_id
)
11374 /* These attributes will be found in the full debug_info section. */
11375 remove_AT (comp_unit
, DW_AT_producer
);
11376 remove_AT (comp_unit
, DW_AT_language
);
11378 switch_to_section (debug_skeleton_info_section
);
11379 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
11381 /* Produce the skeleton compilation-unit header. This one differs enough from
11382 a normal CU header that it's better not to call output_compilation_unit
11384 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
11385 dw2_asm_output_data (4, 0xffffffff,
11386 "Initial length escape value indicating 64-bit "
11387 "DWARF extension");
11389 dw2_asm_output_data (dwarf_offset_size
,
11390 DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11391 - DWARF_INITIAL_LENGTH_SIZE
11392 + size_of_die (comp_unit
),
11393 "Length of Compilation Unit Info");
11394 output_dwarf_version ();
11395 if (dwarf_version
>= 5)
11397 dw2_asm_output_data (1, DW_UT_skeleton
, "DW_UT_skeleton");
11398 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11400 dw2_asm_output_offset (dwarf_offset_size
, debug_skeleton_abbrev_section_label
,
11401 debug_skeleton_abbrev_section
,
11402 "Offset Into Abbrev. Section");
11403 if (dwarf_version
< 5)
11404 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11406 for (int i
= 0; i
< 8; i
++)
11407 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
11409 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
11410 output_die (comp_unit
);
11412 /* Build the skeleton debug_abbrev section. */
11413 switch_to_section (debug_skeleton_abbrev_section
);
11414 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
11416 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
11418 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
11421 /* Output a comdat type unit DIE and its children. */
11424 output_comdat_type_unit (comdat_type_node
*node
,
11425 bool early_lto_debug ATTRIBUTE_UNUSED
)
11427 const char *secname
;
11430 #if defined (OBJECT_FORMAT_ELF)
11434 /* First mark all the DIEs in this CU so we know which get local refs. */
11435 mark_dies (node
->root_die
);
11437 external_ref_hash_type
*extern_map
= optimize_external_refs (node
->root_die
);
11439 build_abbrev_table (node
->root_die
, extern_map
);
11444 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11445 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
11446 calc_die_sizes (node
->root_die
);
11448 #if defined (OBJECT_FORMAT_ELF)
11449 if (dwarf_version
>= 5)
11451 if (!dwarf_split_debug_info
)
11452 secname
= early_lto_debug
? DEBUG_LTO_INFO_SECTION
: DEBUG_INFO_SECTION
;
11454 secname
= (early_lto_debug
11455 ? DEBUG_LTO_DWO_INFO_SECTION
: DEBUG_DWO_INFO_SECTION
);
11457 else if (!dwarf_split_debug_info
)
11458 secname
= early_lto_debug
? ".gnu.debuglto_.debug_types" : ".debug_types";
11460 secname
= (early_lto_debug
11461 ? ".gnu.debuglto_.debug_types.dwo" : ".debug_types.dwo");
11463 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11464 sprintf (tmp
, dwarf_version
>= 5 ? "wi." : "wt.");
11465 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11466 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11467 comdat_key
= get_identifier (tmp
);
11468 targetm
.asm_out
.named_section (secname
,
11469 SECTION_DEBUG
| SECTION_LINKONCE
,
11472 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11473 sprintf (tmp
, (dwarf_version
>= 5
11474 ? ".gnu.linkonce.wi." : ".gnu.linkonce.wt."));
11475 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11476 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11478 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11481 /* Output debugging information. */
11482 output_compilation_unit_header (dwarf_split_debug_info
11483 ? DW_UT_split_type
: DW_UT_type
);
11484 output_signature (node
->signature
, "Type Signature");
11485 dw2_asm_output_data (dwarf_offset_size
, node
->type_die
->die_offset
,
11486 "Offset to Type DIE");
11487 output_die (node
->root_die
);
11489 unmark_dies (node
->root_die
);
11492 /* Return the DWARF2/3 pubname associated with a decl. */
11494 static const char *
11495 dwarf2_name (tree decl
, int scope
)
11497 if (DECL_NAMELESS (decl
))
11499 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
11502 /* Add a new entry to .debug_pubnames if appropriate. */
11505 add_pubname_string (const char *str
, dw_die_ref die
)
11510 e
.name
= xstrdup (str
);
11511 vec_safe_push (pubname_table
, e
);
11515 add_pubname (tree decl
, dw_die_ref die
)
11517 if (!want_pubnames ())
11520 /* Don't add items to the table when we expect that the consumer will have
11521 just read the enclosing die. For example, if the consumer is looking at a
11522 class_member, it will either be inside the class already, or will have just
11523 looked up the class to find the member. Either way, searching the class is
11524 faster than searching the index. */
11525 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
11526 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
11528 const char *name
= dwarf2_name (decl
, 1);
11531 add_pubname_string (name
, die
);
11535 /* Add an enumerator to the pubnames section. */
11538 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
11542 gcc_assert (scope_name
);
11543 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
11545 vec_safe_push (pubname_table
, e
);
11548 /* Add a new entry to .debug_pubtypes if appropriate. */
11551 add_pubtype (tree decl
, dw_die_ref die
)
11555 if (!want_pubnames ())
11558 if ((TREE_PUBLIC (decl
)
11559 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
11560 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
11563 const char *scope_name
= "";
11564 const char *sep
= is_cxx () ? "::" : ".";
11567 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
11568 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
11570 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
11571 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
11572 scope_name
= concat (scope_name
, sep
, NULL
);
11578 name
= type_tag (decl
);
11580 name
= lang_hooks
.dwarf_name (decl
, 1);
11582 /* If we don't have a name for the type, there's no point in adding
11583 it to the table. */
11584 if (name
!= NULL
&& name
[0] != '\0')
11587 e
.name
= concat (scope_name
, name
, NULL
);
11588 vec_safe_push (pubtype_table
, e
);
11591 /* Although it might be more consistent to add the pubinfo for the
11592 enumerators as their dies are created, they should only be added if the
11593 enum type meets the criteria above. So rather than re-check the parent
11594 enum type whenever an enumerator die is created, just output them all
11595 here. This isn't protected by the name conditional because anonymous
11596 enums don't have names. */
11597 if (die
->die_tag
== DW_TAG_enumeration_type
)
11601 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
11606 /* Output a single entry in the pubnames table. */
11609 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
11611 dw_die_ref die
= entry
->die
;
11612 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
11614 dw2_asm_output_data (dwarf_offset_size
, die_offset
, "DIE offset");
11616 if (debug_generate_pub_sections
== 2)
11618 /* This logic follows gdb's method for determining the value of the flag
11620 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
11621 switch (die
->die_tag
)
11623 case DW_TAG_typedef
:
11624 case DW_TAG_base_type
:
11625 case DW_TAG_subrange_type
:
11626 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11627 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11629 case DW_TAG_enumerator
:
11630 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11631 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11633 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11635 case DW_TAG_subprogram
:
11636 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11637 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
11639 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11641 case DW_TAG_constant
:
11642 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11643 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11644 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11646 case DW_TAG_variable
:
11647 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11648 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11649 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11651 case DW_TAG_namespace
:
11652 case DW_TAG_imported_declaration
:
11653 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11655 case DW_TAG_class_type
:
11656 case DW_TAG_interface_type
:
11657 case DW_TAG_structure_type
:
11658 case DW_TAG_union_type
:
11659 case DW_TAG_enumeration_type
:
11660 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11662 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11665 /* An unusual tag. Leave the flag-byte empty. */
11668 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
11669 "GDB-index flags");
11672 dw2_asm_output_nstring (entry
->name
, -1, "external name");
11676 /* Output the public names table used to speed up access to externally
11677 visible names; or the public types table used to find type definitions. */
11680 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
11683 unsigned long pubnames_length
= size_of_pubnames (names
);
11684 pubname_entry
*pub
;
11686 if (!XCOFF_DEBUGGING_INFO
)
11688 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
11689 dw2_asm_output_data (4, 0xffffffff,
11690 "Initial length escape value indicating 64-bit DWARF extension");
11691 dw2_asm_output_data (dwarf_offset_size
, pubnames_length
,
11692 "Pub Info Length");
11695 /* Version number for pubnames/pubtypes is independent of dwarf version. */
11696 dw2_asm_output_data (2, 2, "DWARF pubnames/pubtypes version");
11698 if (dwarf_split_debug_info
)
11699 dw2_asm_output_offset (dwarf_offset_size
, debug_skeleton_info_section_label
,
11700 debug_skeleton_info_section
,
11701 "Offset of Compilation Unit Info");
11703 dw2_asm_output_offset (dwarf_offset_size
, debug_info_section_label
,
11704 debug_info_section
,
11705 "Offset of Compilation Unit Info");
11706 dw2_asm_output_data (dwarf_offset_size
, next_die_offset
,
11707 "Compilation Unit Length");
11709 FOR_EACH_VEC_ELT (*names
, i
, pub
)
11711 if (include_pubname_in_output (names
, pub
))
11713 dw_offset die_offset
= pub
->die
->die_offset
;
11715 /* We shouldn't see pubnames for DIEs outside of the main CU. */
11716 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
11717 gcc_assert (pub
->die
->die_mark
);
11719 /* If we're putting types in their own .debug_types sections,
11720 the .debug_pubtypes table will still point to the compile
11721 unit (not the type unit), so we want to use the offset of
11722 the skeleton DIE (if there is one). */
11723 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
11725 comdat_type_node
*type_node
= pub
->die
->die_id
.die_type_node
;
11727 if (type_node
!= NULL
)
11728 die_offset
= (type_node
->skeleton_die
!= NULL
11729 ? type_node
->skeleton_die
->die_offset
11730 : comp_unit_die ()->die_offset
);
11733 output_pubname (die_offset
, pub
);
11737 dw2_asm_output_data (dwarf_offset_size
, 0, NULL
);
11740 /* Output public names and types tables if necessary. */
11743 output_pubtables (void)
11745 if (!want_pubnames () || !info_section_emitted
)
11748 switch_to_section (debug_pubnames_section
);
11749 output_pubnames (pubname_table
);
11750 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
11751 It shouldn't hurt to emit it always, since pure DWARF2 consumers
11752 simply won't look for the section. */
11753 switch_to_section (debug_pubtypes_section
);
11754 output_pubnames (pubtype_table
);
11758 /* Output the information that goes into the .debug_aranges table.
11759 Namely, define the beginning and ending address range of the
11760 text section generated for this compilation unit. */
11763 output_aranges (void)
11766 unsigned long aranges_length
= size_of_aranges ();
11768 if (!XCOFF_DEBUGGING_INFO
)
11770 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
11771 dw2_asm_output_data (4, 0xffffffff,
11772 "Initial length escape value indicating 64-bit DWARF extension");
11773 dw2_asm_output_data (dwarf_offset_size
, aranges_length
,
11774 "Length of Address Ranges Info");
11777 /* Version number for aranges is still 2, even up to DWARF5. */
11778 dw2_asm_output_data (2, 2, "DWARF aranges version");
11779 if (dwarf_split_debug_info
)
11780 dw2_asm_output_offset (dwarf_offset_size
, debug_skeleton_info_section_label
,
11781 debug_skeleton_info_section
,
11782 "Offset of Compilation Unit Info");
11784 dw2_asm_output_offset (dwarf_offset_size
, debug_info_section_label
,
11785 debug_info_section
,
11786 "Offset of Compilation Unit Info");
11787 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
11788 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
11790 /* We need to align to twice the pointer size here. */
11791 if (DWARF_ARANGES_PAD_SIZE
)
11793 /* Pad using a 2 byte words so that padding is correct for any
11795 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
11796 2 * DWARF2_ADDR_SIZE
);
11797 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
11798 dw2_asm_output_data (2, 0, NULL
);
11801 /* It is necessary not to output these entries if the sections were
11802 not used; if the sections were not used, the length will be 0 and
11803 the address may end up as 0 if the section is discarded by ld
11804 --gc-sections, leaving an invalid (0, 0) entry that can be
11805 confused with the terminator. */
11806 if (switch_text_ranges
)
11808 const char *prev_loc
= text_section_label
;
11812 FOR_EACH_VEC_ELT (*switch_text_ranges
, idx
, loc
)
11815 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, prev_loc
, "Address");
11816 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, loc
, prev_loc
, "Length");
11824 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, prev_loc
, "Address");
11825 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
11826 prev_loc
, "Length");
11830 if (switch_cold_ranges
)
11832 const char *prev_loc
= cold_text_section_label
;
11836 FOR_EACH_VEC_ELT (*switch_cold_ranges
, idx
, loc
)
11839 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, prev_loc
, "Address");
11840 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, loc
, prev_loc
, "Length");
11848 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, prev_loc
, "Address");
11849 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
11850 prev_loc
, "Length");
11854 if (have_multiple_function_sections
)
11859 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
11861 if (fde
->ignored_debug
)
11863 if (!fde
->in_std_section
)
11865 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
11867 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
11868 fde
->dw_fde_begin
, "Length");
11870 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
11872 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
11874 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
11875 fde
->dw_fde_second_begin
, "Length");
11880 /* Output the terminator words. */
11881 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11882 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11885 /* Add a new entry to .debug_ranges. Return its index into
11886 ranges_table vector. */
11888 static unsigned int
11889 add_ranges_num (int num
, bool maybe_new_sec
)
11891 dw_ranges r
= { NULL
, num
, 0, maybe_new_sec
, NULL
, NULL
};
11892 vec_safe_push (ranges_table
, r
);
11893 return vec_safe_length (ranges_table
) - 1;
11896 /* Add a new entry to .debug_ranges corresponding to a block, or a
11897 range terminator if BLOCK is NULL. MAYBE_NEW_SEC is true if
11898 this entry might be in a different section from previous range. */
11900 static unsigned int
11901 add_ranges (const_tree block
, bool maybe_new_sec
)
11903 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0, maybe_new_sec
);
11906 /* Note that (*rnglist_table)[offset] is either a head of a rnglist
11907 chain, or middle entry of a chain that will be directly referred to. */
11910 note_rnglist_head (unsigned int offset
)
11912 if (dwarf_version
< 5 || (*ranges_table
)[offset
].label
)
11914 (*ranges_table
)[offset
].label
= gen_internal_sym ("LLRL");
11917 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
11918 When using dwarf_split_debug_info, address attributes in dies destined
11919 for the final executable should be direct references--setting the
11920 parameter force_direct ensures this behavior. */
11923 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
11924 bool *added
, bool force_direct
)
11926 unsigned int in_use
= vec_safe_length (ranges_by_label
);
11927 unsigned int offset
;
11928 dw_ranges_by_label rbl
= { begin
, end
};
11929 vec_safe_push (ranges_by_label
, rbl
);
11930 offset
= add_ranges_num (-(int)in_use
- 1, true);
11933 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
11935 note_rnglist_head (offset
);
11936 if (dwarf_split_debug_info
&& force_direct
)
11937 (*ranges_table
)[offset
].idx
= DW_RANGES_IDX_SKELETON
;
11941 /* Emit .debug_ranges section. */
11944 output_ranges (void)
11947 static const char *const start_fmt
= "Offset %#x";
11948 const char *fmt
= start_fmt
;
11951 switch_to_section (debug_ranges_section
);
11952 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11953 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11955 int block_num
= r
->num
;
11959 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11960 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11962 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11963 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11965 /* If all code is in the text section, then the compilation
11966 unit base address defaults to DW_AT_low_pc, which is the
11967 base of the text section. */
11968 if (!have_multiple_function_sections
)
11970 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
11971 text_section_label
,
11972 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11973 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
11974 text_section_label
, NULL
);
11977 /* Otherwise, the compilation unit base address is zero,
11978 which allows us to use absolute addresses, and not worry
11979 about whether the target supports cross-section
11983 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11984 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11985 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
11991 /* Negative block_num stands for an index into ranges_by_label. */
11992 else if (block_num
< 0)
11994 int lab_idx
= - block_num
- 1;
11996 if (!have_multiple_function_sections
)
11998 gcc_unreachable ();
12000 /* If we ever use add_ranges_by_labels () for a single
12001 function section, all we have to do is to take out
12002 the #if 0 above. */
12003 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
12004 (*ranges_by_label
)[lab_idx
].begin
,
12005 text_section_label
,
12006 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
12007 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
12008 (*ranges_by_label
)[lab_idx
].end
,
12009 text_section_label
, NULL
);
12014 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
12015 (*ranges_by_label
)[lab_idx
].begin
,
12016 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
12017 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
12018 (*ranges_by_label
)[lab_idx
].end
,
12024 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
12025 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
12031 /* Non-zero if .debug_line_str should be used for .debug_line section
12032 strings or strings that are likely shareable with those. */
12033 #define DWARF5_USE_DEBUG_LINE_STR \
12034 (!DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET \
12035 && (DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) != 0 \
12036 /* FIXME: there is no .debug_line_str.dwo section, \
12037 for -gsplit-dwarf we should use DW_FORM_strx instead. */ \
12038 && !dwarf_split_debug_info)
12041 /* Returns TRUE if we are outputting DWARF5 and the assembler supports
12042 DWARF5 .debug_line tables using .debug_line_str or we generate
12043 it ourselves, except for split-dwarf which doesn't have a
12044 .debug_line_str. */
12046 asm_outputs_debug_line_str (void)
12048 if (dwarf_version
>= 5
12049 && ! output_asm_line_debug_info ()
12050 && DWARF5_USE_DEBUG_LINE_STR
)
12054 #if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
12055 return !dwarf_split_debug_info
&& dwarf_version
>= 5;
12062 /* Return true if it is beneficial to use DW_RLE_base_address{,x}.
12063 I is index of the following range. */
12066 use_distinct_base_address_for_range (unsigned int i
)
12068 if (i
>= vec_safe_length (ranges_table
))
12071 dw_ranges
*r2
= &(*ranges_table
)[i
];
12072 /* Use DW_RLE_base_address{,x} if there is a next range in the
12073 range list and is guaranteed to be in the same section. */
12074 return r2
->num
!= 0 && r2
->label
== NULL
&& !r2
->maybe_new_sec
;
12077 /* Assign .debug_rnglists indexes and unique indexes into the debug_addr
12078 section when needed. */
12081 index_rnglists (void)
12087 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
12089 if (r
->label
&& r
->idx
!= DW_RANGES_IDX_SKELETON
)
12090 r
->idx
= rnglist_idx
++;
12092 int block_num
= r
->num
;
12093 if ((HAVE_AS_LEB128
|| block_num
< 0)
12094 && !have_multiple_function_sections
)
12096 if (HAVE_AS_LEB128
&& (r
->label
|| r
->maybe_new_sec
))
12100 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
12101 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
12103 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
12104 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
12106 if (HAVE_AS_LEB128
)
12108 if (!base
&& use_distinct_base_address_for_range (i
+ 1))
12110 r
->begin_entry
= add_addr_table_entry (xstrdup (blabel
),
12115 /* If we have a base, no need for further
12116 begin_entry/end_entry, as DW_RLE_offset_pair will be
12120 = add_addr_table_entry (xstrdup (blabel
), ate_kind_label
);
12121 /* No need for end_entry, DW_RLE_start{,x}_length will use
12122 length as opposed to a pair of addresses. */
12127 = add_addr_table_entry (xstrdup (blabel
), ate_kind_label
);
12129 = add_addr_table_entry (xstrdup (elabel
), ate_kind_label
);
12133 /* Negative block_num stands for an index into ranges_by_label. */
12134 else if (block_num
< 0)
12136 int lab_idx
= - block_num
- 1;
12137 const char *blabel
= (*ranges_by_label
)[lab_idx
].begin
;
12138 const char *elabel
= (*ranges_by_label
)[lab_idx
].end
;
12141 = add_addr_table_entry (xstrdup (blabel
), ate_kind_label
);
12142 if (!HAVE_AS_LEB128
)
12144 = add_addr_table_entry (xstrdup (elabel
), ate_kind_label
);
12149 /* Emit .debug_rnglists or (when DWO is true) .debug_rnglists.dwo section. */
12152 output_rnglists (unsigned generation
, bool dwo
)
12156 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
12157 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
12158 char basebuf
[MAX_ARTIFICIAL_LABEL_BYTES
];
12161 switch_to_section (debug_ranges_dwo_section
);
12164 switch_to_section (debug_ranges_section
);
12165 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
12167 /* There are up to 4 unique ranges labels per generation.
12168 See also init_sections_and_labels. */
12169 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_RANGES_SECTION_LABEL
,
12170 2 + 2 * dwo
+ generation
* 6);
12171 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_RANGES_SECTION_LABEL
,
12172 3 + 2 * dwo
+ generation
* 6);
12173 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
12174 dw2_asm_output_data (4, 0xffffffff,
12175 "Initial length escape value indicating "
12176 "64-bit DWARF extension");
12177 dw2_asm_output_delta (dwarf_offset_size
, l2
, l1
,
12178 "Length of Range Lists");
12179 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
12180 output_dwarf_version ();
12181 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
12182 dw2_asm_output_data (1, 0, "Segment Size");
12183 /* Emit the offset table only for -gsplit-dwarf. If we don't care
12184 about relocation sizes and primarily care about the size of .debug*
12185 sections in linked shared libraries and executables, then
12186 the offset table plus corresponding DW_FORM_rnglistx uleb128 indexes
12187 into it are usually larger than just DW_FORM_sec_offset offsets
12188 into the .debug_rnglists section. */
12189 dw2_asm_output_data (4, dwo
? rnglist_idx
: 0,
12190 "Offset Entry Count");
12193 ASM_OUTPUT_LABEL (asm_out_file
, ranges_base_label
);
12194 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
12195 if (r
->label
&& r
->idx
!= DW_RANGES_IDX_SKELETON
)
12196 dw2_asm_output_delta (dwarf_offset_size
, r
->label
,
12197 ranges_base_label
, NULL
);
12200 const char *lab
= "";
12201 const char *base
= NULL
;
12202 bool skipping
= false;
12204 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
12206 int block_num
= r
->num
;
12210 if (dwarf_split_debug_info
12211 && (r
->idx
== DW_RANGES_IDX_SKELETON
) == dwo
)
12217 ASM_OUTPUT_LABEL (asm_out_file
, r
->label
);
12222 if (block_num
== 0)
12226 if (HAVE_AS_LEB128
&& (r
->label
|| r
->maybe_new_sec
))
12230 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
12231 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
12233 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
12234 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
12236 if (HAVE_AS_LEB128
)
12238 /* If all code is in the text section, then the compilation
12239 unit base address defaults to DW_AT_low_pc, which is the
12240 base of the text section. */
12241 if (!have_multiple_function_sections
)
12243 dw2_asm_output_data (1, DW_RLE_offset_pair
,
12244 "DW_RLE_offset_pair (%s)", lab
);
12245 dw2_asm_output_delta_uleb128 (blabel
, text_section_label
,
12246 "Range begin address (%s)", lab
);
12247 dw2_asm_output_delta_uleb128 (elabel
, text_section_label
,
12248 "Range end address (%s)", lab
);
12251 if (base
== NULL
&& use_distinct_base_address_for_range (i
+ 1))
12253 if (dwarf_split_debug_info
)
12255 dw2_asm_output_data (1, DW_RLE_base_addressx
,
12256 "DW_RLE_base_addressx (%s)", lab
);
12257 dw2_asm_output_data_uleb128 (r
->begin_entry
->index
,
12258 "Base address index (%s)",
12263 dw2_asm_output_data (1, DW_RLE_base_address
,
12264 "DW_RLE_base_address (%s)", lab
);
12265 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
12266 "Base address (%s)", lab
);
12268 strcpy (basebuf
, blabel
);
12273 dw2_asm_output_data (1, DW_RLE_offset_pair
,
12274 "DW_RLE_offset_pair (%s)", lab
);
12275 dw2_asm_output_delta_uleb128 (blabel
, base
,
12276 "Range begin address (%s)", lab
);
12277 dw2_asm_output_delta_uleb128 (elabel
, base
,
12278 "Range end address (%s)", lab
);
12281 if (dwarf_split_debug_info
)
12283 dw2_asm_output_data (1, DW_RLE_startx_length
,
12284 "DW_RLE_startx_length (%s)", lab
);
12285 dw2_asm_output_data_uleb128 (r
->begin_entry
->index
,
12286 "Range begin address index "
12291 dw2_asm_output_data (1, DW_RLE_start_length
,
12292 "DW_RLE_start_length (%s)", lab
);
12293 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
12294 "Range begin address (%s)", lab
);
12296 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
12297 "Range length (%s)", lab
);
12299 else if (dwarf_split_debug_info
)
12301 dw2_asm_output_data (1, DW_RLE_startx_endx
,
12302 "DW_RLE_startx_endx (%s)", lab
);
12303 dw2_asm_output_data_uleb128 (r
->begin_entry
->index
,
12304 "Range begin address index "
12306 dw2_asm_output_data_uleb128 (r
->end_entry
->index
,
12307 "Range end address index "
12312 dw2_asm_output_data (1, DW_RLE_start_end
,
12313 "DW_RLE_start_end (%s)", lab
);
12314 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
12315 "Range begin address (%s)", lab
);
12316 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
12317 "Range end address (%s)", lab
);
12321 /* Negative block_num stands for an index into ranges_by_label. */
12322 else if (block_num
< 0)
12324 int lab_idx
= - block_num
- 1;
12325 const char *blabel
= (*ranges_by_label
)[lab_idx
].begin
;
12326 const char *elabel
= (*ranges_by_label
)[lab_idx
].end
;
12328 if (!have_multiple_function_sections
)
12329 gcc_unreachable ();
12330 if (HAVE_AS_LEB128
)
12332 if (dwarf_split_debug_info
)
12334 dw2_asm_output_data (1, DW_RLE_startx_length
,
12335 "DW_RLE_startx_length (%s)", lab
);
12336 dw2_asm_output_data_uleb128 (r
->begin_entry
->index
,
12337 "Range begin address index "
12342 dw2_asm_output_data (1, DW_RLE_start_length
,
12343 "DW_RLE_start_length (%s)", lab
);
12344 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
12345 "Range begin address (%s)", lab
);
12347 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
12348 "Range length (%s)", lab
);
12350 else if (dwarf_split_debug_info
)
12352 dw2_asm_output_data (1, DW_RLE_startx_endx
,
12353 "DW_RLE_startx_endx (%s)", lab
);
12354 dw2_asm_output_data_uleb128 (r
->begin_entry
->index
,
12355 "Range begin address index "
12357 dw2_asm_output_data_uleb128 (r
->end_entry
->index
,
12358 "Range end address index "
12363 dw2_asm_output_data (1, DW_RLE_start_end
,
12364 "DW_RLE_start_end (%s)", lab
);
12365 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
12366 "Range begin address (%s)", lab
);
12367 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
12368 "Range end address (%s)", lab
);
12372 dw2_asm_output_data (1, DW_RLE_end_of_list
,
12373 "DW_RLE_end_of_list (%s)", lab
);
12375 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12379 /* Data structure containing information about input files. */
12382 const char *path
; /* Complete file name. */
12383 const char *fname
; /* File name part. */
12384 int length
; /* Length of entire string. */
12385 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
12386 int dir_idx
; /* Index in directory table. */
12389 /* Data structure containing information about directories with source
12393 const char *path
; /* Path including directory name. */
12394 int length
; /* Path length. */
12395 int prefix
; /* Index of directory entry which is a prefix. */
12396 int count
; /* Number of files in this directory. */
12397 int dir_idx
; /* Index of directory used as base. */
12400 /* Callback function for file_info comparison. We sort by looking at
12401 the directories in the path. */
12404 file_info_cmp (const void *p1
, const void *p2
)
12406 const struct file_info
*const s1
= (const struct file_info
*) p1
;
12407 const struct file_info
*const s2
= (const struct file_info
*) p2
;
12408 const unsigned char *cp1
;
12409 const unsigned char *cp2
;
12411 /* Take care of file names without directories. We need to make sure that
12412 we return consistent values to qsort since some will get confused if
12413 we return the same value when identical operands are passed in opposite
12414 orders. So if neither has a directory, return 0 and otherwise return
12415 1 or -1 depending on which one has the directory. We want the one with
12416 the directory to sort after the one without, so all no directory files
12417 are at the start (normally only the compilation unit file). */
12418 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
12419 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
12421 cp1
= (const unsigned char *) s1
->path
;
12422 cp2
= (const unsigned char *) s2
->path
;
12428 /* Reached the end of the first path? If so, handle like above,
12429 but now we want longer directory prefixes before shorter ones. */
12430 if ((cp1
== (const unsigned char *) s1
->fname
)
12431 || (cp2
== (const unsigned char *) s2
->fname
))
12432 return ((cp1
== (const unsigned char *) s1
->fname
)
12433 - (cp2
== (const unsigned char *) s2
->fname
));
12435 /* Character of current path component the same? */
12436 else if (*cp1
!= *cp2
)
12437 return *cp1
- *cp2
;
12441 struct file_name_acquire_data
12443 struct file_info
*files
;
12448 /* Traversal function for the hash table. */
12451 file_name_acquire (dwarf_file_data
**slot
, file_name_acquire_data
*fnad
)
12453 struct dwarf_file_data
*d
= *slot
;
12454 struct file_info
*fi
;
12457 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
12459 if (! d
->emitted_number
)
12462 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
12464 fi
= fnad
->files
+ fnad
->used_files
++;
12468 /* Skip all leading "./". */
12469 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
12472 /* Create a new array entry. */
12474 fi
->length
= strlen (f
);
12477 /* Search for the file name part. */
12478 f
= strrchr (f
, DIR_SEPARATOR
);
12479 #if defined (DIR_SEPARATOR_2)
12481 const char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
12485 if (f
== NULL
|| f
< g
)
12491 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
12495 /* Helper function for output_file_names. Emit a FORM encoded
12496 string STR, with assembly comment start ENTRY_KIND and
12500 output_line_string (enum dwarf_form form
, const char *str
,
12501 const char *entry_kind
, unsigned int idx
)
12505 case DW_FORM_string
:
12506 dw2_asm_output_nstring (str
, -1, "%s: %#x", entry_kind
, idx
);
12508 case DW_FORM_line_strp
:
12509 if (!debug_line_str_hash
)
12510 debug_line_str_hash
12511 = hash_table
<indirect_string_hasher
>::create_ggc (10);
12513 struct indirect_string_node
*node
;
12514 node
= find_AT_string_in_table (str
, debug_line_str_hash
);
12515 set_indirect_string (node
);
12517 dw2_asm_output_offset (dwarf_offset_size
, node
->label
,
12518 debug_line_str_section
, "%s: %#x: \"%s\"",
12519 entry_kind
, 0, node
->str
);
12522 gcc_unreachable ();
12526 /* Output the directory table and the file name table. We try to minimize
12527 the total amount of memory needed. A heuristic is used to avoid large
12528 slowdowns with many input files. */
12531 output_file_names (void)
12533 struct file_name_acquire_data fnad
;
12535 struct file_info
*files
;
12536 struct dir_info
*dirs
;
12544 if (!last_emitted_file
)
12546 if (dwarf_version
>= 5)
12548 const char *comp_dir
= comp_dir_string ();
12549 if (comp_dir
== NULL
)
12551 dw2_asm_output_data (1, 1, "Directory entry format count");
12552 enum dwarf_form str_form
= DW_FORM_string
;
12553 if (DWARF5_USE_DEBUG_LINE_STR
)
12554 str_form
= DW_FORM_line_strp
;
12555 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12556 dw2_asm_output_data_uleb128 (str_form
, "%s",
12557 get_DW_FORM_name (str_form
));
12558 dw2_asm_output_data_uleb128 (1, "Directories count");
12559 if (str_form
== DW_FORM_string
)
12560 dw2_asm_output_nstring (comp_dir
, -1, "Directory Entry: %#x", 0);
12562 output_line_string (str_form
, comp_dir
, "Directory Entry", 0);
12563 const char *filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
12564 if (filename0
== NULL
)
12566 #ifdef VMS_DEBUGGING_INFO
12567 dw2_asm_output_data (1, 4, "File name entry format count");
12569 dw2_asm_output_data (1, 2, "File name entry format count");
12571 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12572 dw2_asm_output_data_uleb128 (str_form
, "%s",
12573 get_DW_FORM_name (str_form
));
12574 dw2_asm_output_data_uleb128 (DW_LNCT_directory_index
,
12575 "DW_LNCT_directory_index");
12576 dw2_asm_output_data_uleb128 (DW_FORM_data1
, "%s",
12577 get_DW_FORM_name (DW_FORM_data1
));
12578 #ifdef VMS_DEBUGGING_INFO
12579 dw2_asm_output_data_uleb128 (DW_LNCT_timestamp
, "DW_LNCT_timestamp");
12580 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12581 dw2_asm_output_data_uleb128 (DW_LNCT_size
, "DW_LNCT_size");
12582 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12584 dw2_asm_output_data_uleb128 (1, "File names count");
12586 output_line_string (str_form
, filename0
, "File Entry", 0);
12587 dw2_asm_output_data (1, 0, NULL
);
12588 #ifdef VMS_DEBUGGING_INFO
12589 dw2_asm_output_data_uleb128 (0, NULL
);
12590 dw2_asm_output_data_uleb128 (0, NULL
);
12595 dw2_asm_output_data (1, 0, "End directory table");
12596 dw2_asm_output_data (1, 0, "End file name table");
12601 numfiles
= last_emitted_file
->emitted_number
;
12603 /* Allocate the various arrays we need. */
12604 files
= XALLOCAVEC (struct file_info
, numfiles
);
12605 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
12607 fnad
.files
= files
;
12608 fnad
.used_files
= 0;
12609 fnad
.max_files
= numfiles
;
12610 file_table
->traverse
<file_name_acquire_data
*, file_name_acquire
> (&fnad
);
12611 gcc_assert (fnad
.used_files
== fnad
.max_files
);
12613 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
12615 /* Find all the different directories used. */
12616 dirs
[0].path
= files
[0].path
;
12617 dirs
[0].length
= files
[0].fname
- files
[0].path
;
12618 dirs
[0].prefix
= -1;
12620 dirs
[0].dir_idx
= 0;
12621 files
[0].dir_idx
= 0;
12624 for (i
= 1; i
< numfiles
; i
++)
12625 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
12626 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
12627 dirs
[ndirs
- 1].length
) == 0)
12629 /* Same directory as last entry. */
12630 files
[i
].dir_idx
= ndirs
- 1;
12631 ++dirs
[ndirs
- 1].count
;
12637 /* This is a new directory. */
12638 dirs
[ndirs
].path
= files
[i
].path
;
12639 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
12640 dirs
[ndirs
].count
= 1;
12641 dirs
[ndirs
].dir_idx
= ndirs
;
12642 files
[i
].dir_idx
= ndirs
;
12644 /* Search for a prefix. */
12645 dirs
[ndirs
].prefix
= -1;
12646 for (j
= 0; j
< ndirs
; j
++)
12647 if (dirs
[j
].length
< dirs
[ndirs
].length
12648 && dirs
[j
].length
> 1
12649 && (dirs
[ndirs
].prefix
== -1
12650 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
12651 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
12652 dirs
[ndirs
].prefix
= j
;
12657 /* Now to the actual work. We have to find a subset of the directories which
12658 allow expressing the file name using references to the directory table
12659 with the least amount of characters. We do not do an exhaustive search
12660 where we would have to check out every combination of every single
12661 possible prefix. Instead we use a heuristic which provides nearly optimal
12662 results in most cases and never is much off. */
12663 saved
= XALLOCAVEC (int, ndirs
);
12664 savehere
= XALLOCAVEC (int, ndirs
);
12666 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
12667 for (i
= 0; i
< ndirs
; i
++)
12672 /* We can always save some space for the current directory. But this
12673 does not mean it will be enough to justify adding the directory. */
12674 savehere
[i
] = dirs
[i
].length
;
12675 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
12677 for (j
= i
+ 1; j
< ndirs
; j
++)
12680 if (saved
[j
] < dirs
[i
].length
)
12682 /* Determine whether the dirs[i] path is a prefix of the
12686 k
= dirs
[j
].prefix
;
12687 while (k
!= -1 && k
!= (int) i
)
12688 k
= dirs
[k
].prefix
;
12692 /* Yes it is. We can possibly save some memory by
12693 writing the filenames in dirs[j] relative to
12695 savehere
[j
] = dirs
[i
].length
;
12696 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
12701 /* Check whether we can save enough to justify adding the dirs[i]
12703 if (total
> dirs
[i
].length
+ 1)
12705 /* It's worthwhile adding. */
12706 for (j
= i
; j
< ndirs
; j
++)
12707 if (savehere
[j
] > 0)
12709 /* Remember how much we saved for this directory so far. */
12710 saved
[j
] = savehere
[j
];
12712 /* Remember the prefix directory. */
12713 dirs
[j
].dir_idx
= i
;
12718 /* Emit the directory name table. */
12719 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
12720 enum dwarf_form str_form
= DW_FORM_string
;
12721 enum dwarf_form idx_form
= DW_FORM_udata
;
12722 if (dwarf_version
>= 5)
12724 const char *comp_dir
= comp_dir_string ();
12725 if (comp_dir
== NULL
)
12727 dw2_asm_output_data (1, 1, "Directory entry format count");
12728 if (DWARF5_USE_DEBUG_LINE_STR
)
12729 str_form
= DW_FORM_line_strp
;
12730 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12731 dw2_asm_output_data_uleb128 (str_form
, "%s",
12732 get_DW_FORM_name (str_form
));
12733 dw2_asm_output_data_uleb128 (ndirs
+ idx_offset
, "Directories count");
12734 if (str_form
== DW_FORM_string
)
12736 dw2_asm_output_nstring (comp_dir
, -1, "Directory Entry: %#x", 0);
12737 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12738 dw2_asm_output_nstring (dirs
[i
].path
,
12740 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
12741 "Directory Entry: %#x", i
+ idx_offset
);
12745 output_line_string (str_form
, comp_dir
, "Directory Entry", 0);
12746 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12749 = ggc_alloc_string (dirs
[i
].path
,
12751 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
);
12752 output_line_string (str_form
, str
, "Directory Entry",
12753 (unsigned) i
+ idx_offset
);
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
);
12765 dw2_asm_output_data (1, 0, "End directory table");
12768 /* We have to emit them in the order of emitted_number since that's
12769 used in the debug info generation. To do this efficiently we
12770 generate a back-mapping of the indices first. */
12771 backmap
= XALLOCAVEC (int, numfiles
);
12772 for (i
= 0; i
< numfiles
; i
++)
12773 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
12775 if (dwarf_version
>= 5)
12777 const char *filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
12778 if (filename0
== NULL
)
12780 /* DW_LNCT_directory_index can use DW_FORM_udata, DW_FORM_data1 and
12781 DW_FORM_data2. Choose one based on the number of directories
12782 and how much space would they occupy in each encoding.
12783 If we have at most 256 directories, all indexes fit into
12784 a single byte, so DW_FORM_data1 is most compact (if there
12785 are at most 128 directories, DW_FORM_udata would be as
12786 compact as that, but not shorter and slower to decode). */
12787 if (ndirs
+ idx_offset
<= 256)
12788 idx_form
= DW_FORM_data1
;
12789 /* If there are more than 65536 directories, we have to use
12790 DW_FORM_udata, DW_FORM_data2 can't refer to them.
12791 Otherwise, compute what space would occupy if all the indexes
12792 used DW_FORM_udata - sum - and compare that to how large would
12793 be DW_FORM_data2 encoding, and pick the more efficient one. */
12794 else if (ndirs
+ idx_offset
<= 65536)
12796 unsigned HOST_WIDE_INT sum
= 1;
12797 for (i
= 0; i
< numfiles
; i
++)
12799 int file_idx
= backmap
[i
];
12800 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
12801 sum
+= size_of_uleb128 (dir_idx
);
12803 if (sum
>= HOST_WIDE_INT_UC (2) * (numfiles
+ 1))
12804 idx_form
= DW_FORM_data2
;
12806 #ifdef VMS_DEBUGGING_INFO
12807 dw2_asm_output_data (1, 4, "File name entry format count");
12809 dw2_asm_output_data (1, 2, "File name entry format count");
12811 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12812 dw2_asm_output_data_uleb128 (str_form
, "%s",
12813 get_DW_FORM_name (str_form
));
12814 dw2_asm_output_data_uleb128 (DW_LNCT_directory_index
,
12815 "DW_LNCT_directory_index");
12816 dw2_asm_output_data_uleb128 (idx_form
, "%s",
12817 get_DW_FORM_name (idx_form
));
12818 #ifdef VMS_DEBUGGING_INFO
12819 dw2_asm_output_data_uleb128 (DW_LNCT_timestamp
, "DW_LNCT_timestamp");
12820 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12821 dw2_asm_output_data_uleb128 (DW_LNCT_size
, "DW_LNCT_size");
12822 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12824 dw2_asm_output_data_uleb128 (numfiles
+ 1, "File names count");
12826 output_line_string (str_form
, filename0
, "File Entry", 0);
12828 /* Include directory index. */
12829 if (idx_form
!= DW_FORM_udata
)
12830 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12833 dw2_asm_output_data_uleb128 (0, NULL
);
12835 #ifdef VMS_DEBUGGING_INFO
12836 dw2_asm_output_data_uleb128 (0, NULL
);
12837 dw2_asm_output_data_uleb128 (0, NULL
);
12841 /* Now write all the file names. */
12842 for (i
= 0; i
< numfiles
; i
++)
12844 int file_idx
= backmap
[i
];
12845 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
12847 #ifdef VMS_DEBUGGING_INFO
12848 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
12850 /* Setting these fields can lead to debugger miscomparisons,
12851 but VMS Debug requires them to be set correctly. */
12856 int maxfilelen
= (strlen (files
[file_idx
].path
)
12857 + dirs
[dir_idx
].length
12858 + MAX_VMS_VERSION_LEN
+ 1);
12859 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
12861 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
12862 snprintf (filebuf
, maxfilelen
, "%s;%d",
12863 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
12865 output_line_string (str_form
, filebuf
, "File Entry", (unsigned) i
+ 1);
12867 /* Include directory index. */
12868 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
12869 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12870 dir_idx
+ idx_offset
, NULL
);
12872 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
12874 /* Modification time. */
12875 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
12876 &cdt
, 0, 0, 0) == 0)
12879 /* File length in bytes. */
12880 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
12881 0, &siz
, 0, 0) == 0)
12884 output_line_string (str_form
,
12885 files
[file_idx
].path
+ dirs
[dir_idx
].length
,
12886 "File Entry", (unsigned) i
+ 1);
12888 /* Include directory index. */
12889 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
12890 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12891 dir_idx
+ idx_offset
, NULL
);
12893 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
12895 if (dwarf_version
>= 5)
12898 /* Modification time. */
12899 dw2_asm_output_data_uleb128 (0, NULL
);
12901 /* File length in bytes. */
12902 dw2_asm_output_data_uleb128 (0, NULL
);
12903 #endif /* VMS_DEBUGGING_INFO */
12906 if (dwarf_version
< 5)
12907 dw2_asm_output_data (1, 0, "End file name table");
12911 /* Output one line number table into the .debug_line section. */
12914 output_one_line_info_table (dw_line_info_table
*table
)
12916 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12917 unsigned int current_line
= 1;
12918 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
12919 dw_line_info_entry
*ent
, *prev_addr
;
12925 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
12927 switch (ent
->opcode
)
12929 case LI_set_address
:
12930 /* ??? Unfortunately, we have little choice here currently, and
12931 must always use the most general form. GCC does not know the
12932 address delta itself, so we can't use DW_LNS_advance_pc. Many
12933 ports do have length attributes which will give an upper bound
12934 on the address range. We could perhaps use length attributes
12935 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
12936 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
12940 /* This can handle any delta. This takes
12941 4+DWARF2_ADDR_SIZE bytes. */
12942 dw2_asm_output_data (1, 0, "set address %s%s", line_label
,
12943 debug_variable_location_views
12944 ? ", reset view to 0" : "");
12945 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12946 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12947 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
12952 case LI_adv_address
:
12954 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
12955 char prev_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12956 ASM_GENERATE_INTERNAL_LABEL (prev_label
, LINE_CODE_LABEL
, prev_addr
->val
);
12960 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
, "fixed advance PC, increment view to %i", view
);
12961 dw2_asm_output_delta (2, line_label
, prev_label
,
12962 "from %s to %s", prev_label
, line_label
);
12969 if (ent
->val
== current_line
)
12971 /* We still need to start a new row, so output a copy insn. */
12972 dw2_asm_output_data (1, DW_LNS_copy
,
12973 "copy line %u", current_line
);
12977 int line_offset
= ent
->val
- current_line
;
12978 int line_delta
= line_offset
- DWARF_LINE_BASE
;
12980 current_line
= ent
->val
;
12981 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
12983 /* This can handle deltas from -10 to 234, using the current
12984 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
12985 This takes 1 byte. */
12986 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
12987 "line %u", current_line
);
12991 /* This can handle any delta. This takes at least 4 bytes,
12992 depending on the value being encoded. */
12993 dw2_asm_output_data (1, DW_LNS_advance_line
,
12994 "advance to line %u", current_line
);
12995 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
12996 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
13002 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
13003 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
13006 case LI_set_column
:
13007 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
13008 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
13011 case LI_negate_stmt
:
13012 current_is_stmt
= !current_is_stmt
;
13013 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
13014 "is_stmt %d", current_is_stmt
);
13017 case LI_set_prologue_end
:
13018 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
13019 "set prologue end");
13022 case LI_set_epilogue_begin
:
13023 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
13024 "set epilogue begin");
13027 case LI_set_discriminator
:
13028 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
13029 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
13030 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
13031 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
13036 /* Emit debug info for the address of the end of the table. */
13037 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
13038 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
13039 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
13040 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
13042 dw2_asm_output_data (1, 0, "end sequence");
13043 dw2_asm_output_data_uleb128 (1, NULL
);
13044 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
13047 static unsigned int output_line_info_generation
;
13049 /* Output the source line number correspondence information. This
13050 information goes into the .debug_line section. */
13053 output_line_info (bool prologue_only
)
13055 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
13056 char p1
[MAX_ARTIFICIAL_LABEL_BYTES
], p2
[MAX_ARTIFICIAL_LABEL_BYTES
];
13057 bool saw_one
= false;
13060 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
,
13061 output_line_info_generation
);
13062 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
,
13063 output_line_info_generation
);
13064 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
,
13065 output_line_info_generation
);
13066 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
,
13067 output_line_info_generation
++);
13069 if (!XCOFF_DEBUGGING_INFO
)
13071 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
13072 dw2_asm_output_data (4, 0xffffffff,
13073 "Initial length escape value indicating 64-bit DWARF extension");
13074 dw2_asm_output_delta (dwarf_offset_size
, l2
, l1
,
13075 "Length of Source Line Info");
13078 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
13080 output_dwarf_version ();
13081 if (dwarf_version
>= 5)
13083 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
13084 dw2_asm_output_data (1, 0, "Segment Size");
13086 dw2_asm_output_delta (dwarf_offset_size
, p2
, p1
, "Prolog Length");
13087 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
13089 /* Define the architecture-dependent minimum instruction length (in bytes).
13090 In this implementation of DWARF, this field is used for information
13091 purposes only. Since GCC generates assembly language, we have no
13092 a priori knowledge of how many instruction bytes are generated for each
13093 source line, and therefore can use only the DW_LNE_set_address and
13094 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
13095 this as '1', which is "correct enough" for all architectures,
13096 and don't let the target override. */
13097 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
13099 if (dwarf_version
>= 4)
13100 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
13101 "Maximum Operations Per Instruction");
13102 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
13103 "Default is_stmt_start flag");
13104 dw2_asm_output_data (1, DWARF_LINE_BASE
,
13105 "Line Base Value (Special Opcodes)");
13106 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
13107 "Line Range Value (Special Opcodes)");
13108 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
13109 "Special Opcode Base");
13111 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
13116 case DW_LNS_advance_pc
:
13117 case DW_LNS_advance_line
:
13118 case DW_LNS_set_file
:
13119 case DW_LNS_set_column
:
13120 case DW_LNS_fixed_advance_pc
:
13121 case DW_LNS_set_isa
:
13129 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
13133 /* Write out the information about the files we use. */
13134 output_file_names ();
13135 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
13138 /* Output the marker for the end of the line number info. */
13139 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
13143 if (separate_line_info
)
13145 dw_line_info_table
*table
;
13148 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
13151 output_one_line_info_table (table
);
13155 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
13157 output_one_line_info_table (cold_text_section_line_info
);
13161 /* ??? Some Darwin linkers crash on a .debug_line section with no
13162 sequences. Further, merely a DW_LNE_end_sequence entry is not
13163 sufficient -- the address column must also be initialized.
13164 Make sure to output at least one set_address/end_sequence pair,
13165 choosing .text since that section is always present. */
13166 if (text_section_line_info
->in_use
|| !saw_one
)
13167 output_one_line_info_table (text_section_line_info
);
13169 /* Output the marker for the end of the line number info. */
13170 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
13173 /* Return true if DW_AT_endianity should be emitted according to REVERSE. */
13176 need_endianity_attribute_p (bool reverse
)
13178 return reverse
&& (dwarf_version
>= 3 || !dwarf_strict
);
13181 /* Given a pointer to a tree node for some base type, return a pointer to
13182 a DIE that describes the given type. REVERSE is true if the type is
13183 to be interpreted in the reverse storage order wrt the target order.
13185 This routine must only be called for GCC type nodes that correspond to
13186 Dwarf base (fundamental) types. */
13189 base_type_die (tree type
, bool reverse
)
13191 dw_die_ref base_type_result
;
13192 enum dwarf_type encoding
;
13193 bool fpt_used
= false;
13194 struct fixed_point_type_info fpt_info
;
13195 tree type_bias
= NULL_TREE
;
13197 /* If this is a subtype that should not be emitted as a subrange type,
13198 use the base type. See subrange_type_for_debug_p. */
13199 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
13200 type
= TREE_TYPE (type
);
13202 switch (TREE_CODE (type
))
13205 if ((dwarf_version
>= 4 || !dwarf_strict
)
13206 && TYPE_NAME (type
)
13207 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
13208 && DECL_IS_UNDECLARED_BUILTIN (TYPE_NAME (type
))
13209 && DECL_NAME (TYPE_NAME (type
)))
13211 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
13212 if (strcmp (name
, "char16_t") == 0
13213 || strcmp (name
, "char32_t") == 0)
13215 encoding
= DW_ATE_UTF
;
13219 if ((dwarf_version
>= 3 || !dwarf_strict
)
13220 && lang_hooks
.types
.get_fixed_point_type_info
)
13222 memset (&fpt_info
, 0, sizeof (fpt_info
));
13223 if (lang_hooks
.types
.get_fixed_point_type_info (type
, &fpt_info
))
13226 encoding
= ((TYPE_UNSIGNED (type
))
13227 ? DW_ATE_unsigned_fixed
13228 : DW_ATE_signed_fixed
);
13232 if (TYPE_STRING_FLAG (type
))
13234 if (TYPE_UNSIGNED (type
))
13235 encoding
= DW_ATE_unsigned_char
;
13237 encoding
= DW_ATE_signed_char
;
13239 else if (TYPE_UNSIGNED (type
))
13240 encoding
= DW_ATE_unsigned
;
13242 encoding
= DW_ATE_signed
;
13245 && lang_hooks
.types
.get_type_bias
)
13246 type_bias
= lang_hooks
.types
.get_type_bias (type
);
13250 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
13252 if (dwarf_version
>= 3 || !dwarf_strict
)
13253 encoding
= DW_ATE_decimal_float
;
13255 encoding
= DW_ATE_lo_user
;
13258 encoding
= DW_ATE_float
;
13261 case FIXED_POINT_TYPE
:
13262 if (!(dwarf_version
>= 3 || !dwarf_strict
))
13263 encoding
= DW_ATE_lo_user
;
13264 else if (TYPE_UNSIGNED (type
))
13265 encoding
= DW_ATE_unsigned_fixed
;
13267 encoding
= DW_ATE_signed_fixed
;
13270 /* Dwarf2 doesn't know anything about complex ints, so use
13271 a user defined type for it. */
13273 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
13274 encoding
= DW_ATE_complex_float
;
13276 encoding
= DW_ATE_lo_user
;
13280 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
13281 encoding
= DW_ATE_boolean
;
13285 /* No other TREE_CODEs are Dwarf fundamental types. */
13286 gcc_unreachable ();
13289 base_type_result
= new_die_raw (DW_TAG_base_type
);
13291 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
13292 int_size_in_bytes (type
));
13293 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
13295 if (need_endianity_attribute_p (reverse
))
13296 add_AT_unsigned (base_type_result
, DW_AT_endianity
,
13297 BYTES_BIG_ENDIAN
? DW_END_little
: DW_END_big
);
13299 add_alignment_attribute (base_type_result
, type
);
13303 switch (fpt_info
.scale_factor_kind
)
13305 case fixed_point_scale_factor_binary
:
13306 add_AT_int (base_type_result
, DW_AT_binary_scale
,
13307 fpt_info
.scale_factor
.binary
);
13310 case fixed_point_scale_factor_decimal
:
13311 add_AT_int (base_type_result
, DW_AT_decimal_scale
,
13312 fpt_info
.scale_factor
.decimal
);
13315 case fixed_point_scale_factor_arbitrary
:
13316 /* Arbitrary scale factors cannot be described in standard DWARF. */
13319 /* Describe the scale factor as a rational constant. */
13320 const dw_die_ref scale_factor
13321 = new_die (DW_TAG_constant
, comp_unit_die (), type
);
13323 add_scalar_info (scale_factor
, DW_AT_GNU_numerator
,
13324 fpt_info
.scale_factor
.arbitrary
.numerator
,
13325 dw_scalar_form_constant
, NULL
);
13326 add_scalar_info (scale_factor
, DW_AT_GNU_denominator
,
13327 fpt_info
.scale_factor
.arbitrary
.denominator
,
13328 dw_scalar_form_constant
, NULL
);
13330 add_AT_die_ref (base_type_result
, DW_AT_small
, scale_factor
);
13335 gcc_unreachable ();
13340 add_scalar_info (base_type_result
, DW_AT_GNU_bias
, type_bias
,
13341 dw_scalar_form_constant
13342 | dw_scalar_form_exprloc
13343 | dw_scalar_form_reference
,
13346 return base_type_result
;
13349 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
13350 named 'auto' in its type: return true for it, false otherwise. */
13353 is_cxx_auto (tree type
)
13357 tree name
= TYPE_IDENTIFIER (type
);
13358 if (name
== get_identifier ("auto")
13359 || name
== get_identifier ("decltype(auto)"))
13365 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
13366 given input type is a Dwarf "fundamental" type. Otherwise return null. */
13369 is_base_type (tree type
)
13371 switch (TREE_CODE (type
))
13375 case FIXED_POINT_TYPE
:
13385 case QUAL_UNION_TYPE
:
13386 case ENUMERAL_TYPE
:
13387 case FUNCTION_TYPE
:
13390 case REFERENCE_TYPE
:
13398 if (is_cxx_auto (type
))
13400 gcc_unreachable ();
13404 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
13405 node, return the size in bits for the type if it is a constant, or else
13406 return the alignment for the type if the type's size is not constant, or
13407 else return BITS_PER_WORD if the type actually turns out to be an
13408 ERROR_MARK node. */
13410 static inline unsigned HOST_WIDE_INT
13411 simple_type_size_in_bits (const_tree type
)
13413 if (TREE_CODE (type
) == ERROR_MARK
)
13414 return BITS_PER_WORD
;
13415 else if (TYPE_SIZE (type
) == NULL_TREE
)
13417 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
13418 return tree_to_uhwi (TYPE_SIZE (type
));
13420 return TYPE_ALIGN (type
);
13423 /* Similarly, but return an offset_int instead of UHWI. */
13425 static inline offset_int
13426 offset_int_type_size_in_bits (const_tree type
)
13428 if (TREE_CODE (type
) == ERROR_MARK
)
13429 return BITS_PER_WORD
;
13430 else if (TYPE_SIZE (type
) == NULL_TREE
)
13432 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
13433 return wi::to_offset (TYPE_SIZE (type
));
13435 return TYPE_ALIGN (type
);
13438 /* Given a pointer to a tree node for a subrange type, return a pointer
13439 to a DIE that describes the given type. */
13442 subrange_type_die (tree type
, tree low
, tree high
, tree bias
,
13443 dw_die_ref context_die
)
13445 dw_die_ref subrange_die
;
13446 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
13448 if (context_die
== NULL
)
13449 context_die
= comp_unit_die ();
13451 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
13453 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
13455 /* The size of the subrange type and its base type do not match,
13456 so we need to generate a size attribute for the subrange type. */
13457 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
13460 add_alignment_attribute (subrange_die
, type
);
13463 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
, NULL
);
13465 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
, NULL
);
13466 if (bias
&& !dwarf_strict
)
13467 add_scalar_info (subrange_die
, DW_AT_GNU_bias
, bias
,
13468 dw_scalar_form_constant
13469 | dw_scalar_form_exprloc
13470 | dw_scalar_form_reference
,
13473 return subrange_die
;
13476 /* Returns the (const and/or volatile) cv_qualifiers associated with
13477 the decl node. This will normally be augmented with the
13478 cv_qualifiers of the underlying type in add_type_attribute. */
13481 decl_quals (const_tree decl
)
13483 return ((TREE_READONLY (decl
)
13484 /* The C++ front-end correctly marks reference-typed
13485 variables as readonly, but from a language (and debug
13486 info) standpoint they are not const-qualified. */
13487 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
13488 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
)
13489 | (TREE_THIS_VOLATILE (decl
)
13490 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
));
13493 /* Determine the TYPE whose qualifiers match the largest strict subset
13494 of the given TYPE_QUALS, and return its qualifiers. Ignore all
13495 qualifiers outside QUAL_MASK. */
13498 get_nearest_type_subqualifiers (tree type
, int type_quals
, int qual_mask
)
13501 int best_rank
= 0, best_qual
= 0, max_rank
;
13503 type_quals
&= qual_mask
;
13504 max_rank
= popcount_hwi (type_quals
) - 1;
13506 for (t
= TYPE_MAIN_VARIANT (type
); t
&& best_rank
< max_rank
;
13507 t
= TYPE_NEXT_VARIANT (t
))
13509 int q
= TYPE_QUALS (t
) & qual_mask
;
13511 if ((q
& type_quals
) == q
&& q
!= type_quals
13512 && check_base_type (t
, type
))
13514 int rank
= popcount_hwi (q
);
13516 if (rank
> best_rank
)
13527 struct dwarf_qual_info_t
{ int q
; enum dwarf_tag t
; };
13528 static const dwarf_qual_info_t dwarf_qual_info
[] =
13530 { TYPE_QUAL_CONST
, DW_TAG_const_type
},
13531 { TYPE_QUAL_VOLATILE
, DW_TAG_volatile_type
},
13532 { TYPE_QUAL_RESTRICT
, DW_TAG_restrict_type
},
13533 { TYPE_QUAL_ATOMIC
, DW_TAG_atomic_type
}
13535 static const unsigned int dwarf_qual_info_size
= ARRAY_SIZE (dwarf_qual_info
);
13537 /* If DIE is a qualified DIE of some base DIE with the same parent,
13538 return the base DIE, otherwise return NULL. Set MASK to the
13539 qualifiers added compared to the returned DIE. */
13542 qualified_die_p (dw_die_ref die
, int *mask
, unsigned int depth
)
13545 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13546 if (die
->die_tag
== dwarf_qual_info
[i
].t
)
13548 if (i
== dwarf_qual_info_size
)
13550 if (vec_safe_length (die
->die_attr
) != 1)
13552 dw_die_ref type
= get_AT_ref (die
, DW_AT_type
);
13553 if (type
== NULL
|| type
->die_parent
!= die
->die_parent
)
13555 *mask
|= dwarf_qual_info
[i
].q
;
13558 dw_die_ref ret
= qualified_die_p (type
, mask
, depth
- 1);
13565 /* If TYPE is long double or complex long double that
13566 should be emitted as artificial typedef to _Float128 or
13567 complex _Float128, return the type it should be emitted as.
13568 This is done in case the target already supports 16-byte
13569 composite floating point type (ibm_extended_format). */
13572 long_double_as_float128 (tree type
)
13574 if (type
!= long_double_type_node
13575 && type
!= complex_long_double_type_node
)
13578 machine_mode mode
, fmode
;
13579 if (TREE_CODE (type
) == COMPLEX_TYPE
)
13580 mode
= TYPE_MODE (TREE_TYPE (type
));
13582 mode
= TYPE_MODE (type
);
13583 if (known_eq (GET_MODE_SIZE (mode
), 16) && !MODE_COMPOSITE_P (mode
))
13584 FOR_EACH_MODE_IN_CLASS (fmode
, MODE_FLOAT
)
13585 if (known_eq (GET_MODE_SIZE (fmode
), 16)
13586 && MODE_COMPOSITE_P (fmode
))
13588 if (type
== long_double_type_node
)
13590 if (float128_type_node
13591 && (TYPE_MODE (float128_type_node
)
13592 == TYPE_MODE (type
)))
13593 return float128_type_node
;
13596 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
13597 if (COMPLEX_FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
13598 && (TYPE_MODE (COMPLEX_FLOATN_NX_TYPE_NODE (i
))
13599 == TYPE_MODE (type
)))
13600 return COMPLEX_FLOATN_NX_TYPE_NODE (i
);
13606 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
13607 entry that chains the modifiers specified by CV_QUALS in front of the
13608 given type. REVERSE is true if the type is to be interpreted in the
13609 reverse storage order wrt the target order. */
13612 modified_type_die (tree type
, int cv_quals
, bool reverse
,
13613 dw_die_ref context_die
)
13615 enum tree_code code
= TREE_CODE (type
);
13616 dw_die_ref mod_type_die
;
13617 dw_die_ref sub_die
= NULL
;
13618 tree item_type
= NULL
;
13619 tree qualified_type
;
13620 tree name
, low
, high
;
13621 dw_die_ref mod_scope
;
13622 struct array_descr_info info
;
13623 /* Only these cv-qualifiers are currently handled. */
13624 const int cv_qual_mask
= (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
13625 | TYPE_QUAL_RESTRICT
| TYPE_QUAL_ATOMIC
|
13626 ENCODE_QUAL_ADDR_SPACE(~0U));
13627 const bool reverse_base_type
13628 = need_endianity_attribute_p (reverse
) && is_base_type (type
);
13630 if (code
== ERROR_MARK
)
13633 if (lang_hooks
.types
.get_debug_type
)
13635 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
13637 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
13638 return modified_type_die (debug_type
, cv_quals
, reverse
, context_die
);
13641 cv_quals
&= cv_qual_mask
;
13643 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
13644 tag modifier (and not an attribute) old consumers won't be able
13646 if (dwarf_version
< 3)
13647 cv_quals
&= ~TYPE_QUAL_RESTRICT
;
13649 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
13650 if (dwarf_version
< 5)
13651 cv_quals
&= ~TYPE_QUAL_ATOMIC
;
13653 /* See if we already have the appropriately qualified variant of
13655 qualified_type
= get_qualified_type (type
, cv_quals
);
13657 if (qualified_type
== sizetype
)
13659 /* Try not to expose the internal sizetype type's name. */
13660 if (TYPE_NAME (qualified_type
)
13661 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
13663 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
13665 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
13666 && (TYPE_PRECISION (t
)
13667 == TYPE_PRECISION (qualified_type
))
13668 && (TYPE_UNSIGNED (t
)
13669 == TYPE_UNSIGNED (qualified_type
)));
13670 qualified_type
= t
;
13672 else if (qualified_type
== sizetype
13673 && TREE_CODE (sizetype
) == TREE_CODE (size_type_node
)
13674 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (size_type_node
)
13675 && TYPE_UNSIGNED (sizetype
) == TYPE_UNSIGNED (size_type_node
))
13676 qualified_type
= size_type_node
;
13677 if (type
== sizetype
)
13678 type
= qualified_type
;
13681 /* If we do, then we can just use its DIE, if it exists. */
13682 if (qualified_type
)
13684 mod_type_die
= lookup_type_die (qualified_type
);
13686 /* DW_AT_endianity doesn't come from a qualifier on the type, so it is
13687 dealt with specially: the DIE with the attribute, if it exists, is
13688 placed immediately after the regular DIE for the same base type. */
13690 && (!reverse_base_type
13691 || ((mod_type_die
= mod_type_die
->die_sib
) != NULL
13692 && get_AT_unsigned (mod_type_die
, DW_AT_endianity
))))
13693 return mod_type_die
;
13696 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
13698 /* Handle C typedef types. */
13700 && TREE_CODE (name
) == TYPE_DECL
13701 && DECL_ORIGINAL_TYPE (name
)
13702 && !DECL_ARTIFICIAL (name
))
13704 tree dtype
= TREE_TYPE (name
);
13706 /* Skip the typedef for base types with DW_AT_endianity, no big deal. */
13707 if (qualified_type
== dtype
&& !reverse_base_type
)
13709 tree origin
= decl_ultimate_origin (name
);
13711 /* Typedef variants that have an abstract origin don't get their own
13712 type DIE (see gen_typedef_die), so fall back on the ultimate
13713 abstract origin instead. */
13714 if (origin
!= NULL
&& origin
!= name
)
13715 return modified_type_die (TREE_TYPE (origin
), cv_quals
, reverse
,
13718 /* For a named type, use the typedef. */
13719 gen_type_die (qualified_type
, context_die
);
13720 return lookup_type_die (qualified_type
);
13724 int dquals
= TYPE_QUALS_NO_ADDR_SPACE (dtype
);
13725 dquals
&= cv_qual_mask
;
13726 if ((dquals
& ~cv_quals
) != TYPE_UNQUALIFIED
13727 || (cv_quals
== dquals
&& DECL_ORIGINAL_TYPE (name
) != type
))
13728 /* cv-unqualified version of named type. Just use
13729 the unnamed type to which it refers. */
13730 return modified_type_die (DECL_ORIGINAL_TYPE (name
), cv_quals
,
13731 reverse
, context_die
);
13732 /* Else cv-qualified version of named type; fall through. */
13736 mod_scope
= scope_die_for (type
, context_die
);
13740 int sub_quals
= 0, first_quals
= 0;
13742 dw_die_ref first
= NULL
, last
= NULL
;
13744 /* Determine a lesser qualified type that most closely matches
13745 this one. Then generate DW_TAG_* entries for the remaining
13747 sub_quals
= get_nearest_type_subqualifiers (type
, cv_quals
,
13749 if (sub_quals
&& use_debug_types
)
13751 bool needed
= false;
13752 /* If emitting type units, make sure the order of qualifiers
13753 is canonical. Thus, start from unqualified type if
13754 an earlier qualifier is missing in sub_quals, but some later
13755 one is present there. */
13756 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13757 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
13759 else if (needed
&& (dwarf_qual_info
[i
].q
& cv_quals
))
13765 mod_type_die
= modified_type_die (type
, sub_quals
, reverse
, context_die
);
13766 if (mod_scope
&& mod_type_die
&& mod_type_die
->die_parent
== mod_scope
)
13768 /* As not all intermediate qualified DIEs have corresponding
13769 tree types, ensure that qualified DIEs in the same scope
13770 as their DW_AT_type are emitted after their DW_AT_type,
13771 only with other qualified DIEs for the same type possibly
13772 in between them. Determine the range of such qualified
13773 DIEs now (first being the base type, last being corresponding
13774 last qualified DIE for it). */
13775 unsigned int count
= 0;
13776 first
= qualified_die_p (mod_type_die
, &first_quals
,
13777 dwarf_qual_info_size
);
13779 first
= mod_type_die
;
13780 gcc_assert ((first_quals
& ~sub_quals
) == 0);
13781 for (count
= 0, last
= first
;
13782 count
< (1U << dwarf_qual_info_size
);
13783 count
++, last
= last
->die_sib
)
13786 if (last
== mod_scope
->die_child
)
13788 if (qualified_die_p (last
->die_sib
, &quals
, dwarf_qual_info_size
)
13794 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13795 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
13798 if (first
&& first
!= last
)
13800 for (d
= first
->die_sib
; ; d
= d
->die_sib
)
13803 qualified_die_p (d
, &quals
, dwarf_qual_info_size
);
13804 if (quals
== (first_quals
| dwarf_qual_info
[i
].q
))
13820 d
= new_die_raw (dwarf_qual_info
[i
].t
);
13821 add_child_die_after (mod_scope
, d
, last
);
13825 d
= new_die (dwarf_qual_info
[i
].t
, mod_scope
, type
);
13827 add_AT_die_ref (d
, DW_AT_type
, mod_type_die
);
13829 first_quals
|= dwarf_qual_info
[i
].q
;
13832 else if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
)
13834 dwarf_tag tag
= DW_TAG_pointer_type
;
13835 if (code
== REFERENCE_TYPE
)
13837 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
13838 tag
= DW_TAG_rvalue_reference_type
;
13840 tag
= DW_TAG_reference_type
;
13842 mod_type_die
= new_die (tag
, mod_scope
, type
);
13844 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
13845 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
13846 add_alignment_attribute (mod_type_die
, type
);
13847 item_type
= TREE_TYPE (type
);
13849 addr_space_t as
= TYPE_ADDR_SPACE (item_type
);
13850 if (!ADDR_SPACE_GENERIC_P (as
))
13852 int action
= targetm
.addr_space
.debug (as
);
13855 /* Positive values indicate an address_class. */
13856 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, action
);
13860 /* Negative values indicate an (inverted) segment base reg. */
13862 = one_reg_loc_descriptor (~action
, VAR_INIT_STATUS_INITIALIZED
);
13863 add_AT_loc (mod_type_die
, DW_AT_segment
, d
);
13867 else if (code
== ARRAY_TYPE
13868 || (lang_hooks
.types
.get_array_descr_info
13869 && lang_hooks
.types
.get_array_descr_info (type
, &info
)))
13871 gen_type_die (type
, context_die
);
13872 return lookup_type_die (type
);
13874 else if (code
== INTEGER_TYPE
13875 && TREE_TYPE (type
) != NULL_TREE
13876 && subrange_type_for_debug_p (type
, &low
, &high
))
13878 tree bias
= NULL_TREE
;
13879 if (lang_hooks
.types
.get_type_bias
)
13880 bias
= lang_hooks
.types
.get_type_bias (type
);
13881 mod_type_die
= subrange_type_die (type
, low
, high
, bias
, context_die
);
13882 item_type
= TREE_TYPE (type
);
13884 else if (is_base_type (type
))
13886 /* If a target supports long double as different floating point
13887 modes with the same 16-byte size, use normal DW_TAG_base_type
13888 only for the composite (ibm_extended_real_format) type and
13889 for the other for the time being emit instead a "_Float128"
13890 or "complex _Float128" DW_TAG_base_type and a "long double"
13891 or "complex long double" typedef to it. */
13892 if (tree other_type
= long_double_as_float128 (type
))
13894 dw_die_ref other_die
;
13895 if (TYPE_NAME (other_type
))
13897 = modified_type_die (other_type
, TYPE_UNQUALIFIED
, reverse
,
13901 other_die
= base_type_die (type
, reverse
);
13902 add_child_die (comp_unit_die (), other_die
);
13903 add_name_attribute (other_die
,
13904 TREE_CODE (type
) == COMPLEX_TYPE
13905 ? "complex _Float128" : "_Float128");
13907 mod_type_die
= new_die_raw (DW_TAG_typedef
);
13908 add_AT_die_ref (mod_type_die
, DW_AT_type
, other_die
);
13911 mod_type_die
= base_type_die (type
, reverse
);
13913 /* The DIE with DW_AT_endianity is placed right after the naked DIE. */
13914 if (reverse_base_type
)
13916 dw_die_ref after_die
13917 = modified_type_die (type
, cv_quals
, false, context_die
);
13918 add_child_die_after (comp_unit_die (), mod_type_die
, after_die
);
13921 add_child_die (comp_unit_die (), mod_type_die
);
13923 add_pubtype (type
, mod_type_die
);
13927 gen_type_die (type
, context_die
);
13929 /* We have to get the type_main_variant here (and pass that to the
13930 `lookup_type_die' routine) because the ..._TYPE node we have
13931 might simply be a *copy* of some original type node (where the
13932 copy was created to help us keep track of typedef names) and
13933 that copy might have a different TYPE_UID from the original
13935 if (code
== FUNCTION_TYPE
|| code
== METHOD_TYPE
)
13937 /* For function/method types, can't just use type_main_variant here,
13938 because that can have different ref-qualifiers for C++,
13939 but try to canonicalize. */
13940 tree main
= TYPE_MAIN_VARIANT (type
);
13941 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
13942 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
13943 && check_base_type (t
, main
)
13944 && check_lang_type (t
, type
))
13945 return lookup_type_die (t
);
13946 return lookup_type_die (type
);
13948 /* Vectors have the debugging information in the type,
13949 not the main variant. */
13950 else if (code
== VECTOR_TYPE
)
13951 return lookup_type_die (type
);
13953 return lookup_type_die (type_main_variant (type
));
13956 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
13957 don't output a DW_TAG_typedef, since there isn't one in the
13958 user's program; just attach a DW_AT_name to the type.
13959 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
13960 if the base type already has the same name. */
13962 && ((TREE_CODE (name
) != TYPE_DECL
13963 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
13964 || (cv_quals
== TYPE_UNQUALIFIED
)))
13965 || (TREE_CODE (name
) == TYPE_DECL
13966 && TREE_TYPE (name
) == qualified_type
13967 && DECL_NAME (name
))))
13969 if (TREE_CODE (name
) == TYPE_DECL
)
13970 /* Could just call add_name_and_src_coords_attributes here,
13971 but since this is a builtin type it doesn't have any
13972 useful source coordinates anyway. */
13973 name
= DECL_NAME (name
);
13974 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
13976 /* This probably indicates a bug. */
13977 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
13979 name
= TYPE_IDENTIFIER (type
);
13980 add_name_attribute (mod_type_die
,
13981 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
13984 if (qualified_type
&& !reverse_base_type
)
13985 equate_type_number_to_die (qualified_type
, mod_type_die
);
13988 /* We must do this after the equate_type_number_to_die call, in case
13989 this is a recursive type. This ensures that the modified_type_die
13990 recursion will terminate even if the type is recursive. Recursive
13991 types are possible in Ada. */
13992 sub_die
= modified_type_die (item_type
,
13993 TYPE_QUALS_NO_ADDR_SPACE (item_type
),
13997 if (sub_die
!= NULL
)
13998 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
14000 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
14001 if (TYPE_ARTIFICIAL (type
))
14002 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
14004 return mod_type_die
;
14007 /* Generate DIEs for the generic parameters of T.
14008 T must be either a generic type or a generic function.
14009 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
14012 gen_generic_params_dies (tree t
)
14016 dw_die_ref die
= NULL
;
14019 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
14023 die
= lookup_type_die (t
);
14024 else if (DECL_P (t
))
14025 die
= lookup_decl_die (t
);
14029 parms
= lang_hooks
.get_innermost_generic_parms (t
);
14031 /* T has no generic parameter. It means T is neither a generic type
14032 or function. End of story. */
14035 parms_num
= TREE_VEC_LENGTH (parms
);
14036 args
= lang_hooks
.get_innermost_generic_args (t
);
14037 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
14038 non_default
= int_cst_value (TREE_CHAIN (args
));
14040 non_default
= TREE_VEC_LENGTH (args
);
14041 for (i
= 0; i
< parms_num
; i
++)
14043 tree parm
, arg
, arg_pack_elems
;
14044 dw_die_ref parm_die
;
14046 parm
= TREE_VEC_ELT (parms
, i
);
14047 arg
= TREE_VEC_ELT (args
, i
);
14048 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
14049 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
14051 if (parm
&& TREE_VALUE (parm
) && arg
)
14053 /* If PARM represents a template parameter pack,
14054 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
14055 by DW_TAG_template_*_parameter DIEs for the argument
14056 pack elements of ARG. Note that ARG would then be
14057 an argument pack. */
14058 if (arg_pack_elems
)
14059 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
14063 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
14064 true /* emit name */, die
);
14065 if (i
>= non_default
)
14066 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
14071 /* Create and return a DIE for PARM which should be
14072 the representation of a generic type parameter.
14073 For instance, in the C++ front end, PARM would be a template parameter.
14074 ARG is the argument to PARM.
14075 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
14077 PARENT_DIE is the parent DIE which the new created DIE should be added to,
14078 as a child node. */
14081 generic_parameter_die (tree parm
, tree arg
,
14083 dw_die_ref parent_die
)
14085 dw_die_ref tmpl_die
= NULL
;
14086 const char *name
= NULL
;
14088 /* C++20 accepts class literals as template parameters, and var
14089 decls with initializers represent them. The VAR_DECLs would be
14090 rejected, but we can take the DECL_INITIAL constructor and
14091 attempt to expand it. */
14092 if (arg
&& VAR_P (arg
))
14093 arg
= DECL_INITIAL (arg
);
14095 if (!parm
|| !DECL_NAME (parm
) || !arg
)
14098 /* We support non-type generic parameters and arguments,
14099 type generic parameters and arguments, as well as
14100 generic generic parameters (a.k.a. template template parameters in C++)
14102 if (TREE_CODE (parm
) == PARM_DECL
)
14103 /* PARM is a nontype generic parameter */
14104 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
14105 else if (TREE_CODE (parm
) == TYPE_DECL
)
14106 /* PARM is a type generic parameter. */
14107 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
14108 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
14109 /* PARM is a generic generic parameter.
14110 Its DIE is a GNU extension. It shall have a
14111 DW_AT_name attribute to represent the name of the template template
14112 parameter, and a DW_AT_GNU_template_name attribute to represent the
14113 name of the template template argument. */
14114 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
14117 gcc_unreachable ();
14123 /* If PARM is a generic parameter pack, it means we are
14124 emitting debug info for a template argument pack element.
14125 In other terms, ARG is a template argument pack element.
14126 In that case, we don't emit any DW_AT_name attribute for
14130 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
14132 add_AT_string (tmpl_die
, DW_AT_name
, name
);
14135 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
14137 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
14138 TMPL_DIE should have a child DW_AT_type attribute that is set
14139 to the type of the argument to PARM, which is ARG.
14140 If PARM is a type generic parameter, TMPL_DIE should have a
14141 child DW_AT_type that is set to ARG. */
14142 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
14143 add_type_attribute (tmpl_die
, tmpl_type
,
14144 (TREE_THIS_VOLATILE (tmpl_type
)
14145 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
),
14146 false, parent_die
);
14150 /* So TMPL_DIE is a DIE representing a
14151 a generic generic template parameter, a.k.a template template
14152 parameter in C++ and arg is a template. */
14154 /* The DW_AT_GNU_template_name attribute of the DIE must be set
14155 to the name of the argument. */
14156 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
14158 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
14161 if (TREE_CODE (parm
) == PARM_DECL
)
14162 /* So PARM is a non-type generic parameter.
14163 DWARF3 5.6.8 says we must set a DW_AT_const_value child
14164 attribute of TMPL_DIE which value represents the value
14166 We must be careful here:
14167 The value of ARG might reference some function decls.
14168 We might currently be emitting debug info for a generic
14169 type and types are emitted before function decls, we don't
14170 know if the function decls referenced by ARG will actually be
14171 emitted after cgraph computations.
14172 So must defer the generation of the DW_AT_const_value to
14173 after cgraph is ready. */
14174 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
14180 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
14181 PARM_PACK must be a template parameter pack. The returned DIE
14182 will be child DIE of PARENT_DIE. */
14185 template_parameter_pack_die (tree parm_pack
,
14186 tree parm_pack_args
,
14187 dw_die_ref parent_die
)
14192 gcc_assert (parent_die
&& parm_pack
);
14194 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
14195 add_name_and_src_coords_attributes (die
, parm_pack
);
14196 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
14197 generic_parameter_die (parm_pack
,
14198 TREE_VEC_ELT (parm_pack_args
, j
),
14199 false /* Don't emit DW_AT_name */,
14204 /* Return the DBX register number described by a given RTL node. */
14206 static unsigned int
14207 dbx_reg_number (const_rtx rtl
)
14209 unsigned regno
= REGNO (rtl
);
14211 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
14213 #ifdef LEAF_REG_REMAP
14214 if (crtl
->uses_only_leaf_regs
)
14216 int leaf_reg
= LEAF_REG_REMAP (regno
);
14217 if (leaf_reg
!= -1)
14218 regno
= (unsigned) leaf_reg
;
14222 regno
= DBX_REGISTER_NUMBER (regno
);
14223 gcc_assert (regno
!= INVALID_REGNUM
);
14227 /* Optionally add a DW_OP_piece term to a location description expression.
14228 DW_OP_piece is only added if the location description expression already
14229 doesn't end with DW_OP_piece. */
14232 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
14234 dw_loc_descr_ref loc
;
14236 if (*list_head
!= NULL
)
14238 /* Find the end of the chain. */
14239 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
14242 if (loc
->dw_loc_opc
!= DW_OP_piece
)
14243 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
14247 /* Return a location descriptor that designates a machine register or
14248 zero if there is none. */
14250 static dw_loc_descr_ref
14251 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
14255 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
14258 /* We only use "frame base" when we're sure we're talking about the
14259 post-prologue local stack frame. We do this by *not* running
14260 register elimination until this point, and recognizing the special
14261 argument pointer and soft frame pointer rtx's.
14262 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
14263 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
14264 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
14266 dw_loc_descr_ref result
= NULL
;
14268 if (dwarf_version
>= 4 || !dwarf_strict
)
14270 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
14273 add_loc_descr (&result
,
14274 new_loc_descr (DW_OP_stack_value
, 0, 0));
14279 regs
= targetm
.dwarf_register_span (rtl
);
14281 if (REG_NREGS (rtl
) > 1 || regs
)
14282 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
14285 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
14286 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
14288 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
14292 /* Return a location descriptor that designates a machine register for
14293 a given hard register number. */
14295 static dw_loc_descr_ref
14296 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
14298 dw_loc_descr_ref reg_loc_descr
;
14302 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
14304 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
14306 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14307 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14309 return reg_loc_descr
;
14312 /* Given an RTL of a register, return a location descriptor that
14313 designates a value that spans more than one register. */
14315 static dw_loc_descr_ref
14316 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
14317 enum var_init_status initialized
)
14320 dw_loc_descr_ref loc_result
= NULL
;
14322 /* Simple, contiguous registers. */
14323 if (regs
== NULL_RTX
)
14325 unsigned reg
= REGNO (rtl
);
14328 #ifdef LEAF_REG_REMAP
14329 if (crtl
->uses_only_leaf_regs
)
14331 int leaf_reg
= LEAF_REG_REMAP (reg
);
14332 if (leaf_reg
!= -1)
14333 reg
= (unsigned) leaf_reg
;
14337 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
14338 nregs
= REG_NREGS (rtl
);
14340 /* At present we only track constant-sized pieces. */
14341 if (!GET_MODE_SIZE (GET_MODE (rtl
)).is_constant (&size
))
14348 dw_loc_descr_ref t
;
14350 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
14351 VAR_INIT_STATUS_INITIALIZED
);
14352 add_loc_descr (&loc_result
, t
);
14353 add_loc_descr_op_piece (&loc_result
, size
);
14359 /* Now onto stupid register sets in non contiguous locations. */
14361 gcc_assert (GET_CODE (regs
) == PARALLEL
);
14363 /* At present we only track constant-sized pieces. */
14364 if (!GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0))).is_constant (&size
))
14368 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
14370 dw_loc_descr_ref t
;
14372 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
14373 VAR_INIT_STATUS_INITIALIZED
);
14374 add_loc_descr (&loc_result
, t
);
14375 add_loc_descr_op_piece (&loc_result
, size
);
14378 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14379 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14383 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
14385 /* Return a location descriptor that designates a constant i,
14386 as a compound operation from constant (i >> shift), constant shift
14389 static dw_loc_descr_ref
14390 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
14392 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
14393 add_loc_descr (&ret
, int_loc_descriptor (shift
));
14394 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
14398 /* Return a location descriptor that designates constant POLY_I. */
14400 static dw_loc_descr_ref
14401 int_loc_descriptor (poly_int64 poly_i
)
14403 enum dwarf_location_atom op
;
14406 if (!poly_i
.is_constant (&i
))
14408 /* Create location descriptions for the non-constant part and
14409 add any constant offset at the end. */
14410 dw_loc_descr_ref ret
= NULL
;
14411 HOST_WIDE_INT constant
= poly_i
.coeffs
[0];
14412 for (unsigned int j
= 1; j
< NUM_POLY_INT_COEFFS
; ++j
)
14414 HOST_WIDE_INT coeff
= poly_i
.coeffs
[j
];
14417 dw_loc_descr_ref start
= ret
;
14418 unsigned int factor
;
14420 unsigned int regno
= targetm
.dwarf_poly_indeterminate_value
14421 (j
, &factor
, &bias
);
14423 /* Add COEFF * ((REGNO / FACTOR) - BIAS) to the value:
14424 add COEFF * (REGNO / FACTOR) now and subtract
14425 COEFF * BIAS from the final constant part. */
14426 constant
-= coeff
* bias
;
14427 add_loc_descr (&ret
, new_reg_loc_descr (regno
, 0));
14428 if (coeff
% factor
== 0)
14432 int amount
= exact_log2 (factor
);
14433 gcc_assert (amount
>= 0);
14434 add_loc_descr (&ret
, int_loc_descriptor (amount
));
14435 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
14439 add_loc_descr (&ret
, int_loc_descriptor (coeff
));
14440 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
14443 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
14446 loc_descr_plus_const (&ret
, constant
);
14450 /* Pick the smallest representation of a constant, rather than just
14451 defaulting to the LEB encoding. */
14454 int clz
= clz_hwi (i
);
14455 int ctz
= ctz_hwi (i
);
14457 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
14458 else if (i
<= 0xff)
14459 op
= DW_OP_const1u
;
14460 else if (i
<= 0xffff)
14461 op
= DW_OP_const2u
;
14462 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
14463 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
14464 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
14465 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
14466 while DW_OP_const4u is 5 bytes. */
14467 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
14468 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14469 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
14470 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
14471 while DW_OP_const4u is 5 bytes. */
14472 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
14474 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
14475 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
14478 /* As i >= 2**31, the double cast above will yield a negative number.
14479 Since wrapping is defined in DWARF expressions we can output big
14480 positive integers as small negative ones, regardless of the size
14483 Here, since the evaluator will handle 32-bit values and since i >=
14484 2**31, we know it's going to be interpreted as a negative literal:
14485 store it this way if we can do better than 5 bytes this way. */
14486 return int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
14488 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14489 op
= DW_OP_const4u
;
14491 /* Past this point, i >= 0x100000000 and thus DW_OP_constu will take at
14492 least 6 bytes: see if we can do better before falling back to it. */
14493 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14494 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
14495 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes. */
14496 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
14497 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
14498 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
14499 >= HOST_BITS_PER_WIDE_INT
)
14500 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
14501 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes. */
14502 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
14503 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
14504 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
14505 && size_of_uleb128 (i
) > 6)
14506 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
14507 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
14514 op
= DW_OP_const1s
;
14515 else if (i
>= -0x8000)
14516 op
= DW_OP_const2s
;
14517 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
14519 if (size_of_int_loc_descriptor (i
) < 5)
14521 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
14522 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14525 op
= DW_OP_const4s
;
14529 if (size_of_int_loc_descriptor (i
)
14530 < (unsigned long) 1 + size_of_sleb128 (i
))
14532 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
14533 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14540 return new_loc_descr (op
, i
, 0);
14543 /* Likewise, for unsigned constants. */
14545 static dw_loc_descr_ref
14546 uint_loc_descriptor (unsigned HOST_WIDE_INT i
)
14548 const unsigned HOST_WIDE_INT max_int
= INTTYPE_MAXIMUM (HOST_WIDE_INT
);
14549 const unsigned HOST_WIDE_INT max_uint
14550 = INTTYPE_MAXIMUM (unsigned HOST_WIDE_INT
);
14552 /* If possible, use the clever signed constants handling. */
14554 return int_loc_descriptor ((HOST_WIDE_INT
) i
);
14556 /* Here, we are left with positive numbers that cannot be represented as
14557 HOST_WIDE_INT, i.e.:
14558 max (HOST_WIDE_INT) < i <= max (unsigned HOST_WIDE_INT)
14560 Using DW_OP_const4/8/./u operation to encode them consumes a lot of bytes
14561 whereas may be better to output a negative integer: thanks to integer
14562 wrapping, we know that:
14563 x = x - 2 ** DWARF2_ADDR_SIZE
14564 = x - 2 * (max (HOST_WIDE_INT) + 1)
14565 So numbers close to max (unsigned HOST_WIDE_INT) could be represented as
14566 small negative integers. Let's try that in cases it will clearly improve
14567 the encoding: there is no gain turning DW_OP_const4u into
14569 if (DWARF2_ADDR_SIZE
* 8 == HOST_BITS_PER_WIDE_INT
14570 && ((DWARF2_ADDR_SIZE
== 4 && i
> max_uint
- 0x8000)
14571 || (DWARF2_ADDR_SIZE
== 8 && i
> max_uint
- 0x80000000)))
14573 const unsigned HOST_WIDE_INT first_shift
= i
- max_int
- 1;
14575 /* Now, -1 < first_shift <= max (HOST_WIDE_INT)
14576 i.e. 0 <= first_shift <= max (HOST_WIDE_INT). */
14577 const HOST_WIDE_INT second_shift
14578 = (HOST_WIDE_INT
) first_shift
- (HOST_WIDE_INT
) max_int
- 1;
14580 /* So we finally have:
14581 -max (HOST_WIDE_INT) - 1 <= second_shift <= -1.
14582 i.e. min (HOST_WIDE_INT) <= second_shift < 0. */
14583 return int_loc_descriptor (second_shift
);
14586 /* Last chance: fallback to a simple constant operation. */
14587 return new_loc_descr
14588 ((HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14594 /* Generate and return a location description that computes the unsigned
14595 comparison of the two stack top entries (a OP b where b is the top-most
14596 entry and a is the second one). The KIND of comparison can be LT_EXPR,
14597 LE_EXPR, GT_EXPR or GE_EXPR. */
14599 static dw_loc_descr_ref
14600 uint_comparison_loc_list (enum tree_code kind
)
14602 enum dwarf_location_atom op
, flip_op
;
14603 dw_loc_descr_ref ret
, bra_node
, jmp_node
, tmp
;
14620 gcc_unreachable ();
14623 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14624 jmp_node
= new_loc_descr (DW_OP_skip
, 0, 0);
14626 /* Until DWARFv4, operations all work on signed integers. It is nevertheless
14627 possible to perform unsigned comparisons: we just have to distinguish
14630 1. when a and b have the same sign (as signed integers); then we should
14631 return: a OP(signed) b;
14633 2. when a is a negative signed integer while b is a positive one, then a
14634 is a greater unsigned integer than b; likewise when a and b's roles
14637 So first, compare the sign of the two operands. */
14638 ret
= new_loc_descr (DW_OP_over
, 0, 0);
14639 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
14640 add_loc_descr (&ret
, new_loc_descr (DW_OP_xor
, 0, 0));
14641 /* If they have different signs (i.e. they have different sign bits), then
14642 the stack top value has now the sign bit set and thus it's smaller than
14644 add_loc_descr (&ret
, new_loc_descr (DW_OP_lit0
, 0, 0));
14645 add_loc_descr (&ret
, new_loc_descr (DW_OP_lt
, 0, 0));
14646 add_loc_descr (&ret
, bra_node
);
14648 /* We are in case 1. At this point, we know both operands have the same
14649 sign, to it's safe to use the built-in signed comparison. */
14650 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14651 add_loc_descr (&ret
, jmp_node
);
14653 /* We are in case 2. Here, we know both operands do not have the same sign,
14654 so we have to flip the signed comparison. */
14655 flip_op
= (kind
== LT_EXPR
|| kind
== LE_EXPR
) ? DW_OP_gt
: DW_OP_lt
;
14656 tmp
= new_loc_descr (flip_op
, 0, 0);
14657 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14658 bra_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14659 add_loc_descr (&ret
, tmp
);
14661 /* This dummy operation is necessary to make the two branches join. */
14662 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
14663 jmp_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14664 jmp_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14665 add_loc_descr (&ret
, tmp
);
14670 /* Likewise, but takes the location description lists (might be destructive on
14671 them). Return NULL if either is NULL or if concatenation fails. */
14673 static dw_loc_list_ref
14674 loc_list_from_uint_comparison (dw_loc_list_ref left
, dw_loc_list_ref right
,
14675 enum tree_code kind
)
14677 if (left
== NULL
|| right
== NULL
)
14680 add_loc_list (&left
, right
);
14684 add_loc_descr_to_each (left
, uint_comparison_loc_list (kind
));
14688 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
14689 without actually allocating it. */
14691 static unsigned long
14692 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
14694 return size_of_int_loc_descriptor (i
>> shift
)
14695 + size_of_int_loc_descriptor (shift
)
14699 /* Return size_of_locs (int_loc_descriptor (i)) without
14700 actually allocating it. */
14702 static unsigned long
14703 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
14712 else if (i
<= 0xff)
14714 else if (i
<= 0xffff)
14718 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
14719 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
14720 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14722 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14723 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
14724 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14726 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
14727 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
14729 return size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
14730 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14732 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
14733 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14734 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
14735 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14737 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
14738 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
14739 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14741 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
14742 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
14744 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14753 else if (i
>= -0x8000)
14755 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
14757 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
14759 s
= size_of_int_loc_descriptor (-i
) + 1;
14767 unsigned long r
= 1 + size_of_sleb128 (i
);
14768 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
14770 s
= size_of_int_loc_descriptor (-i
) + 1;
14779 /* Return loc description representing "address" of integer value.
14780 This can appear only as toplevel expression. */
14782 static dw_loc_descr_ref
14783 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
14786 dw_loc_descr_ref loc_result
= NULL
;
14788 if (!(dwarf_version
>= 4 || !dwarf_strict
))
14791 litsize
= size_of_int_loc_descriptor (i
);
14792 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
14793 is more compact. For DW_OP_stack_value we need:
14794 litsize + 1 (DW_OP_stack_value)
14795 and for DW_OP_implicit_value:
14796 1 (DW_OP_implicit_value) + 1 (length) + size. */
14797 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
14799 loc_result
= int_loc_descriptor (i
);
14800 add_loc_descr (&loc_result
,
14801 new_loc_descr (DW_OP_stack_value
, 0, 0));
14805 loc_result
= new_loc_descr (DW_OP_implicit_value
,
14807 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
14808 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
14812 /* Return a location descriptor that designates a base+offset location. */
14814 static dw_loc_descr_ref
14815 based_loc_descr (rtx reg
, poly_int64 offset
,
14816 enum var_init_status initialized
)
14818 unsigned int regno
;
14819 dw_loc_descr_ref result
;
14820 dw_fde_ref fde
= cfun
->fde
;
14822 /* We only use "frame base" when we're sure we're talking about the
14823 post-prologue local stack frame. We do this by *not* running
14824 register elimination until this point, and recognizing the special
14825 argument pointer and soft frame pointer rtx's. */
14826 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
14828 rtx elim
= (ira_use_lra_p
14829 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
14830 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
14834 /* Allow hard frame pointer here even if frame pointer
14835 isn't used since hard frame pointer is encoded with
14836 DW_OP_fbreg which uses the DW_AT_frame_base attribute,
14837 not hard frame pointer directly. */
14838 elim
= strip_offset_and_add (elim
, &offset
);
14839 gcc_assert (elim
== hard_frame_pointer_rtx
14840 || elim
== stack_pointer_rtx
);
14842 /* If drap register is used to align stack, use frame
14843 pointer + offset to access stack variables. If stack
14844 is aligned without drap, use stack pointer + offset to
14845 access stack variables. */
14846 if (crtl
->stack_realign_tried
14847 && reg
== frame_pointer_rtx
)
14850 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
14851 ? HARD_FRAME_POINTER_REGNUM
14853 return new_reg_loc_descr (base_reg
, offset
);
14856 gcc_assert (frame_pointer_fb_offset_valid
);
14857 offset
+= frame_pointer_fb_offset
;
14858 HOST_WIDE_INT const_offset
;
14859 if (offset
.is_constant (&const_offset
))
14860 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
14863 dw_loc_descr_ref ret
= new_loc_descr (DW_OP_fbreg
, 0, 0);
14864 loc_descr_plus_const (&ret
, offset
);
14870 regno
= REGNO (reg
);
14871 #ifdef LEAF_REG_REMAP
14872 if (crtl
->uses_only_leaf_regs
)
14874 int leaf_reg
= LEAF_REG_REMAP (regno
);
14875 if (leaf_reg
!= -1)
14876 regno
= (unsigned) leaf_reg
;
14879 regno
= DWARF_FRAME_REGNUM (regno
);
14881 HOST_WIDE_INT const_offset
;
14882 if (!optimize
&& fde
14883 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
)
14884 && offset
.is_constant (&const_offset
))
14886 /* Use cfa+offset to represent the location of arguments passed
14887 on the stack when drap is used to align stack.
14888 Only do this when not optimizing, for optimized code var-tracking
14889 is supposed to track where the arguments live and the register
14890 used as vdrap or drap in some spot might be used for something
14891 else in other part of the routine. */
14892 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
14895 result
= new_reg_loc_descr (regno
, offset
);
14897 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14898 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14903 /* Return true if this RTL expression describes a base+offset calculation. */
14906 is_based_loc (const_rtx rtl
)
14908 return (GET_CODE (rtl
) == PLUS
14909 && ((REG_P (XEXP (rtl
, 0))
14910 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
14911 && CONST_INT_P (XEXP (rtl
, 1)))));
14914 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
14917 static dw_loc_descr_ref
14918 tls_mem_loc_descriptor (rtx mem
)
14921 dw_loc_descr_ref loc_result
;
14923 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
14926 base
= get_base_address (MEM_EXPR (mem
));
14929 || !DECL_THREAD_LOCAL_P (base
))
14932 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1, NULL
);
14933 if (loc_result
== NULL
)
14936 if (maybe_ne (MEM_OFFSET (mem
), 0))
14937 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
14942 /* Output debug info about reason why we failed to expand expression as dwarf
14946 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
14948 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
14950 fprintf (dump_file
, "Failed to expand as dwarf: ");
14952 print_generic_expr (dump_file
, expr
, dump_flags
);
14955 fprintf (dump_file
, "\n");
14956 print_rtl (dump_file
, rtl
);
14958 fprintf (dump_file
, "\nReason: %s\n", reason
);
14962 /* Helper function for const_ok_for_output. */
14965 const_ok_for_output_1 (rtx rtl
)
14967 if (targetm
.const_not_ok_for_debug_p (rtl
))
14969 if (GET_CODE (rtl
) != UNSPEC
)
14971 expansion_failed (NULL_TREE
, rtl
,
14972 "Expression rejected for debug by the backend.\n");
14976 /* If delegitimize_address couldn't do anything with the UNSPEC, and
14977 the target hook doesn't explicitly allow it in debug info, assume
14978 we can't express it in the debug info. */
14979 /* Don't complain about TLS UNSPECs, those are just too hard to
14980 delegitimize. Note this could be a non-decl SYMBOL_REF such as
14981 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
14982 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
14984 && (XVECLEN (rtl
, 0) == 0
14985 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
14986 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
))
14987 inform (current_function_decl
14988 ? DECL_SOURCE_LOCATION (current_function_decl
)
14989 : UNKNOWN_LOCATION
,
14990 #if NUM_UNSPEC_VALUES > 0
14991 "non-delegitimized UNSPEC %s (%d) found in variable location",
14992 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
14993 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
14995 "non-delegitimized UNSPEC %d found in variable location",
14998 expansion_failed (NULL_TREE
, rtl
,
14999 "UNSPEC hasn't been delegitimized.\n");
15003 if (CONST_POLY_INT_P (rtl
))
15006 /* FIXME: Refer to PR60655. It is possible for simplification
15007 of rtl expressions in var tracking to produce such expressions.
15008 We should really identify / validate expressions
15009 enclosed in CONST that can be handled by assemblers on various
15010 targets and only handle legitimate cases here. */
15011 switch (GET_CODE (rtl
))
15020 /* Make sure SYMBOL_REFs/UNSPECs are at most in one of the
15022 subrtx_var_iterator::array_type array
;
15023 bool first
= false;
15024 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
15025 if (SYMBOL_REF_P (*iter
)
15027 || GET_CODE (*iter
) == UNSPEC
)
15034 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 1), ALL
)
15035 if (SYMBOL_REF_P (*iter
)
15037 || GET_CODE (*iter
) == UNSPEC
)
15043 /* Disallow negation of SYMBOL_REFs or UNSPECs when they
15044 appear in the second operand of MINUS. */
15045 subrtx_var_iterator::array_type array
;
15046 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 1), ALL
)
15047 if (SYMBOL_REF_P (*iter
)
15049 || GET_CODE (*iter
) == UNSPEC
)
15057 if (CONSTANT_POOL_ADDRESS_P (rtl
))
15060 get_pool_constant_mark (rtl
, &marked
);
15061 /* If all references to this pool constant were optimized away,
15062 it was not output and thus we can't represent it. */
15065 expansion_failed (NULL_TREE
, rtl
,
15066 "Constant was removed from constant pool.\n");
15071 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
15074 /* Avoid references to external symbols in debug info, on several targets
15075 the linker might even refuse to link when linking a shared library,
15076 and in many other cases the relocations for .debug_info/.debug_loc are
15077 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
15078 to be defined within the same shared library or executable are fine. */
15079 if (SYMBOL_REF_EXTERNAL_P (rtl
))
15081 tree decl
= SYMBOL_REF_DECL (rtl
);
15083 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
15085 expansion_failed (NULL_TREE
, rtl
,
15086 "Symbol not defined in current TU.\n");
15094 /* Return true if constant RTL can be emitted in DW_OP_addr or
15095 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
15096 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
15099 const_ok_for_output (rtx rtl
)
15101 if (GET_CODE (rtl
) == SYMBOL_REF
)
15102 return const_ok_for_output_1 (rtl
);
15104 if (GET_CODE (rtl
) == CONST
)
15106 subrtx_var_iterator::array_type array
;
15107 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
15108 if (!const_ok_for_output_1 (*iter
))
15116 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
15117 if possible, NULL otherwise. */
15120 base_type_for_mode (machine_mode mode
, bool unsignedp
)
15122 dw_die_ref type_die
;
15123 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
15127 switch (TREE_CODE (type
))
15135 type_die
= lookup_type_die (type
);
15137 type_die
= modified_type_die (type
, TYPE_UNQUALIFIED
, false,
15139 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
15144 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
15145 type matching MODE, or, if MODE is narrower than or as wide as
15146 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
15149 static dw_loc_descr_ref
15150 convert_descriptor_to_mode (scalar_int_mode mode
, dw_loc_descr_ref op
)
15152 machine_mode outer_mode
= mode
;
15153 dw_die_ref type_die
;
15154 dw_loc_descr_ref cvt
;
15156 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
15158 add_loc_descr (&op
, new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0));
15161 type_die
= base_type_for_mode (outer_mode
, 1);
15162 if (type_die
== NULL
)
15164 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15165 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15166 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15167 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15168 add_loc_descr (&op
, cvt
);
15172 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
15174 static dw_loc_descr_ref
15175 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
15176 dw_loc_descr_ref op1
)
15178 dw_loc_descr_ref ret
= op0
;
15179 add_loc_descr (&ret
, op1
);
15180 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
15181 if (STORE_FLAG_VALUE
!= 1)
15183 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
15184 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
15189 /* Subroutine of scompare_loc_descriptor for the case in which we're
15190 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
15191 and in which OP_MODE is bigger than DWARF2_ADDR_SIZE. */
15193 static dw_loc_descr_ref
15194 scompare_loc_descriptor_wide (enum dwarf_location_atom op
,
15195 scalar_int_mode op_mode
,
15196 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
15198 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
15199 dw_loc_descr_ref cvt
;
15201 if (type_die
== NULL
)
15203 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15204 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15205 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15206 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15207 add_loc_descr (&op0
, cvt
);
15208 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15209 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15210 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15211 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15212 add_loc_descr (&op1
, cvt
);
15213 return compare_loc_descriptor (op
, op0
, op1
);
15216 /* Subroutine of scompare_loc_descriptor for the case in which we're
15217 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
15218 and in which OP_MODE is smaller than DWARF2_ADDR_SIZE. */
15220 static dw_loc_descr_ref
15221 scompare_loc_descriptor_narrow (enum dwarf_location_atom op
, rtx rtl
,
15222 scalar_int_mode op_mode
,
15223 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
15225 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
15226 /* For eq/ne, if the operands are known to be zero-extended,
15227 there is no need to do the fancy shifting up. */
15228 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
15230 dw_loc_descr_ref last0
, last1
;
15231 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
15233 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
15235 /* deref_size zero extends, and for constants we can check
15236 whether they are zero extended or not. */
15237 if (((last0
->dw_loc_opc
== DW_OP_deref_size
15238 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
15239 || (CONST_INT_P (XEXP (rtl
, 0))
15240 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
15241 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
15242 && ((last1
->dw_loc_opc
== DW_OP_deref_size
15243 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
15244 || (CONST_INT_P (XEXP (rtl
, 1))
15245 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
15246 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
15247 return compare_loc_descriptor (op
, op0
, op1
);
15249 /* EQ/NE comparison against constant in narrower type than
15250 DWARF2_ADDR_SIZE can be performed either as
15251 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
15254 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
15255 DW_OP_{eq,ne}. Pick whatever is shorter. */
15256 if (CONST_INT_P (XEXP (rtl
, 1))
15257 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
15258 && (size_of_int_loc_descriptor (shift
) + 1
15259 + size_of_int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
)
15260 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
15261 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
15262 & GET_MODE_MASK (op_mode
))))
15264 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
15265 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
15266 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
15267 & GET_MODE_MASK (op_mode
));
15268 return compare_loc_descriptor (op
, op0
, op1
);
15271 add_loc_descr (&op0
, int_loc_descriptor (shift
));
15272 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
15273 if (CONST_INT_P (XEXP (rtl
, 1)))
15274 op1
= int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
);
15277 add_loc_descr (&op1
, int_loc_descriptor (shift
));
15278 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
15280 return compare_loc_descriptor (op
, op0
, op1
);
15283 /* Return location descriptor for signed comparison OP RTL. */
15285 static dw_loc_descr_ref
15286 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
15287 machine_mode mem_mode
)
15289 machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
15290 dw_loc_descr_ref op0
, op1
;
15292 if (op_mode
== VOIDmode
)
15293 op_mode
= GET_MODE (XEXP (rtl
, 1));
15294 if (op_mode
== VOIDmode
)
15297 scalar_int_mode int_op_mode
;
15299 && dwarf_version
< 5
15300 && (!is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
)
15301 || GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
))
15304 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
15305 VAR_INIT_STATUS_INITIALIZED
);
15306 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
15307 VAR_INIT_STATUS_INITIALIZED
);
15309 if (op0
== NULL
|| op1
== NULL
)
15312 if (is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
))
15314 if (GET_MODE_SIZE (int_op_mode
) < DWARF2_ADDR_SIZE
)
15315 return scompare_loc_descriptor_narrow (op
, rtl
, int_op_mode
, op0
, op1
);
15317 if (GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
)
15318 return scompare_loc_descriptor_wide (op
, int_op_mode
, op0
, op1
);
15320 return compare_loc_descriptor (op
, op0
, op1
);
15323 /* Return location descriptor for unsigned comparison OP RTL. */
15325 static dw_loc_descr_ref
15326 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
15327 machine_mode mem_mode
)
15329 dw_loc_descr_ref op0
, op1
;
15331 machine_mode test_op_mode
= GET_MODE (XEXP (rtl
, 0));
15332 if (test_op_mode
== VOIDmode
)
15333 test_op_mode
= GET_MODE (XEXP (rtl
, 1));
15335 scalar_int_mode op_mode
;
15336 if (!is_a
<scalar_int_mode
> (test_op_mode
, &op_mode
))
15340 && dwarf_version
< 5
15341 && GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
15344 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
15345 VAR_INIT_STATUS_INITIALIZED
);
15346 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
15347 VAR_INIT_STATUS_INITIALIZED
);
15349 if (op0
== NULL
|| op1
== NULL
)
15352 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
15354 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
15355 dw_loc_descr_ref last0
, last1
;
15356 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
15358 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
15360 if (CONST_INT_P (XEXP (rtl
, 0)))
15361 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
15362 /* deref_size zero extends, so no need to mask it again. */
15363 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
15364 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
15366 add_loc_descr (&op0
, int_loc_descriptor (mask
));
15367 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
15369 if (CONST_INT_P (XEXP (rtl
, 1)))
15370 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
15371 /* deref_size zero extends, so no need to mask it again. */
15372 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
15373 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
15375 add_loc_descr (&op1
, int_loc_descriptor (mask
));
15376 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
15379 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
15381 HOST_WIDE_INT bias
= 1;
15382 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
15383 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
15384 if (CONST_INT_P (XEXP (rtl
, 1)))
15385 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
15386 + INTVAL (XEXP (rtl
, 1)));
15388 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
15391 return compare_loc_descriptor (op
, op0
, op1
);
15394 /* Return location descriptor for {U,S}{MIN,MAX}. */
15396 static dw_loc_descr_ref
15397 minmax_loc_descriptor (rtx rtl
, machine_mode mode
,
15398 machine_mode mem_mode
)
15400 enum dwarf_location_atom op
;
15401 dw_loc_descr_ref op0
, op1
, ret
;
15402 dw_loc_descr_ref bra_node
, drop_node
;
15404 scalar_int_mode int_mode
;
15406 && dwarf_version
< 5
15407 && (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15408 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
))
15411 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15412 VAR_INIT_STATUS_INITIALIZED
);
15413 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15414 VAR_INIT_STATUS_INITIALIZED
);
15416 if (op0
== NULL
|| op1
== NULL
)
15419 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
15420 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
15421 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
15422 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
15424 /* Checked by the caller. */
15425 int_mode
= as_a
<scalar_int_mode
> (mode
);
15426 if (GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
15428 HOST_WIDE_INT mask
= GET_MODE_MASK (int_mode
);
15429 add_loc_descr (&op0
, int_loc_descriptor (mask
));
15430 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
15431 add_loc_descr (&op1
, int_loc_descriptor (mask
));
15432 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
15434 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
15436 HOST_WIDE_INT bias
= 1;
15437 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
15438 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
15439 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
15442 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15443 && GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
15445 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (int_mode
)) * BITS_PER_UNIT
;
15446 add_loc_descr (&op0
, int_loc_descriptor (shift
));
15447 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
15448 add_loc_descr (&op1
, int_loc_descriptor (shift
));
15449 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
15451 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15452 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15454 dw_die_ref type_die
= base_type_for_mode (int_mode
, 0);
15455 dw_loc_descr_ref cvt
;
15456 if (type_die
== NULL
)
15458 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15459 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15460 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15461 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15462 add_loc_descr (&op0
, cvt
);
15463 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15464 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15465 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15466 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15467 add_loc_descr (&op1
, cvt
);
15470 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
15475 add_loc_descr (&ret
, op1
);
15476 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
15477 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
15478 add_loc_descr (&ret
, bra_node
);
15479 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15480 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
15481 add_loc_descr (&ret
, drop_node
);
15482 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15483 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
15484 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
15485 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15486 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15487 ret
= convert_descriptor_to_mode (int_mode
, ret
);
15491 /* Helper function for mem_loc_descriptor. Perform OP binary op,
15492 but after converting arguments to type_die, afterwards
15493 convert back to unsigned. */
15495 static dw_loc_descr_ref
15496 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
15497 scalar_int_mode mode
, machine_mode mem_mode
)
15499 dw_loc_descr_ref cvt
, op0
, op1
;
15501 if (type_die
== NULL
)
15503 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15504 VAR_INIT_STATUS_INITIALIZED
);
15505 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15506 VAR_INIT_STATUS_INITIALIZED
);
15507 if (op0
== NULL
|| op1
== NULL
)
15509 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15510 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15511 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15512 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15513 add_loc_descr (&op0
, cvt
);
15514 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15515 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15516 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15517 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15518 add_loc_descr (&op1
, cvt
);
15519 add_loc_descr (&op0
, op1
);
15520 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
15521 return convert_descriptor_to_mode (mode
, op0
);
15524 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
15525 const0 is DW_OP_lit0 or corresponding typed constant,
15526 const1 is DW_OP_lit1 or corresponding typed constant
15527 and constMSB is constant with just the MSB bit set
15529 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
15530 L1: const0 DW_OP_swap
15531 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
15532 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15537 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
15538 L1: const0 DW_OP_swap
15539 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
15540 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15545 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
15546 L1: const1 DW_OP_swap
15547 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
15548 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15552 static dw_loc_descr_ref
15553 clz_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15554 machine_mode mem_mode
)
15556 dw_loc_descr_ref op0
, ret
, tmp
;
15557 HOST_WIDE_INT valv
;
15558 dw_loc_descr_ref l1jump
, l1label
;
15559 dw_loc_descr_ref l2jump
, l2label
;
15560 dw_loc_descr_ref l3jump
, l3label
;
15561 dw_loc_descr_ref l4jump
, l4label
;
15564 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
15567 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15568 VAR_INIT_STATUS_INITIALIZED
);
15572 if (GET_CODE (rtl
) == CLZ
)
15574 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
15575 valv
= GET_MODE_BITSIZE (mode
);
15577 else if (GET_CODE (rtl
) == FFS
)
15579 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
15580 valv
= GET_MODE_BITSIZE (mode
);
15581 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15582 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15583 add_loc_descr (&ret
, l1jump
);
15584 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
15585 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
15586 VAR_INIT_STATUS_INITIALIZED
);
15589 add_loc_descr (&ret
, tmp
);
15590 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15591 add_loc_descr (&ret
, l4jump
);
15592 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
15593 ? const1_rtx
: const0_rtx
,
15595 VAR_INIT_STATUS_INITIALIZED
);
15596 if (l1label
== NULL
)
15598 add_loc_descr (&ret
, l1label
);
15599 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15600 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
15601 add_loc_descr (&ret
, l2label
);
15602 if (GET_CODE (rtl
) != CLZ
)
15604 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
15605 msb
= GEN_INT (HOST_WIDE_INT_1U
15606 << (GET_MODE_BITSIZE (mode
) - 1));
15608 msb
= immed_wide_int_const
15609 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode
) - 1,
15610 GET_MODE_PRECISION (mode
)), mode
);
15611 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
15612 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
15613 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
15614 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
15616 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
15617 VAR_INIT_STATUS_INITIALIZED
);
15620 add_loc_descr (&ret
, tmp
);
15621 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15622 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15623 add_loc_descr (&ret
, l3jump
);
15624 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15625 VAR_INIT_STATUS_INITIALIZED
);
15628 add_loc_descr (&ret
, tmp
);
15629 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
15630 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
15631 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15632 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
15633 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15634 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15635 add_loc_descr (&ret
, l2jump
);
15636 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
15637 add_loc_descr (&ret
, l3label
);
15638 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
15639 add_loc_descr (&ret
, l4label
);
15640 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15641 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15642 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15643 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15644 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15645 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
15646 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15647 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
15651 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
15652 const1 is DW_OP_lit1 or corresponding typed constant):
15654 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15655 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15659 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15660 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15663 static dw_loc_descr_ref
15664 popcount_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15665 machine_mode mem_mode
)
15667 dw_loc_descr_ref op0
, ret
, tmp
;
15668 dw_loc_descr_ref l1jump
, l1label
;
15669 dw_loc_descr_ref l2jump
, l2label
;
15671 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
15674 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15675 VAR_INIT_STATUS_INITIALIZED
);
15679 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15680 VAR_INIT_STATUS_INITIALIZED
);
15683 add_loc_descr (&ret
, tmp
);
15684 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15685 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
15686 add_loc_descr (&ret
, l1label
);
15687 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15688 add_loc_descr (&ret
, l2jump
);
15689 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15690 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
15691 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15692 VAR_INIT_STATUS_INITIALIZED
);
15695 add_loc_descr (&ret
, tmp
);
15696 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15697 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
15698 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
15699 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15700 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15701 VAR_INIT_STATUS_INITIALIZED
);
15702 add_loc_descr (&ret
, tmp
);
15703 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15704 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15705 add_loc_descr (&ret
, l1jump
);
15706 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
15707 add_loc_descr (&ret
, l2label
);
15708 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15709 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15710 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15711 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15715 /* BSWAP (constS is initial shift count, either 56 or 24):
15717 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
15718 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
15719 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
15720 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
15721 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
15723 static dw_loc_descr_ref
15724 bswap_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15725 machine_mode mem_mode
)
15727 dw_loc_descr_ref op0
, ret
, tmp
;
15728 dw_loc_descr_ref l1jump
, l1label
;
15729 dw_loc_descr_ref l2jump
, l2label
;
15731 if (BITS_PER_UNIT
!= 8
15732 || (GET_MODE_BITSIZE (mode
) != 32
15733 && GET_MODE_BITSIZE (mode
) != 64))
15736 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15737 VAR_INIT_STATUS_INITIALIZED
);
15742 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
15744 VAR_INIT_STATUS_INITIALIZED
);
15747 add_loc_descr (&ret
, tmp
);
15748 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15749 VAR_INIT_STATUS_INITIALIZED
);
15752 add_loc_descr (&ret
, tmp
);
15753 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
15754 add_loc_descr (&ret
, l1label
);
15755 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
15757 VAR_INIT_STATUS_INITIALIZED
);
15758 add_loc_descr (&ret
, tmp
);
15759 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
15760 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15761 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15762 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
15763 VAR_INIT_STATUS_INITIALIZED
);
15766 add_loc_descr (&ret
, tmp
);
15767 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15768 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
15769 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
15770 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
15771 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15772 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15773 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15774 VAR_INIT_STATUS_INITIALIZED
);
15775 add_loc_descr (&ret
, tmp
);
15776 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
15777 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15778 add_loc_descr (&ret
, l2jump
);
15779 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
15780 VAR_INIT_STATUS_INITIALIZED
);
15781 add_loc_descr (&ret
, tmp
);
15782 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15783 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15784 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15785 add_loc_descr (&ret
, l1jump
);
15786 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
15787 add_loc_descr (&ret
, l2label
);
15788 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15789 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
15790 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15791 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15792 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15793 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15797 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
15798 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15799 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
15800 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
15802 ROTATERT is similar:
15803 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
15804 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15805 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
15807 static dw_loc_descr_ref
15808 rotate_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15809 machine_mode mem_mode
)
15811 rtx rtlop1
= XEXP (rtl
, 1);
15812 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
15815 if (is_narrower_int_mode (GET_MODE (rtlop1
), mode
))
15816 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
15817 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15818 VAR_INIT_STATUS_INITIALIZED
);
15819 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
15820 VAR_INIT_STATUS_INITIALIZED
);
15821 if (op0
== NULL
|| op1
== NULL
)
15823 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
15824 for (i
= 0; i
< 2; i
++)
15826 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
15827 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
15829 VAR_INIT_STATUS_INITIALIZED
);
15830 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
15831 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
15833 : HOST_BITS_PER_WIDE_INT
== 64
15834 ? DW_OP_const8u
: DW_OP_constu
,
15835 GET_MODE_MASK (mode
), 0);
15838 if (mask
[i
] == NULL
)
15840 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
15843 add_loc_descr (&ret
, op1
);
15844 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
15845 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
15846 if (GET_CODE (rtl
) == ROTATERT
)
15848 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
15849 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
15850 GET_MODE_BITSIZE (mode
), 0));
15852 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
15853 if (mask
[0] != NULL
)
15854 add_loc_descr (&ret
, mask
[0]);
15855 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
15856 if (mask
[1] != NULL
)
15858 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15859 add_loc_descr (&ret
, mask
[1]);
15860 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15862 if (GET_CODE (rtl
) == ROTATE
)
15864 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
15865 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
15866 GET_MODE_BITSIZE (mode
), 0));
15868 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15869 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
15873 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
15874 for DEBUG_PARAMETER_REF RTL. */
15876 static dw_loc_descr_ref
15877 parameter_ref_descriptor (rtx rtl
)
15879 dw_loc_descr_ref ret
;
15884 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
15885 /* With LTO during LTRANS we get the late DIE that refers to the early
15886 DIE, thus we add another indirection here. This seems to confuse
15887 gdb enough to make gcc.dg/guality/pr68860-1.c FAIL with LTO. */
15888 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
15889 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
15892 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15893 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
15894 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15898 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
15899 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
15904 /* The following routine converts the RTL for a variable or parameter
15905 (resident in memory) into an equivalent Dwarf representation of a
15906 mechanism for getting the address of that same variable onto the top of a
15907 hypothetical "address evaluation" stack.
15909 When creating memory location descriptors, we are effectively transforming
15910 the RTL for a memory-resident object into its Dwarf postfix expression
15911 equivalent. This routine recursively descends an RTL tree, turning
15912 it into Dwarf postfix code as it goes.
15914 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
15916 MEM_MODE is the mode of the memory reference, needed to handle some
15917 autoincrement addressing modes.
15919 Return 0 if we can't represent the location. */
15922 mem_loc_descriptor (rtx rtl
, machine_mode mode
,
15923 machine_mode mem_mode
,
15924 enum var_init_status initialized
)
15926 dw_loc_descr_ref mem_loc_result
= NULL
;
15927 enum dwarf_location_atom op
;
15928 dw_loc_descr_ref op0
, op1
;
15929 rtx inner
= NULL_RTX
;
15932 if (mode
== VOIDmode
)
15933 mode
= GET_MODE (rtl
);
15935 /* Note that for a dynamically sized array, the location we will generate a
15936 description of here will be the lowest numbered location which is
15937 actually within the array. That's *not* necessarily the same as the
15938 zeroth element of the array. */
15940 rtl
= targetm
.delegitimize_address (rtl
);
15942 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
15945 scalar_int_mode int_mode
= BImode
, inner_mode
, op1_mode
;
15946 switch (GET_CODE (rtl
))
15951 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
15954 /* The case of a subreg may arise when we have a local (register)
15955 variable or a formal (register) parameter which doesn't quite fill
15956 up an entire register. For now, just assume that it is
15957 legitimate to make the Dwarf info refer to the whole register which
15958 contains the given subreg. */
15959 if (!subreg_lowpart_p (rtl
))
15961 inner
= SUBREG_REG (rtl
);
15964 if (inner
== NULL_RTX
)
15965 inner
= XEXP (rtl
, 0);
15966 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15967 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
15968 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15969 #ifdef POINTERS_EXTEND_UNSIGNED
15970 || (int_mode
== Pmode
&& mem_mode
!= VOIDmode
)
15973 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
)
15975 mem_loc_result
= mem_loc_descriptor (inner
,
15977 mem_mode
, initialized
);
15980 if (dwarf_strict
&& dwarf_version
< 5)
15982 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15983 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
15984 ? GET_MODE_SIZE (int_mode
) <= GET_MODE_SIZE (inner_mode
)
15985 : known_eq (GET_MODE_SIZE (mode
), GET_MODE_SIZE (GET_MODE (inner
))))
15987 dw_die_ref type_die
;
15988 dw_loc_descr_ref cvt
;
15990 mem_loc_result
= mem_loc_descriptor (inner
,
15992 mem_mode
, initialized
);
15993 if (mem_loc_result
== NULL
)
15995 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15996 if (type_die
== NULL
)
15998 mem_loc_result
= NULL
;
16001 if (maybe_ne (GET_MODE_SIZE (mode
), GET_MODE_SIZE (GET_MODE (inner
))))
16002 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16004 cvt
= new_loc_descr (dwarf_OP (DW_OP_reinterpret
), 0, 0);
16005 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16006 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16007 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16008 add_loc_descr (&mem_loc_result
, cvt
);
16009 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16010 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
16012 /* Convert it to untyped afterwards. */
16013 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16014 add_loc_descr (&mem_loc_result
, cvt
);
16020 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16021 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
16022 && rtl
!= arg_pointer_rtx
16023 && rtl
!= frame_pointer_rtx
16024 #ifdef POINTERS_EXTEND_UNSIGNED
16025 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
16029 dw_die_ref type_die
;
16030 unsigned int dbx_regnum
;
16032 if (dwarf_strict
&& dwarf_version
< 5)
16034 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
16036 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16037 if (type_die
== NULL
)
16040 dbx_regnum
= dbx_reg_number (rtl
);
16041 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
16043 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_regval_type
),
16045 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
16046 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
16047 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
16050 /* Whenever a register number forms a part of the description of the
16051 method for calculating the (dynamic) address of a memory resident
16052 object, DWARF rules require the register number be referred to as
16053 a "base register". This distinction is not based in any way upon
16054 what category of register the hardware believes the given register
16055 belongs to. This is strictly DWARF terminology we're dealing with
16056 here. Note that in cases where the location of a memory-resident
16057 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
16058 OP_CONST (0)) the actual DWARF location descriptor that we generate
16059 may just be OP_BASEREG (basereg). This may look deceptively like
16060 the object in question was allocated to a register (rather than in
16061 memory) so DWARF consumers need to be aware of the subtle
16062 distinction between OP_REG and OP_BASEREG. */
16063 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
16064 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
16065 else if (stack_realign_drap
16067 && crtl
->args
.internal_arg_pointer
== rtl
16068 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
16070 /* If RTL is internal_arg_pointer, which has been optimized
16071 out, use DRAP instead. */
16072 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
16073 VAR_INIT_STATUS_INITIALIZED
);
16079 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16080 || !is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
))
16082 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
16083 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16086 else if (GET_CODE (rtl
) == ZERO_EXTEND
16087 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16088 && GET_MODE_BITSIZE (inner_mode
) < HOST_BITS_PER_WIDE_INT
16089 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
16090 to expand zero extend as two shifts instead of
16092 && GET_MODE_SIZE (inner_mode
) <= 4)
16094 mem_loc_result
= op0
;
16095 add_loc_descr (&mem_loc_result
,
16096 int_loc_descriptor (GET_MODE_MASK (inner_mode
)));
16097 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
16099 else if (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
16101 int shift
= DWARF2_ADDR_SIZE
- GET_MODE_SIZE (inner_mode
);
16102 shift
*= BITS_PER_UNIT
;
16103 if (GET_CODE (rtl
) == SIGN_EXTEND
)
16107 mem_loc_result
= op0
;
16108 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
16109 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
16110 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
16111 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16113 else if (!dwarf_strict
|| dwarf_version
>= 5)
16115 dw_die_ref type_die1
, type_die2
;
16116 dw_loc_descr_ref cvt
;
16118 type_die1
= base_type_for_mode (inner_mode
,
16119 GET_CODE (rtl
) == ZERO_EXTEND
);
16120 if (type_die1
== NULL
)
16122 type_die2
= base_type_for_mode (int_mode
, 1);
16123 if (type_die2
== NULL
)
16125 mem_loc_result
= op0
;
16126 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16127 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16128 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
16129 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16130 add_loc_descr (&mem_loc_result
, cvt
);
16131 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16132 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16133 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
16134 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16135 add_loc_descr (&mem_loc_result
, cvt
);
16141 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
16142 if (new_rtl
!= rtl
)
16144 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
16146 if (mem_loc_result
!= NULL
)
16147 return mem_loc_result
;
16150 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
16151 get_address_mode (rtl
), mode
,
16152 VAR_INIT_STATUS_INITIALIZED
);
16153 if (mem_loc_result
== NULL
)
16154 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
16155 if (mem_loc_result
!= NULL
)
16157 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16158 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
16160 dw_die_ref type_die
;
16161 dw_loc_descr_ref deref
;
16162 HOST_WIDE_INT size
;
16164 if (dwarf_strict
&& dwarf_version
< 5)
16166 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
16169 = base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16170 if (type_die
== NULL
)
16172 deref
= new_loc_descr (dwarf_OP (DW_OP_deref_type
), size
, 0);
16173 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
16174 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
16175 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
16176 add_loc_descr (&mem_loc_result
, deref
);
16178 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
16179 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
16181 add_loc_descr (&mem_loc_result
,
16182 new_loc_descr (DW_OP_deref_size
,
16183 GET_MODE_SIZE (int_mode
), 0));
16188 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
16191 /* Some ports can transform a symbol ref into a label ref, because
16192 the symbol ref is too far away and has to be dumped into a constant
16197 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16198 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
16199 #ifdef POINTERS_EXTEND_UNSIGNED
16200 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
16205 if (GET_CODE (rtl
) == UNSPEC
)
16207 /* If delegitimize_address couldn't do anything with the UNSPEC, we
16208 can't express it in the debug info. This can happen e.g. with some
16209 TLS UNSPECs. Allow UNSPECs formerly from CONST that the backend
16211 bool not_ok
= false;
16212 subrtx_var_iterator::array_type array
;
16213 FOR_EACH_SUBRTX_VAR (iter
, array
, rtl
, ALL
)
16214 if (*iter
!= rtl
&& !CONSTANT_P (*iter
))
16223 FOR_EACH_SUBRTX_VAR (iter
, array
, rtl
, ALL
)
16224 if (!const_ok_for_output_1 (*iter
))
16233 rtl
= gen_rtx_CONST (GET_MODE (rtl
), rtl
);
16237 if (GET_CODE (rtl
) == SYMBOL_REF
16238 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
16240 dw_loc_descr_ref temp
;
16242 /* If this is not defined, we have no way to emit the data. */
16243 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
16246 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
16248 /* We check for DWARF 5 here because gdb did not implement
16249 DW_OP_form_tls_address until after 7.12. */
16250 mem_loc_result
= new_loc_descr ((dwarf_version
>= 5
16251 ? DW_OP_form_tls_address
16252 : DW_OP_GNU_push_tls_address
),
16254 add_loc_descr (&mem_loc_result
, temp
);
16259 if (!const_ok_for_output (rtl
))
16261 if (GET_CODE (rtl
) == CONST
)
16262 switch (GET_CODE (XEXP (rtl
, 0)))
16266 goto try_const_unop
;
16269 goto try_const_unop
;
16272 arg
= XEXP (XEXP (rtl
, 0), 0);
16273 if (!CONSTANT_P (arg
))
16274 arg
= gen_rtx_CONST (int_mode
, arg
);
16275 op0
= mem_loc_descriptor (arg
, int_mode
, mem_mode
,
16279 mem_loc_result
= op0
;
16280 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16284 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
,
16285 mem_mode
, initialized
);
16292 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
16293 vec_safe_push (used_rtx_array
, rtl
);
16299 case DEBUG_IMPLICIT_PTR
:
16300 expansion_failed (NULL_TREE
, rtl
,
16301 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
16305 if (dwarf_strict
&& dwarf_version
< 5)
16307 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
16309 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16310 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
16311 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
16312 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16315 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
16316 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
16318 op0
= one_reg_loc_descriptor (dbx_regnum
,
16319 VAR_INIT_STATUS_INITIALIZED
);
16322 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
16323 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
16325 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
16326 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16327 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
16331 gcc_unreachable ();
16334 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_entry_value
), 0, 0);
16335 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
16336 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
16339 case DEBUG_PARAMETER_REF
:
16340 mem_loc_result
= parameter_ref_descriptor (rtl
);
16344 /* Extract the PLUS expression nested inside and fall into
16345 PLUS code below. */
16346 rtl
= XEXP (rtl
, 1);
16351 /* Turn these into a PLUS expression and fall into the PLUS code
16353 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
16354 gen_int_mode (GET_CODE (rtl
) == PRE_INC
16355 ? GET_MODE_UNIT_SIZE (mem_mode
)
16356 : -GET_MODE_UNIT_SIZE (mem_mode
),
16363 if (is_based_loc (rtl
)
16364 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16365 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16366 || XEXP (rtl
, 0) == arg_pointer_rtx
16367 || XEXP (rtl
, 0) == frame_pointer_rtx
))
16368 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
16369 INTVAL (XEXP (rtl
, 1)),
16370 VAR_INIT_STATUS_INITIALIZED
);
16373 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
16374 VAR_INIT_STATUS_INITIALIZED
);
16375 if (mem_loc_result
== 0)
16378 if (CONST_INT_P (XEXP (rtl
, 1))
16379 && (GET_MODE_SIZE (as_a
<scalar_int_mode
> (mode
))
16380 <= DWARF2_ADDR_SIZE
))
16381 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
16384 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16385 VAR_INIT_STATUS_INITIALIZED
);
16388 add_loc_descr (&mem_loc_result
, op1
);
16389 add_loc_descr (&mem_loc_result
,
16390 new_loc_descr (DW_OP_plus
, 0, 0));
16395 /* If a pseudo-reg is optimized away, it is possible for it to
16396 be replaced with a MEM containing a multiply or shift. */
16406 if ((!dwarf_strict
|| dwarf_version
>= 5)
16407 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16408 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
16410 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
16411 base_type_for_mode (mode
, 0),
16412 int_mode
, mem_mode
);
16435 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
))
16437 op0
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
, mem_mode
,
16438 VAR_INIT_STATUS_INITIALIZED
);
16440 rtx rtlop1
= XEXP (rtl
, 1);
16441 if (is_a
<scalar_int_mode
> (GET_MODE (rtlop1
), &op1_mode
)
16442 && GET_MODE_BITSIZE (op1_mode
) < GET_MODE_BITSIZE (int_mode
))
16443 rtlop1
= gen_rtx_ZERO_EXTEND (int_mode
, rtlop1
);
16444 op1
= mem_loc_descriptor (rtlop1
, int_mode
, mem_mode
,
16445 VAR_INIT_STATUS_INITIALIZED
);
16448 if (op0
== 0 || op1
== 0)
16451 mem_loc_result
= op0
;
16452 add_loc_descr (&mem_loc_result
, op1
);
16453 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16469 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
16470 VAR_INIT_STATUS_INITIALIZED
);
16471 if (XEXP (rtl
, 0) == XEXP (rtl
, 1))
16475 mem_loc_result
= op0
;
16476 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_dup
, 0, 0));
16477 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16480 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16481 VAR_INIT_STATUS_INITIALIZED
);
16483 if (op0
== 0 || op1
== 0)
16486 mem_loc_result
= op0
;
16487 add_loc_descr (&mem_loc_result
, op1
);
16488 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16492 if ((!dwarf_strict
|| dwarf_version
>= 5)
16493 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16494 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
16496 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
16497 base_type_for_mode (mode
, 0),
16498 int_mode
, mem_mode
);
16502 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
16503 VAR_INIT_STATUS_INITIALIZED
);
16504 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16505 VAR_INIT_STATUS_INITIALIZED
);
16507 if (op0
== 0 || op1
== 0)
16510 mem_loc_result
= op0
;
16511 add_loc_descr (&mem_loc_result
, op1
);
16512 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
16513 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
16514 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
16515 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
16516 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
16520 if ((!dwarf_strict
|| dwarf_version
>= 5)
16521 && is_a
<scalar_int_mode
> (mode
, &int_mode
))
16523 /* We can use a signed divide if the sign bit is not set. */
16524 if (GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
16530 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
16531 base_type_for_mode (int_mode
, 1),
16532 int_mode
, mem_mode
);
16549 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
16550 VAR_INIT_STATUS_INITIALIZED
);
16555 mem_loc_result
= op0
;
16556 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16560 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16561 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16562 #ifdef POINTERS_EXTEND_UNSIGNED
16563 || (int_mode
== Pmode
16564 && mem_mode
!= VOIDmode
16565 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
16569 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
16572 if ((!dwarf_strict
|| dwarf_version
>= 5)
16573 && (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
16574 || GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_DOUBLE_INT
))
16576 dw_die_ref type_die
= base_type_for_mode (int_mode
, 1);
16577 scalar_int_mode amode
;
16578 if (type_die
== NULL
)
16580 if (INTVAL (rtl
) >= 0
16581 && (int_mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
, 0)
16583 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
16584 /* const DW_OP_convert <XXX> vs.
16585 DW_OP_const_type <XXX, 1, const>. */
16586 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
16587 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (int_mode
))
16589 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
16590 op0
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16591 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16592 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16593 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16594 add_loc_descr (&mem_loc_result
, op0
);
16595 return mem_loc_result
;
16597 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0,
16599 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16600 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16601 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16602 if (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
)
16603 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
16606 mem_loc_result
->dw_loc_oprnd2
.val_class
16607 = dw_val_class_const_double
;
16608 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
16609 = double_int::from_shwi (INTVAL (rtl
));
16615 if (!dwarf_strict
|| dwarf_version
>= 5)
16617 dw_die_ref type_die
;
16619 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
16620 CONST_DOUBLE rtx could represent either a large integer
16621 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
16622 the value is always a floating point constant.
16624 When it is an integer, a CONST_DOUBLE is used whenever
16625 the constant requires 2 HWIs to be adequately represented.
16626 We output CONST_DOUBLEs as blocks. */
16627 if (mode
== VOIDmode
16628 || (GET_MODE (rtl
) == VOIDmode
16629 && maybe_ne (GET_MODE_BITSIZE (mode
),
16630 HOST_BITS_PER_DOUBLE_INT
)))
16632 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16633 if (type_die
== NULL
)
16635 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
16636 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16637 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16638 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16639 #if TARGET_SUPPORTS_WIDE_INT == 0
16640 if (!SCALAR_FLOAT_MODE_P (mode
))
16642 mem_loc_result
->dw_loc_oprnd2
.val_class
16643 = dw_val_class_const_double
;
16644 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
16645 = rtx_to_double_int (rtl
);
16650 scalar_float_mode float_mode
= as_a
<scalar_float_mode
> (mode
);
16651 unsigned int length
= GET_MODE_SIZE (float_mode
);
16652 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
16653 unsigned int elt_size
= insert_float (rtl
, array
);
16655 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16656 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
16657 = length
/ elt_size
;
16658 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
16659 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16664 case CONST_WIDE_INT
:
16665 if (!dwarf_strict
|| dwarf_version
>= 5)
16667 dw_die_ref type_die
;
16669 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16670 if (type_die
== NULL
)
16672 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
16673 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16674 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16675 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16676 mem_loc_result
->dw_loc_oprnd2
.val_class
16677 = dw_val_class_wide_int
;
16678 mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
16679 *mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, mode
);
16683 case CONST_POLY_INT
:
16684 mem_loc_result
= int_loc_descriptor (rtx_to_poly_int64 (rtl
));
16688 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
16692 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
16696 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
16700 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
16704 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
16708 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
16712 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
16716 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
16720 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
16724 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
16729 if (!SCALAR_INT_MODE_P (mode
))
16734 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
16739 if (CONST_INT_P (XEXP (rtl
, 1))
16740 && CONST_INT_P (XEXP (rtl
, 2))
16741 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16742 && is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
)
16743 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16744 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
16745 && ((unsigned) INTVAL (XEXP (rtl
, 1))
16746 + (unsigned) INTVAL (XEXP (rtl
, 2))
16747 <= GET_MODE_BITSIZE (int_mode
)))
16750 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
16751 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16754 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
16758 mem_loc_result
= op0
;
16759 size
= INTVAL (XEXP (rtl
, 1));
16760 shift
= INTVAL (XEXP (rtl
, 2));
16761 if (BITS_BIG_ENDIAN
)
16762 shift
= GET_MODE_BITSIZE (inner_mode
) - shift
- size
;
16763 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
16765 add_loc_descr (&mem_loc_result
,
16766 int_loc_descriptor (DWARF2_ADDR_SIZE
16768 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
16770 if (size
!= (int) DWARF2_ADDR_SIZE
)
16772 add_loc_descr (&mem_loc_result
,
16773 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
16774 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16781 dw_loc_descr_ref op2
, bra_node
, drop_node
;
16782 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
16783 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
16784 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
16785 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16786 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16787 VAR_INIT_STATUS_INITIALIZED
);
16788 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
16789 VAR_INIT_STATUS_INITIALIZED
);
16790 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
16793 mem_loc_result
= op1
;
16794 add_loc_descr (&mem_loc_result
, op2
);
16795 add_loc_descr (&mem_loc_result
, op0
);
16796 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
16797 add_loc_descr (&mem_loc_result
, bra_node
);
16798 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
16799 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
16800 add_loc_descr (&mem_loc_result
, drop_node
);
16801 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
16802 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
16807 case FLOAT_TRUNCATE
:
16809 case UNSIGNED_FLOAT
:
16812 if (!dwarf_strict
|| dwarf_version
>= 5)
16814 dw_die_ref type_die
;
16815 dw_loc_descr_ref cvt
;
16817 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
16818 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16821 if (is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &int_mode
)
16822 && (GET_CODE (rtl
) == FLOAT
16823 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
))
16825 type_die
= base_type_for_mode (int_mode
,
16826 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
16827 if (type_die
== NULL
)
16829 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16830 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16831 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16832 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16833 add_loc_descr (&op0
, cvt
);
16835 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
16836 if (type_die
== NULL
)
16838 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16839 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16840 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16841 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16842 add_loc_descr (&op0
, cvt
);
16843 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16844 && (GET_CODE (rtl
) == FIX
16845 || GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
))
16847 op0
= convert_descriptor_to_mode (int_mode
, op0
);
16851 mem_loc_result
= op0
;
16858 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16859 mem_loc_result
= clz_loc_descriptor (rtl
, int_mode
, mem_mode
);
16864 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16865 mem_loc_result
= popcount_loc_descriptor (rtl
, int_mode
, mem_mode
);
16869 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16870 mem_loc_result
= bswap_loc_descriptor (rtl
, int_mode
, mem_mode
);
16875 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16876 mem_loc_result
= rotate_loc_descriptor (rtl
, int_mode
, mem_mode
);
16880 /* In theory, we could implement the above. */
16881 /* DWARF cannot represent the unsigned compare operations
16906 case FRACT_CONVERT
:
16907 case UNSIGNED_FRACT_CONVERT
:
16909 case UNSIGNED_SAT_FRACT
:
16915 case VEC_DUPLICATE
:
16919 case STRICT_LOW_PART
:
16924 case SMUL_HIGHPART
:
16925 case UMUL_HIGHPART
:
16929 resolve_one_addr (&rtl
);
16932 /* RTL sequences inside PARALLEL record a series of DWARF operations for
16933 the expression. An UNSPEC rtx represents a raw DWARF operation,
16934 new_loc_descr is called for it to build the operation directly.
16935 Otherwise mem_loc_descriptor is called recursively. */
16939 dw_loc_descr_ref exp_result
= NULL
;
16941 for (; index
< XVECLEN (rtl
, 0); index
++)
16943 rtx elem
= XVECEXP (rtl
, 0, index
);
16944 if (GET_CODE (elem
) == UNSPEC
)
16946 /* Each DWARF operation UNSPEC contain two operands, if
16947 one operand is not used for the operation, const0_rtx is
16949 gcc_assert (XVECLEN (elem
, 0) == 2);
16951 HOST_WIDE_INT dw_op
= XINT (elem
, 1);
16952 HOST_WIDE_INT oprnd1
= INTVAL (XVECEXP (elem
, 0, 0));
16953 HOST_WIDE_INT oprnd2
= INTVAL (XVECEXP (elem
, 0, 1));
16955 = new_loc_descr ((enum dwarf_location_atom
) dw_op
, oprnd1
,
16960 = mem_loc_descriptor (elem
, mode
, mem_mode
,
16961 VAR_INIT_STATUS_INITIALIZED
);
16963 if (!mem_loc_result
)
16964 mem_loc_result
= exp_result
;
16966 add_loc_descr (&mem_loc_result
, exp_result
);
16975 print_rtl (stderr
, rtl
);
16976 gcc_unreachable ();
16981 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
16982 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
16984 return mem_loc_result
;
16987 /* Return a descriptor that describes the concatenation of two locations.
16988 This is typically a complex variable. */
16990 static dw_loc_descr_ref
16991 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
16993 /* At present we only track constant-sized pieces. */
16994 unsigned int size0
, size1
;
16995 if (!GET_MODE_SIZE (GET_MODE (x0
)).is_constant (&size0
)
16996 || !GET_MODE_SIZE (GET_MODE (x1
)).is_constant (&size1
))
16999 dw_loc_descr_ref cc_loc_result
= NULL
;
17000 dw_loc_descr_ref x0_ref
17001 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
17002 dw_loc_descr_ref x1_ref
17003 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
17005 if (x0_ref
== 0 || x1_ref
== 0)
17008 cc_loc_result
= x0_ref
;
17009 add_loc_descr_op_piece (&cc_loc_result
, size0
);
17011 add_loc_descr (&cc_loc_result
, x1_ref
);
17012 add_loc_descr_op_piece (&cc_loc_result
, size1
);
17014 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
17015 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
17017 return cc_loc_result
;
17020 /* Return a descriptor that describes the concatenation of N
17023 static dw_loc_descr_ref
17024 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
17027 dw_loc_descr_ref cc_loc_result
= NULL
;
17028 unsigned int n
= XVECLEN (concatn
, 0);
17031 for (i
= 0; i
< n
; ++i
)
17033 dw_loc_descr_ref ref
;
17034 rtx x
= XVECEXP (concatn
, 0, i
);
17036 /* At present we only track constant-sized pieces. */
17037 if (!GET_MODE_SIZE (GET_MODE (x
)).is_constant (&size
))
17040 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
17044 add_loc_descr (&cc_loc_result
, ref
);
17045 add_loc_descr_op_piece (&cc_loc_result
, size
);
17048 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
17049 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
17051 return cc_loc_result
;
17054 /* Helper function for loc_descriptor. Return DW_OP_implicit_pointer
17055 for DEBUG_IMPLICIT_PTR RTL. */
17057 static dw_loc_descr_ref
17058 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
17060 dw_loc_descr_ref ret
;
17063 if (dwarf_strict
&& dwarf_version
< 5)
17065 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
17066 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
17067 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
17068 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
17069 ret
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
17070 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
17073 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
17074 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
17075 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
17079 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
17080 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
17085 /* Output a proper Dwarf location descriptor for a variable or parameter
17086 which is either allocated in a register or in a memory location. For a
17087 register, we just generate an OP_REG and the register number. For a
17088 memory location we provide a Dwarf postfix expression describing how to
17089 generate the (dynamic) address of the object onto the address stack.
17091 MODE is mode of the decl if this loc_descriptor is going to be used in
17092 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
17093 allowed, VOIDmode otherwise.
17095 If we don't know how to describe it, return 0. */
17097 static dw_loc_descr_ref
17098 loc_descriptor (rtx rtl
, machine_mode mode
,
17099 enum var_init_status initialized
)
17101 dw_loc_descr_ref loc_result
= NULL
;
17102 scalar_int_mode int_mode
;
17104 switch (GET_CODE (rtl
))
17107 /* The case of a subreg may arise when we have a local (register)
17108 variable or a formal (register) parameter which doesn't quite fill
17109 up an entire register. For now, just assume that it is
17110 legitimate to make the Dwarf info refer to the whole register which
17111 contains the given subreg. */
17112 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
17113 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
17114 GET_MODE (SUBREG_REG (rtl
)), initialized
);
17120 loc_result
= reg_loc_descriptor (rtl
, initialized
);
17124 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
17125 GET_MODE (rtl
), initialized
);
17126 if (loc_result
== NULL
)
17127 loc_result
= tls_mem_loc_descriptor (rtl
);
17128 if (loc_result
== NULL
)
17130 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
17131 if (new_rtl
!= rtl
)
17132 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
17137 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
17142 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
17147 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
17149 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
17150 if (GET_CODE (loc
) == EXPR_LIST
)
17151 loc
= XEXP (loc
, 0);
17152 loc_result
= loc_descriptor (loc
, mode
, initialized
);
17156 rtl
= XEXP (rtl
, 1);
17161 rtvec par_elems
= XVEC (rtl
, 0);
17162 int num_elem
= GET_NUM_ELEM (par_elems
);
17166 /* Create the first one, so we have something to add to. */
17167 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
17168 VOIDmode
, initialized
);
17169 if (loc_result
== NULL
)
17171 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
17172 /* At present we only track constant-sized pieces. */
17173 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
17175 add_loc_descr_op_piece (&loc_result
, size
);
17176 for (i
= 1; i
< num_elem
; i
++)
17178 dw_loc_descr_ref temp
;
17180 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
17181 VOIDmode
, initialized
);
17184 add_loc_descr (&loc_result
, temp
);
17185 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
17186 /* At present we only track constant-sized pieces. */
17187 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
17189 add_loc_descr_op_piece (&loc_result
, size
);
17195 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
17197 int_mode
= as_a
<scalar_int_mode
> (mode
);
17198 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (int_mode
),
17204 if (mode
== VOIDmode
)
17205 mode
= GET_MODE (rtl
);
17207 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
17209 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
17211 /* Note that a CONST_DOUBLE rtx could represent either an integer
17212 or a floating-point constant. A CONST_DOUBLE is used whenever
17213 the constant requires more than one word in order to be
17214 adequately represented. We output CONST_DOUBLEs as blocks. */
17215 scalar_mode smode
= as_a
<scalar_mode
> (mode
);
17216 loc_result
= new_loc_descr (DW_OP_implicit_value
,
17217 GET_MODE_SIZE (smode
), 0);
17218 #if TARGET_SUPPORTS_WIDE_INT == 0
17219 if (!SCALAR_FLOAT_MODE_P (smode
))
17221 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
17222 loc_result
->dw_loc_oprnd2
.v
.val_double
17223 = rtx_to_double_int (rtl
);
17228 unsigned int length
= GET_MODE_SIZE (smode
);
17229 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
17230 unsigned int elt_size
= insert_float (rtl
, array
);
17232 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
17233 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ elt_size
;
17234 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
17235 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
17240 case CONST_WIDE_INT
:
17241 if (mode
== VOIDmode
)
17242 mode
= GET_MODE (rtl
);
17244 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
17246 int_mode
= as_a
<scalar_int_mode
> (mode
);
17247 loc_result
= new_loc_descr (DW_OP_implicit_value
,
17248 GET_MODE_SIZE (int_mode
), 0);
17249 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_wide_int
;
17250 loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
17251 *loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, int_mode
);
17256 if (mode
== VOIDmode
)
17257 mode
= GET_MODE (rtl
);
17259 if (mode
!= VOIDmode
17260 /* The combination of a length and byte elt_size doesn't extend
17261 naturally to boolean vectors, where several elements are packed
17262 into the same byte. */
17263 && GET_MODE_CLASS (mode
) != MODE_VECTOR_BOOL
17264 && (dwarf_version
>= 4 || !dwarf_strict
))
17266 unsigned int length
;
17267 if (!CONST_VECTOR_NUNITS (rtl
).is_constant (&length
))
17270 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
17271 unsigned char *array
17272 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
17275 machine_mode imode
= GET_MODE_INNER (mode
);
17277 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
17278 switch (GET_MODE_CLASS (mode
))
17280 case MODE_VECTOR_INT
:
17281 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
17283 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
17284 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
17288 case MODE_VECTOR_FLOAT
:
17289 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
17291 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
17292 insert_float (elt
, p
);
17297 gcc_unreachable ();
17300 loc_result
= new_loc_descr (DW_OP_implicit_value
,
17301 length
* elt_size
, 0);
17302 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
17303 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
17304 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
17305 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
17310 if (mode
== VOIDmode
17311 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
17312 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
17313 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
17315 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
17320 if (!const_ok_for_output (rtl
))
17324 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
17325 && GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
17326 && (dwarf_version
>= 4 || !dwarf_strict
))
17328 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
17329 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
17330 vec_safe_push (used_rtx_array
, rtl
);
17334 case DEBUG_IMPLICIT_PTR
:
17335 loc_result
= implicit_ptr_descriptor (rtl
, 0);
17339 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
17340 && CONST_INT_P (XEXP (rtl
, 1)))
17343 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
17349 if ((is_a
<scalar_int_mode
> (mode
, &int_mode
)
17350 && GET_MODE (rtl
) == int_mode
17351 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
17352 && dwarf_version
>= 4)
17353 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
17355 /* Value expression. */
17356 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
17358 add_loc_descr (&loc_result
,
17359 new_loc_descr (DW_OP_stack_value
, 0, 0));
17367 /* We need to figure out what section we should use as the base for the
17368 address ranges where a given location is valid.
17369 1. If this particular DECL has a section associated with it, use that.
17370 2. If this function has a section associated with it, use that.
17371 3. Otherwise, use the text section.
17372 XXX: If you split a variable across multiple sections, we won't notice. */
17374 static const char *
17375 secname_for_decl (const_tree decl
)
17377 const char *secname
;
17379 if (VAR_OR_FUNCTION_DECL_P (decl
)
17380 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
) || TREE_STATIC (decl
))
17381 && DECL_SECTION_NAME (decl
))
17382 secname
= DECL_SECTION_NAME (decl
);
17383 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
17385 if (in_cold_section_p
)
17387 section
*sec
= current_function_section ();
17388 if (sec
->common
.flags
& SECTION_NAMED
)
17389 return sec
->named
.name
;
17391 secname
= DECL_SECTION_NAME (current_function_decl
);
17393 else if (cfun
&& in_cold_section_p
)
17394 secname
= crtl
->subsections
.cold_section_label
;
17396 secname
= text_section_label
;
17401 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
17404 decl_by_reference_p (tree decl
)
17406 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
17408 && DECL_BY_REFERENCE (decl
));
17411 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
17414 static dw_loc_descr_ref
17415 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
17416 enum var_init_status initialized
)
17418 int have_address
= 0;
17419 dw_loc_descr_ref descr
;
17422 if (want_address
!= 2)
17424 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
17426 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
17428 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
17429 if (GET_CODE (varloc
) == EXPR_LIST
)
17430 varloc
= XEXP (varloc
, 0);
17431 mode
= GET_MODE (varloc
);
17432 if (MEM_P (varloc
))
17434 rtx addr
= XEXP (varloc
, 0);
17435 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
17436 mode
, initialized
);
17441 rtx x
= avoid_constant_pool_reference (varloc
);
17443 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
17448 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
17455 if (GET_CODE (varloc
) == VAR_LOCATION
)
17456 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
17458 mode
= DECL_MODE (loc
);
17459 descr
= loc_descriptor (varloc
, mode
, initialized
);
17466 if (want_address
== 2 && !have_address
17467 && (dwarf_version
>= 4 || !dwarf_strict
))
17469 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
17471 expansion_failed (loc
, NULL_RTX
,
17472 "DWARF address size mismatch");
17475 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
17478 /* Show if we can't fill the request for an address. */
17479 if (want_address
&& !have_address
)
17481 expansion_failed (loc
, NULL_RTX
,
17482 "Want address and only have value");
17486 /* If we've got an address and don't want one, dereference. */
17487 if (!want_address
&& have_address
)
17489 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
17490 enum dwarf_location_atom op
;
17492 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
17494 expansion_failed (loc
, NULL_RTX
,
17495 "DWARF address size mismatch");
17498 else if (size
== DWARF2_ADDR_SIZE
)
17501 op
= DW_OP_deref_size
;
17503 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
17509 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
17510 if it is not possible. */
17512 static dw_loc_descr_ref
17513 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
17515 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
17516 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
17517 else if (dwarf_version
>= 3 || !dwarf_strict
)
17518 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
17523 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
17524 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
17526 static dw_loc_descr_ref
17527 dw_sra_loc_expr (tree decl
, rtx loc
)
17530 unsigned HOST_WIDE_INT padsize
= 0;
17531 dw_loc_descr_ref descr
, *descr_tail
;
17532 unsigned HOST_WIDE_INT decl_size
;
17534 enum var_init_status initialized
;
17536 if (DECL_SIZE (decl
) == NULL
17537 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
17540 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
17542 descr_tail
= &descr
;
17544 for (p
= loc
; p
; p
= XEXP (p
, 1))
17546 unsigned HOST_WIDE_INT bitsize
= decl_piece_bitsize (p
);
17547 rtx loc_note
= *decl_piece_varloc_ptr (p
);
17548 dw_loc_descr_ref cur_descr
;
17549 dw_loc_descr_ref
*tail
, last
= NULL
;
17550 unsigned HOST_WIDE_INT opsize
= 0;
17552 if (loc_note
== NULL_RTX
17553 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
17555 padsize
+= bitsize
;
17558 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
17559 varloc
= NOTE_VAR_LOCATION (loc_note
);
17560 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
17561 if (cur_descr
== NULL
)
17563 padsize
+= bitsize
;
17567 /* Check that cur_descr either doesn't use
17568 DW_OP_*piece operations, or their sum is equal
17569 to bitsize. Otherwise we can't embed it. */
17570 for (tail
= &cur_descr
; *tail
!= NULL
;
17571 tail
= &(*tail
)->dw_loc_next
)
17572 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
17574 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
17578 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
17580 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
17584 if (last
!= NULL
&& opsize
!= bitsize
)
17586 padsize
+= bitsize
;
17587 /* Discard the current piece of the descriptor and release any
17588 addr_table entries it uses. */
17589 remove_loc_list_addr_table_entries (cur_descr
);
17593 /* If there is a hole, add DW_OP_*piece after empty DWARF
17594 expression, which means that those bits are optimized out. */
17597 if (padsize
> decl_size
)
17599 remove_loc_list_addr_table_entries (cur_descr
);
17600 goto discard_descr
;
17602 decl_size
-= padsize
;
17603 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
17604 if (*descr_tail
== NULL
)
17606 remove_loc_list_addr_table_entries (cur_descr
);
17607 goto discard_descr
;
17609 descr_tail
= &(*descr_tail
)->dw_loc_next
;
17612 *descr_tail
= cur_descr
;
17614 if (bitsize
> decl_size
)
17615 goto discard_descr
;
17616 decl_size
-= bitsize
;
17619 HOST_WIDE_INT offset
= 0;
17620 if (GET_CODE (varloc
) == VAR_LOCATION
17621 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
17623 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
17624 if (GET_CODE (varloc
) == EXPR_LIST
)
17625 varloc
= XEXP (varloc
, 0);
17629 if (GET_CODE (varloc
) == CONST
17630 || GET_CODE (varloc
) == SIGN_EXTEND
17631 || GET_CODE (varloc
) == ZERO_EXTEND
)
17632 varloc
= XEXP (varloc
, 0);
17633 else if (GET_CODE (varloc
) == SUBREG
)
17634 varloc
= SUBREG_REG (varloc
);
17639 /* DW_OP_bit_size offset should be zero for register
17640 or implicit location descriptions and empty location
17641 descriptions, but for memory addresses needs big endian
17643 if (MEM_P (varloc
))
17645 unsigned HOST_WIDE_INT memsize
;
17646 if (!poly_uint64 (MEM_SIZE (varloc
)).is_constant (&memsize
))
17647 goto discard_descr
;
17648 memsize
*= BITS_PER_UNIT
;
17649 if (memsize
!= bitsize
)
17651 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
17652 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
17653 goto discard_descr
;
17654 if (memsize
< bitsize
)
17655 goto discard_descr
;
17656 if (BITS_BIG_ENDIAN
)
17657 offset
= memsize
- bitsize
;
17661 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
17662 if (*descr_tail
== NULL
)
17663 goto discard_descr
;
17664 descr_tail
= &(*descr_tail
)->dw_loc_next
;
17668 /* If there were any non-empty expressions, add padding till the end of
17670 if (descr
!= NULL
&& decl_size
!= 0)
17672 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
17673 if (*descr_tail
== NULL
)
17674 goto discard_descr
;
17679 /* Discard the descriptor and release any addr_table entries it uses. */
17680 remove_loc_list_addr_table_entries (descr
);
17684 /* Return the dwarf representation of the location list LOC_LIST of
17685 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
17688 static dw_loc_list_ref
17689 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
17691 const char *endname
, *secname
;
17692 var_loc_view endview
;
17694 enum var_init_status initialized
;
17695 struct var_loc_node
*node
;
17696 dw_loc_descr_ref descr
;
17697 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
17698 dw_loc_list_ref list
= NULL
;
17699 dw_loc_list_ref
*listp
= &list
;
17701 /* Now that we know what section we are using for a base,
17702 actually construct the list of locations.
17703 The first location information is what is passed to the
17704 function that creates the location list, and the remaining
17705 locations just get added on to that list.
17706 Note that we only know the start address for a location
17707 (IE location changes), so to build the range, we use
17708 the range [current location start, next location start].
17709 This means we have to special case the last node, and generate
17710 a range of [last location start, end of function label]. */
17712 if (cfun
&& crtl
->has_bb_partition
)
17714 bool save_in_cold_section_p
= in_cold_section_p
;
17715 in_cold_section_p
= first_function_block_is_cold
;
17716 if (loc_list
->last_before_switch
== NULL
)
17717 in_cold_section_p
= !in_cold_section_p
;
17718 secname
= secname_for_decl (decl
);
17719 in_cold_section_p
= save_in_cold_section_p
;
17722 secname
= secname_for_decl (decl
);
17724 for (node
= loc_list
->first
; node
; node
= node
->next
)
17726 bool range_across_switch
= false;
17727 if (GET_CODE (node
->loc
) == EXPR_LIST
17728 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
17730 if (GET_CODE (node
->loc
) == EXPR_LIST
)
17733 /* This requires DW_OP_{,bit_}piece, which is not usable
17734 inside DWARF expressions. */
17735 if (want_address
== 2)
17736 descr
= dw_sra_loc_expr (decl
, node
->loc
);
17740 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
17741 varloc
= NOTE_VAR_LOCATION (node
->loc
);
17742 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
17746 /* If section switch happens in between node->label
17747 and node->next->label (or end of function) and
17748 we can't emit it as a single entry list,
17749 emit two ranges, first one ending at the end
17750 of first partition and second one starting at the
17751 beginning of second partition. */
17752 if (node
== loc_list
->last_before_switch
17753 && (node
!= loc_list
->first
|| loc_list
->first
->next
17754 /* If we are to emit a view number, we will emit
17755 a loclist rather than a single location
17756 expression for the entire function (see
17757 loc_list_has_views), so we have to split the
17758 range that straddles across partitions. */
17759 || !ZERO_VIEW_P (node
->view
))
17760 && current_function_decl
)
17762 endname
= cfun
->fde
->dw_fde_end
;
17764 range_across_switch
= true;
17766 /* The variable has a location between NODE->LABEL and
17767 NODE->NEXT->LABEL. */
17768 else if (node
->next
)
17769 endname
= node
->next
->label
, endview
= node
->next
->view
;
17770 /* If the variable has a location at the last label
17771 it keeps its location until the end of function. */
17772 else if (!current_function_decl
)
17773 endname
= text_end_label
, endview
= 0;
17776 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
17777 current_function_funcdef_no
);
17778 endname
= ggc_strdup (label_id
);
17782 *listp
= new_loc_list (descr
, node
->label
, node
->view
,
17783 endname
, endview
, secname
);
17784 if (TREE_CODE (decl
) == PARM_DECL
17785 && node
== loc_list
->first
17786 && NOTE_P (node
->loc
)
17787 && strcmp (node
->label
, endname
) == 0)
17788 (*listp
)->force
= true;
17789 listp
= &(*listp
)->dw_loc_next
;
17794 && crtl
->has_bb_partition
17795 && node
== loc_list
->last_before_switch
)
17797 bool save_in_cold_section_p
= in_cold_section_p
;
17798 in_cold_section_p
= !first_function_block_is_cold
;
17799 secname
= secname_for_decl (decl
);
17800 in_cold_section_p
= save_in_cold_section_p
;
17803 if (range_across_switch
)
17805 if (GET_CODE (node
->loc
) == EXPR_LIST
)
17806 descr
= dw_sra_loc_expr (decl
, node
->loc
);
17809 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
17810 varloc
= NOTE_VAR_LOCATION (node
->loc
);
17811 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
17814 gcc_assert (descr
);
17815 /* The variable has a location between NODE->LABEL and
17816 NODE->NEXT->LABEL. */
17818 endname
= node
->next
->label
, endview
= node
->next
->view
;
17820 endname
= cfun
->fde
->dw_fde_second_end
, endview
= 0;
17821 *listp
= new_loc_list (descr
, cfun
->fde
->dw_fde_second_begin
, 0,
17822 endname
, endview
, secname
);
17823 listp
= &(*listp
)->dw_loc_next
;
17827 /* Try to avoid the overhead of a location list emitting a location
17828 expression instead, but only if we didn't have more than one
17829 location entry in the first place. If some entries were not
17830 representable, we don't want to pretend a single entry that was
17831 applies to the entire scope in which the variable is
17833 if (list
&& loc_list
->first
->next
)
17836 maybe_gen_llsym (list
);
17841 /* Return if the loc_list has only single element and thus can be represented
17842 as location description. */
17845 single_element_loc_list_p (dw_loc_list_ref list
)
17847 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
17848 return !list
->ll_symbol
;
17851 /* Duplicate a single element of location list. */
17853 static inline dw_loc_descr_ref
17854 copy_loc_descr (dw_loc_descr_ref ref
)
17856 dw_loc_descr_ref copy
= ggc_alloc
<dw_loc_descr_node
> ();
17857 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
17861 /* To each location in list LIST append loc descr REF. */
17864 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
17866 dw_loc_descr_ref copy
;
17867 add_loc_descr (&list
->expr
, ref
);
17868 list
= list
->dw_loc_next
;
17871 copy
= copy_loc_descr (ref
);
17872 add_loc_descr (&list
->expr
, copy
);
17873 while (copy
->dw_loc_next
)
17874 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
17875 list
= list
->dw_loc_next
;
17879 /* To each location in list LIST prepend loc descr REF. */
17882 prepend_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
17884 dw_loc_descr_ref copy
;
17885 dw_loc_descr_ref ref_end
= list
->expr
;
17886 add_loc_descr (&ref
, list
->expr
);
17888 list
= list
->dw_loc_next
;
17891 dw_loc_descr_ref end
= list
->expr
;
17892 list
->expr
= copy
= copy_loc_descr (ref
);
17893 while (copy
->dw_loc_next
!= ref_end
)
17894 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
17895 copy
->dw_loc_next
= end
;
17896 list
= list
->dw_loc_next
;
17900 /* Given two lists RET and LIST
17901 produce location list that is result of adding expression in LIST
17902 to expression in RET on each position in program.
17903 Might be destructive on both RET and LIST.
17905 TODO: We handle only simple cases of RET or LIST having at most one
17906 element. General case would involve sorting the lists in program order
17907 and merging them that will need some additional work.
17908 Adding that will improve quality of debug info especially for SRA-ed
17912 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
17921 if (!list
->dw_loc_next
)
17923 add_loc_descr_to_each (*ret
, list
->expr
);
17926 if (!(*ret
)->dw_loc_next
)
17928 prepend_loc_descr_to_each (list
, (*ret
)->expr
);
17932 expansion_failed (NULL_TREE
, NULL_RTX
,
17933 "Don't know how to merge two non-trivial"
17934 " location lists.\n");
17939 /* LOC is constant expression. Try a luck, look it up in constant
17940 pool and return its loc_descr of its address. */
17942 static dw_loc_descr_ref
17943 cst_pool_loc_descr (tree loc
)
17945 /* Get an RTL for this, if something has been emitted. */
17946 rtx rtl
= lookup_constant_def (loc
);
17948 if (!rtl
|| !MEM_P (rtl
))
17953 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
17955 /* TODO: We might get more coverage if we was actually delaying expansion
17956 of all expressions till end of compilation when constant pools are fully
17958 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
17960 expansion_failed (loc
, NULL_RTX
,
17961 "CST value in contant pool but not marked.");
17964 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
17965 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
17968 /* Return dw_loc_list representing address of addr_expr LOC
17969 by looking for inner INDIRECT_REF expression and turning
17970 it into simple arithmetics.
17972 See loc_list_from_tree for the meaning of CONTEXT. */
17974 static dw_loc_list_ref
17975 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
,
17976 loc_descr_context
*context
)
17979 poly_int64 bitsize
, bitpos
, bytepos
;
17981 int unsignedp
, reversep
, volatilep
= 0;
17982 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
17984 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
17985 &bitsize
, &bitpos
, &offset
, &mode
,
17986 &unsignedp
, &reversep
, &volatilep
);
17988 if (!multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
))
17990 expansion_failed (loc
, NULL_RTX
, "bitfield access");
17993 if (!INDIRECT_REF_P (obj
))
17995 expansion_failed (obj
,
17996 NULL_RTX
, "no indirect ref in inner refrence");
17999 if (!offset
&& known_eq (bitpos
, 0))
18000 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1,
18003 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
18004 && (dwarf_version
>= 4 || !dwarf_strict
))
18006 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0, context
);
18011 /* Variable offset. */
18012 list_ret1
= loc_list_from_tree (offset
, 0, context
);
18013 if (list_ret1
== 0)
18015 add_loc_list (&list_ret
, list_ret1
);
18018 add_loc_descr_to_each (list_ret
,
18019 new_loc_descr (DW_OP_plus
, 0, 0));
18021 HOST_WIDE_INT value
;
18022 if (bytepos
.is_constant (&value
) && value
> 0)
18023 add_loc_descr_to_each (list_ret
,
18024 new_loc_descr (DW_OP_plus_uconst
, value
, 0));
18025 else if (maybe_ne (bytepos
, 0))
18026 loc_list_plus_const (list_ret
, bytepos
);
18027 add_loc_descr_to_each (list_ret
,
18028 new_loc_descr (DW_OP_stack_value
, 0, 0));
18033 /* Set LOC to the next operation that is not a DW_OP_nop operation. In the case
18034 all operations from LOC are nops, move to the last one. Insert in NOPS all
18035 operations that are skipped. */
18038 loc_descr_to_next_no_nop (dw_loc_descr_ref
&loc
,
18039 hash_set
<dw_loc_descr_ref
> &nops
)
18041 while (loc
->dw_loc_next
!= NULL
&& loc
->dw_loc_opc
== DW_OP_nop
)
18044 loc
= loc
->dw_loc_next
;
18048 /* Helper for loc_descr_without_nops: free the location description operation
18052 free_loc_descr (const dw_loc_descr_ref
&loc
, void *data ATTRIBUTE_UNUSED
)
18058 /* Remove all DW_OP_nop operations from LOC except, if it exists, the one that
18062 loc_descr_without_nops (dw_loc_descr_ref
&loc
)
18064 if (loc
->dw_loc_opc
== DW_OP_nop
&& loc
->dw_loc_next
== NULL
)
18067 /* Set of all DW_OP_nop operations we remove. */
18068 hash_set
<dw_loc_descr_ref
> nops
;
18070 /* First, strip all prefix NOP operations in order to keep the head of the
18071 operations list. */
18072 loc_descr_to_next_no_nop (loc
, nops
);
18074 for (dw_loc_descr_ref cur
= loc
; cur
!= NULL
;)
18076 /* For control flow operations: strip "prefix" nops in destination
18078 if (cur
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
)
18079 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd1
.v
.val_loc
, nops
);
18080 if (cur
->dw_loc_oprnd2
.val_class
== dw_val_class_loc
)
18081 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd2
.v
.val_loc
, nops
);
18083 /* Do the same for the operations that follow, then move to the next
18085 if (cur
->dw_loc_next
!= NULL
)
18086 loc_descr_to_next_no_nop (cur
->dw_loc_next
, nops
);
18087 cur
= cur
->dw_loc_next
;
18090 nops
.traverse
<void *, free_loc_descr
> (NULL
);
18094 struct dwarf_procedure_info
;
18096 /* Helper structure for location descriptions generation. */
18097 struct loc_descr_context
18099 /* The type that is implicitly referenced by DW_OP_push_object_address, or
18100 NULL_TREE if DW_OP_push_object_address in invalid for this location
18101 description. This is used when processing PLACEHOLDER_EXPR nodes. */
18103 /* The ..._DECL node that should be translated as a
18104 DW_OP_push_object_address operation. */
18106 /* Information about the DWARF procedure we are currently generating. NULL if
18107 we are not generating a DWARF procedure. */
18108 struct dwarf_procedure_info
*dpi
;
18109 /* True if integral PLACEHOLDER_EXPR stands for the first argument passed
18110 by consumer. Used for DW_TAG_generic_subrange attributes. */
18111 bool placeholder_arg
;
18112 /* True if PLACEHOLDER_EXPR has been seen. */
18113 bool placeholder_seen
;
18114 /* True if strict preservation of signedness has been requested. */
18115 bool strict_signedness
;
18118 /* DWARF procedures generation
18120 DWARF expressions (aka. location descriptions) are used to encode variable
18121 things such as sizes or offsets. Such computations can have redundant parts
18122 that can be factorized in order to reduce the size of the output debug
18123 information. This is the whole point of DWARF procedures.
18125 Thanks to stor-layout.cc, size and offset expressions in GENERIC trees are
18126 already factorized into functions ("size functions") in order to handle very
18127 big and complex types. Such functions are quite simple: they have integral
18128 arguments, they return an integral result and their body contains only a
18129 return statement with arithmetic expressions. This is the only kind of
18130 function we are interested in translating into DWARF procedures, here.
18132 DWARF expressions and DWARF procedure are executed using a stack, so we have
18133 to define some calling convention for them to interact. Let's say that:
18135 - Before calling a DWARF procedure, DWARF expressions must push on the stack
18136 all arguments in reverse order (right-to-left) so that when the DWARF
18137 procedure execution starts, the first argument is the top of the stack.
18139 - Then, when returning, the DWARF procedure must have consumed all arguments
18140 on the stack, must have pushed the result and touched nothing else.
18142 - Each integral argument and the result are integral types can be hold in a
18145 - We call "frame offset" the number of stack slots that are "under DWARF
18146 procedure control": it includes the arguments slots, the temporaries and
18147 the result slot. Thus, it is equal to the number of arguments when the
18148 procedure execution starts and must be equal to one (the result) when it
18151 /* Helper structure used when generating operations for a DWARF procedure. */
18152 struct dwarf_procedure_info
18154 /* The FUNCTION_DECL node corresponding to the DWARF procedure that is
18155 currently translated. */
18157 /* The number of arguments FNDECL takes. */
18158 unsigned args_count
;
18161 /* Return a pointer to a newly created DIE node for a DWARF procedure. Add
18162 LOCATION as its DW_AT_location attribute. If FNDECL is not NULL_TREE,
18163 equate it to this DIE. */
18166 new_dwarf_proc_die (dw_loc_descr_ref location
, tree fndecl
,
18167 dw_die_ref parent_die
)
18169 dw_die_ref dwarf_proc_die
;
18171 if ((dwarf_version
< 3 && dwarf_strict
)
18172 || location
== NULL
)
18175 dwarf_proc_die
= new_die (DW_TAG_dwarf_procedure
, parent_die
, fndecl
);
18177 equate_decl_number_to_die (fndecl
, dwarf_proc_die
);
18178 add_AT_loc (dwarf_proc_die
, DW_AT_location
, location
);
18179 return dwarf_proc_die
;
18182 /* Return whether TYPE is a supported type as a DWARF procedure argument
18183 type or return type (we handle only scalar types and pointer types that
18184 aren't wider than the DWARF expression evaluation stack). */
18187 is_handled_procedure_type (tree type
)
18189 return ((INTEGRAL_TYPE_P (type
)
18190 || TREE_CODE (type
) == OFFSET_TYPE
18191 || TREE_CODE (type
) == POINTER_TYPE
)
18192 && int_size_in_bytes (type
) <= DWARF2_ADDR_SIZE
);
18195 /* Helper for resolve_args_picking: do the same but stop when coming across
18196 visited nodes. For each node we visit, register in FRAME_OFFSETS the frame
18197 offset *before* evaluating the corresponding operation. */
18200 resolve_args_picking_1 (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
18201 struct dwarf_procedure_info
*dpi
,
18202 hash_map
<dw_loc_descr_ref
, unsigned> &frame_offsets
)
18204 /* The "frame_offset" identifier is already used to name a macro... */
18205 unsigned frame_offset_
= initial_frame_offset
;
18206 dw_loc_descr_ref l
;
18208 for (l
= loc
; l
!= NULL
;)
18211 unsigned &l_frame_offset
= frame_offsets
.get_or_insert (l
, &existed
);
18213 /* If we already met this node, there is nothing to compute anymore. */
18216 /* Make sure that the stack size is consistent wherever the execution
18217 flow comes from. */
18218 gcc_assert ((unsigned) l_frame_offset
== frame_offset_
);
18221 l_frame_offset
= frame_offset_
;
18223 /* If needed, relocate the picking offset with respect to the frame
18225 if (l
->frame_offset_rel
)
18227 unsigned HOST_WIDE_INT off
;
18228 switch (l
->dw_loc_opc
)
18231 off
= l
->dw_loc_oprnd1
.v
.val_unsigned
;
18240 gcc_unreachable ();
18242 /* frame_offset_ is the size of the current stack frame, including
18243 incoming arguments. Besides, the arguments are pushed
18244 right-to-left. Thus, in order to access the Nth argument from
18245 this operation node, the picking has to skip temporaries *plus*
18246 one stack slot per argument (0 for the first one, 1 for the second
18249 The targetted argument number (N) is already set as the operand,
18250 and the number of temporaries can be computed with:
18251 frame_offsets_ - dpi->args_count */
18252 off
+= frame_offset_
- dpi
->args_count
;
18254 /* DW_OP_pick handles only offsets from 0 to 255 (inclusive)... */
18260 l
->dw_loc_opc
= DW_OP_dup
;
18261 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
18265 l
->dw_loc_opc
= DW_OP_over
;
18266 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
18270 l
->dw_loc_opc
= DW_OP_pick
;
18271 l
->dw_loc_oprnd1
.v
.val_unsigned
= off
;
18275 /* Update frame_offset according to the effect the current operation has
18277 switch (l
->dw_loc_opc
)
18285 case DW_OP_plus_uconst
:
18321 case DW_OP_deref_size
:
18323 case DW_OP_bit_piece
:
18324 case DW_OP_implicit_value
:
18325 case DW_OP_stack_value
:
18326 case DW_OP_deref_type
:
18327 case DW_OP_convert
:
18328 case DW_OP_reinterpret
:
18329 case DW_OP_GNU_deref_type
:
18330 case DW_OP_GNU_convert
:
18331 case DW_OP_GNU_reinterpret
:
18335 case DW_OP_const1u
:
18336 case DW_OP_const1s
:
18337 case DW_OP_const2u
:
18338 case DW_OP_const2s
:
18339 case DW_OP_const4u
:
18340 case DW_OP_const4s
:
18341 case DW_OP_const8u
:
18342 case DW_OP_const8s
:
18413 case DW_OP_push_object_address
:
18414 case DW_OP_call_frame_cfa
:
18415 case DW_OP_GNU_variable_value
:
18416 case DW_OP_GNU_addr_index
:
18417 case DW_OP_GNU_const_index
:
18442 case DW_OP_xderef_size
:
18448 case DW_OP_call_ref
:
18450 dw_die_ref dwarf_proc
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
18451 int *stack_usage
= dwarf_proc_stack_usage_map
->get (dwarf_proc
);
18453 if (stack_usage
== NULL
)
18455 frame_offset_
+= *stack_usage
;
18459 case DW_OP_implicit_pointer
:
18460 case DW_OP_entry_value
:
18461 case DW_OP_const_type
:
18462 case DW_OP_regval_type
:
18463 case DW_OP_form_tls_address
:
18464 case DW_OP_GNU_push_tls_address
:
18465 case DW_OP_GNU_uninit
:
18466 case DW_OP_GNU_encoded_addr
:
18467 case DW_OP_GNU_implicit_pointer
:
18468 case DW_OP_GNU_entry_value
:
18469 case DW_OP_GNU_const_type
:
18470 case DW_OP_GNU_regval_type
:
18471 case DW_OP_GNU_parameter_ref
:
18472 /* loc_list_from_tree will probably not output these operations for
18473 size functions, so assume they will not appear here. */
18474 /* Fall through... */
18477 gcc_unreachable ();
18480 /* Now, follow the control flow (except subroutine calls). */
18481 switch (l
->dw_loc_opc
)
18484 if (!resolve_args_picking_1 (l
->dw_loc_next
, frame_offset_
, dpi
,
18487 /* Fall through. */
18490 l
= l
->dw_loc_oprnd1
.v
.val_loc
;
18493 case DW_OP_stack_value
:
18497 l
= l
->dw_loc_next
;
18505 /* Make a DFS over operations reachable through LOC (i.e. follow branch
18506 operations) in order to resolve the operand of DW_OP_pick operations that
18507 target DWARF procedure arguments (DPI). INITIAL_FRAME_OFFSET is the frame
18508 offset *before* LOC is executed. Return if all relocations were
18512 resolve_args_picking (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
18513 struct dwarf_procedure_info
*dpi
)
18515 /* Associate to all visited operations the frame offset *before* evaluating
18517 hash_map
<dw_loc_descr_ref
, unsigned> frame_offsets
;
18520 resolve_args_picking_1 (loc
, initial_frame_offset
, dpi
, frame_offsets
);
18523 /* Try to generate a DWARF procedure that computes the same result as FNDECL.
18524 Return NULL if it is not possible. */
18527 function_to_dwarf_procedure (tree fndecl
)
18529 struct dwarf_procedure_info dpi
;
18530 struct loc_descr_context ctx
= {
18531 NULL_TREE
, /* context_type */
18532 NULL_TREE
, /* base_decl */
18534 false, /* placeholder_arg */
18535 false, /* placeholder_seen */
18536 true /* strict_signedness */
18538 dw_die_ref dwarf_proc_die
;
18539 tree tree_body
= DECL_SAVED_TREE (fndecl
);
18540 dw_loc_descr_ref loc_body
, epilogue
;
18545 /* Do not generate multiple DWARF procedures for the same function
18547 dwarf_proc_die
= lookup_decl_die (fndecl
);
18548 if (dwarf_proc_die
!= NULL
)
18549 return dwarf_proc_die
;
18551 /* DWARF procedures are available starting with the DWARFv3 standard. */
18552 if (dwarf_version
< 3 && dwarf_strict
)
18555 /* We handle only functions for which we still have a body, that return a
18556 supported type and that takes arguments with supported types. Note that
18557 there is no point translating functions that return nothing. */
18558 if (tree_body
== NULL_TREE
18559 || DECL_RESULT (fndecl
) == NULL_TREE
18560 || !is_handled_procedure_type (TREE_TYPE (DECL_RESULT (fndecl
))))
18563 for (cursor
= DECL_ARGUMENTS (fndecl
);
18564 cursor
!= NULL_TREE
;
18565 cursor
= TREE_CHAIN (cursor
))
18566 if (!is_handled_procedure_type (TREE_TYPE (cursor
)))
18569 /* Match only "expr" in: RETURN_EXPR (MODIFY_EXPR (RESULT_DECL, expr)). */
18570 if (TREE_CODE (tree_body
) != RETURN_EXPR
)
18572 tree_body
= TREE_OPERAND (tree_body
, 0);
18573 if (TREE_CODE (tree_body
) != MODIFY_EXPR
18574 || TREE_OPERAND (tree_body
, 0) != DECL_RESULT (fndecl
))
18576 tree_body
= TREE_OPERAND (tree_body
, 1);
18578 /* Try to translate the body expression itself. Note that this will probably
18579 cause an infinite recursion if its call graph has a cycle. This is very
18580 unlikely for size functions, however, so don't bother with such things at
18582 dpi
.fndecl
= fndecl
;
18583 dpi
.args_count
= list_length (DECL_ARGUMENTS (fndecl
));
18584 loc_body
= loc_descriptor_from_tree (tree_body
, 0, &ctx
);
18588 /* After evaluating all operands in "loc_body", we should still have on the
18589 stack all arguments plus the desired function result (top of the stack).
18590 Generate code in order to keep only the result in our stack frame. */
18592 for (i
= 0; i
< dpi
.args_count
; ++i
)
18594 dw_loc_descr_ref op_couple
= new_loc_descr (DW_OP_swap
, 0, 0);
18595 op_couple
->dw_loc_next
= new_loc_descr (DW_OP_drop
, 0, 0);
18596 op_couple
->dw_loc_next
->dw_loc_next
= epilogue
;
18597 epilogue
= op_couple
;
18599 add_loc_descr (&loc_body
, epilogue
);
18600 if (!resolve_args_picking (loc_body
, dpi
.args_count
, &dpi
))
18603 /* Trailing nops from loc_descriptor_from_tree (if any) cannot be removed
18604 because they are considered useful. Now there is an epilogue, they are
18605 not anymore, so give it another try. */
18606 loc_descr_without_nops (loc_body
);
18608 /* fndecl may be used both as a regular DW_TAG_subprogram DIE and as
18609 a DW_TAG_dwarf_procedure, so we may have a conflict, here. It's unlikely,
18610 though, given that size functions do not come from source, so they should
18611 not have a dedicated DW_TAG_subprogram DIE. */
18613 = new_dwarf_proc_die (loc_body
, fndecl
,
18614 get_context_die (DECL_CONTEXT (fndecl
)));
18616 /* The called DWARF procedure consumes one stack slot per argument and
18617 returns one stack slot. */
18618 dwarf_proc_stack_usage_map
->put (dwarf_proc_die
, 1 - dpi
.args_count
);
18620 return dwarf_proc_die
;
18623 /* Helper function for loc_list_from_tree. Perform OP binary op,
18624 but after converting arguments to type_die, afterwards convert
18625 back to unsigned. */
18627 static dw_loc_list_ref
18628 typed_binop_from_tree (enum dwarf_location_atom op
, tree loc
,
18629 dw_die_ref type_die
, scalar_int_mode mode
,
18630 struct loc_descr_context
*context
)
18632 dw_loc_list_ref op0
, op1
;
18633 dw_loc_descr_ref cvt
, binop
;
18635 if (type_die
== NULL
)
18638 op0
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0, context
);
18639 op1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
18640 if (op0
== NULL
|| op1
== NULL
)
18643 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
18644 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18645 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
18646 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18647 add_loc_descr_to_each (op0
, cvt
);
18649 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
18650 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18651 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
18652 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18653 add_loc_descr_to_each (op1
, cvt
);
18655 add_loc_list (&op0
, op1
);
18659 binop
= new_loc_descr (op
, 0, 0);
18660 convert_descriptor_to_mode (mode
, binop
);
18661 add_loc_descr_to_each (op0
, binop
);
18666 /* Generate Dwarf location list representing LOC.
18667 If WANT_ADDRESS is false, expression computing LOC will be computed
18668 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
18669 if WANT_ADDRESS is 2, expression computing address useable in location
18670 will be returned (i.e. DW_OP_reg can be used
18671 to refer to register values).
18673 CONTEXT provides information to customize the location descriptions
18674 generation. Its context_type field specifies what type is implicitly
18675 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
18676 will not be generated.
18678 Its DPI field determines whether we are generating a DWARF expression for a
18679 DWARF procedure, so PARM_DECL references are processed specifically.
18681 If CONTEXT is NULL, the behavior is the same as if context_type, base_decl
18682 and dpi fields were null. */
18684 static dw_loc_list_ref
18685 loc_list_from_tree_1 (tree loc
, int want_address
,
18686 struct loc_descr_context
*context
)
18688 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
18689 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
18690 int have_address
= 0;
18691 enum dwarf_location_atom op
;
18693 /* ??? Most of the time we do not take proper care for sign/zero
18694 extending the values properly. Hopefully this won't be a real
18697 if (context
!= NULL
18698 && context
->base_decl
== loc
18699 && want_address
== 0)
18701 if (dwarf_version
>= 3 || !dwarf_strict
)
18702 return new_loc_list (new_loc_descr (DW_OP_push_object_address
, 0, 0),
18703 NULL
, 0, NULL
, 0, NULL
);
18708 switch (TREE_CODE (loc
))
18711 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
18714 case PLACEHOLDER_EXPR
:
18715 /* This case involves extracting fields from an object to determine the
18716 position of other fields. It is supposed to appear only as the first
18717 operand of COMPONENT_REF nodes and to reference precisely the type
18718 that the context allows or its enclosing type. */
18719 if (context
!= NULL
18720 && (TREE_TYPE (loc
) == context
->context_type
18721 || TREE_TYPE (loc
) == TYPE_CONTEXT (context
->context_type
))
18722 && want_address
>= 1)
18724 if (dwarf_version
>= 3 || !dwarf_strict
)
18726 ret
= new_loc_descr (DW_OP_push_object_address
, 0, 0);
18733 /* For DW_TAG_generic_subrange attributes, PLACEHOLDER_EXPR stands for
18734 the single argument passed by consumer. */
18735 else if (context
!= NULL
18736 && context
->placeholder_arg
18737 && INTEGRAL_TYPE_P (TREE_TYPE (loc
))
18738 && want_address
== 0)
18740 ret
= new_loc_descr (DW_OP_pick
, 0, 0);
18741 ret
->frame_offset_rel
= 1;
18742 context
->placeholder_seen
= true;
18746 expansion_failed (loc
, NULL_RTX
,
18747 "PLACEHOLDER_EXPR for an unexpected type");
18752 tree callee
= get_callee_fndecl (loc
);
18753 dw_die_ref dwarf_proc
;
18756 && is_handled_procedure_type (TREE_TYPE (TREE_TYPE (callee
)))
18757 && (dwarf_proc
= function_to_dwarf_procedure (callee
)))
18759 /* DWARF procedures are used for size functions, which are built
18760 when size expressions contain conditional constructs, so we
18761 request strict preservation of signedness for comparisons. */
18762 bool old_strict_signedness
;
18765 old_strict_signedness
= context
->strict_signedness
;
18766 context
->strict_signedness
= true;
18769 /* Evaluate arguments right-to-left so that the first argument
18770 will be the top-most one on the stack. */
18771 for (int i
= call_expr_nargs (loc
) - 1; i
>= 0; --i
)
18773 tree arg
= CALL_EXPR_ARG (loc
, i
);
18774 ret1
= loc_descriptor_from_tree (arg
, 0, context
);
18777 expansion_failed (arg
, NULL_RTX
, "CALL_EXPR argument");
18780 add_loc_descr (&ret
, ret1
);
18783 ret1
= new_loc_descr (DW_OP_call4
, 0, 0);
18784 ret1
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18785 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.die
= dwarf_proc
;
18786 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18787 add_loc_descr (&ret
, ret1
);
18789 context
->strict_signedness
= old_strict_signedness
;
18792 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR target");
18796 case PREINCREMENT_EXPR
:
18797 case PREDECREMENT_EXPR
:
18798 case POSTINCREMENT_EXPR
:
18799 case POSTDECREMENT_EXPR
:
18800 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
18801 /* There are no opcodes for these operations. */
18805 /* If we already want an address, see if there is INDIRECT_REF inside
18806 e.g. for &this->field. */
18809 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
18810 (loc
, want_address
== 2, context
);
18813 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
18814 && (ret
= cst_pool_loc_descr (loc
)))
18817 /* Otherwise, process the argument and look for the address. */
18818 if (!list_ret
&& !ret
)
18819 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 1, context
);
18823 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
18829 if (DECL_THREAD_LOCAL_P (loc
))
18832 enum dwarf_location_atom tls_op
;
18833 enum dtprel_bool dtprel
= dtprel_false
;
18835 if (targetm
.have_tls
)
18837 /* If this is not defined, we have no way to emit the
18839 if (!targetm
.asm_out
.output_dwarf_dtprel
)
18842 /* The way DW_OP_GNU_push_tls_address is specified, we
18843 can only look up addresses of objects in the current
18844 module. We used DW_OP_addr as first op, but that's
18845 wrong, because DW_OP_addr is relocated by the debug
18846 info consumer, while DW_OP_GNU_push_tls_address
18847 operand shouldn't be. */
18848 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
18850 dtprel
= dtprel_true
;
18851 /* We check for DWARF 5 here because gdb did not implement
18852 DW_OP_form_tls_address until after 7.12. */
18853 tls_op
= (dwarf_version
>= 5 ? DW_OP_form_tls_address
18854 : DW_OP_GNU_push_tls_address
);
18858 if (!targetm
.emutls
.debug_form_tls_address
18859 || !(dwarf_version
>= 3 || !dwarf_strict
))
18861 /* We stuffed the control variable into the DECL_VALUE_EXPR
18862 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
18863 no longer appear in gimple code. We used the control
18864 variable in specific so that we could pick it up here. */
18865 loc
= DECL_VALUE_EXPR (loc
);
18866 tls_op
= DW_OP_form_tls_address
;
18869 rtl
= rtl_for_decl_location (loc
);
18870 if (rtl
== NULL_RTX
)
18875 rtl
= XEXP (rtl
, 0);
18876 if (! CONSTANT_P (rtl
))
18879 ret
= new_addr_loc_descr (rtl
, dtprel
);
18880 ret1
= new_loc_descr (tls_op
, 0, 0);
18881 add_loc_descr (&ret
, ret1
);
18889 if (context
!= NULL
&& context
->dpi
!= NULL
18890 && DECL_CONTEXT (loc
) == context
->dpi
->fndecl
)
18892 /* We are generating code for a DWARF procedure and we want to access
18893 one of its arguments: find the appropriate argument offset and let
18894 the resolve_args_picking pass compute the offset that complies
18895 with the stack frame size. */
18899 for (cursor
= DECL_ARGUMENTS (context
->dpi
->fndecl
);
18900 cursor
!= NULL_TREE
&& cursor
!= loc
;
18901 cursor
= TREE_CHAIN (cursor
), ++i
)
18903 /* If we are translating a DWARF procedure, all referenced parameters
18904 must belong to the current function. */
18905 gcc_assert (cursor
!= NULL_TREE
);
18907 ret
= new_loc_descr (DW_OP_pick
, i
, 0);
18908 ret
->frame_offset_rel
= 1;
18914 if (DECL_HAS_VALUE_EXPR_P (loc
))
18916 tree value_expr
= DECL_VALUE_EXPR (loc
);
18918 /* Non-local frame structures are DECL_IGNORED_P variables so we need
18919 to wait until they get an RTX in order to reference them. */
18921 && TREE_CODE (value_expr
) == COMPONENT_REF
18922 && VAR_P (TREE_OPERAND (value_expr
, 0))
18923 && DECL_NONLOCAL_FRAME (TREE_OPERAND (value_expr
, 0)))
18926 return loc_list_from_tree_1 (value_expr
, want_address
, context
);
18931 case FUNCTION_DECL
:
18934 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
18936 if (loc_list
&& loc_list
->first
)
18938 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
18939 have_address
= want_address
!= 0;
18942 rtl
= rtl_for_decl_location (loc
);
18943 if (rtl
== NULL_RTX
)
18945 if (TREE_CODE (loc
) != FUNCTION_DECL
18947 && want_address
!= 1
18948 && ! DECL_IGNORED_P (loc
)
18949 && (INTEGRAL_TYPE_P (TREE_TYPE (loc
))
18950 || POINTER_TYPE_P (TREE_TYPE (loc
)))
18951 && (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (loc
)))
18952 <= DWARF2_ADDR_SIZE
))
18954 dw_die_ref ref
= lookup_decl_die (loc
);
18957 ret
= new_loc_descr (DW_OP_GNU_variable_value
, 0, 0);
18958 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18959 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
18960 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18962 else if (current_function_decl
18963 && DECL_CONTEXT (loc
) == current_function_decl
)
18965 ret
= new_loc_descr (DW_OP_GNU_variable_value
, 0, 0);
18966 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
18967 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= loc
;
18971 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
18974 else if (CONST_INT_P (rtl
))
18976 HOST_WIDE_INT val
= INTVAL (rtl
);
18977 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18978 val
&= GET_MODE_MASK (DECL_MODE (loc
));
18979 ret
= int_loc_descriptor (val
);
18981 else if (GET_CODE (rtl
) == CONST_STRING
)
18983 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
18986 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
18987 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
18990 machine_mode mode
, mem_mode
;
18992 /* Certain constructs can only be represented at top-level. */
18993 if (want_address
== 2)
18995 ret
= loc_descriptor (rtl
, VOIDmode
,
18996 VAR_INIT_STATUS_INITIALIZED
);
19001 mode
= GET_MODE (rtl
);
19002 mem_mode
= VOIDmode
;
19006 mode
= get_address_mode (rtl
);
19007 rtl
= XEXP (rtl
, 0);
19010 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
19011 VAR_INIT_STATUS_INITIALIZED
);
19014 expansion_failed (loc
, rtl
,
19015 "failed to produce loc descriptor for rtl");
19021 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
19028 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19032 case TARGET_MEM_REF
:
19034 case DEBUG_EXPR_DECL
:
19037 case COMPOUND_EXPR
:
19038 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), want_address
,
19042 case VIEW_CONVERT_EXPR
:
19045 case NON_LVALUE_EXPR
:
19046 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), want_address
,
19049 case COMPONENT_REF
:
19050 case BIT_FIELD_REF
:
19052 case ARRAY_RANGE_REF
:
19053 case REALPART_EXPR
:
19054 case IMAGPART_EXPR
:
19057 poly_int64 bitsize
, bitpos
, bytepos
;
19059 int unsignedp
, reversep
, volatilep
= 0;
19061 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
19062 &unsignedp
, &reversep
, &volatilep
);
19064 gcc_assert (obj
!= loc
);
19066 list_ret
= loc_list_from_tree_1 (obj
,
19068 && known_eq (bitpos
, 0)
19069 && !offset
? 2 : 1,
19071 /* TODO: We can extract value of the small expression via shifting even
19072 for nonzero bitpos. */
19075 if (!multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
19076 || !multiple_p (bitsize
, BITS_PER_UNIT
))
19078 expansion_failed (loc
, NULL_RTX
,
19079 "bitfield access");
19083 if (offset
!= NULL_TREE
)
19085 /* Variable offset. */
19086 list_ret1
= loc_list_from_tree_1 (offset
, 0, context
);
19087 if (list_ret1
== 0)
19089 add_loc_list (&list_ret
, list_ret1
);
19092 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
19095 HOST_WIDE_INT value
;
19096 if (bytepos
.is_constant (&value
) && value
> 0)
19097 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
,
19099 else if (maybe_ne (bytepos
, 0))
19100 loc_list_plus_const (list_ret
, bytepos
);
19107 if ((want_address
|| !tree_fits_shwi_p (loc
))
19108 && (ret
= cst_pool_loc_descr (loc
)))
19110 else if (want_address
== 2
19111 && tree_fits_shwi_p (loc
)
19112 && (ret
= address_of_int_loc_descriptor
19113 (int_size_in_bytes (TREE_TYPE (loc
)),
19114 tree_to_shwi (loc
))))
19116 else if (tree_fits_shwi_p (loc
))
19117 ret
= int_loc_descriptor (tree_to_shwi (loc
));
19118 else if (tree_fits_uhwi_p (loc
))
19119 ret
= uint_loc_descriptor (tree_to_uhwi (loc
));
19122 expansion_failed (loc
, NULL_RTX
,
19123 "Integer operand is not host integer");
19132 expansion_failed (loc
, NULL_RTX
,
19133 "constant address with a runtime component");
19137 if (!poly_int_tree_p (loc
, &value
))
19139 expansion_failed (loc
, NULL_RTX
, "constant too big");
19142 ret
= int_loc_descriptor (value
);
19150 if ((ret
= cst_pool_loc_descr (loc
)))
19152 else if (TREE_CODE (loc
) == CONSTRUCTOR
)
19154 tree type
= TREE_TYPE (loc
);
19155 unsigned HOST_WIDE_INT size
= int_size_in_bytes (type
);
19156 unsigned HOST_WIDE_INT offset
= 0;
19157 unsigned HOST_WIDE_INT cnt
;
19158 constructor_elt
*ce
;
19160 if (TREE_CODE (type
) == RECORD_TYPE
)
19162 /* This is very limited, but it's enough to output
19163 pointers to member functions, as long as the
19164 referenced function is defined in the current
19165 translation unit. */
19166 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (loc
), cnt
, ce
)
19168 tree val
= ce
->value
;
19170 tree field
= ce
->index
;
19175 if (!field
|| DECL_BIT_FIELD (field
))
19177 expansion_failed (loc
, NULL_RTX
,
19178 "bitfield in record type constructor");
19179 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
19184 HOST_WIDE_INT fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
19185 unsigned HOST_WIDE_INT pos
= int_byte_position (field
);
19186 gcc_assert (pos
+ fieldsize
<= size
);
19189 expansion_failed (loc
, NULL_RTX
,
19190 "out-of-order fields in record constructor");
19191 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
19197 ret1
= new_loc_descr (DW_OP_piece
, pos
- offset
, 0);
19198 add_loc_descr (&ret
, ret1
);
19201 if (val
&& fieldsize
!= 0)
19203 ret1
= loc_descriptor_from_tree (val
, want_address
, context
);
19206 expansion_failed (loc
, NULL_RTX
,
19207 "unsupported expression in field");
19208 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
19212 add_loc_descr (&ret
, ret1
);
19216 ret1
= new_loc_descr (DW_OP_piece
, fieldsize
, 0);
19217 add_loc_descr (&ret
, ret1
);
19218 offset
= pos
+ fieldsize
;
19222 if (offset
!= size
)
19224 ret1
= new_loc_descr (DW_OP_piece
, size
- offset
, 0);
19225 add_loc_descr (&ret
, ret1
);
19229 have_address
= !!want_address
;
19232 expansion_failed (loc
, NULL_RTX
,
19233 "constructor of non-record type");
19236 /* We can construct small constants here using int_loc_descriptor. */
19237 expansion_failed (loc
, NULL_RTX
,
19238 "constructor or constant not in constant pool");
19241 case TRUTH_AND_EXPR
:
19242 case TRUTH_ANDIF_EXPR
:
19247 case TRUTH_XOR_EXPR
:
19252 case TRUTH_OR_EXPR
:
19253 case TRUTH_ORIF_EXPR
:
19258 case EXACT_DIV_EXPR
:
19259 case FLOOR_DIV_EXPR
:
19260 case TRUNC_DIV_EXPR
:
19261 /* Turn a divide by a power of 2 into a shift when possible. */
19262 if (TYPE_UNSIGNED (TREE_TYPE (loc
))
19263 && tree_fits_uhwi_p (TREE_OPERAND (loc
, 1)))
19265 const int log2
= exact_log2 (tree_to_uhwi (TREE_OPERAND (loc
, 1)));
19269 = loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19273 add_loc_descr_to_each (list_ret
, uint_loc_descriptor (log2
));
19274 add_loc_descr_to_each (list_ret
,
19275 new_loc_descr (DW_OP_shr
, 0, 0));
19282 case CEIL_DIV_EXPR
:
19283 case ROUND_DIV_EXPR
:
19284 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
19286 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (loc
));
19287 scalar_int_mode int_mode
;
19289 if ((dwarf_strict
&& dwarf_version
< 5)
19290 || !is_a
<scalar_int_mode
> (mode
, &int_mode
))
19293 /* We can use a signed divide if the sign bit is not set. */
19294 if (GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
19300 list_ret
= typed_binop_from_tree (DW_OP_div
, loc
,
19301 base_type_for_mode (int_mode
, 1),
19302 int_mode
, context
);
19312 case FLOOR_MOD_EXPR
:
19313 case CEIL_MOD_EXPR
:
19314 case ROUND_MOD_EXPR
:
19315 case TRUNC_MOD_EXPR
:
19316 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
19321 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19322 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
19323 if (list_ret
== 0 || list_ret1
== 0)
19326 add_loc_list (&list_ret
, list_ret1
);
19329 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
19330 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
19331 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
19332 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
19333 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
19345 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
19348 case POINTER_PLUS_EXPR
:
19351 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
19353 /* Big unsigned numbers can fit in HOST_WIDE_INT but it may be
19354 smarter to encode their opposite. The DW_OP_plus_uconst operation
19355 takes 1 + X bytes, X being the size of the ULEB128 addend. On the
19356 other hand, a "<push literal>; DW_OP_minus" pattern takes 1 + Y
19357 bytes, Y being the size of the operation that pushes the opposite
19358 of the addend. So let's choose the smallest representation. */
19359 const tree tree_addend
= TREE_OPERAND (loc
, 1);
19360 offset_int wi_addend
;
19361 HOST_WIDE_INT shwi_addend
;
19362 dw_loc_descr_ref loc_naddend
;
19364 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19368 /* Try to get the literal to push. It is the opposite of the addend,
19369 so as we rely on wrapping during DWARF evaluation, first decode
19370 the literal as a "DWARF-sized" signed number. */
19371 wi_addend
= wi::to_offset (tree_addend
);
19372 wi_addend
= wi::sext (wi_addend
, DWARF2_ADDR_SIZE
* 8);
19373 shwi_addend
= wi_addend
.to_shwi ();
19374 loc_naddend
= (shwi_addend
!= INTTYPE_MINIMUM (HOST_WIDE_INT
))
19375 ? int_loc_descriptor (-shwi_addend
)
19378 if (loc_naddend
!= NULL
19379 && ((unsigned) size_of_uleb128 (shwi_addend
)
19380 > size_of_loc_descr (loc_naddend
)))
19382 add_loc_descr_to_each (list_ret
, loc_naddend
);
19383 add_loc_descr_to_each (list_ret
,
19384 new_loc_descr (DW_OP_minus
, 0, 0));
19388 for (dw_loc_descr_ref loc_cur
= loc_naddend
; loc_cur
!= NULL
; )
19390 loc_naddend
= loc_cur
;
19391 loc_cur
= loc_cur
->dw_loc_next
;
19392 ggc_free (loc_naddend
);
19394 loc_list_plus_const (list_ret
, wi_addend
.to_shwi ());
19404 goto do_comp_binop
;
19408 goto do_comp_binop
;
19412 goto do_comp_binop
;
19416 goto do_comp_binop
;
19419 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
19421 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0, context
);
19422 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
19423 list_ret
= loc_list_from_uint_comparison (list_ret
, list_ret1
,
19439 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19440 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
19441 if (list_ret
== 0 || list_ret1
== 0)
19444 add_loc_list (&list_ret
, list_ret1
);
19447 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
19450 case TRUTH_NOT_EXPR
:
19451 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19455 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_lit0
, 0, 0));
19456 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_eq
, 0, 0));
19472 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19476 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
19482 const enum tree_code code
=
19483 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
19485 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
19486 build2 (code
, integer_type_node
,
19487 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
19488 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
19495 dw_loc_descr_ref lhs
19496 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
19497 dw_loc_list_ref rhs
19498 = loc_list_from_tree_1 (TREE_OPERAND (loc
, 2), 0, context
);
19499 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
19501 /* DW_OP_bra is branch-on-nonzero so avoid doing useless work. */
19502 if (TREE_CODE (TREE_OPERAND (loc
, 0)) == NE_EXPR
19503 && integer_zerop (TREE_OPERAND (TREE_OPERAND (loc
, 0), 1)))
19505 = loc_list_from_tree_1 (TREE_OPERAND (TREE_OPERAND (loc
, 0), 0),
19507 /* Likewise, swap the operands for a logically negated condition. */
19508 else if (TREE_CODE (TREE_OPERAND (loc
, 0)) == TRUTH_NOT_EXPR
)
19510 lhs
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 2), 0, context
);
19511 rhs
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
19513 = loc_list_from_tree_1 (TREE_OPERAND (TREE_OPERAND (loc
, 0), 0),
19517 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
19518 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
19521 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
19522 add_loc_descr_to_each (list_ret
, bra_node
);
19524 add_loc_list (&list_ret
, rhs
);
19525 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
19526 add_loc_descr_to_each (list_ret
, jump_node
);
19528 add_loc_descr_to_each (list_ret
, lhs
);
19529 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
19530 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
19532 /* ??? Need a node to point the skip at. Use a nop. */
19533 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
19534 add_loc_descr_to_each (list_ret
, tmp
);
19535 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
19536 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
19540 case FIX_TRUNC_EXPR
:
19543 case COMPOUND_LITERAL_EXPR
:
19544 return loc_list_from_tree_1 (COMPOUND_LITERAL_EXPR_DECL (loc
),
19548 /* Leave front-end specific codes as simply unknown. This comes
19549 up, for instance, with the C STMT_EXPR. */
19550 if ((unsigned int) TREE_CODE (loc
)
19551 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
19553 expansion_failed (loc
, NULL_RTX
,
19554 "language specific tree node");
19558 /* Otherwise this is a generic code; we should just lists all of
19559 these explicitly. We forgot one. */
19561 gcc_unreachable ();
19563 /* In a release build, we want to degrade gracefully: better to
19564 generate incomplete debugging information than to crash. */
19568 if (!ret
&& !list_ret
)
19571 if (want_address
== 2 && !have_address
19572 && (dwarf_version
>= 4 || !dwarf_strict
))
19574 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
19576 expansion_failed (loc
, NULL_RTX
,
19577 "DWARF address size mismatch");
19581 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
19583 add_loc_descr_to_each (list_ret
,
19584 new_loc_descr (DW_OP_stack_value
, 0, 0));
19587 /* Show if we can't fill the request for an address. */
19588 if (want_address
&& !have_address
)
19590 expansion_failed (loc
, NULL_RTX
,
19591 "Want address and only have value");
19595 gcc_assert (!ret
|| !list_ret
);
19597 /* If we've got an address and don't want one, dereference. */
19598 if (!want_address
&& have_address
)
19600 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
19601 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (loc
));
19602 scalar_int_mode int_mode
;
19603 dw_die_ref type_die
;
19604 dw_loc_descr_ref deref
;
19606 /* If the size is greater than DWARF2_ADDR_SIZE, bail out. */
19607 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
19609 expansion_failed (loc
, NULL_RTX
,
19610 "DWARF address size mismatch");
19614 /* If it is equal to DWARF2_ADDR_SIZE, extension does not matter. */
19615 else if (size
== DWARF2_ADDR_SIZE
)
19616 deref
= new_loc_descr (DW_OP_deref
, size
, 0);
19618 /* If it is lower than DWARF2_ADDR_SIZE, DW_OP_deref_size will zero-
19619 extend the value, which is really OK for unsigned types only. */
19620 else if (!(context
&& context
->strict_signedness
)
19621 || TYPE_UNSIGNED (TREE_TYPE (loc
))
19622 || (dwarf_strict
&& dwarf_version
< 5)
19623 || !is_a
<scalar_int_mode
> (mode
, &int_mode
)
19624 || !(type_die
= base_type_for_mode (mode
, false)))
19625 deref
= new_loc_descr (DW_OP_deref_size
, size
, 0);
19627 /* Use DW_OP_deref_type for signed integral types if possible, but
19628 convert back to the generic type to avoid type mismatches later. */
19631 deref
= new_loc_descr (dwarf_OP (DW_OP_deref_type
), size
, 0);
19632 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
19633 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
19634 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
19635 add_loc_descr (&deref
,
19636 new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0));
19640 add_loc_descr (&ret
, deref
);
19642 add_loc_descr_to_each (list_ret
, deref
);
19646 list_ret
= new_loc_list (ret
, NULL
, 0, NULL
, 0, NULL
);
19651 /* Likewise, but strip useless DW_OP_nop operations in the resulting
19654 static dw_loc_list_ref
19655 loc_list_from_tree (tree loc
, int want_address
,
19656 struct loc_descr_context
*context
)
19658 dw_loc_list_ref result
= loc_list_from_tree_1 (loc
, want_address
, context
);
19660 for (dw_loc_list_ref loc_cur
= result
;
19661 loc_cur
!= NULL
; loc_cur
= loc_cur
->dw_loc_next
)
19662 loc_descr_without_nops (loc_cur
->expr
);
19666 /* Same as above but return only single location expression. */
19667 static dw_loc_descr_ref
19668 loc_descriptor_from_tree (tree loc
, int want_address
,
19669 struct loc_descr_context
*context
)
19671 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
, context
);
19674 if (ret
->dw_loc_next
)
19676 expansion_failed (loc
, NULL_RTX
,
19677 "Location list where only loc descriptor needed");
19683 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
19684 pointer to the declared type for the relevant field variable, or return
19685 `integer_type_node' if the given node turns out to be an
19686 ERROR_MARK node. */
19689 field_type (const_tree decl
)
19693 if (TREE_CODE (decl
) == ERROR_MARK
)
19694 return integer_type_node
;
19696 type
= DECL_BIT_FIELD_TYPE (decl
);
19697 if (type
== NULL_TREE
)
19698 type
= TREE_TYPE (decl
);
19703 /* Given a pointer to a tree node, return the alignment in bits for
19704 it, or else return BITS_PER_WORD if the node actually turns out to
19705 be an ERROR_MARK node. */
19707 static inline unsigned
19708 simple_type_align_in_bits (const_tree type
)
19710 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
19713 static inline unsigned
19714 simple_decl_align_in_bits (const_tree decl
)
19716 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
19719 /* Return the result of rounding T up to ALIGN. */
19721 static inline offset_int
19722 round_up_to_align (const offset_int
&t
, unsigned int align
)
19724 return wi::udiv_trunc (t
+ align
- 1, align
) * align
;
19727 /* Helper structure for RECORD_TYPE processing. */
19730 /* Root RECORD_TYPE. It is needed to generate data member location
19731 descriptions in variable-length records (VLR), but also to cope with
19732 variants, which are composed of nested structures multiplexed with
19733 QUAL_UNION_TYPE nodes. Each time such a structure is passed to a
19734 function processing a FIELD_DECL, it is required to be non null. */
19737 /* When generating a variant part in a RECORD_TYPE (i.e. a nested
19738 QUAL_UNION_TYPE), this holds an expression that computes the offset for
19739 this variant part as part of the root record (in storage units). For
19740 regular records, it must be NULL_TREE. */
19741 tree variant_part_offset
;
19744 /* Given a pointer to a FIELD_DECL, compute the byte offset of the lowest
19745 addressed byte of the "containing object" for the given FIELD_DECL. If
19746 possible, return a native constant through CST_OFFSET (in which case NULL is
19747 returned); otherwise return a DWARF expression that computes the offset.
19749 Set *CST_OFFSET to 0 and return NULL if we are unable to determine what
19750 that offset is, either because the argument turns out to be a pointer to an
19751 ERROR_MARK node, or because the offset expression is too complex for us.
19753 CTX is required: see the comment for VLR_CONTEXT. */
19755 static dw_loc_descr_ref
19756 field_byte_offset (const_tree decl
, struct vlr_context
*ctx
,
19757 HOST_WIDE_INT
*cst_offset
)
19760 dw_loc_list_ref loc_result
;
19764 if (TREE_CODE (decl
) == ERROR_MARK
)
19767 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
19769 /* We cannot handle variable bit offsets at the moment, so abort if it's the
19771 if (TREE_CODE (DECL_FIELD_BIT_OFFSET (decl
)) != INTEGER_CST
)
19774 /* We used to handle only constant offsets in all cases. Now, we handle
19775 properly dynamic byte offsets only when PCC bitfield type doesn't
19777 if (PCC_BITFIELD_TYPE_MATTERS
19778 && DECL_BIT_FIELD_TYPE (decl
)
19779 && TREE_CODE (DECL_FIELD_OFFSET (decl
)) == INTEGER_CST
)
19781 offset_int object_offset_in_bits
;
19782 offset_int object_offset_in_bytes
;
19783 offset_int bitpos_int
;
19785 tree field_size_tree
;
19786 offset_int deepest_bitpos
;
19787 offset_int field_size_in_bits
;
19788 unsigned int type_align_in_bits
;
19789 unsigned int decl_align_in_bits
;
19790 offset_int type_size_in_bits
;
19792 bitpos_int
= wi::to_offset (bit_position (decl
));
19793 type
= field_type (decl
);
19794 type_size_in_bits
= offset_int_type_size_in_bits (type
);
19795 type_align_in_bits
= simple_type_align_in_bits (type
);
19797 field_size_tree
= DECL_SIZE (decl
);
19799 /* The size could be unspecified if there was an error, or for
19800 a flexible array member. */
19801 if (!field_size_tree
)
19802 field_size_tree
= bitsize_zero_node
;
19804 /* If the size of the field is not constant, use the type size. */
19805 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
19806 field_size_in_bits
= wi::to_offset (field_size_tree
);
19808 field_size_in_bits
= type_size_in_bits
;
19810 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
19812 /* The GCC front-end doesn't make any attempt to keep track of the
19813 starting bit offset (relative to the start of the containing
19814 structure type) of the hypothetical "containing object" for a
19815 bit-field. Thus, when computing the byte offset value for the
19816 start of the "containing object" of a bit-field, we must deduce
19817 this information on our own. This can be rather tricky to do in
19818 some cases. For example, handling the following structure type
19819 definition when compiling for an i386/i486 target (which only
19820 aligns long long's to 32-bit boundaries) can be very tricky:
19822 struct S { int field1; long long field2:31; };
19824 Fortunately, there is a simple rule-of-thumb which can be used
19825 in such cases. When compiling for an i386/i486, GCC will
19826 allocate 8 bytes for the structure shown above. It decides to
19827 do this based upon one simple rule for bit-field allocation.
19828 GCC allocates each "containing object" for each bit-field at
19829 the first (i.e. lowest addressed) legitimate alignment boundary
19830 (based upon the required minimum alignment for the declared
19831 type of the field) which it can possibly use, subject to the
19832 condition that there is still enough available space remaining
19833 in the containing object (when allocated at the selected point)
19834 to fully accommodate all of the bits of the bit-field itself.
19836 This simple rule makes it obvious why GCC allocates 8 bytes for
19837 each object of the structure type shown above. When looking
19838 for a place to allocate the "containing object" for `field2',
19839 the compiler simply tries to allocate a 64-bit "containing
19840 object" at each successive 32-bit boundary (starting at zero)
19841 until it finds a place to allocate that 64- bit field such that
19842 at least 31 contiguous (and previously unallocated) bits remain
19843 within that selected 64 bit field. (As it turns out, for the
19844 example above, the compiler finds it is OK to allocate the
19845 "containing object" 64-bit field at bit-offset zero within the
19848 Here we attempt to work backwards from the limited set of facts
19849 we're given, and we try to deduce from those facts, where GCC
19850 must have believed that the containing object started (within
19851 the structure type). The value we deduce is then used (by the
19852 callers of this routine) to generate DW_AT_location and
19853 DW_AT_bit_offset attributes for fields (both bit-fields and, in
19854 the case of DW_AT_location, regular fields as well). */
19856 /* Figure out the bit-distance from the start of the structure to
19857 the "deepest" bit of the bit-field. */
19858 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
19860 /* This is the tricky part. Use some fancy footwork to deduce
19861 where the lowest addressed bit of the containing object must
19863 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
19865 /* Round up to type_align by default. This works best for
19867 object_offset_in_bits
19868 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
19870 if (wi::gtu_p (object_offset_in_bits
, bitpos_int
))
19872 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
19874 /* Round up to decl_align instead. */
19875 object_offset_in_bits
19876 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
19879 object_offset_in_bytes
19880 = wi::lrshift (object_offset_in_bits
, LOG2_BITS_PER_UNIT
);
19881 if (ctx
->variant_part_offset
== NULL_TREE
)
19883 *cst_offset
= object_offset_in_bytes
.to_shwi ();
19886 tree_result
= wide_int_to_tree (sizetype
, object_offset_in_bytes
);
19889 tree_result
= byte_position (decl
);
19891 if (ctx
->variant_part_offset
!= NULL_TREE
)
19892 tree_result
= fold_build2 (PLUS_EXPR
, TREE_TYPE (tree_result
),
19893 ctx
->variant_part_offset
, tree_result
);
19895 /* If the byte offset is a constant, it's simplier to handle a native
19896 constant rather than a DWARF expression. */
19897 if (TREE_CODE (tree_result
) == INTEGER_CST
)
19899 *cst_offset
= wi::to_offset (tree_result
).to_shwi ();
19903 struct loc_descr_context loc_ctx
= {
19904 ctx
->struct_type
, /* context_type */
19905 NULL_TREE
, /* base_decl */
19907 false, /* placeholder_arg */
19908 false, /* placeholder_seen */
19909 false /* strict_signedness */
19911 loc_result
= loc_list_from_tree (tree_result
, 0, &loc_ctx
);
19913 /* We want a DWARF expression: abort if we only have a location list with
19914 multiple elements. */
19915 if (!loc_result
|| !single_element_loc_list_p (loc_result
))
19918 return loc_result
->expr
;
19921 /* The following routines define various Dwarf attributes and any data
19922 associated with them. */
19924 /* Add a location description attribute value to a DIE.
19926 This emits location attributes suitable for whole variables and
19927 whole parameters. Note that the location attributes for struct fields are
19928 generated by the routine `data_member_location_attribute' below. */
19931 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
19932 dw_loc_list_ref descr
)
19934 bool check_no_locviews
= true;
19937 if (single_element_loc_list_p (descr
))
19938 add_AT_loc (die
, attr_kind
, descr
->expr
);
19941 add_AT_loc_list (die
, attr_kind
, descr
);
19942 gcc_assert (descr
->ll_symbol
);
19943 if (attr_kind
== DW_AT_location
&& descr
->vl_symbol
19944 && dwarf2out_locviews_in_attribute ())
19946 add_AT_view_list (die
, DW_AT_GNU_locviews
);
19947 check_no_locviews
= false;
19951 if (check_no_locviews
)
19952 gcc_assert (!get_AT (die
, DW_AT_GNU_locviews
));
19955 /* Add DW_AT_accessibility attribute to DIE if needed. */
19958 add_accessibility_attribute (dw_die_ref die
, tree decl
)
19960 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19961 children, otherwise the default is DW_ACCESS_public. In DWARF2
19962 the default has always been DW_ACCESS_public. */
19963 if (TREE_PROTECTED (decl
))
19964 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
19965 else if (TREE_PRIVATE (decl
))
19967 if (dwarf_version
== 2
19968 || die
->die_parent
== NULL
19969 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
19970 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
19972 else if (dwarf_version
> 2
19974 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
19975 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
19978 /* Attach the specialized form of location attribute used for data members of
19979 struct and union types. In the special case of a FIELD_DECL node which
19980 represents a bit-field, the "offset" part of this special location
19981 descriptor must indicate the distance in bytes from the lowest-addressed
19982 byte of the containing struct or union type to the lowest-addressed byte of
19983 the "containing object" for the bit-field. (See the `field_byte_offset'
19986 For any given bit-field, the "containing object" is a hypothetical object
19987 (of some integral or enum type) within which the given bit-field lives. The
19988 type of this hypothetical "containing object" is always the same as the
19989 declared type of the individual bit-field itself (for GCC anyway... the
19990 DWARF spec doesn't actually mandate this). Note that it is the size (in
19991 bytes) of the hypothetical "containing object" which will be given in the
19992 DW_AT_byte_size attribute for this bit-field. (See the
19993 `byte_size_attribute' function below.) It is also used when calculating the
19994 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
19997 CTX is required: see the comment for VLR_CONTEXT. */
20000 add_data_member_location_attribute (dw_die_ref die
,
20002 struct vlr_context
*ctx
)
20004 HOST_WIDE_INT offset
;
20005 dw_loc_descr_ref loc_descr
= 0;
20007 if (TREE_CODE (decl
) == TREE_BINFO
)
20009 /* We're working on the TAG_inheritance for a base class. */
20010 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
20012 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
20013 aren't at a fixed offset from all (sub)objects of the same
20014 type. We need to extract the appropriate offset from our
20015 vtable. The following dwarf expression means
20017 BaseAddr = ObAddr + *((*ObAddr) - Offset)
20019 This is specific to the V3 ABI, of course. */
20021 dw_loc_descr_ref tmp
;
20023 /* Make a copy of the object address. */
20024 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
20025 add_loc_descr (&loc_descr
, tmp
);
20027 /* Extract the vtable address. */
20028 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
20029 add_loc_descr (&loc_descr
, tmp
);
20031 /* Calculate the address of the offset. */
20032 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
20033 gcc_assert (offset
< 0);
20035 tmp
= int_loc_descriptor (-offset
);
20036 add_loc_descr (&loc_descr
, tmp
);
20037 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
20038 add_loc_descr (&loc_descr
, tmp
);
20040 /* Extract the offset. */
20041 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
20042 add_loc_descr (&loc_descr
, tmp
);
20044 /* Add it to the object address. */
20045 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
20046 add_loc_descr (&loc_descr
, tmp
);
20049 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
20053 loc_descr
= field_byte_offset (decl
, ctx
, &offset
);
20058 /* If loc_descr is available, then we know the offset is dynamic. */
20059 else if (gnat_encodings
== DWARF_GNAT_ENCODINGS_ALL
)
20065 /* Data member location evaluation starts with the base address on the
20066 stack. Compute the field offset and add it to this base address. */
20068 add_loc_descr (&loc_descr
, new_loc_descr (DW_OP_plus
, 0, 0));
20073 /* While DW_AT_data_bit_offset has been added already in DWARF4,
20074 e.g. GDB only added support to it in November 2016. For DWARF5
20075 we need newer debug info consumers anyway. We might change this
20076 to dwarf_version >= 4 once most consumers catched up. */
20077 if (dwarf_version
>= 5
20078 && TREE_CODE (decl
) == FIELD_DECL
20079 && DECL_BIT_FIELD_TYPE (decl
)
20080 && (ctx
->variant_part_offset
== NULL_TREE
20081 || TREE_CODE (ctx
->variant_part_offset
) == INTEGER_CST
))
20083 tree off
= bit_position (decl
);
20084 if (ctx
->variant_part_offset
)
20085 off
= bit_from_pos (ctx
->variant_part_offset
, off
);
20086 if (tree_fits_uhwi_p (off
) && get_AT (die
, DW_AT_bit_size
))
20088 remove_AT (die
, DW_AT_byte_size
);
20089 remove_AT (die
, DW_AT_bit_offset
);
20090 add_AT_unsigned (die
, DW_AT_data_bit_offset
, tree_to_uhwi (off
));
20094 if (dwarf_version
> 2)
20096 /* Don't need to output a location expression, just the constant. */
20098 add_AT_int (die
, DW_AT_data_member_location
, offset
);
20100 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
20105 enum dwarf_location_atom op
;
20107 /* The DWARF2 standard says that we should assume that the structure
20108 address is already on the stack, so we can specify a structure
20109 field address by using DW_OP_plus_uconst. */
20110 op
= DW_OP_plus_uconst
;
20111 loc_descr
= new_loc_descr (op
, offset
, 0);
20115 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
20118 /* Writes integer values to dw_vec_const array. */
20121 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
20125 *dest
++ = val
& 0xff;
20131 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
20133 static HOST_WIDE_INT
20134 extract_int (const unsigned char *src
, unsigned int size
)
20136 HOST_WIDE_INT val
= 0;
20142 val
|= *--src
& 0xff;
20148 /* Writes wide_int values to dw_vec_const array. */
20151 insert_wide_int (const wide_int
&val
, unsigned char *dest
, int elt_size
)
20155 if (elt_size
<= HOST_BITS_PER_WIDE_INT
/BITS_PER_UNIT
)
20157 insert_int ((HOST_WIDE_INT
) val
.elt (0), elt_size
, dest
);
20161 /* We'd have to extend this code to support odd sizes. */
20162 gcc_assert (elt_size
% (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
) == 0);
20164 int n
= elt_size
/ (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
20166 if (WORDS_BIG_ENDIAN
)
20167 for (i
= n
- 1; i
>= 0; i
--)
20169 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
20170 dest
+= sizeof (HOST_WIDE_INT
);
20173 for (i
= 0; i
< n
; i
++)
20175 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
20176 dest
+= sizeof (HOST_WIDE_INT
);
20180 /* Writes floating point values to dw_vec_const array. */
20183 insert_float (const_rtx rtl
, unsigned char *array
)
20187 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
20189 real_to_target (val
, CONST_DOUBLE_REAL_VALUE (rtl
), mode
);
20191 /* real_to_target puts 32-bit pieces in each long. Pack them. */
20192 if (GET_MODE_SIZE (mode
) < 4)
20194 gcc_assert (GET_MODE_SIZE (mode
) == 2);
20195 insert_int (val
[0], 2, array
);
20199 for (i
= 0; i
< GET_MODE_SIZE (mode
) / 4; i
++)
20201 insert_int (val
[i
], 4, array
);
20207 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
20208 does not have a "location" either in memory or in a register. These
20209 things can arise in GNU C when a constant is passed as an actual parameter
20210 to an inlined function. They can also arise in C++ where declared
20211 constants do not necessarily get memory "homes". */
20214 add_const_value_attribute (dw_die_ref die
, machine_mode mode
, rtx rtl
)
20216 scalar_mode int_mode
;
20218 switch (GET_CODE (rtl
))
20222 HOST_WIDE_INT val
= INTVAL (rtl
);
20225 add_AT_int (die
, DW_AT_const_value
, val
);
20227 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
20231 case CONST_WIDE_INT
:
20232 if (is_int_mode (mode
, &int_mode
)
20233 && (GET_MODE_PRECISION (int_mode
)
20234 & (HOST_BITS_PER_WIDE_INT
- 1)) == 0)
20236 wide_int w
= rtx_mode_t (rtl
, int_mode
);
20237 add_AT_wide (die
, DW_AT_const_value
, w
);
20243 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
20244 floating-point constant. A CONST_DOUBLE is used whenever the
20245 constant requires more than one word in order to be adequately
20247 if (TARGET_SUPPORTS_WIDE_INT
== 0
20248 && !SCALAR_FLOAT_MODE_P (GET_MODE (rtl
)))
20249 add_AT_double (die
, DW_AT_const_value
,
20250 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
20253 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
20254 unsigned int length
= GET_MODE_SIZE (mode
);
20255 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
20256 unsigned int elt_size
= insert_float (rtl
, array
);
20258 add_AT_vec (die
, DW_AT_const_value
, length
/ elt_size
, elt_size
,
20265 unsigned int length
;
20266 if (!CONST_VECTOR_NUNITS (rtl
).is_constant (&length
))
20269 machine_mode mode
= GET_MODE (rtl
);
20270 /* The combination of a length and byte elt_size doesn't extend
20271 naturally to boolean vectors, where several elements are packed
20272 into the same byte. */
20273 if (GET_MODE_CLASS (mode
) == MODE_VECTOR_BOOL
)
20276 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
20277 unsigned char *array
20278 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
20281 machine_mode imode
= GET_MODE_INNER (mode
);
20283 switch (GET_MODE_CLASS (mode
))
20285 case MODE_VECTOR_INT
:
20286 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
20288 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
20289 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
20293 case MODE_VECTOR_FLOAT
:
20294 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
20296 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
20297 insert_float (elt
, p
);
20302 gcc_unreachable ();
20305 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
20310 if (dwarf_version
>= 4 || !dwarf_strict
)
20312 dw_loc_descr_ref loc_result
;
20313 resolve_one_addr (&rtl
);
20315 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
20316 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
20317 add_AT_loc (die
, DW_AT_location
, loc_result
);
20318 vec_safe_push (used_rtx_array
, rtl
);
20324 if (CONSTANT_P (XEXP (rtl
, 0)))
20325 return add_const_value_attribute (die
, mode
, XEXP (rtl
, 0));
20328 if (!const_ok_for_output (rtl
))
20332 if (dwarf_version
>= 4 || !dwarf_strict
)
20337 /* In cases where an inlined instance of an inline function is passed
20338 the address of an `auto' variable (which is local to the caller) we
20339 can get a situation where the DECL_RTL of the artificial local
20340 variable (for the inlining) which acts as a stand-in for the
20341 corresponding formal parameter (of the inline function) will look
20342 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
20343 exactly a compile-time constant expression, but it isn't the address
20344 of the (artificial) local variable either. Rather, it represents the
20345 *value* which the artificial local variable always has during its
20346 lifetime. We currently have no way to represent such quasi-constant
20347 values in Dwarf, so for now we just punt and generate nothing. */
20355 case CONST_POLY_INT
:
20359 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
20360 && MEM_READONLY_P (rtl
)
20361 && GET_MODE (rtl
) == BLKmode
)
20363 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
20369 /* No other kinds of rtx should be possible here. */
20370 gcc_unreachable ();
20374 /* Determine whether the evaluation of EXPR references any variables
20375 or functions which aren't otherwise used (and therefore may not be
20378 reference_to_unused (tree
* tp
, int * walk_subtrees
,
20379 void * data ATTRIBUTE_UNUSED
)
20381 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
20382 *walk_subtrees
= 0;
20384 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
20385 && ! TREE_ASM_WRITTEN (*tp
))
20387 /* ??? The C++ FE emits debug information for using decls, so
20388 putting gcc_unreachable here falls over. See PR31899. For now
20389 be conservative. */
20390 else if (!symtab
->global_info_ready
&& VAR_P (*tp
))
20392 else if (VAR_P (*tp
))
20394 varpool_node
*node
= varpool_node::get (*tp
);
20395 if (!node
|| !node
->definition
)
20398 else if (TREE_CODE (*tp
) == FUNCTION_DECL
20399 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
20401 /* The call graph machinery must have finished analyzing,
20402 optimizing and gimplifying the CU by now.
20403 So if *TP has no call graph node associated
20404 to it, it means *TP will not be emitted. */
20405 if (!symtab
->global_info_ready
|| !cgraph_node::get (*tp
))
20408 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
20414 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
20415 for use in a later add_const_value_attribute call. */
20418 rtl_for_decl_init (tree init
, tree type
)
20420 rtx rtl
= NULL_RTX
;
20424 /* If a variable is initialized with a string constant without embedded
20425 zeros, build CONST_STRING. */
20426 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
20428 tree enttype
= TREE_TYPE (type
);
20429 tree domain
= TYPE_DOMAIN (type
);
20430 scalar_int_mode mode
;
20432 if (is_int_mode (TYPE_MODE (enttype
), &mode
)
20433 && GET_MODE_SIZE (mode
) == 1
20435 && TYPE_MAX_VALUE (domain
)
20436 && TREE_CODE (TYPE_MAX_VALUE (domain
)) == INTEGER_CST
20437 && integer_zerop (TYPE_MIN_VALUE (domain
))
20438 && compare_tree_int (TYPE_MAX_VALUE (domain
),
20439 TREE_STRING_LENGTH (init
) - 1) == 0
20440 && ((size_t) TREE_STRING_LENGTH (init
)
20441 == strlen (TREE_STRING_POINTER (init
)) + 1))
20443 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
20444 ggc_strdup (TREE_STRING_POINTER (init
)));
20445 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
20446 MEM_READONLY_P (rtl
) = 1;
20449 /* Other aggregates, and complex values, could be represented using
20451 If this changes, please adjust tree_add_const_value_attribute
20452 so that for early_dwarf it will for such initializers mangle referenced
20454 else if (AGGREGATE_TYPE_P (type
)
20455 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
20456 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
20457 || TREE_CODE (type
) == COMPLEX_TYPE
)
20459 /* Vectors only work if their mode is supported by the target.
20460 FIXME: generic vectors ought to work too. */
20461 else if (TREE_CODE (type
) == VECTOR_TYPE
20462 && !VECTOR_MODE_P (TYPE_MODE (type
)))
20464 /* If the initializer is something that we know will expand into an
20465 immediate RTL constant, expand it now. We must be careful not to
20466 reference variables which won't be output. */
20467 else if (initializer_constant_valid_p (init
, type
)
20468 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
20470 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
20472 if (TREE_CODE (type
) == VECTOR_TYPE
)
20473 switch (TREE_CODE (init
))
20478 if (TREE_CONSTANT (init
))
20480 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
20481 bool constant_p
= true;
20483 unsigned HOST_WIDE_INT ix
;
20485 /* Even when ctor is constant, it might contain non-*_CST
20486 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
20487 belong into VECTOR_CST nodes. */
20488 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
20489 if (!CONSTANT_CLASS_P (value
))
20491 constant_p
= false;
20497 init
= build_vector_from_ctor (type
, elts
);
20507 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
20509 /* If expand_expr returns a MEM, it wasn't immediate. */
20510 gcc_assert (!rtl
|| !MEM_P (rtl
));
20516 /* Generate RTL for the variable DECL to represent its location. */
20519 rtl_for_decl_location (tree decl
)
20523 /* Here we have to decide where we are going to say the parameter "lives"
20524 (as far as the debugger is concerned). We only have a couple of
20525 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
20527 DECL_RTL normally indicates where the parameter lives during most of the
20528 activation of the function. If optimization is enabled however, this
20529 could be either NULL or else a pseudo-reg. Both of those cases indicate
20530 that the parameter doesn't really live anywhere (as far as the code
20531 generation parts of GCC are concerned) during most of the function's
20532 activation. That will happen (for example) if the parameter is never
20533 referenced within the function.
20535 We could just generate a location descriptor here for all non-NULL
20536 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
20537 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
20538 where DECL_RTL is NULL or is a pseudo-reg.
20540 Note however that we can only get away with using DECL_INCOMING_RTL as
20541 a backup substitute for DECL_RTL in certain limited cases. In cases
20542 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
20543 we can be sure that the parameter was passed using the same type as it is
20544 declared to have within the function, and that its DECL_INCOMING_RTL
20545 points us to a place where a value of that type is passed.
20547 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
20548 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
20549 because in these cases DECL_INCOMING_RTL points us to a value of some
20550 type which is *different* from the type of the parameter itself. Thus,
20551 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
20552 such cases, the debugger would end up (for example) trying to fetch a
20553 `float' from a place which actually contains the first part of a
20554 `double'. That would lead to really incorrect and confusing
20555 output at debug-time.
20557 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
20558 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
20559 are a couple of exceptions however. On little-endian machines we can
20560 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
20561 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
20562 an integral type that is smaller than TREE_TYPE (decl). These cases arise
20563 when (on a little-endian machine) a non-prototyped function has a
20564 parameter declared to be of type `short' or `char'. In such cases,
20565 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
20566 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
20567 passed `int' value. If the debugger then uses that address to fetch
20568 a `short' or a `char' (on a little-endian machine) the result will be
20569 the correct data, so we allow for such exceptional cases below.
20571 Note that our goal here is to describe the place where the given formal
20572 parameter lives during most of the function's activation (i.e. between the
20573 end of the prologue and the start of the epilogue). We'll do that as best
20574 as we can. Note however that if the given formal parameter is modified
20575 sometime during the execution of the function, then a stack backtrace (at
20576 debug-time) will show the function as having been called with the *new*
20577 value rather than the value which was originally passed in. This happens
20578 rarely enough that it is not a major problem, but it *is* a problem, and
20579 I'd like to fix it.
20581 A future version of dwarf2out.cc may generate two additional attributes for
20582 any given DW_TAG_formal_parameter DIE which will describe the "passed
20583 type" and the "passed location" for the given formal parameter in addition
20584 to the attributes we now generate to indicate the "declared type" and the
20585 "active location" for each parameter. This additional set of attributes
20586 could be used by debuggers for stack backtraces. Separately, note that
20587 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
20588 This happens (for example) for inlined-instances of inline function formal
20589 parameters which are never referenced. This really shouldn't be
20590 happening. All PARM_DECL nodes should get valid non-NULL
20591 DECL_INCOMING_RTL values. FIXME. */
20593 /* Use DECL_RTL as the "location" unless we find something better. */
20594 rtl
= DECL_RTL_IF_SET (decl
);
20596 /* When generating abstract instances, ignore everything except
20597 constants, symbols living in memory, and symbols living in
20598 fixed registers. */
20599 if (! reload_completed
)
20602 && (CONSTANT_P (rtl
)
20604 && CONSTANT_P (XEXP (rtl
, 0)))
20607 && TREE_STATIC (decl
))))
20609 rtl
= targetm
.delegitimize_address (rtl
);
20614 else if (TREE_CODE (decl
) == PARM_DECL
)
20616 if (rtl
== NULL_RTX
20617 || is_pseudo_reg (rtl
)
20619 && is_pseudo_reg (XEXP (rtl
, 0))
20620 && DECL_INCOMING_RTL (decl
)
20621 && MEM_P (DECL_INCOMING_RTL (decl
))
20622 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
20624 tree declared_type
= TREE_TYPE (decl
);
20625 tree passed_type
= DECL_ARG_TYPE (decl
);
20626 machine_mode dmode
= TYPE_MODE (declared_type
);
20627 machine_mode pmode
= TYPE_MODE (passed_type
);
20629 /* This decl represents a formal parameter which was optimized out.
20630 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
20631 all cases where (rtl == NULL_RTX) just below. */
20632 if (dmode
== pmode
)
20633 rtl
= DECL_INCOMING_RTL (decl
);
20634 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
20635 && SCALAR_INT_MODE_P (dmode
)
20636 && known_le (GET_MODE_SIZE (dmode
), GET_MODE_SIZE (pmode
))
20637 && DECL_INCOMING_RTL (decl
))
20639 rtx inc
= DECL_INCOMING_RTL (decl
);
20642 else if (MEM_P (inc
))
20644 if (BYTES_BIG_ENDIAN
)
20645 rtl
= adjust_address_nv (inc
, dmode
,
20646 GET_MODE_SIZE (pmode
)
20647 - GET_MODE_SIZE (dmode
));
20654 /* If the parm was passed in registers, but lives on the stack, then
20655 make a big endian correction if the mode of the type of the
20656 parameter is not the same as the mode of the rtl. */
20657 /* ??? This is the same series of checks that are made in dbxout.cc before
20658 we reach the big endian correction code there. It isn't clear if all
20659 of these checks are necessary here, but keeping them all is the safe
20661 else if (MEM_P (rtl
)
20662 && XEXP (rtl
, 0) != const0_rtx
20663 && ! CONSTANT_P (XEXP (rtl
, 0))
20664 /* Not passed in memory. */
20665 && !MEM_P (DECL_INCOMING_RTL (decl
))
20666 /* Not passed by invisible reference. */
20667 && (!REG_P (XEXP (rtl
, 0))
20668 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
20669 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
20670 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
20671 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
20674 /* Big endian correction check. */
20675 && BYTES_BIG_ENDIAN
20676 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
20677 && known_lt (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))),
20680 machine_mode addr_mode
= get_address_mode (rtl
);
20681 poly_int64 offset
= (UNITS_PER_WORD
20682 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
20684 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
20685 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
20688 else if (VAR_P (decl
)
20691 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
)))
20693 machine_mode addr_mode
= get_address_mode (rtl
);
20694 poly_int64 offset
= byte_lowpart_offset (TYPE_MODE (TREE_TYPE (decl
)),
20697 /* If a variable is declared "register" yet is smaller than
20698 a register, then if we store the variable to memory, it
20699 looks like we're storing a register-sized value, when in
20700 fact we are not. We need to adjust the offset of the
20701 storage location to reflect the actual value's bytes,
20702 else gdb will not be able to display it. */
20703 if (maybe_ne (offset
, 0))
20704 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
20705 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
20708 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
20709 and will have been substituted directly into all expressions that use it.
20710 C does not have such a concept, but C++ and other languages do. */
20711 if (!rtl
&& VAR_P (decl
) && DECL_INITIAL (decl
))
20712 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
20715 rtl
= targetm
.delegitimize_address (rtl
);
20717 /* If we don't look past the constant pool, we risk emitting a
20718 reference to a constant pool entry that isn't referenced from
20719 code, and thus is not emitted. */
20721 rtl
= avoid_constant_pool_reference (rtl
);
20723 /* Try harder to get a rtl. If this symbol ends up not being emitted
20724 in the current CU, resolve_addr will remove the expression referencing
20726 if (rtl
== NULL_RTX
20727 && !(early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
20729 && !DECL_EXTERNAL (decl
)
20730 && TREE_STATIC (decl
)
20731 && DECL_NAME (decl
)
20732 && !DECL_HARD_REGISTER (decl
)
20733 && DECL_MODE (decl
) != VOIDmode
)
20735 rtl
= make_decl_rtl_for_debug (decl
);
20737 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
20738 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
20745 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
20746 returned. If so, the decl for the COMMON block is returned, and the
20747 value is the offset into the common block for the symbol. */
20750 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
20752 tree val_expr
, cvar
;
20754 poly_int64 bitsize
, bitpos
;
20756 HOST_WIDE_INT cbitpos
;
20757 int unsignedp
, reversep
, volatilep
= 0;
20759 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
20760 it does not have a value (the offset into the common area), or if it
20761 is thread local (as opposed to global) then it isn't common, and shouldn't
20762 be handled as such. */
20764 || !TREE_STATIC (decl
)
20765 || !DECL_HAS_VALUE_EXPR_P (decl
)
20769 val_expr
= DECL_VALUE_EXPR (decl
);
20770 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
20773 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
, &mode
,
20774 &unsignedp
, &reversep
, &volatilep
);
20776 if (cvar
== NULL_TREE
20778 || DECL_ARTIFICIAL (cvar
)
20779 || !TREE_PUBLIC (cvar
)
20780 /* We don't expect to have to cope with variable offsets,
20781 since at present all static data must have a constant size. */
20782 || !bitpos
.is_constant (&cbitpos
))
20786 if (offset
!= NULL
)
20788 if (!tree_fits_shwi_p (offset
))
20790 *value
= tree_to_shwi (offset
);
20793 *value
+= cbitpos
/ BITS_PER_UNIT
;
20798 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
20799 data attribute for a variable or a parameter. We generate the
20800 DW_AT_const_value attribute only in those cases where the given variable
20801 or parameter does not have a true "location" either in memory or in a
20802 register. This can happen (for example) when a constant is passed as an
20803 actual argument in a call to an inline function. (It's possible that
20804 these things can crop up in other ways also.) Note that one type of
20805 constant value which can be passed into an inlined function is a constant
20806 pointer. This can happen for example if an actual argument in an inlined
20807 function call evaluates to a compile-time constant address.
20809 CACHE_P is true if it is worth caching the location list for DECL,
20810 so that future calls can reuse it rather than regenerate it from scratch.
20811 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
20812 since we will need to refer to them each time the function is inlined. */
20815 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
)
20818 dw_loc_list_ref list
;
20819 var_loc_list
*loc_list
;
20820 cached_dw_loc_list
*cache
;
20825 if (TREE_CODE (decl
) == ERROR_MARK
)
20828 if (get_AT (die
, DW_AT_location
)
20829 || get_AT (die
, DW_AT_const_value
))
20832 gcc_assert (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
20833 || TREE_CODE (decl
) == RESULT_DECL
);
20835 /* Try to get some constant RTL for this decl, and use that as the value of
20838 rtl
= rtl_for_decl_location (decl
);
20839 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
20840 && add_const_value_attribute (die
, DECL_MODE (decl
), rtl
))
20843 /* See if we have single element location list that is equivalent to
20844 a constant value. That way we are better to use add_const_value_attribute
20845 rather than expanding constant value equivalent. */
20846 loc_list
= lookup_decl_loc (decl
);
20849 && loc_list
->first
->next
== NULL
20850 && NOTE_P (loc_list
->first
->loc
)
20851 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
20852 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
20854 struct var_loc_node
*node
;
20856 node
= loc_list
->first
;
20857 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
20858 if (GET_CODE (rtl
) == EXPR_LIST
)
20859 rtl
= XEXP (rtl
, 0);
20860 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
20861 && add_const_value_attribute (die
, DECL_MODE (decl
), rtl
))
20864 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
20865 list several times. See if we've already cached the contents. */
20867 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
20871 cache
= cached_dw_loc_list_table
->find_with_hash (decl
, DECL_UID (decl
));
20873 list
= cache
->loc_list
;
20877 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2,
20879 /* It is usually worth caching this result if the decl is from
20880 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
20881 if (cache_p
&& list
&& list
->dw_loc_next
)
20883 cached_dw_loc_list
**slot
20884 = cached_dw_loc_list_table
->find_slot_with_hash (decl
,
20887 cache
= ggc_cleared_alloc
<cached_dw_loc_list
> ();
20888 cache
->decl_id
= DECL_UID (decl
);
20889 cache
->loc_list
= list
;
20895 add_AT_location_description (die
, DW_AT_location
, list
);
20898 /* None of that worked, so it must not really have a location;
20899 try adding a constant value attribute from the DECL_INITIAL. */
20900 return tree_add_const_value_attribute_for_decl (die
, decl
);
20903 /* Mangle referenced decls. */
20905 mangle_referenced_decls (tree
*tp
, int *walk_subtrees
, void *)
20907 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
20908 *walk_subtrees
= 0;
20910 if (VAR_OR_FUNCTION_DECL_P (*tp
))
20911 assign_assembler_name_if_needed (*tp
);
20916 /* Attach a DW_AT_const_value attribute to DIE. The value of the
20917 attribute is the const value T. */
20920 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
20923 tree type
= TREE_TYPE (t
);
20925 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
20929 gcc_assert (!DECL_P (init
));
20931 if (TREE_CODE (init
) == INTEGER_CST
)
20933 if (tree_fits_uhwi_p (init
))
20935 add_AT_unsigned (die
, DW_AT_const_value
, tree_to_uhwi (init
));
20938 if (tree_fits_shwi_p (init
))
20940 add_AT_int (die
, DW_AT_const_value
, tree_to_shwi (init
));
20946 rtx rtl
= rtl_for_decl_init (init
, type
);
20948 return add_const_value_attribute (die
, TYPE_MODE (type
), rtl
);
20952 /* For early_dwarf force mangling of all referenced symbols. */
20953 tree initializer
= init
;
20954 STRIP_NOPS (initializer
);
20955 /* rtl_for_decl_init punts on other aggregates, and complex values. */
20956 if (AGGREGATE_TYPE_P (type
)
20957 || (TREE_CODE (initializer
) == VIEW_CONVERT_EXPR
20958 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (initializer
, 0))))
20959 || TREE_CODE (type
) == COMPLEX_TYPE
)
20961 else if (initializer_constant_valid_p (initializer
, type
))
20962 walk_tree (&initializer
, mangle_referenced_decls
, NULL
, NULL
);
20964 /* If the host and target are sane, try harder. */
20965 if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
20966 && initializer_constant_valid_p (init
, type
))
20968 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
20969 if (size
> 0 && (int) size
== size
)
20971 unsigned char *array
= ggc_cleared_vec_alloc
<unsigned char> (size
);
20973 if (native_encode_initializer (init
, array
, size
) == size
)
20975 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
20984 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
20985 attribute is the const value of T, where T is an integral constant
20986 variable with static storage duration
20987 (so it can't be a PARM_DECL or a RESULT_DECL). */
20990 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
20994 || (!VAR_P (decl
) && TREE_CODE (decl
) != CONST_DECL
)
20995 || (VAR_P (decl
) && !TREE_STATIC (decl
)))
20998 if (TREE_READONLY (decl
)
20999 && ! TREE_THIS_VOLATILE (decl
)
21000 && DECL_INITIAL (decl
))
21005 /* Don't add DW_AT_const_value if abstract origin already has one. */
21006 if (get_AT (var_die
, DW_AT_const_value
))
21009 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
21012 /* Convert the CFI instructions for the current function into a
21013 location list. This is used for DW_AT_frame_base when we targeting
21014 a dwarf2 consumer that does not support the dwarf3
21015 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
21018 static dw_loc_list_ref
21019 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
21023 dw_loc_list_ref list
, *list_tail
;
21025 dw_cfa_location last_cfa
, next_cfa
;
21026 const char *start_label
, *last_label
, *section
;
21027 dw_cfa_location remember
;
21030 gcc_assert (fde
!= NULL
);
21032 section
= secname_for_decl (current_function_decl
);
21036 memset (&next_cfa
, 0, sizeof (next_cfa
));
21037 next_cfa
.reg
.set_by_dwreg (INVALID_REGNUM
);
21038 remember
= next_cfa
;
21040 start_label
= fde
->dw_fde_begin
;
21042 /* ??? Bald assumption that the CIE opcode list does not contain
21043 advance opcodes. */
21044 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
21045 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
21047 last_cfa
= next_cfa
;
21048 last_label
= start_label
;
21050 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
21052 /* If the first partition contained no CFI adjustments, the
21053 CIE opcodes apply to the whole first partition. */
21054 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
21055 fde
->dw_fde_begin
, 0, fde
->dw_fde_end
, 0, section
);
21056 list_tail
=&(*list_tail
)->dw_loc_next
;
21057 start_label
= last_label
= fde
->dw_fde_second_begin
;
21060 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
21062 switch (cfi
->dw_cfi_opc
)
21064 case DW_CFA_set_loc
:
21065 case DW_CFA_advance_loc1
:
21066 case DW_CFA_advance_loc2
:
21067 case DW_CFA_advance_loc4
:
21068 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
21070 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
21071 start_label
, 0, last_label
, 0, section
);
21073 list_tail
= &(*list_tail
)->dw_loc_next
;
21074 last_cfa
= next_cfa
;
21075 start_label
= last_label
;
21077 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
21080 case DW_CFA_advance_loc
:
21081 /* The encoding is complex enough that we should never emit this. */
21082 gcc_unreachable ();
21085 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
21088 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
21090 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
21092 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
21093 start_label
, 0, last_label
, 0, section
);
21095 list_tail
= &(*list_tail
)->dw_loc_next
;
21096 last_cfa
= next_cfa
;
21097 start_label
= last_label
;
21099 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
21100 start_label
, 0, fde
->dw_fde_end
, 0, section
);
21101 list_tail
= &(*list_tail
)->dw_loc_next
;
21102 start_label
= last_label
= fde
->dw_fde_second_begin
;
21106 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
21108 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
21109 start_label
, 0, last_label
, 0, section
);
21110 list_tail
= &(*list_tail
)->dw_loc_next
;
21111 start_label
= last_label
;
21114 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
21116 fde
->dw_fde_second_begin
21117 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
, 0,
21120 maybe_gen_llsym (list
);
21125 /* Compute a displacement from the "steady-state frame pointer" to the
21126 frame base (often the same as the CFA), and store it in
21127 frame_pointer_fb_offset. OFFSET is added to the displacement
21128 before the latter is negated. */
21131 compute_frame_pointer_to_fb_displacement (poly_int64 offset
)
21135 #ifdef FRAME_POINTER_CFA_OFFSET
21136 reg
= frame_pointer_rtx
;
21137 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
21139 reg
= arg_pointer_rtx
;
21140 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
21143 elim
= (ira_use_lra_p
21144 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
21145 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
21146 elim
= strip_offset_and_add (elim
, &offset
);
21148 frame_pointer_fb_offset
= -offset
;
21150 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
21151 in which to eliminate. This is because it's stack pointer isn't
21152 directly accessible as a register within the ISA. To work around
21153 this, assume that while we cannot provide a proper value for
21154 frame_pointer_fb_offset, we won't need one either. We can use
21155 hard frame pointer in debug info even if frame pointer isn't used
21156 since hard frame pointer in debug info is encoded with DW_OP_fbreg
21157 which uses the DW_AT_frame_base attribute, not hard frame pointer
21159 frame_pointer_fb_offset_valid
21160 = (elim
== hard_frame_pointer_rtx
|| elim
== stack_pointer_rtx
);
21163 /* Generate a DW_AT_name attribute given some string value to be included as
21164 the value of the attribute. */
21167 add_name_attribute (dw_die_ref die
, const char *name_string
)
21169 if (name_string
!= NULL
&& *name_string
!= 0)
21171 if (demangle_name_func
)
21172 name_string
= (*demangle_name_func
) (name_string
);
21174 add_AT_string (die
, DW_AT_name
, name_string
);
21178 /* Generate a DW_AT_name attribute given some string value representing a
21179 file or filepath to be included as value of the attribute. */
21181 add_filename_attribute (dw_die_ref die
, const char *name_string
)
21183 if (name_string
!= NULL
&& *name_string
!= 0)
21184 add_filepath_AT_string (die
, DW_AT_name
, name_string
);
21187 /* Generate a DW_AT_description attribute given some string value to be included
21188 as the value of the attribute. */
21191 add_desc_attribute (dw_die_ref die
, const char *name_string
)
21193 if (!flag_describe_dies
|| (dwarf_version
< 3 && dwarf_strict
))
21196 if (name_string
== NULL
|| *name_string
== 0)
21199 if (demangle_name_func
)
21200 name_string
= (*demangle_name_func
) (name_string
);
21202 add_AT_string (die
, DW_AT_description
, name_string
);
21205 /* Generate a DW_AT_description attribute given some decl to be included
21206 as the value of the attribute. */
21209 add_desc_attribute (dw_die_ref die
, tree decl
)
21213 if (!flag_describe_dies
|| (dwarf_version
< 3 && dwarf_strict
))
21216 if (decl
== NULL_TREE
|| !DECL_P (decl
))
21218 decl_name
= DECL_NAME (decl
);
21220 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
21222 const char *name
= dwarf2_name (decl
, 0);
21223 add_desc_attribute (die
, name
? name
: IDENTIFIER_POINTER (decl_name
));
21227 char *desc
= print_generic_expr_to_str (decl
);
21228 add_desc_attribute (die
, desc
);
21233 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
21234 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
21235 of TYPE accordingly.
21237 ??? This is a temporary measure until after we're able to generate
21238 regular DWARF for the complex Ada type system. */
21241 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
21242 dw_die_ref context_die
)
21245 dw_die_ref dtype_die
;
21247 if (!lang_hooks
.types
.descriptive_type
)
21250 dtype
= lang_hooks
.types
.descriptive_type (type
);
21254 dtype_die
= lookup_type_die (dtype
);
21257 gen_type_die (dtype
, context_die
);
21258 dtype_die
= lookup_type_die (dtype
);
21259 gcc_assert (dtype_die
);
21262 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
21265 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
21267 static const char *
21268 comp_dir_string (void)
21271 char *wd_plus_sep
= NULL
;
21272 static const char *cached_wd
= NULL
;
21274 if (cached_wd
!= NULL
)
21277 wd
= get_src_pwd ();
21281 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
21283 size_t wdlen
= strlen (wd
);
21284 wd_plus_sep
= XNEWVEC (char, wdlen
+ 2);
21285 strcpy (wd_plus_sep
, wd
);
21286 wd_plus_sep
[wdlen
] = DIR_SEPARATOR
;
21287 wd_plus_sep
[wdlen
+ 1] = 0;
21291 cached_wd
= remap_debug_filename (wd
);
21293 /* remap_debug_filename can just pass through wd or return a new gc string.
21294 These two types can't be both stored in a GTY(())-tagged string, but since
21295 the cached value lives forever just copy it if needed. */
21296 if (cached_wd
!= wd
)
21298 cached_wd
= xstrdup (cached_wd
);
21299 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
&& wd_plus_sep
!= NULL
)
21300 free (wd_plus_sep
);
21306 /* Generate a DW_AT_comp_dir attribute for DIE. */
21309 add_comp_dir_attribute (dw_die_ref die
)
21311 const char * wd
= comp_dir_string ();
21313 add_filepath_AT_string (die
, DW_AT_comp_dir
, wd
);
21316 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
21317 pointer computation, ...), output a representation for that bound according
21318 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
21319 loc_list_from_tree for the meaning of CONTEXT. */
21322 add_scalar_info (dw_die_ref die
, enum dwarf_attribute attr
, tree value
,
21323 int forms
, struct loc_descr_context
*context
)
21325 dw_die_ref context_die
, decl_die
= NULL
;
21326 dw_loc_list_ref list
;
21327 bool strip_conversions
= true;
21328 bool placeholder_seen
= false;
21330 while (strip_conversions
)
21331 switch (TREE_CODE (value
))
21338 case VIEW_CONVERT_EXPR
:
21339 value
= TREE_OPERAND (value
, 0);
21343 strip_conversions
= false;
21347 /* If possible and permitted, output the attribute as a constant. */
21348 if ((forms
& dw_scalar_form_constant
) != 0
21349 && TREE_CODE (value
) == INTEGER_CST
)
21351 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (value
));
21353 /* If HOST_WIDE_INT is big enough then represent the bound as
21354 a constant value. We need to choose a form based on
21355 whether the type is signed or unsigned. We cannot just
21356 call add_AT_unsigned if the value itself is positive
21357 (add_AT_unsigned might add the unsigned value encoded as
21358 DW_FORM_data[1248]). Some DWARF consumers will lookup the
21359 bounds type and then sign extend any unsigned values found
21360 for signed types. This is needed only for
21361 DW_AT_{lower,upper}_bound, since for most other attributes,
21362 consumers will treat DW_FORM_data[1248] as unsigned values,
21363 regardless of the underlying type. */
21364 if (prec
<= HOST_BITS_PER_WIDE_INT
21365 || tree_fits_uhwi_p (value
))
21367 if (TYPE_UNSIGNED (TREE_TYPE (value
)))
21368 add_AT_unsigned (die
, attr
, TREE_INT_CST_LOW (value
));
21370 add_AT_int (die
, attr
, TREE_INT_CST_LOW (value
));
21372 else if (dwarf_version
>= 5
21373 && TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (value
))) == 128)
21374 /* Otherwise represent the bound as an unsigned value with
21375 the precision of its type. The precision and signedness
21376 of the type will be necessary to re-interpret it
21378 add_AT_wide (die
, attr
, wi::to_wide (value
));
21381 rtx v
= immed_wide_int_const (wi::to_wide (value
),
21382 TYPE_MODE (TREE_TYPE (value
)));
21383 dw_loc_descr_ref loc
21384 = loc_descriptor (v
, TYPE_MODE (TREE_TYPE (value
)),
21385 VAR_INIT_STATUS_INITIALIZED
);
21387 add_AT_loc (die
, attr
, loc
);
21392 /* Otherwise, if it's possible and permitted too, output a reference to
21394 if ((forms
& dw_scalar_form_reference
) != 0)
21396 tree decl
= NULL_TREE
;
21398 /* Some type attributes reference an outer type. For instance, the upper
21399 bound of an array may reference an embedding record (this happens in
21401 if (TREE_CODE (value
) == COMPONENT_REF
21402 && TREE_CODE (TREE_OPERAND (value
, 0)) == PLACEHOLDER_EXPR
21403 && TREE_CODE (TREE_OPERAND (value
, 1)) == FIELD_DECL
)
21404 decl
= TREE_OPERAND (value
, 1);
21406 else if (VAR_P (value
)
21407 || TREE_CODE (value
) == PARM_DECL
21408 || TREE_CODE (value
) == RESULT_DECL
)
21411 if (decl
!= NULL_TREE
)
21413 decl_die
= lookup_decl_die (decl
);
21415 /* ??? Can this happen, or should the variable have been bound
21416 first? Probably it can, since I imagine that we try to create
21417 the types of parameters in the order in which they exist in
21418 the list, and won't have created a forward reference to a
21419 later parameter. */
21420 if (decl_die
!= NULL
)
21422 if (get_AT (decl_die
, DW_AT_location
)
21423 || get_AT (decl_die
, DW_AT_data_member_location
)
21424 || get_AT (decl_die
, DW_AT_data_bit_offset
)
21425 || get_AT (decl_die
, DW_AT_const_value
))
21427 add_AT_die_ref (die
, attr
, decl_die
);
21434 /* Last chance: try to create a stack operation procedure to evaluate the
21435 value. Do nothing if even that is not possible or permitted. */
21436 if ((forms
& dw_scalar_form_exprloc
) == 0)
21439 list
= loc_list_from_tree (value
, 2, context
);
21440 if (context
&& context
->placeholder_arg
)
21442 placeholder_seen
= context
->placeholder_seen
;
21443 context
->placeholder_seen
= false;
21445 if (list
== NULL
|| single_element_loc_list_p (list
))
21447 /* If this attribute is not a reference nor constant, it is
21448 a DWARF expression rather than location description. For that
21449 loc_list_from_tree (value, 0, &context) is needed. */
21450 dw_loc_list_ref list2
= loc_list_from_tree (value
, 0, context
);
21451 if (list2
&& single_element_loc_list_p (list2
))
21453 if (placeholder_seen
)
21455 struct dwarf_procedure_info dpi
;
21456 dpi
.fndecl
= NULL_TREE
;
21457 dpi
.args_count
= 1;
21458 if (!resolve_args_picking (list2
->expr
, 1, &dpi
))
21461 add_AT_loc (die
, attr
, list2
->expr
);
21466 /* If that failed to give a single element location list, fall back to
21467 outputting this as a reference... still if permitted. */
21469 || (forms
& dw_scalar_form_reference
) == 0
21470 || placeholder_seen
)
21475 if (current_function_decl
== 0)
21476 context_die
= comp_unit_die ();
21478 context_die
= lookup_decl_die (current_function_decl
);
21480 decl_die
= new_die (DW_TAG_variable
, context_die
, value
);
21481 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
21482 add_type_attribute (decl_die
, TREE_TYPE (value
), TYPE_QUAL_CONST
, false,
21486 add_AT_location_description (decl_die
, DW_AT_location
, list
);
21487 add_AT_die_ref (die
, attr
, decl_die
);
21490 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
21494 lower_bound_default (void)
21496 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
21502 case DW_LANG_C_plus_plus
:
21503 case DW_LANG_C_plus_plus_11
:
21504 case DW_LANG_C_plus_plus_14
:
21506 case DW_LANG_ObjC_plus_plus
:
21508 case DW_LANG_Fortran77
:
21509 case DW_LANG_Fortran90
:
21510 case DW_LANG_Fortran95
:
21511 case DW_LANG_Fortran03
:
21512 case DW_LANG_Fortran08
:
21516 case DW_LANG_Python
:
21517 return dwarf_version
>= 4 ? 0 : -1;
21518 case DW_LANG_Ada95
:
21519 case DW_LANG_Ada83
:
21520 case DW_LANG_Cobol74
:
21521 case DW_LANG_Cobol85
:
21522 case DW_LANG_Modula2
:
21524 return dwarf_version
>= 4 ? 1 : -1;
21530 /* Given a tree node describing an array bound (either lower or upper) output
21531 a representation for that bound. */
21534 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
,
21535 tree bound
, struct loc_descr_context
*context
)
21540 switch (TREE_CODE (bound
))
21542 /* Strip all conversions. */
21544 case VIEW_CONVERT_EXPR
:
21545 bound
= TREE_OPERAND (bound
, 0);
21548 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
21549 are even omitted when they are the default. */
21551 /* If the value for this bound is the default one, we can even omit the
21553 if (bound_attr
== DW_AT_lower_bound
21554 && tree_fits_shwi_p (bound
)
21555 && (dflt
= lower_bound_default ()) != -1
21556 && tree_to_shwi (bound
) == dflt
)
21562 /* Let GNAT encodings do the magic for self-referential bounds. */
21564 && gnat_encodings
== DWARF_GNAT_ENCODINGS_ALL
21565 && contains_placeholder_p (bound
))
21568 add_scalar_info (subrange_die
, bound_attr
, bound
,
21569 dw_scalar_form_constant
21570 | dw_scalar_form_exprloc
21571 | dw_scalar_form_reference
,
21577 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
21578 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
21580 This function reuses previously set type and bound information if
21584 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
21586 dw_die_ref child
= type_die
->die_child
;
21587 struct array_descr_info info
;
21588 int dimension_number
;
21590 if (lang_hooks
.types
.get_array_descr_info
)
21592 memset (&info
, 0, sizeof (info
));
21593 if (lang_hooks
.types
.get_array_descr_info (type
, &info
))
21594 /* Fortran sometimes emits array types with no dimension. */
21595 gcc_assert (info
.ndimensions
>= 0
21596 && info
.ndimensions
21597 <= DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN
);
21600 info
.ndimensions
= 0;
21602 for (dimension_number
= 0;
21603 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
21604 type
= TREE_TYPE (type
), dimension_number
++)
21606 tree domain
= TYPE_DOMAIN (type
);
21608 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
21611 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
21612 and (in GNU C only) variable bounds. Handle all three forms
21615 /* Find and reuse a previously generated DW_TAG_subrange_type if
21618 For multi-dimensional arrays, as we iterate through the
21619 various dimensions in the enclosing for loop above, we also
21620 iterate through the DIE children and pick at each
21621 DW_TAG_subrange_type previously generated (if available).
21622 Each child DW_TAG_subrange_type DIE describes the range of
21623 the current dimension. At this point we should have as many
21624 DW_TAG_subrange_type's as we have dimensions in the
21626 dw_die_ref subrange_die
= NULL
;
21630 child
= child
->die_sib
;
21631 if (child
->die_tag
== DW_TAG_subrange_type
)
21632 subrange_die
= child
;
21633 if (child
== type_die
->die_child
)
21635 /* If we wrapped around, stop looking next time. */
21639 if (child
->die_tag
== DW_TAG_subrange_type
)
21643 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
21647 /* We have an array type with specified bounds. */
21648 tree lower
= TYPE_MIN_VALUE (domain
);
21649 tree upper
= TYPE_MAX_VALUE (domain
);
21650 tree index_type
= TREE_TYPE (domain
);
21652 if (dimension_number
<= info
.ndimensions
- 1)
21654 lower
= info
.dimen
[dimension_number
].lower_bound
;
21655 upper
= info
.dimen
[dimension_number
].upper_bound
;
21656 index_type
= info
.dimen
[dimension_number
].bounds_type
;
21659 /* Define the index type. */
21660 if (index_type
&& !get_AT (subrange_die
, DW_AT_type
))
21661 add_type_attribute (subrange_die
, index_type
, TYPE_UNQUALIFIED
,
21664 /* ??? If upper is NULL, the array has unspecified length,
21665 but it does have a lower bound. This happens with Fortran
21667 Since the debugger is definitely going to need to know N
21668 to produce useful results, go ahead and output the lower
21669 bound solo, and hope the debugger can cope. */
21671 if (lower
&& !get_AT (subrange_die
, DW_AT_lower_bound
))
21672 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
, NULL
);
21674 if (!get_AT (subrange_die
, DW_AT_upper_bound
)
21675 && !get_AT (subrange_die
, DW_AT_count
))
21678 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
, NULL
);
21679 else if ((is_c () || is_cxx ()) && COMPLETE_TYPE_P (type
))
21680 /* Zero-length array. */
21681 add_bound_info (subrange_die
, DW_AT_count
,
21682 build_int_cst (TREE_TYPE (lower
), 0), NULL
);
21686 /* Otherwise we have an array type with an unspecified length. The
21687 DWARF-2 spec does not say how to handle this; let's just leave out the
21692 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
21695 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
21697 dw_die_ref decl_die
;
21698 HOST_WIDE_INT size
;
21700 switch (TREE_CODE (tree_node
))
21705 case ENUMERAL_TYPE
:
21708 case QUAL_UNION_TYPE
:
21709 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
21710 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
21712 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
21715 size
= int_size_in_bytes (tree_node
);
21718 /* For a data member of a struct or union, the DW_AT_byte_size is
21719 generally given as the number of bytes normally allocated for an
21720 object of the *declared* type of the member itself. This is true
21721 even for bit-fields. */
21722 size
= int_size_in_bytes (field_type (tree_node
));
21725 gcc_unreachable ();
21728 /* Note that `size' might be -1 when we get to this point. If it is, that
21729 indicates that the byte size of the entity in question is variable. */
21731 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
21733 /* Support for dynamically-sized objects was introduced in DWARF3. */
21734 else if (TYPE_P (tree_node
)
21735 && (dwarf_version
>= 3 || !dwarf_strict
)
21736 && gnat_encodings
!= DWARF_GNAT_ENCODINGS_ALL
)
21738 struct loc_descr_context ctx
= {
21739 const_cast<tree
> (tree_node
), /* context_type */
21740 NULL_TREE
, /* base_decl */
21742 false, /* placeholder_arg */
21743 false, /* placeholder_seen */
21744 false /* strict_signedness */
21747 tree tree_size
= TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (tree_node
));
21748 add_scalar_info (die
, DW_AT_byte_size
, tree_size
,
21749 dw_scalar_form_constant
21750 | dw_scalar_form_exprloc
21751 | dw_scalar_form_reference
,
21756 /* Add a DW_AT_alignment attribute to DIE with TREE_NODE's non-default
21760 add_alignment_attribute (dw_die_ref die
, tree tree_node
)
21762 if (dwarf_version
< 5 && dwarf_strict
)
21767 if (DECL_P (tree_node
))
21769 if (!DECL_USER_ALIGN (tree_node
))
21772 align
= DECL_ALIGN_UNIT (tree_node
);
21774 else if (TYPE_P (tree_node
))
21776 if (!TYPE_USER_ALIGN (tree_node
))
21779 align
= TYPE_ALIGN_UNIT (tree_node
);
21782 gcc_unreachable ();
21784 add_AT_unsigned (die
, DW_AT_alignment
, align
);
21787 /* For a FIELD_DECL node which represents a bit-field, output an attribute
21788 which specifies the distance in bits from the highest order bit of the
21789 "containing object" for the bit-field to the highest order bit of the
21792 For any given bit-field, the "containing object" is a hypothetical object
21793 (of some integral or enum type) within which the given bit-field lives. The
21794 type of this hypothetical "containing object" is always the same as the
21795 declared type of the individual bit-field itself. The determination of the
21796 exact location of the "containing object" for a bit-field is rather
21797 complicated. It's handled by the `field_byte_offset' function (above).
21799 Note that it is the size (in bytes) of the hypothetical "containing object"
21800 which will be given in the DW_AT_byte_size attribute for this bit-field.
21801 (See `byte_size_attribute' above). */
21804 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
21806 HOST_WIDE_INT object_offset_in_bytes
;
21807 tree original_type
= DECL_BIT_FIELD_TYPE (decl
);
21808 HOST_WIDE_INT bitpos_int
;
21809 HOST_WIDE_INT highest_order_object_bit_offset
;
21810 HOST_WIDE_INT highest_order_field_bit_offset
;
21811 HOST_WIDE_INT bit_offset
;
21813 /* The containing object is within the DECL_CONTEXT. */
21814 struct vlr_context ctx
= { DECL_CONTEXT (decl
), NULL_TREE
};
21816 field_byte_offset (decl
, &ctx
, &object_offset_in_bytes
);
21818 /* Must be a field and a bit field. */
21819 gcc_assert (original_type
&& TREE_CODE (decl
) == FIELD_DECL
);
21821 /* We can't yet handle bit-fields whose offsets are variable, so if we
21822 encounter such things, just return without generating any attribute
21823 whatsoever. Likewise for variable or too large size. */
21824 if (! tree_fits_shwi_p (bit_position (decl
))
21825 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
21828 bitpos_int
= int_bit_position (decl
);
21830 /* Note that the bit offset is always the distance (in bits) from the
21831 highest-order bit of the "containing object" to the highest-order bit of
21832 the bit-field itself. Since the "high-order end" of any object or field
21833 is different on big-endian and little-endian machines, the computation
21834 below must take account of these differences. */
21835 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
21836 highest_order_field_bit_offset
= bitpos_int
;
21838 if (! BYTES_BIG_ENDIAN
)
21840 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
21841 highest_order_object_bit_offset
+=
21842 simple_type_size_in_bits (original_type
);
21846 = (! BYTES_BIG_ENDIAN
21847 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
21848 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
21850 if (bit_offset
< 0)
21851 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
21853 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
21856 /* For a FIELD_DECL node which represents a bit field, output an attribute
21857 which specifies the length in bits of the given field. */
21860 add_bit_size_attribute (dw_die_ref die
, tree decl
)
21862 /* Must be a field and a bit field. */
21863 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
21864 && DECL_BIT_FIELD_TYPE (decl
));
21866 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
21867 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
21870 /* If the compiled language is ANSI C, then add a 'prototyped'
21871 attribute, if arg types are given for the parameters of a function. */
21874 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
21876 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
21883 if (prototype_p (func_type
))
21884 add_AT_flag (die
, DW_AT_prototyped
, 1);
21891 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
21892 by looking in the type declaration, the object declaration equate table or
21893 the block mapping. */
21896 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
21898 dw_die_ref origin_die
= NULL
;
21900 /* For late LTO debug output we want to refer directly to the abstract
21901 DIE in the early debug rather to the possibly existing concrete
21902 instance and avoid creating that just for this purpose. */
21903 sym_off_pair
*desc
;
21905 && external_die_map
21906 && (desc
= external_die_map
->get (origin
)))
21908 add_AT_external_die_ref (die
, DW_AT_abstract_origin
,
21909 desc
->sym
, desc
->off
);
21913 if (DECL_P (origin
))
21914 origin_die
= lookup_decl_die (origin
);
21915 else if (TYPE_P (origin
))
21916 origin_die
= lookup_type_die (origin
);
21917 else if (TREE_CODE (origin
) == BLOCK
)
21918 origin_die
= lookup_block_die (origin
);
21920 /* XXX: Functions that are never lowered don't always have correct block
21921 trees (in the case of java, they simply have no block tree, in some other
21922 languages). For these functions, there is nothing we can really do to
21923 output correct debug info for inlined functions in all cases. Rather
21924 than die, we'll just produce deficient debug info now, in that we will
21925 have variables without a proper abstract origin. In the future, when all
21926 functions are lowered, we should re-add a gcc_assert (origin_die)
21932 /* Like above, if we already created a concrete instance DIE
21933 do not use that for the abstract origin but the early DIE
21936 && (a
= get_AT (origin_die
, DW_AT_abstract_origin
)))
21937 origin_die
= AT_ref (a
);
21938 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
21942 /* We do not currently support the pure_virtual attribute. */
21945 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
21947 if (DECL_VINDEX (func_decl
))
21949 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
21951 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
21952 add_AT_loc (die
, DW_AT_vtable_elem_location
,
21953 new_loc_descr (DW_OP_constu
,
21954 tree_to_shwi (DECL_VINDEX (func_decl
)),
21957 /* GNU extension: Record what type this method came from originally. */
21958 if (debug_info_level
> DINFO_LEVEL_TERSE
21959 && DECL_CONTEXT (func_decl
))
21960 add_AT_die_ref (die
, DW_AT_containing_type
,
21961 lookup_type_die (DECL_CONTEXT (func_decl
)));
21965 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
21966 given decl. This used to be a vendor extension until after DWARF 4
21967 standardized it. */
21970 add_linkage_attr (dw_die_ref die
, tree decl
)
21972 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
21974 /* Mimic what assemble_name_raw does with a leading '*'. */
21975 if (name
[0] == '*')
21978 if (dwarf_version
>= 4)
21979 add_AT_string (die
, DW_AT_linkage_name
, name
);
21981 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
21984 /* Add source coordinate attributes for the given decl. */
21987 add_src_coords_attributes (dw_die_ref die
, tree decl
)
21989 expanded_location s
;
21991 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
21993 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
21994 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
21995 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
21996 if (debug_column_info
&& s
.column
)
21997 add_AT_unsigned (die
, DW_AT_decl_column
, s
.column
);
22000 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
22003 add_linkage_name_raw (dw_die_ref die
, tree decl
)
22005 /* Defer until we have an assembler name set. */
22006 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
22008 limbo_die_node
*asm_name
;
22010 asm_name
= ggc_cleared_alloc
<limbo_die_node
> ();
22011 asm_name
->die
= die
;
22012 asm_name
->created_for
= decl
;
22013 asm_name
->next
= deferred_asm_name
;
22014 deferred_asm_name
= asm_name
;
22016 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
22017 add_linkage_attr (die
, decl
);
22020 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl if desired. */
22023 add_linkage_name (dw_die_ref die
, tree decl
)
22025 if (debug_info_level
> DINFO_LEVEL_NONE
22026 && VAR_OR_FUNCTION_DECL_P (decl
)
22027 && TREE_PUBLIC (decl
)
22028 && !(VAR_P (decl
) && DECL_REGISTER (decl
))
22029 && die
->die_tag
!= DW_TAG_member
)
22030 add_linkage_name_raw (die
, decl
);
22033 /* Add a DW_AT_name attribute and source coordinate attribute for the
22034 given decl, but only if it actually has a name. */
22037 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
,
22038 bool no_linkage_name
)
22042 decl_name
= DECL_NAME (decl
);
22043 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
22045 const char *name
= dwarf2_name (decl
, 0);
22047 add_name_attribute (die
, name
);
22049 add_desc_attribute (die
, decl
);
22051 if (! DECL_ARTIFICIAL (decl
))
22052 add_src_coords_attributes (die
, decl
);
22054 if (!no_linkage_name
)
22055 add_linkage_name (die
, decl
);
22058 add_desc_attribute (die
, decl
);
22060 #ifdef VMS_DEBUGGING_INFO
22061 /* Get the function's name, as described by its RTL. This may be different
22062 from the DECL_NAME name used in the source file. */
22063 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
22065 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
22066 XEXP (DECL_RTL (decl
), 0), false);
22067 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
22069 #endif /* VMS_DEBUGGING_INFO */
22072 /* Add VALUE as a DW_AT_discr_value attribute to DIE. */
22075 add_discr_value (dw_die_ref die
, dw_discr_value
*value
)
22079 attr
.dw_attr
= DW_AT_discr_value
;
22080 attr
.dw_attr_val
.val_class
= dw_val_class_discr_value
;
22081 attr
.dw_attr_val
.val_entry
= NULL
;
22082 attr
.dw_attr_val
.v
.val_discr_value
.pos
= value
->pos
;
22084 attr
.dw_attr_val
.v
.val_discr_value
.v
.uval
= value
->v
.uval
;
22086 attr
.dw_attr_val
.v
.val_discr_value
.v
.sval
= value
->v
.sval
;
22087 add_dwarf_attr (die
, &attr
);
22090 /* Add DISCR_LIST as a DW_AT_discr_list to DIE. */
22093 add_discr_list (dw_die_ref die
, dw_discr_list_ref discr_list
)
22097 attr
.dw_attr
= DW_AT_discr_list
;
22098 attr
.dw_attr_val
.val_class
= dw_val_class_discr_list
;
22099 attr
.dw_attr_val
.val_entry
= NULL
;
22100 attr
.dw_attr_val
.v
.val_discr_list
= discr_list
;
22101 add_dwarf_attr (die
, &attr
);
22104 static inline dw_discr_list_ref
22105 AT_discr_list (dw_attr_node
*attr
)
22107 return attr
->dw_attr_val
.v
.val_discr_list
;
22110 #ifdef VMS_DEBUGGING_INFO
22111 /* Output the debug main pointer die for VMS */
22114 dwarf2out_vms_debug_main_pointer (void)
22116 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
22119 /* Allocate the VMS debug main subprogram die. */
22120 die
= new_die_raw (DW_TAG_subprogram
);
22121 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
22122 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
22123 current_function_funcdef_no
);
22124 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
22126 /* Make it the first child of comp_unit_die (). */
22127 die
->die_parent
= comp_unit_die ();
22128 if (comp_unit_die ()->die_child
)
22130 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
22131 comp_unit_die ()->die_child
->die_sib
= die
;
22135 die
->die_sib
= die
;
22136 comp_unit_die ()->die_child
= die
;
22139 #endif /* VMS_DEBUGGING_INFO */
22141 /* walk_tree helper function for uses_local_type, below. */
22144 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
22147 *walk_subtrees
= 0;
22150 tree name
= TYPE_NAME (*tp
);
22151 if (name
&& DECL_P (name
) && decl_function_context (name
))
22157 /* If TYPE involves a function-local type (including a local typedef to a
22158 non-local type), returns that type; otherwise returns NULL_TREE. */
22161 uses_local_type (tree type
)
22163 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
22167 /* Return the DIE for the scope that immediately contains this type.
22168 Non-named types that do not involve a function-local type get global
22169 scope. Named types nested in namespaces or other types get their
22170 containing scope. All other types (i.e. function-local named types) get
22171 the current active scope. */
22174 scope_die_for (tree t
, dw_die_ref context_die
)
22176 dw_die_ref scope_die
= NULL
;
22177 tree containing_scope
;
22179 /* Non-types always go in the current scope. */
22180 gcc_assert (TYPE_P (t
));
22182 /* Use the scope of the typedef, rather than the scope of the type
22184 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
22185 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
22187 containing_scope
= TYPE_CONTEXT (t
);
22189 /* Use the containing namespace if there is one. */
22190 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
22192 if (context_die
== lookup_decl_die (containing_scope
))
22194 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
22195 context_die
= get_context_die (containing_scope
);
22197 containing_scope
= NULL_TREE
;
22200 /* Ignore function type "scopes" from the C frontend. They mean that
22201 a tagged type is local to a parmlist of a function declarator, but
22202 that isn't useful to DWARF. */
22203 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
22204 containing_scope
= NULL_TREE
;
22206 if (SCOPE_FILE_SCOPE_P (containing_scope
))
22208 /* If T uses a local type keep it local as well, to avoid references
22209 to function-local DIEs from outside the function. */
22210 if (current_function_decl
&& uses_local_type (t
))
22211 scope_die
= context_die
;
22213 scope_die
= comp_unit_die ();
22215 else if (TYPE_P (containing_scope
))
22217 /* For types, we can just look up the appropriate DIE. */
22218 if (debug_info_level
> DINFO_LEVEL_TERSE
)
22219 scope_die
= get_context_die (containing_scope
);
22222 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
22223 if (scope_die
== NULL
)
22224 scope_die
= comp_unit_die ();
22228 scope_die
= context_die
;
22233 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
22236 local_scope_p (dw_die_ref context_die
)
22238 for (; context_die
; context_die
= context_die
->die_parent
)
22239 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
22240 || context_die
->die_tag
== DW_TAG_subprogram
)
22246 /* Returns nonzero if CONTEXT_DIE is a class. */
22249 class_scope_p (dw_die_ref context_die
)
22251 return (context_die
22252 && (context_die
->die_tag
== DW_TAG_structure_type
22253 || context_die
->die_tag
== DW_TAG_class_type
22254 || context_die
->die_tag
== DW_TAG_interface_type
22255 || context_die
->die_tag
== DW_TAG_union_type
));
22258 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
22259 whether or not to treat a DIE in this context as a declaration. */
22262 class_or_namespace_scope_p (dw_die_ref context_die
)
22264 return (class_scope_p (context_die
)
22265 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
22268 /* Many forms of DIEs require a "type description" attribute. This
22269 routine locates the proper "type descriptor" die for the type given
22270 by 'type' plus any additional qualifiers given by 'cv_quals', and
22271 adds a DW_AT_type attribute below the given die. */
22274 add_type_attribute (dw_die_ref object_die
, tree type
, int cv_quals
,
22275 bool reverse
, dw_die_ref context_die
)
22277 enum tree_code code
= TREE_CODE (type
);
22278 dw_die_ref type_die
= NULL
;
22280 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
22283 /* ??? If this type is an unnamed subrange type of an integral, floating-point
22284 or fixed-point type, use the inner type. This is because we have no
22285 support for unnamed types in base_type_die. This can happen if this is
22286 an Ada subrange type. Correct solution is emit a subrange type die. */
22287 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
22288 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
22289 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
22291 if (code
== ERROR_MARK
22292 /* Handle a special case. For functions whose return type is void, we
22293 generate *no* type attribute. (Note that no object may have type
22294 `void', so this only applies to function return types). */
22295 || code
== VOID_TYPE
)
22298 type_die
= modified_type_die (type
,
22299 cv_quals
| TYPE_QUALS (type
),
22303 if (type_die
!= NULL
)
22304 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
22307 /* Given an object die, add the calling convention attribute for the
22308 function call type. */
22310 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
22312 enum dwarf_calling_convention value
= DW_CC_normal
;
22314 value
= ((enum dwarf_calling_convention
)
22315 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
22318 && id_equal (DECL_ASSEMBLER_NAME (decl
), "MAIN__"))
22320 /* DWARF 2 doesn't provide a way to identify a program's source-level
22321 entry point. DW_AT_calling_convention attributes are only meant
22322 to describe functions' calling conventions. However, lacking a
22323 better way to signal the Fortran main program, we used this for
22324 a long time, following existing custom. Now, DWARF 4 has
22325 DW_AT_main_subprogram, which we add below, but some tools still
22326 rely on the old way, which we thus keep. */
22327 value
= DW_CC_program
;
22329 if (dwarf_version
>= 4 || !dwarf_strict
)
22330 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
22333 /* Only add the attribute if the backend requests it, and
22334 is not DW_CC_normal. */
22335 if (value
&& (value
!= DW_CC_normal
))
22336 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
22339 /* Given a tree pointer to a struct, class, union, or enum type node, return
22340 a pointer to the (string) tag name for the given type, or zero if the type
22341 was declared without a tag. */
22343 static const char *
22344 type_tag (const_tree type
)
22346 const char *name
= 0;
22348 if (TYPE_NAME (type
) != 0)
22352 /* Find the IDENTIFIER_NODE for the type name. */
22353 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
22354 && !TYPE_NAMELESS (type
))
22355 t
= TYPE_NAME (type
);
22357 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
22358 a TYPE_DECL node, regardless of whether or not a `typedef' was
22360 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
22361 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
22363 /* We want to be extra verbose. Don't call dwarf_name if
22364 DECL_NAME isn't set. The default hook for decl_printable_name
22365 doesn't like that, and in this context it's correct to return
22366 0, instead of "<anonymous>" or the like. */
22367 if (DECL_NAME (TYPE_NAME (type
))
22368 && !DECL_NAMELESS (TYPE_NAME (type
)))
22369 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
22372 /* Now get the name as a string, or invent one. */
22373 if (!name
&& t
!= 0)
22374 name
= IDENTIFIER_POINTER (t
);
22377 return (name
== 0 || *name
== '\0') ? 0 : name
;
22380 /* Return the type associated with a data member, make a special check
22381 for bit field types. */
22384 member_declared_type (const_tree member
)
22386 return (DECL_BIT_FIELD_TYPE (member
)
22387 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
22390 /* Get the decl's label, as described by its RTL. This may be different
22391 from the DECL_NAME name used in the source file. */
22394 static const char *
22395 decl_start_label (tree decl
)
22398 const char *fnname
;
22400 x
= DECL_RTL (decl
);
22401 gcc_assert (MEM_P (x
));
22404 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
22406 fnname
= XSTR (x
, 0);
22411 /* For variable-length arrays that have been previously generated, but
22412 may be incomplete due to missing subscript info, fill the subscript
22413 info. Return TRUE if this is one of those cases. */
22416 fill_variable_array_bounds (tree type
)
22418 if (TREE_ASM_WRITTEN (type
)
22419 && TREE_CODE (type
) == ARRAY_TYPE
22420 && variably_modified_type_p (type
, NULL
))
22422 dw_die_ref array_die
= lookup_type_die (type
);
22425 add_subscript_info (array_die
, type
, !is_ada ());
22431 /* These routines generate the internal representation of the DIE's for
22432 the compilation unit. Debugging information is collected by walking
22433 the declaration trees passed in from dwarf2out_decl(). */
22436 gen_array_type_die (tree type
, dw_die_ref context_die
)
22438 dw_die_ref array_die
;
22440 /* GNU compilers represent multidimensional array types as sequences of one
22441 dimensional array types whose element types are themselves array types.
22442 We sometimes squish that down to a single array_type DIE with multiple
22443 subscripts in the Dwarf debugging info. The draft Dwarf specification
22444 say that we are allowed to do this kind of compression in C, because
22445 there is no difference between an array of arrays and a multidimensional
22446 array. We don't do this for Ada to remain as close as possible to the
22447 actual representation, which is especially important against the language
22448 flexibilty wrt arrays of variable size. */
22450 bool collapse_nested_arrays
= !is_ada ();
22452 if (fill_variable_array_bounds (type
))
22455 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
22458 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
22459 DW_TAG_string_type doesn't have DW_AT_type attribute). */
22460 if (TREE_CODE (type
) == ARRAY_TYPE
22461 && TYPE_STRING_FLAG (type
)
22463 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
22465 HOST_WIDE_INT size
;
22467 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
22468 add_name_attribute (array_die
, type_tag (type
));
22469 equate_type_number_to_die (type
, array_die
);
22470 size
= int_size_in_bytes (type
);
22472 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
22473 /* ??? We can't annotate types late, but for LTO we may not
22474 generate a location early either (gfortran.dg/save_6.f90). */
22475 else if (! (early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
22476 && TYPE_DOMAIN (type
) != NULL_TREE
22477 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
)
22479 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
22480 tree rszdecl
= szdecl
;
22482 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
22483 if (!DECL_P (szdecl
))
22485 if (TREE_CODE (szdecl
) == INDIRECT_REF
22486 && DECL_P (TREE_OPERAND (szdecl
, 0)))
22488 rszdecl
= TREE_OPERAND (szdecl
, 0);
22489 if (int_size_in_bytes (TREE_TYPE (rszdecl
))
22490 != DWARF2_ADDR_SIZE
)
22498 dw_loc_list_ref loc
22499 = loc_list_from_tree (rszdecl
, szdecl
== rszdecl
? 2 : 0,
22503 add_AT_location_description (array_die
, DW_AT_string_length
,
22505 if (size
!= DWARF2_ADDR_SIZE
)
22506 add_AT_unsigned (array_die
, dwarf_version
>= 5
22507 ? DW_AT_string_length_byte_size
22508 : DW_AT_byte_size
, size
);
22515 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
22516 add_name_attribute (array_die
, type_tag (type
));
22517 equate_type_number_to_die (type
, array_die
);
22519 if (TREE_CODE (type
) == VECTOR_TYPE
)
22520 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
22522 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
22524 && TREE_CODE (type
) == ARRAY_TYPE
22525 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
22526 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
22527 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
22530 /* We default the array ordering. Debuggers will probably do the right
22531 things even if DW_AT_ordering is not present. It's not even an issue
22532 until we start to get into multidimensional arrays anyway. If a debugger
22533 is ever caught doing the Wrong Thing for multi-dimensional arrays,
22534 then we'll have to put the DW_AT_ordering attribute back in. (But if
22535 and when we find out that we need to put these in, we will only do so
22536 for multidimensional arrays. */
22537 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
22540 if (TREE_CODE (type
) == VECTOR_TYPE
)
22542 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
22543 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
22544 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
, NULL
);
22545 add_bound_info (subrange_die
, DW_AT_upper_bound
,
22546 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1), NULL
);
22549 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
22551 /* Add representation of the type of the elements of this array type and
22552 emit the corresponding DIE if we haven't done it already. */
22553 element_type
= TREE_TYPE (type
);
22554 if (collapse_nested_arrays
)
22555 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
22557 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
22559 element_type
= TREE_TYPE (element_type
);
22562 add_type_attribute (array_die
, element_type
, TYPE_UNQUALIFIED
,
22563 TREE_CODE (type
) == ARRAY_TYPE
22564 && TYPE_REVERSE_STORAGE_ORDER (type
),
22567 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
22568 if (TYPE_ARTIFICIAL (type
))
22569 add_AT_flag (array_die
, DW_AT_artificial
, 1);
22571 if (get_AT (array_die
, DW_AT_name
))
22572 add_pubtype (type
, array_die
);
22574 add_alignment_attribute (array_die
, type
);
22577 /* This routine generates DIE for array with hidden descriptor, details
22578 are filled into *info by a langhook. */
22581 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
22582 dw_die_ref context_die
)
22584 const dw_die_ref scope_die
= scope_die_for (type
, context_die
);
22585 const dw_die_ref array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
22586 struct loc_descr_context context
= {
22587 type
, /* context_type */
22588 info
->base_decl
, /* base_decl */
22590 false, /* placeholder_arg */
22591 false, /* placeholder_seen */
22592 false /* strict_signedness */
22594 enum dwarf_tag subrange_tag
= DW_TAG_subrange_type
;
22597 add_name_attribute (array_die
, type_tag (type
));
22598 equate_type_number_to_die (type
, array_die
);
22600 if (info
->ndimensions
> 1)
22601 switch (info
->ordering
)
22603 case array_descr_ordering_row_major
:
22604 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
22606 case array_descr_ordering_column_major
:
22607 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
22613 if (dwarf_version
>= 3 || !dwarf_strict
)
22615 if (info
->data_location
)
22616 add_scalar_info (array_die
, DW_AT_data_location
, info
->data_location
,
22617 dw_scalar_form_exprloc
, &context
);
22618 if (info
->associated
)
22619 add_scalar_info (array_die
, DW_AT_associated
, info
->associated
,
22620 dw_scalar_form_constant
22621 | dw_scalar_form_exprloc
22622 | dw_scalar_form_reference
, &context
);
22623 if (info
->allocated
)
22624 add_scalar_info (array_die
, DW_AT_allocated
, info
->allocated
,
22625 dw_scalar_form_constant
22626 | dw_scalar_form_exprloc
22627 | dw_scalar_form_reference
, &context
);
22630 const enum dwarf_attribute attr
22631 = (info
->stride_in_bits
) ? DW_AT_bit_stride
: DW_AT_byte_stride
;
22633 = (info
->stride_in_bits
)
22634 ? dw_scalar_form_constant
22635 : (dw_scalar_form_constant
22636 | dw_scalar_form_exprloc
22637 | dw_scalar_form_reference
);
22639 add_scalar_info (array_die
, attr
, info
->stride
, forms
, &context
);
22642 if (dwarf_version
>= 5)
22646 add_scalar_info (array_die
, DW_AT_rank
, info
->rank
,
22647 dw_scalar_form_constant
22648 | dw_scalar_form_exprloc
, &context
);
22649 subrange_tag
= DW_TAG_generic_subrange
;
22650 context
.placeholder_arg
= true;
22654 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
22656 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
22658 dw_die_ref subrange_die
= new_die (subrange_tag
, array_die
, NULL
);
22660 if (info
->dimen
[dim
].bounds_type
)
22661 add_type_attribute (subrange_die
,
22662 info
->dimen
[dim
].bounds_type
, TYPE_UNQUALIFIED
,
22663 false, context_die
);
22664 if (info
->dimen
[dim
].lower_bound
)
22665 add_bound_info (subrange_die
, DW_AT_lower_bound
,
22666 info
->dimen
[dim
].lower_bound
, &context
);
22667 if (info
->dimen
[dim
].upper_bound
)
22668 add_bound_info (subrange_die
, DW_AT_upper_bound
,
22669 info
->dimen
[dim
].upper_bound
, &context
);
22670 if ((dwarf_version
>= 3 || !dwarf_strict
) && info
->dimen
[dim
].stride
)
22671 add_scalar_info (subrange_die
, DW_AT_byte_stride
,
22672 info
->dimen
[dim
].stride
,
22673 dw_scalar_form_constant
22674 | dw_scalar_form_exprloc
22675 | dw_scalar_form_reference
,
22679 gen_type_die (info
->element_type
, context_die
);
22680 add_type_attribute (array_die
, info
->element_type
, TYPE_UNQUALIFIED
,
22681 TREE_CODE (type
) == ARRAY_TYPE
22682 && TYPE_REVERSE_STORAGE_ORDER (type
),
22685 if (get_AT (array_die
, DW_AT_name
))
22686 add_pubtype (type
, array_die
);
22688 add_alignment_attribute (array_die
, type
);
22693 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
22695 tree origin
= decl_ultimate_origin (decl
);
22696 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
22698 if (origin
!= NULL
)
22699 add_abstract_origin_attribute (decl_die
, origin
);
22702 add_name_and_src_coords_attributes (decl_die
, decl
);
22703 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
22704 TYPE_UNQUALIFIED
, false, context_die
);
22707 if (DECL_ABSTRACT_P (decl
))
22708 equate_decl_number_to_die (decl
, decl_die
);
22710 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
22714 /* Walk through the list of incomplete types again, trying once more to
22715 emit full debugging info for them. */
22718 retry_incomplete_types (void)
22723 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
22724 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
22725 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
22726 vec_safe_truncate (incomplete_types
, 0);
22729 /* Determine what tag to use for a record type. */
22731 static enum dwarf_tag
22732 record_type_tag (tree type
)
22734 if (! lang_hooks
.types
.classify_record
)
22735 return DW_TAG_structure_type
;
22737 switch (lang_hooks
.types
.classify_record (type
))
22739 case RECORD_IS_STRUCT
:
22740 return DW_TAG_structure_type
;
22742 case RECORD_IS_CLASS
:
22743 return DW_TAG_class_type
;
22745 case RECORD_IS_INTERFACE
:
22746 if (dwarf_version
>= 3 || !dwarf_strict
)
22747 return DW_TAG_interface_type
;
22748 return DW_TAG_structure_type
;
22751 gcc_unreachable ();
22755 /* Generate a DIE to represent an enumeration type. Note that these DIEs
22756 include all of the information about the enumeration values also. Each
22757 enumerated type name/value is listed as a child of the enumerated type
22761 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
22763 dw_die_ref type_die
= lookup_type_die (type
);
22764 dw_die_ref orig_type_die
= type_die
;
22766 if (type_die
== NULL
)
22768 type_die
= new_die (DW_TAG_enumeration_type
,
22769 scope_die_for (type
, context_die
), type
);
22770 equate_type_number_to_die (type
, type_die
);
22771 add_name_attribute (type_die
, type_tag (type
));
22772 if ((dwarf_version
>= 4 || !dwarf_strict
)
22773 && ENUM_IS_SCOPED (type
))
22774 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
22775 if (ENUM_IS_OPAQUE (type
) && TYPE_SIZE (type
))
22776 add_AT_flag (type_die
, DW_AT_declaration
, 1);
22778 add_AT_unsigned (type_die
, DW_AT_encoding
,
22779 TYPE_UNSIGNED (type
)
22783 else if (! TYPE_SIZE (type
) || ENUM_IS_OPAQUE (type
))
22786 remove_AT (type_die
, DW_AT_declaration
);
22788 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
22789 given enum type is incomplete, do not generate the DW_AT_byte_size
22790 attribute or the DW_AT_element_list attribute. */
22791 if (TYPE_SIZE (type
))
22795 if (!ENUM_IS_OPAQUE (type
))
22796 TREE_ASM_WRITTEN (type
) = 1;
22797 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_byte_size
))
22798 add_byte_size_attribute (type_die
, type
);
22799 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_alignment
))
22800 add_alignment_attribute (type_die
, type
);
22801 if ((dwarf_version
>= 3 || !dwarf_strict
)
22802 && (!orig_type_die
|| !get_AT (type_die
, DW_AT_type
)))
22804 tree underlying
= lang_hooks
.types
.enum_underlying_base_type (type
);
22805 add_type_attribute (type_die
, underlying
, TYPE_UNQUALIFIED
, false,
22808 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
22810 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_decl_file
))
22811 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
22812 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_accessibility
))
22813 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
22816 /* If the first reference to this type was as the return type of an
22817 inline function, then it may not have a parent. Fix this now. */
22818 if (type_die
->die_parent
== NULL
)
22819 add_child_die (scope_die_for (type
, context_die
), type_die
);
22821 for (link
= TYPE_VALUES (type
);
22822 link
!= NULL
; link
= TREE_CHAIN (link
))
22824 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
22825 tree value
= TREE_VALUE (link
);
22827 if (DECL_P (value
))
22828 equate_decl_number_to_die (value
, enum_die
);
22830 gcc_assert (!ENUM_IS_OPAQUE (type
));
22831 add_name_attribute (enum_die
,
22832 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
22834 if (TREE_CODE (value
) == CONST_DECL
)
22835 value
= DECL_INITIAL (value
);
22837 if (simple_type_size_in_bits (TREE_TYPE (value
))
22838 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
22840 /* For constant forms created by add_AT_unsigned DWARF
22841 consumers (GDB, elfutils, etc.) always zero extend
22842 the value. Only when the actual value is negative
22843 do we need to use add_AT_int to generate a constant
22844 form that can represent negative values. */
22845 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
22846 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
22847 add_AT_unsigned (enum_die
, DW_AT_const_value
,
22848 (unsigned HOST_WIDE_INT
) val
);
22850 add_AT_int (enum_die
, DW_AT_const_value
, val
);
22853 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
22854 that here. TODO: This should be re-worked to use correct
22855 signed/unsigned double tags for all cases. */
22856 add_AT_wide (enum_die
, DW_AT_const_value
, wi::to_wide (value
));
22859 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
22860 if (TYPE_ARTIFICIAL (type
)
22861 && (!orig_type_die
|| !get_AT (type_die
, DW_AT_artificial
)))
22862 add_AT_flag (type_die
, DW_AT_artificial
, 1);
22865 add_AT_flag (type_die
, DW_AT_declaration
, 1);
22867 add_pubtype (type
, type_die
);
22872 /* Generate a DIE to represent either a real live formal parameter decl or to
22873 represent just the type of some formal parameter position in some function
22876 Note that this routine is a bit unusual because its argument may be a
22877 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
22878 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
22879 node. If it's the former then this function is being called to output a
22880 DIE to represent a formal parameter object (or some inlining thereof). If
22881 it's the latter, then this function is only being called to output a
22882 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
22883 argument type of some subprogram type.
22884 If EMIT_NAME_P is true, name and source coordinate attributes
22888 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
22889 dw_die_ref context_die
)
22891 tree node_or_origin
= node
? node
: origin
;
22892 tree ultimate_origin
;
22893 dw_die_ref parm_die
= NULL
;
22895 if (DECL_P (node_or_origin
))
22897 parm_die
= lookup_decl_die (node
);
22899 /* If the contexts differ, we may not be talking about the same
22901 ??? When in LTO the DIE parent is the "abstract" copy and the
22902 context_die is the specification "copy". */
22904 && parm_die
->die_parent
!= context_die
22905 && (parm_die
->die_parent
->die_tag
!= DW_TAG_GNU_formal_parameter_pack
22906 || parm_die
->die_parent
->die_parent
!= context_die
)
22909 gcc_assert (!DECL_ABSTRACT_P (node
));
22910 /* This can happen when creating a concrete instance, in
22911 which case we need to create a new DIE that will get
22912 annotated with DW_AT_abstract_origin. */
22916 if (parm_die
&& parm_die
->die_parent
== NULL
)
22918 /* Check that parm_die already has the right attributes that
22919 we would have added below. If any attributes are
22920 missing, fall through to add them. */
22921 if (! DECL_ABSTRACT_P (node_or_origin
)
22922 && !get_AT (parm_die
, DW_AT_location
)
22923 && !get_AT (parm_die
, DW_AT_const_value
))
22924 /* We are missing location info, and are about to add it. */
22928 add_child_die (context_die
, parm_die
);
22934 /* If we have a previously generated DIE, use it, unless this is an
22935 concrete instance (origin != NULL), in which case we need a new
22936 DIE with a corresponding DW_AT_abstract_origin. */
22938 if (parm_die
&& origin
== NULL
)
22939 reusing_die
= true;
22942 parm_die
= new_die (DW_TAG_formal_parameter
, context_die
, node
);
22943 reusing_die
= false;
22946 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
22948 case tcc_declaration
:
22949 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
22950 if (node
|| ultimate_origin
)
22951 origin
= ultimate_origin
;
22956 if (origin
!= NULL
)
22957 add_abstract_origin_attribute (parm_die
, origin
);
22958 else if (emit_name_p
)
22959 add_name_and_src_coords_attributes (parm_die
, node
);
22961 || (! DECL_ABSTRACT_P (node_or_origin
)
22962 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
22963 decl_function_context
22964 (node_or_origin
))))
22966 tree type
= TREE_TYPE (node_or_origin
);
22967 if (decl_by_reference_p (node_or_origin
))
22968 add_type_attribute (parm_die
, TREE_TYPE (type
),
22970 false, context_die
);
22972 add_type_attribute (parm_die
, type
,
22973 decl_quals (node_or_origin
),
22974 false, context_die
);
22976 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
22977 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22979 if (node
&& node
!= origin
)
22980 equate_decl_number_to_die (node
, parm_die
);
22981 if (! DECL_ABSTRACT_P (node_or_origin
))
22982 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
22988 /* We were called with some kind of a ..._TYPE node. */
22989 add_type_attribute (parm_die
, node_or_origin
, TYPE_UNQUALIFIED
, false,
22994 gcc_unreachable ();
23000 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
23001 children DW_TAG_formal_parameter DIEs representing the arguments of the
23004 PARM_PACK must be a function parameter pack.
23005 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
23006 must point to the subsequent arguments of the function PACK_ARG belongs to.
23007 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
23008 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
23009 following the last one for which a DIE was generated. */
23012 gen_formal_parameter_pack_die (tree parm_pack
,
23014 dw_die_ref subr_die
,
23018 dw_die_ref parm_pack_die
;
23020 gcc_assert (parm_pack
23021 && lang_hooks
.function_parameter_pack_p (parm_pack
)
23024 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
23025 add_src_coords_attributes (parm_pack_die
, parm_pack
);
23027 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
23029 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
23032 gen_formal_parameter_die (arg
, NULL
,
23033 false /* Don't emit name attribute. */,
23038 return parm_pack_die
;
23041 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
23042 at the end of an (ANSI prototyped) formal parameters list. */
23045 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
23047 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
23050 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
23051 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
23052 parameters as specified in some function type specification (except for
23053 those which appear as part of a function *definition*). */
23056 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
23059 tree formal_type
= NULL
;
23060 tree first_parm_type
;
23063 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
23065 arg
= DECL_ARGUMENTS (function_or_method_type
);
23066 function_or_method_type
= TREE_TYPE (function_or_method_type
);
23071 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
23073 /* Make our first pass over the list of formal parameter types and output a
23074 DW_TAG_formal_parameter DIE for each one. */
23075 for (link
= first_parm_type
; link
; )
23077 dw_die_ref parm_die
;
23079 formal_type
= TREE_VALUE (link
);
23080 if (formal_type
== void_type_node
)
23083 /* Output a (nameless) DIE to represent the formal parameter itself. */
23084 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
23085 true /* Emit name attribute. */,
23087 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
23088 && link
== first_parm_type
)
23090 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
23091 if (dwarf_version
>= 3 || !dwarf_strict
)
23092 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
23094 else if (arg
&& DECL_ARTIFICIAL (arg
))
23095 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
23097 link
= TREE_CHAIN (link
);
23099 arg
= DECL_CHAIN (arg
);
23102 /* If this function type has an ellipsis, add a
23103 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
23104 if (formal_type
!= void_type_node
)
23105 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
23107 /* Make our second (and final) pass over the list of formal parameter types
23108 and output DIEs to represent those types (as necessary). */
23109 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
23110 link
&& TREE_VALUE (link
);
23111 link
= TREE_CHAIN (link
))
23112 gen_type_die (TREE_VALUE (link
), context_die
);
23115 /* We want to generate the DIE for TYPE so that we can generate the
23116 die for MEMBER, which has been defined; we will need to refer back
23117 to the member declaration nested within TYPE. If we're trying to
23118 generate minimal debug info for TYPE, processing TYPE won't do the
23119 trick; we need to attach the member declaration by hand. */
23122 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
23124 gen_type_die (type
, context_die
);
23126 /* If we're trying to avoid duplicate debug info, we may not have
23127 emitted the member decl for this function. Emit it now. */
23128 if (TYPE_STUB_DECL (type
)
23129 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
23130 && ! lookup_decl_die (member
))
23132 dw_die_ref type_die
;
23133 gcc_assert (!decl_ultimate_origin (member
));
23135 type_die
= lookup_type_die_strip_naming_typedef (type
);
23136 if (TREE_CODE (member
) == FUNCTION_DECL
)
23137 gen_subprogram_die (member
, type_die
);
23138 else if (TREE_CODE (member
) == FIELD_DECL
)
23140 /* Ignore the nameless fields that are used to skip bits but handle
23141 C++ anonymous unions and structs. */
23142 if (DECL_NAME (member
) != NULL_TREE
23143 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
23144 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
23146 struct vlr_context vlr_ctx
= {
23147 DECL_CONTEXT (member
), /* struct_type */
23148 NULL_TREE
/* variant_part_offset */
23150 gen_type_die (member_declared_type (member
), type_die
);
23151 gen_field_die (member
, &vlr_ctx
, type_die
);
23155 gen_variable_die (member
, NULL_TREE
, type_die
);
23159 /* Forward declare these functions, because they are mutually recursive
23160 with their set_block_* pairing functions. */
23161 static void set_decl_origin_self (tree
);
23163 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
23164 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
23165 that it points to the node itself, thus indicating that the node is its
23166 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
23167 the given node is NULL, recursively descend the decl/block tree which
23168 it is the root of, and for each other ..._DECL or BLOCK node contained
23169 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
23170 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
23171 values to point to themselves. */
23174 set_block_origin_self (tree stmt
)
23176 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
23178 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
23183 for (local_decl
= BLOCK_VARS (stmt
);
23184 local_decl
!= NULL_TREE
;
23185 local_decl
= DECL_CHAIN (local_decl
))
23186 /* Do not recurse on nested functions since the inlining status
23187 of parent and child can be different as per the DWARF spec. */
23188 if (TREE_CODE (local_decl
) != FUNCTION_DECL
23189 && !DECL_EXTERNAL (local_decl
))
23190 set_decl_origin_self (local_decl
);
23196 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
23197 subblock
!= NULL_TREE
;
23198 subblock
= BLOCK_CHAIN (subblock
))
23199 set_block_origin_self (subblock
); /* Recurse. */
23204 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
23205 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
23206 node to so that it points to the node itself, thus indicating that the
23207 node represents its own (abstract) origin. Additionally, if the
23208 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
23209 the decl/block tree of which the given node is the root of, and for
23210 each other ..._DECL or BLOCK node contained therein whose
23211 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
23212 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
23213 point to themselves. */
23216 set_decl_origin_self (tree decl
)
23218 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
23220 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
23221 if (TREE_CODE (decl
) == FUNCTION_DECL
)
23225 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
23226 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
23227 if (DECL_INITIAL (decl
) != NULL_TREE
23228 && DECL_INITIAL (decl
) != error_mark_node
)
23229 set_block_origin_self (DECL_INITIAL (decl
));
23234 /* Mark the early DIE for DECL as the abstract instance. */
23237 dwarf2out_abstract_function (tree decl
)
23239 dw_die_ref old_die
;
23241 /* Make sure we have the actual abstract inline, not a clone. */
23242 decl
= DECL_ORIGIN (decl
);
23244 if (DECL_IGNORED_P (decl
))
23247 /* In LTO we're all set. We already created abstract instances
23248 early and we want to avoid creating a concrete instance of that
23249 if we don't output it. */
23253 old_die
= lookup_decl_die (decl
);
23254 gcc_assert (old_die
!= NULL
);
23255 if (get_AT (old_die
, DW_AT_inline
))
23256 /* We've already generated the abstract instance. */
23259 /* Go ahead and put DW_AT_inline on the DIE. */
23260 if (DECL_DECLARED_INLINE_P (decl
))
23262 if (cgraph_function_possibly_inlined_p (decl
))
23263 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_inlined
);
23265 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
23269 if (cgraph_function_possibly_inlined_p (decl
))
23270 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_inlined
);
23272 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_not_inlined
);
23275 if (DECL_DECLARED_INLINE_P (decl
)
23276 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
23277 add_AT_flag (old_die
, DW_AT_artificial
, 1);
23279 set_decl_origin_self (decl
);
23282 /* Helper function of premark_used_types() which gets called through
23285 Marks the DIE of a given type in *SLOT as perennial, so it never gets
23286 marked as unused by prune_unused_types. */
23289 premark_used_types_helper (tree
const &type
, void *)
23293 die
= lookup_type_die (type
);
23295 die
->die_perennial_p
= 1;
23299 /* Helper function of premark_types_used_by_global_vars which gets called
23300 through htab_traverse.
23302 Marks the DIE of a given type in *SLOT as perennial, so it never gets
23303 marked as unused by prune_unused_types. The DIE of the type is marked
23304 only if the global variable using the type will actually be emitted. */
23307 premark_types_used_by_global_vars_helper (types_used_by_vars_entry
**slot
,
23310 struct types_used_by_vars_entry
*entry
;
23313 entry
= (struct types_used_by_vars_entry
*) *slot
;
23314 gcc_assert (entry
->type
!= NULL
23315 && entry
->var_decl
!= NULL
);
23316 die
= lookup_type_die (entry
->type
);
23319 /* Ask cgraph if the global variable really is to be emitted.
23320 If yes, then we'll keep the DIE of ENTRY->TYPE. */
23321 varpool_node
*node
= varpool_node::get (entry
->var_decl
);
23322 if (node
&& node
->definition
)
23324 die
->die_perennial_p
= 1;
23325 /* Keep the parent DIEs as well. */
23326 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
23327 die
->die_perennial_p
= 1;
23333 /* Mark all members of used_types_hash as perennial. */
23336 premark_used_types (struct function
*fun
)
23338 if (fun
&& fun
->used_types_hash
)
23339 fun
->used_types_hash
->traverse
<void *, premark_used_types_helper
> (NULL
);
23342 /* Mark all members of types_used_by_vars_entry as perennial. */
23345 premark_types_used_by_global_vars (void)
23347 if (types_used_by_vars_hash
)
23348 types_used_by_vars_hash
23349 ->traverse
<void *, premark_types_used_by_global_vars_helper
> (NULL
);
23352 /* Mark all variables used by the symtab as perennial. */
23355 premark_used_variables (void)
23357 /* Mark DIEs in the symtab as used. */
23359 FOR_EACH_VARIABLE (var
)
23361 dw_die_ref die
= lookup_decl_die (var
->decl
);
23363 die
->die_perennial_p
= 1;
23367 /* Generate a DW_TAG_call_site DIE in function DECL under SUBR_DIE
23368 for CA_LOC call arg loc node. */
23371 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
23372 struct call_arg_loc_node
*ca_loc
)
23374 dw_die_ref stmt_die
= NULL
, die
;
23375 tree block
= ca_loc
->block
;
23378 && block
!= DECL_INITIAL (decl
)
23379 && TREE_CODE (block
) == BLOCK
)
23381 stmt_die
= lookup_block_die (block
);
23384 block
= BLOCK_SUPERCONTEXT (block
);
23386 if (stmt_die
== NULL
)
23387 stmt_die
= subr_die
;
23388 die
= new_die (dwarf_TAG (DW_TAG_call_site
), stmt_die
, NULL_TREE
);
23389 add_AT_lbl_id (die
, dwarf_AT (DW_AT_call_return_pc
), ca_loc
->label
);
23390 if (ca_loc
->tail_call_p
)
23391 add_AT_flag (die
, dwarf_AT (DW_AT_call_tail_call
), 1);
23392 if (ca_loc
->symbol_ref
)
23394 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
23396 add_AT_die_ref (die
, dwarf_AT (DW_AT_call_origin
), tdie
);
23398 add_AT_addr (die
, dwarf_AT (DW_AT_call_origin
), ca_loc
->symbol_ref
,
23404 /* Generate a DIE to represent a declared function (either file-scope or
23408 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
23410 tree origin
= decl_ultimate_origin (decl
);
23411 dw_die_ref subr_die
;
23412 dw_die_ref old_die
= lookup_decl_die (decl
);
23413 bool old_die_had_no_children
= false;
23415 /* This function gets called multiple times for different stages of
23416 the debug process. For example, for func() in this code:
23420 void func() { ... }
23423 ...we get called 4 times. Twice in early debug and twice in
23429 1. Once while generating func() within the namespace. This is
23430 the declaration. The declaration bit below is set, as the
23431 context is the namespace.
23433 A new DIE will be generated with DW_AT_declaration set.
23435 2. Once for func() itself. This is the specification. The
23436 declaration bit below is clear as the context is the CU.
23438 We will use the cached DIE from (1) to create a new DIE with
23439 DW_AT_specification pointing to the declaration in (1).
23441 Late debug via rest_of_handle_final()
23442 -------------------------------------
23444 3. Once generating func() within the namespace. This is also the
23445 declaration, as in (1), but this time we will early exit below
23446 as we have a cached DIE and a declaration needs no additional
23447 annotations (no locations), as the source declaration line
23450 4. Once for func() itself. As in (2), this is the specification,
23451 but this time we will re-use the cached DIE, and just annotate
23452 it with the location information that should now be available.
23454 For something without namespaces, but with abstract instances, we
23455 are also called a multiple times:
23460 Base (); // constructor declaration (1)
23463 Base::Base () { } // constructor specification (2)
23468 1. Once for the Base() constructor by virtue of it being a
23469 member of the Base class. This is done via
23470 rest_of_type_compilation.
23472 This is a declaration, so a new DIE will be created with
23475 2. Once for the Base() constructor definition, but this time
23476 while generating the abstract instance of the base
23477 constructor (__base_ctor) which is being generated via early
23478 debug of reachable functions.
23480 Even though we have a cached version of the declaration (1),
23481 we will create a DW_AT_specification of the declaration DIE
23484 3. Once for the __base_ctor itself, but this time, we generate
23485 an DW_AT_abstract_origin version of the DW_AT_specification in
23488 Late debug via rest_of_handle_final
23489 -----------------------------------
23491 4. One final time for the __base_ctor (which will have a cached
23492 DIE with DW_AT_abstract_origin created in (3). This time,
23493 we will just annotate the location information now
23496 int declaration
= (current_function_decl
!= decl
23497 || (!DECL_INITIAL (decl
) && !origin
)
23498 || class_or_namespace_scope_p (context_die
));
23500 /* A declaration that has been previously dumped needs no
23501 additional information. */
23502 if (old_die
&& declaration
)
23505 if (in_lto_p
&& old_die
&& old_die
->die_child
== NULL
)
23506 old_die_had_no_children
= true;
23508 /* Now that the C++ front end lazily declares artificial member fns, we
23509 might need to retrofit the declaration into its class. */
23510 if (!declaration
&& !origin
&& !old_die
23511 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
23512 && !class_or_namespace_scope_p (context_die
)
23513 && debug_info_level
> DINFO_LEVEL_TERSE
)
23514 old_die
= force_decl_die (decl
);
23516 /* A concrete instance, tag a new DIE with DW_AT_abstract_origin. */
23517 if (origin
!= NULL
)
23519 gcc_assert (!declaration
|| local_scope_p (context_die
));
23521 /* Fixup die_parent for the abstract instance of a nested
23522 inline function. */
23523 if (old_die
&& old_die
->die_parent
== NULL
)
23524 add_child_die (context_die
, old_die
);
23526 if (old_die
&& get_AT_ref (old_die
, DW_AT_abstract_origin
))
23528 /* If we have a DW_AT_abstract_origin we have a working
23530 subr_die
= old_die
;
23534 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
23535 add_abstract_origin_attribute (subr_die
, origin
);
23536 /* This is where the actual code for a cloned function is.
23537 Let's emit linkage name attribute for it. This helps
23538 debuggers to e.g, set breakpoints into
23539 constructors/destructors when the user asks "break
23541 add_linkage_name (subr_die
, decl
);
23544 /* A cached copy, possibly from early dwarf generation. Reuse as
23545 much as possible. */
23548 if (!get_AT_flag (old_die
, DW_AT_declaration
)
23549 /* We can have a normal definition following an inline one in the
23550 case of redefinition of GNU C extern inlines.
23551 It seems reasonable to use AT_specification in this case. */
23552 && !get_AT (old_die
, DW_AT_inline
))
23554 /* Detect and ignore this case, where we are trying to output
23555 something we have already output. */
23556 if (get_AT (old_die
, DW_AT_low_pc
)
23557 || get_AT (old_die
, DW_AT_ranges
))
23560 /* If we have no location information, this must be a
23561 partially generated DIE from early dwarf generation.
23562 Fall through and generate it. */
23565 /* If the definition comes from the same place as the declaration,
23566 maybe use the old DIE. We always want the DIE for this function
23567 that has the *_pc attributes to be under comp_unit_die so the
23568 debugger can find it. We also need to do this for abstract
23569 instances of inlines, since the spec requires the out-of-line copy
23570 to have the same parent. For local class methods, this doesn't
23571 apply; we just use the old DIE. */
23572 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
23573 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
23574 if (((is_unit_die (old_die
->die_parent
)
23575 /* This condition fixes the inconsistency/ICE with the
23576 following Fortran test (or some derivative thereof) while
23577 building libgfortran:
23581 logical function funky (FLAG)
23586 || (old_die
->die_parent
23587 && old_die
->die_parent
->die_tag
== DW_TAG_module
)
23588 || local_scope_p (old_die
->die_parent
)
23589 || context_die
== NULL
)
23590 && (DECL_ARTIFICIAL (decl
)
23591 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
23592 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
23593 == (unsigned) s
.line
)
23594 && (!debug_column_info
23596 || (get_AT_unsigned (old_die
, DW_AT_decl_column
)
23597 == (unsigned) s
.column
)))))
23598 /* With LTO if there's an abstract instance for
23599 the old DIE, this is a concrete instance and
23600 thus re-use the DIE. */
23601 || get_AT (old_die
, DW_AT_abstract_origin
))
23603 subr_die
= old_die
;
23605 /* Clear out the declaration attribute, but leave the
23606 parameters so they can be augmented with location
23607 information later. Unless this was a declaration, in
23608 which case, wipe out the nameless parameters and recreate
23609 them further down. */
23610 if (remove_AT (subr_die
, DW_AT_declaration
))
23613 remove_AT (subr_die
, DW_AT_object_pointer
);
23614 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
23617 /* Make a specification pointing to the previously built
23621 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
23622 add_AT_specification (subr_die
, old_die
);
23623 add_pubname (decl
, subr_die
);
23624 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
23625 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
23626 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
23627 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
23628 if (debug_column_info
23630 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
23631 != (unsigned) s
.column
))
23632 add_AT_unsigned (subr_die
, DW_AT_decl_column
, s
.column
);
23634 /* If the prototype had an 'auto' or 'decltype(auto)' in
23635 the return type, emit the real type on the definition die. */
23636 if (is_cxx () && debug_info_level
> DINFO_LEVEL_TERSE
)
23638 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
23640 && (die
->die_tag
== DW_TAG_reference_type
23641 || die
->die_tag
== DW_TAG_rvalue_reference_type
23642 || die
->die_tag
== DW_TAG_pointer_type
23643 || die
->die_tag
== DW_TAG_const_type
23644 || die
->die_tag
== DW_TAG_volatile_type
23645 || die
->die_tag
== DW_TAG_restrict_type
23646 || die
->die_tag
== DW_TAG_array_type
23647 || die
->die_tag
== DW_TAG_ptr_to_member_type
23648 || die
->die_tag
== DW_TAG_subroutine_type
))
23649 die
= get_AT_ref (die
, DW_AT_type
);
23650 if (die
== auto_die
|| die
== decltype_auto_die
)
23651 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
23652 TYPE_UNQUALIFIED
, false, context_die
);
23655 /* When we process the method declaration, we haven't seen
23656 the out-of-class defaulted definition yet, so we have to
23658 if ((dwarf_version
>= 5 || ! dwarf_strict
)
23659 && !get_AT (subr_die
, DW_AT_defaulted
))
23662 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23664 if (defaulted
!= -1)
23666 /* Other values must have been handled before. */
23667 gcc_assert (defaulted
== DW_DEFAULTED_out_of_class
);
23668 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
23673 /* Create a fresh DIE for anything else. */
23676 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
23678 if (TREE_PUBLIC (decl
))
23679 add_AT_flag (subr_die
, DW_AT_external
, 1);
23681 add_name_and_src_coords_attributes (subr_die
, decl
);
23682 add_pubname (decl
, subr_die
);
23683 if (debug_info_level
> DINFO_LEVEL_TERSE
)
23685 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
23686 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
23687 TYPE_UNQUALIFIED
, false, context_die
);
23690 add_pure_or_virtual_attribute (subr_die
, decl
);
23691 if (DECL_ARTIFICIAL (decl
))
23692 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
23694 if (TREE_THIS_VOLATILE (decl
) && (dwarf_version
>= 5 || !dwarf_strict
))
23695 add_AT_flag (subr_die
, DW_AT_noreturn
, 1);
23697 add_alignment_attribute (subr_die
, decl
);
23699 add_accessibility_attribute (subr_die
, decl
);
23702 /* Unless we have an existing non-declaration DIE, equate the new
23704 if (!old_die
|| is_declaration_die (old_die
))
23705 equate_decl_number_to_die (decl
, subr_die
);
23709 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
23711 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
23713 /* If this is an explicit function declaration then generate
23714 a DW_AT_explicit attribute. */
23715 if ((dwarf_version
>= 3 || !dwarf_strict
)
23716 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23717 DW_AT_explicit
) == 1)
23718 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
23720 /* If this is a C++11 deleted special function member then generate
23721 a DW_AT_deleted attribute. */
23722 if ((dwarf_version
>= 5 || !dwarf_strict
)
23723 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23724 DW_AT_deleted
) == 1)
23725 add_AT_flag (subr_die
, DW_AT_deleted
, 1);
23727 /* If this is a C++11 defaulted special function member then
23728 generate a DW_AT_defaulted attribute. */
23729 if (dwarf_version
>= 5 || !dwarf_strict
)
23732 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23734 if (defaulted
!= -1)
23735 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
23738 /* If this is a C++11 non-static member function with & ref-qualifier
23739 then generate a DW_AT_reference attribute. */
23740 if ((dwarf_version
>= 5 || !dwarf_strict
)
23741 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23742 DW_AT_reference
) == 1)
23743 add_AT_flag (subr_die
, DW_AT_reference
, 1);
23745 /* If this is a C++11 non-static member function with &&
23746 ref-qualifier then generate a DW_AT_reference attribute. */
23747 if ((dwarf_version
>= 5 || !dwarf_strict
)
23748 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23749 DW_AT_rvalue_reference
)
23751 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
23754 /* For non DECL_EXTERNALs, if range information is available, fill
23755 the DIE with it. */
23756 else if (!DECL_EXTERNAL (decl
) && !early_dwarf
)
23758 HOST_WIDE_INT cfa_fb_offset
;
23760 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
23762 if (!crtl
->has_bb_partition
)
23764 dw_fde_ref fde
= fun
->fde
;
23765 if (fde
->dw_fde_begin
)
23767 /* We have already generated the labels. */
23768 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
23769 fde
->dw_fde_end
, false);
23773 /* Create start/end labels and add the range. */
23774 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
23775 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
23776 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
23777 current_function_funcdef_no
);
23778 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
23779 current_function_funcdef_no
);
23780 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
23784 #if VMS_DEBUGGING_INFO
23785 /* HP OpenVMS Industry Standard 64: DWARF Extensions
23786 Section 2.3 Prologue and Epilogue Attributes:
23787 When a breakpoint is set on entry to a function, it is generally
23788 desirable for execution to be suspended, not on the very first
23789 instruction of the function, but rather at a point after the
23790 function's frame has been set up, after any language defined local
23791 declaration processing has been completed, and before execution of
23792 the first statement of the function begins. Debuggers generally
23793 cannot properly determine where this point is. Similarly for a
23794 breakpoint set on exit from a function. The prologue and epilogue
23795 attributes allow a compiler to communicate the location(s) to use. */
23798 if (fde
->dw_fde_vms_end_prologue
)
23799 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
23800 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
23802 if (fde
->dw_fde_vms_begin_epilogue
)
23803 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
23804 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
23811 /* Generate pubnames entries for the split function code ranges. */
23812 dw_fde_ref fde
= fun
->fde
;
23814 if (fde
->dw_fde_second_begin
)
23816 if (dwarf_version
>= 3 || !dwarf_strict
)
23818 /* We should use ranges for non-contiguous code section
23819 addresses. Use the actual code range for the initial
23820 section, since the HOT/COLD labels might precede an
23821 alignment offset. */
23822 bool range_list_added
= false;
23823 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
23824 fde
->dw_fde_end
, &range_list_added
,
23826 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
23827 fde
->dw_fde_second_end
,
23828 &range_list_added
, false);
23829 if (range_list_added
)
23834 /* There is no real support in DW2 for this .. so we make
23835 a work-around. First, emit the pub name for the segment
23836 containing the function label. Then make and emit a
23837 simplified subprogram DIE for the second segment with the
23838 name pre-fixed by __hot/cold_sect_of_. We use the same
23839 linkage name for the second die so that gdb will find both
23840 sections when given "b foo". */
23841 const char *name
= NULL
;
23842 tree decl_name
= DECL_NAME (decl
);
23843 dw_die_ref seg_die
;
23845 /* Do the 'primary' section. */
23846 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
23847 fde
->dw_fde_end
, false);
23849 /* Build a minimal DIE for the secondary section. */
23850 seg_die
= new_die (DW_TAG_subprogram
,
23851 subr_die
->die_parent
, decl
);
23853 if (TREE_PUBLIC (decl
))
23854 add_AT_flag (seg_die
, DW_AT_external
, 1);
23856 if (decl_name
!= NULL
23857 && IDENTIFIER_POINTER (decl_name
) != NULL
)
23859 name
= dwarf2_name (decl
, 1);
23860 if (! DECL_ARTIFICIAL (decl
))
23861 add_src_coords_attributes (seg_die
, decl
);
23863 add_linkage_name (seg_die
, decl
);
23865 gcc_assert (name
!= NULL
);
23866 add_pure_or_virtual_attribute (seg_die
, decl
);
23867 if (DECL_ARTIFICIAL (decl
))
23868 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
23870 name
= concat ("__second_sect_of_", name
, NULL
);
23871 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
23872 fde
->dw_fde_second_end
, false);
23873 add_name_attribute (seg_die
, name
);
23874 if (want_pubnames ())
23875 add_pubname_string (name
, seg_die
);
23879 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
23883 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
23885 /* We define the "frame base" as the function's CFA. This is more
23886 convenient for several reasons: (1) It's stable across the prologue
23887 and epilogue, which makes it better than just a frame pointer,
23888 (2) With dwarf3, there exists a one-byte encoding that allows us
23889 to reference the .debug_frame data by proxy, but failing that,
23890 (3) We can at least reuse the code inspection and interpretation
23891 code that determines the CFA position at various points in the
23893 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
23895 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
23896 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
23900 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
23901 if (list
->dw_loc_next
)
23902 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
23904 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
23907 /* Compute a displacement from the "steady-state frame pointer" to
23908 the CFA. The former is what all stack slots and argument slots
23909 will reference in the rtl; the latter is what we've told the
23910 debugger about. We'll need to adjust all frame_base references
23911 by this displacement. */
23912 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
23914 if (fun
->static_chain_decl
)
23916 /* DWARF requires here a location expression that computes the
23917 address of the enclosing subprogram's frame base. The machinery
23918 in tree-nested.cc is supposed to store this specific address in the
23919 last field of the FRAME record. */
23920 const tree frame_type
23921 = TREE_TYPE (TREE_TYPE (fun
->static_chain_decl
));
23922 const tree fb_decl
= tree_last (TYPE_FIELDS (frame_type
));
23925 = build1 (INDIRECT_REF
, frame_type
, fun
->static_chain_decl
);
23926 fb_expr
= build3 (COMPONENT_REF
, TREE_TYPE (fb_decl
),
23927 fb_expr
, fb_decl
, NULL_TREE
);
23929 add_AT_location_description (subr_die
, DW_AT_static_link
,
23930 loc_list_from_tree (fb_expr
, 0, NULL
));
23933 resolve_variable_values ();
23936 /* Generate child dies for template parameters. */
23937 if (early_dwarf
&& debug_info_level
> DINFO_LEVEL_TERSE
)
23938 gen_generic_params_dies (decl
);
23940 /* Now output descriptions of the arguments for this function. This gets
23941 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
23942 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
23943 `...' at the end of the formal parameter list. In order to find out if
23944 there was a trailing ellipsis or not, we must instead look at the type
23945 associated with the FUNCTION_DECL. This will be a node of type
23946 FUNCTION_TYPE. If the chain of type nodes hanging off of this
23947 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
23948 an ellipsis at the end. */
23950 /* In the case where we are describing a mere function declaration, all we
23951 need to do here (and all we *can* do here) is to describe the *types* of
23952 its formal parameters. */
23953 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
23955 else if (declaration
)
23956 gen_formal_types_die (decl
, subr_die
);
23959 /* Generate DIEs to represent all known formal parameters. */
23960 tree parm
= DECL_ARGUMENTS (decl
);
23961 tree generic_decl
= early_dwarf
23962 ? lang_hooks
.decls
.get_generic_function_decl (decl
) : NULL
;
23963 tree generic_decl_parm
= generic_decl
23964 ? DECL_ARGUMENTS (generic_decl
)
23967 /* Now we want to walk the list of parameters of the function and
23968 emit their relevant DIEs.
23970 We consider the case of DECL being an instance of a generic function
23971 as well as it being a normal function.
23973 If DECL is an instance of a generic function we walk the
23974 parameters of the generic function declaration _and_ the parameters of
23975 DECL itself. This is useful because we want to emit specific DIEs for
23976 function parameter packs and those are declared as part of the
23977 generic function declaration. In that particular case,
23978 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
23979 That DIE has children DIEs representing the set of arguments
23980 of the pack. Note that the set of pack arguments can be empty.
23981 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
23984 Otherwise, we just consider the parameters of DECL. */
23985 while (generic_decl_parm
|| parm
)
23987 if (generic_decl_parm
23988 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
23989 gen_formal_parameter_pack_die (generic_decl_parm
,
23994 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, NULL
, subr_die
);
23997 && parm
== DECL_ARGUMENTS (decl
)
23998 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
24000 && (dwarf_version
>= 3 || !dwarf_strict
))
24001 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
24003 parm
= DECL_CHAIN (parm
);
24006 if (generic_decl_parm
)
24007 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
24010 /* Decide whether we need an unspecified_parameters DIE at the end.
24011 There are 2 more cases to do this for: 1) the ansi ... declaration -
24012 this is detectable when the end of the arg list is not a
24013 void_type_node 2) an unprototyped function declaration (not a
24014 definition). This just means that we have no info about the
24015 parameters at all. */
24018 if (prototype_p (TREE_TYPE (decl
)))
24020 /* This is the prototyped case, check for.... */
24021 if (stdarg_p (TREE_TYPE (decl
)))
24022 gen_unspecified_parameters_die (decl
, subr_die
);
24024 else if (DECL_INITIAL (decl
) == NULL_TREE
)
24025 gen_unspecified_parameters_die (decl
, subr_die
);
24027 else if ((subr_die
!= old_die
|| old_die_had_no_children
)
24028 && prototype_p (TREE_TYPE (decl
))
24029 && stdarg_p (TREE_TYPE (decl
)))
24030 gen_unspecified_parameters_die (decl
, subr_die
);
24033 if (subr_die
!= old_die
)
24034 /* Add the calling convention attribute if requested. */
24035 add_calling_convention_attribute (subr_die
, decl
);
24037 /* Output Dwarf info for all of the stuff within the body of the function
24038 (if it has one - it may be just a declaration).
24040 OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
24041 a function. This BLOCK actually represents the outermost binding contour
24042 for the function, i.e. the contour in which the function's formal
24043 parameters and labels get declared. Curiously, it appears that the front
24044 end doesn't actually put the PARM_DECL nodes for the current function onto
24045 the BLOCK_VARS list for this outer scope, but are strung off of the
24046 DECL_ARGUMENTS list for the function instead.
24048 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
24049 the LABEL_DECL nodes for the function however, and we output DWARF info
24050 for those in decls_for_scope. Just within the `outer_scope' there will be
24051 a BLOCK node representing the function's outermost pair of curly braces,
24052 and any blocks used for the base and member initializers of a C++
24053 constructor function. */
24054 tree outer_scope
= DECL_INITIAL (decl
);
24055 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
24057 int call_site_note_count
= 0;
24058 int tail_call_site_note_count
= 0;
24060 /* Emit a DW_TAG_variable DIE for a named return value. */
24061 if (DECL_NAME (DECL_RESULT (decl
)))
24062 gen_decl_die (DECL_RESULT (decl
), NULL
, NULL
, subr_die
);
24064 /* The first time through decls_for_scope we will generate the
24065 DIEs for the locals. The second time, we fill in the
24067 decls_for_scope (outer_scope
, subr_die
);
24069 if (call_arg_locations
&& (!dwarf_strict
|| dwarf_version
>= 5))
24071 struct call_arg_loc_node
*ca_loc
;
24072 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
24074 dw_die_ref die
= NULL
;
24075 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
24077 tree arg_decl
= NULL_TREE
;
24079 for (arg
= (ca_loc
->call_arg_loc_note
!= NULL_RTX
24080 ? XEXP (ca_loc
->call_arg_loc_note
, 0)
24082 arg
; arg
= next_arg
)
24084 dw_loc_descr_ref reg
, val
;
24085 machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
24086 dw_die_ref cdie
, tdie
= NULL
;
24088 next_arg
= XEXP (arg
, 1);
24089 if (REG_P (XEXP (XEXP (arg
, 0), 0))
24091 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
24092 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
24093 && REGNO (XEXP (XEXP (arg
, 0), 0))
24094 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
24095 next_arg
= XEXP (next_arg
, 1);
24096 if (mode
== VOIDmode
)
24098 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
24099 if (mode
== VOIDmode
)
24100 mode
= GET_MODE (XEXP (arg
, 0));
24102 if (mode
== VOIDmode
|| mode
== BLKmode
)
24104 /* Get dynamic information about call target only if we
24105 have no static information: we cannot generate both
24106 DW_AT_call_origin and DW_AT_call_target
24108 if (ca_loc
->symbol_ref
== NULL_RTX
)
24110 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
24112 tloc
= XEXP (XEXP (arg
, 0), 1);
24115 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
24116 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
24118 tlocc
= XEXP (XEXP (arg
, 0), 1);
24123 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
24124 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
24125 VAR_INIT_STATUS_INITIALIZED
);
24126 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
24128 rtx mem
= XEXP (XEXP (arg
, 0), 0);
24129 reg
= mem_loc_descriptor (XEXP (mem
, 0),
24130 get_address_mode (mem
),
24132 VAR_INIT_STATUS_INITIALIZED
);
24134 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
24135 == DEBUG_PARAMETER_REF
)
24138 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
24139 tdie
= lookup_decl_die (tdecl
);
24147 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
24148 != DEBUG_PARAMETER_REF
)
24150 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
24152 VAR_INIT_STATUS_INITIALIZED
);
24156 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
24157 cdie
= new_die (dwarf_TAG (DW_TAG_call_site_parameter
), die
,
24159 add_desc_attribute (cdie
, arg_decl
);
24161 add_AT_loc (cdie
, DW_AT_location
, reg
);
24162 else if (tdie
!= NULL
)
24163 add_AT_die_ref (cdie
, dwarf_AT (DW_AT_call_parameter
),
24165 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_value
), val
);
24166 if (next_arg
!= XEXP (arg
, 1))
24168 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
24169 if (mode
== VOIDmode
)
24170 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
24171 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
24174 VAR_INIT_STATUS_INITIALIZED
);
24176 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_data_value
),
24181 && (ca_loc
->symbol_ref
|| tloc
))
24182 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
24183 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
24185 dw_loc_descr_ref tval
= NULL
;
24187 if (tloc
!= NULL_RTX
)
24188 tval
= mem_loc_descriptor (tloc
,
24189 GET_MODE (tloc
) == VOIDmode
24190 ? Pmode
: GET_MODE (tloc
),
24192 VAR_INIT_STATUS_INITIALIZED
);
24194 add_AT_loc (die
, dwarf_AT (DW_AT_call_target
), tval
);
24195 else if (tlocc
!= NULL_RTX
)
24197 tval
= mem_loc_descriptor (tlocc
,
24198 GET_MODE (tlocc
) == VOIDmode
24199 ? Pmode
: GET_MODE (tlocc
),
24201 VAR_INIT_STATUS_INITIALIZED
);
24204 dwarf_AT (DW_AT_call_target_clobbered
),
24210 call_site_note_count
++;
24211 if (ca_loc
->tail_call_p
)
24212 tail_call_site_note_count
++;
24216 call_arg_locations
= NULL
;
24217 call_arg_loc_last
= NULL
;
24218 if (tail_call_site_count
>= 0
24219 && tail_call_site_count
== tail_call_site_note_count
24220 && (!dwarf_strict
|| dwarf_version
>= 5))
24222 if (call_site_count
>= 0
24223 && call_site_count
== call_site_note_count
)
24224 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_calls
), 1);
24226 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_tail_calls
), 1);
24228 call_site_count
= -1;
24229 tail_call_site_count
= -1;
24232 /* Mark used types after we have created DIEs for the functions scopes. */
24233 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
24236 /* Returns a hash value for X (which really is a die_struct). */
24239 block_die_hasher::hash (die_struct
*d
)
24241 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
24244 /* Return nonzero if decl_id and die_parent of die_struct X is the same
24245 as decl_id and die_parent of die_struct Y. */
24248 block_die_hasher::equal (die_struct
*x
, die_struct
*y
)
24250 return x
->decl_id
== y
->decl_id
&& x
->die_parent
== y
->die_parent
;
24253 /* Hold information about markers for inlined entry points. */
24254 struct GTY ((for_user
)) inline_entry_data
24256 /* The block that's the inlined_function_outer_scope for an inlined
24260 /* The label at the inlined entry point. */
24261 const char *label_pfx
;
24262 unsigned int label_num
;
24264 /* The view number to be used as the inlined entry point. */
24268 struct inline_entry_data_hasher
: ggc_ptr_hash
<inline_entry_data
>
24270 typedef tree compare_type
;
24271 static inline hashval_t
hash (const inline_entry_data
*);
24272 static inline bool equal (const inline_entry_data
*, const_tree
);
24275 /* Hash table routines for inline_entry_data. */
24278 inline_entry_data_hasher::hash (const inline_entry_data
*data
)
24280 return htab_hash_pointer (data
->block
);
24284 inline_entry_data_hasher::equal (const inline_entry_data
*data
,
24287 return data
->block
== block
;
24290 /* Inlined entry points pending DIE creation in this compilation unit. */
24292 static GTY(()) hash_table
<inline_entry_data_hasher
> *inline_entry_data_table
;
24295 /* Return TRUE if DECL, which may have been previously generated as
24296 OLD_DIE, is a candidate for a DW_AT_specification. DECLARATION is
24297 true if decl (or its origin) is either an extern declaration or a
24298 class/namespace scoped declaration.
24300 The declare_in_namespace support causes us to get two DIEs for one
24301 variable, both of which are declarations. We want to avoid
24302 considering one to be a specification, so we must test for
24303 DECLARATION and DW_AT_declaration. */
24305 decl_will_get_specification_p (dw_die_ref old_die
, tree decl
, bool declaration
)
24307 return (old_die
&& TREE_STATIC (decl
) && !declaration
24308 && get_AT_flag (old_die
, DW_AT_declaration
) == 1);
24311 /* Return true if DECL is a local static. */
24314 local_function_static (tree decl
)
24316 gcc_assert (VAR_P (decl
));
24317 return TREE_STATIC (decl
)
24318 && DECL_CONTEXT (decl
)
24319 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
;
24322 /* Return true iff DECL overrides (presumably completes) the type of
24323 OLD_DIE within CONTEXT_DIE. */
24326 override_type_for_decl_p (tree decl
, dw_die_ref old_die
,
24327 dw_die_ref context_die
)
24329 tree type
= TREE_TYPE (decl
);
24332 if (decl_by_reference_p (decl
))
24334 type
= TREE_TYPE (type
);
24335 cv_quals
= TYPE_UNQUALIFIED
;
24338 cv_quals
= decl_quals (decl
);
24340 dw_die_ref type_die
= modified_type_die (type
,
24341 cv_quals
| TYPE_QUALS (type
),
24345 dw_die_ref old_type_die
= get_AT_ref (old_die
, DW_AT_type
);
24347 return type_die
!= old_type_die
;
24350 /* Generate a DIE to represent a declared data object.
24351 Either DECL or ORIGIN must be non-null. */
24354 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
24356 HOST_WIDE_INT off
= 0;
24358 tree decl_or_origin
= decl
? decl
: origin
;
24359 tree ultimate_origin
;
24360 dw_die_ref var_die
;
24361 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
24362 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
24363 || class_or_namespace_scope_p (context_die
));
24364 bool specialization_p
= false;
24365 bool no_linkage_name
= false;
24367 /* While C++ inline static data members have definitions inside of the
24368 class, force the first DIE to be a declaration, then let gen_member_die
24369 reparent it to the class context and call gen_variable_die again
24370 to create the outside of the class DIE for the definition. */
24374 && DECL_CONTEXT (decl
)
24375 && TYPE_P (DECL_CONTEXT (decl
))
24376 && lang_hooks
.decls
.decl_dwarf_attribute (decl
, DW_AT_inline
) != -1)
24378 declaration
= true;
24379 if (dwarf_version
< 5)
24380 no_linkage_name
= true;
24383 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
24384 if (decl
|| ultimate_origin
)
24385 origin
= ultimate_origin
;
24386 com_decl
= fortran_common (decl_or_origin
, &off
);
24388 /* Symbol in common gets emitted as a child of the common block, in the form
24389 of a data member. */
24392 dw_die_ref com_die
;
24393 dw_loc_list_ref loc
= NULL
;
24394 die_node com_die_arg
;
24396 var_die
= lookup_decl_die (decl_or_origin
);
24399 if (! early_dwarf
&& get_AT (var_die
, DW_AT_location
) == NULL
)
24401 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2, NULL
);
24406 /* Optimize the common case. */
24407 if (single_element_loc_list_p (loc
)
24408 && loc
->expr
->dw_loc_opc
== DW_OP_addr
24409 && loc
->expr
->dw_loc_next
== NULL
24410 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
24413 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
24414 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
24415 = plus_constant (GET_MODE (x
), x
, off
);
24418 loc_list_plus_const (loc
, off
);
24420 add_AT_location_description (var_die
, DW_AT_location
, loc
);
24421 remove_AT (var_die
, DW_AT_declaration
);
24427 if (common_block_die_table
== NULL
)
24428 common_block_die_table
= hash_table
<block_die_hasher
>::create_ggc (10);
24430 com_die_arg
.decl_id
= DECL_UID (com_decl
);
24431 com_die_arg
.die_parent
= context_die
;
24432 com_die
= common_block_die_table
->find (&com_die_arg
);
24434 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
24435 if (com_die
== NULL
)
24438 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
24441 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
24442 add_name_and_src_coords_attributes (com_die
, com_decl
);
24445 add_AT_location_description (com_die
, DW_AT_location
, loc
);
24446 /* Avoid sharing the same loc descriptor between
24447 DW_TAG_common_block and DW_TAG_variable. */
24448 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
24450 else if (DECL_EXTERNAL (decl_or_origin
))
24451 add_AT_flag (com_die
, DW_AT_declaration
, 1);
24452 if (want_pubnames ())
24453 add_pubname_string (cnam
, com_die
); /* ??? needed? */
24454 com_die
->decl_id
= DECL_UID (com_decl
);
24455 slot
= common_block_die_table
->find_slot (com_die
, INSERT
);
24458 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
24460 add_AT_location_description (com_die
, DW_AT_location
, loc
);
24461 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
24462 remove_AT (com_die
, DW_AT_declaration
);
24464 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
24465 add_name_and_src_coords_attributes (var_die
, decl_or_origin
);
24466 add_type_attribute (var_die
, TREE_TYPE (decl_or_origin
),
24467 decl_quals (decl_or_origin
), false,
24469 add_alignment_attribute (var_die
, decl
);
24470 add_AT_flag (var_die
, DW_AT_external
, 1);
24475 /* Optimize the common case. */
24476 if (single_element_loc_list_p (loc
)
24477 && loc
->expr
->dw_loc_opc
== DW_OP_addr
24478 && loc
->expr
->dw_loc_next
== NULL
24479 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
24481 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
24482 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
24483 = plus_constant (GET_MODE (x
), x
, off
);
24486 loc_list_plus_const (loc
, off
);
24488 add_AT_location_description (var_die
, DW_AT_location
, loc
);
24490 else if (DECL_EXTERNAL (decl_or_origin
))
24491 add_AT_flag (var_die
, DW_AT_declaration
, 1);
24493 equate_decl_number_to_die (decl
, var_die
);
24501 /* A declaration that has been previously dumped, needs no
24502 further annotations, since it doesn't need location on
24503 the second pass. */
24506 else if (decl_will_get_specification_p (old_die
, decl
, declaration
)
24507 && !get_AT (old_die
, DW_AT_specification
))
24509 /* Fall-thru so we can make a new variable die along with a
24510 DW_AT_specification. */
24512 else if (origin
&& old_die
->die_parent
!= context_die
)
24514 /* If we will be creating an inlined instance, we need a
24515 new DIE that will get annotated with
24516 DW_AT_abstract_origin. */
24517 gcc_assert (!DECL_ABSTRACT_P (decl
));
24521 /* If a DIE was dumped early, it still needs location info.
24522 Skip to where we fill the location bits. */
24525 /* ??? In LTRANS we cannot annotate early created variably
24526 modified type DIEs without copying them and adjusting all
24527 references to them. Thus we dumped them again. Also add a
24528 reference to them but beware of -g0 compile and -g link
24529 in which case the reference will be already present. */
24530 tree type
= TREE_TYPE (decl_or_origin
);
24532 && ! get_AT (var_die
, DW_AT_type
)
24533 && variably_modified_type_p
24534 (type
, decl_function_context (decl_or_origin
)))
24536 if (decl_by_reference_p (decl_or_origin
))
24537 add_type_attribute (var_die
, TREE_TYPE (type
),
24538 TYPE_UNQUALIFIED
, false, context_die
);
24540 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
),
24541 false, context_die
);
24544 goto gen_variable_die_location
;
24548 /* For static data members, the declaration in the class is supposed
24549 to have DW_TAG_member tag in DWARF{3,4} and we emit it for compatibility
24550 also in DWARF2; the specification should still be DW_TAG_variable
24551 referencing the DW_TAG_member DIE. */
24552 if (declaration
&& class_scope_p (context_die
) && dwarf_version
< 5)
24553 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
24555 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
24557 if (origin
!= NULL
)
24558 add_abstract_origin_attribute (var_die
, origin
);
24560 /* Loop unrolling can create multiple blocks that refer to the same
24561 static variable, so we must test for the DW_AT_declaration flag.
24563 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
24564 copy decls and set the DECL_ABSTRACT_P flag on them instead of
24567 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
24568 else if (decl_will_get_specification_p (old_die
, decl
, declaration
))
24570 /* This is a definition of a C++ class level static. */
24571 add_AT_specification (var_die
, old_die
);
24572 specialization_p
= true;
24573 if (DECL_NAME (decl
))
24575 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
24576 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
24578 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
24579 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
24581 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
24582 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
24584 if (debug_column_info
24586 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
24587 != (unsigned) s
.column
))
24588 add_AT_unsigned (var_die
, DW_AT_decl_column
, s
.column
);
24590 if (old_die
->die_tag
== DW_TAG_member
)
24591 add_linkage_name (var_die
, decl
);
24595 add_name_and_src_coords_attributes (var_die
, decl
, no_linkage_name
);
24597 if ((origin
== NULL
&& !specialization_p
)
24599 && !DECL_ABSTRACT_P (decl_or_origin
)
24600 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
24601 decl_function_context
24603 || (old_die
&& specialization_p
24604 && override_type_for_decl_p (decl_or_origin
, old_die
, context_die
)))
24606 tree type
= TREE_TYPE (decl_or_origin
);
24608 if (decl_by_reference_p (decl_or_origin
))
24609 add_type_attribute (var_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
24612 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
), false,
24616 if (origin
== NULL
&& !specialization_p
)
24618 if (TREE_PUBLIC (decl
))
24619 add_AT_flag (var_die
, DW_AT_external
, 1);
24621 if (DECL_ARTIFICIAL (decl
))
24622 add_AT_flag (var_die
, DW_AT_artificial
, 1);
24624 add_alignment_attribute (var_die
, decl
);
24626 add_accessibility_attribute (var_die
, decl
);
24630 add_AT_flag (var_die
, DW_AT_declaration
, 1);
24632 if (decl
&& (DECL_ABSTRACT_P (decl
)
24633 || !old_die
|| is_declaration_die (old_die
)))
24634 equate_decl_number_to_die (decl
, var_die
);
24636 gen_variable_die_location
:
24638 && (! DECL_ABSTRACT_P (decl_or_origin
)
24639 /* Local static vars are shared between all clones/inlines,
24640 so emit DW_AT_location on the abstract DIE if DECL_RTL is
24642 || (VAR_P (decl_or_origin
)
24643 && TREE_STATIC (decl_or_origin
)
24644 && DECL_RTL_SET_P (decl_or_origin
))))
24648 add_pubname (decl_or_origin
, var_die
);
24649 /* For global register variables, emit DW_AT_location if possible
24650 already during early_dwarf, as late_global_decl won't be usually
24652 if (DECL_HARD_REGISTER (decl_or_origin
)
24653 && TREE_STATIC (decl_or_origin
)
24654 && !decl_by_reference_p (decl_or_origin
)
24655 && !get_AT (var_die
, DW_AT_location
)
24656 && !get_AT (var_die
, DW_AT_const_value
)
24657 && DECL_RTL_SET_P (decl_or_origin
)
24658 && REG_P (DECL_RTL (decl_or_origin
)))
24660 dw_loc_descr_ref descr
24661 = reg_loc_descriptor (DECL_RTL (decl_or_origin
),
24662 VAR_INIT_STATUS_INITIALIZED
);
24664 add_AT_loc (var_die
, DW_AT_location
, descr
);
24668 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
24672 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
24674 if ((dwarf_version
>= 4 || !dwarf_strict
)
24675 && lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
24676 DW_AT_const_expr
) == 1
24677 && !get_AT (var_die
, DW_AT_const_expr
)
24678 && !specialization_p
)
24679 add_AT_flag (var_die
, DW_AT_const_expr
, 1);
24683 int inl
= lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
24686 && !get_AT (var_die
, DW_AT_inline
)
24687 && !specialization_p
)
24688 add_AT_unsigned (var_die
, DW_AT_inline
, inl
);
24692 /* Generate a DIE to represent a named constant. */
24695 gen_const_die (tree decl
, dw_die_ref context_die
)
24697 dw_die_ref const_die
;
24698 tree type
= TREE_TYPE (decl
);
24700 const_die
= lookup_decl_die (decl
);
24704 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
24705 equate_decl_number_to_die (decl
, const_die
);
24706 add_name_and_src_coords_attributes (const_die
, decl
);
24707 add_type_attribute (const_die
, type
, TYPE_QUAL_CONST
, false, context_die
);
24708 if (TREE_PUBLIC (decl
))
24709 add_AT_flag (const_die
, DW_AT_external
, 1);
24710 if (DECL_ARTIFICIAL (decl
))
24711 add_AT_flag (const_die
, DW_AT_artificial
, 1);
24712 tree_add_const_value_attribute_for_decl (const_die
, decl
);
24715 /* Generate a DIE to represent a label identifier. */
24718 gen_label_die (tree decl
, dw_die_ref context_die
)
24720 tree origin
= decl_ultimate_origin (decl
);
24721 dw_die_ref lbl_die
= lookup_decl_die (decl
);
24723 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
24727 lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
24728 equate_decl_number_to_die (decl
, lbl_die
);
24730 if (origin
!= NULL
)
24731 add_abstract_origin_attribute (lbl_die
, origin
);
24733 add_name_and_src_coords_attributes (lbl_die
, decl
);
24736 if (DECL_ABSTRACT_P (decl
))
24737 equate_decl_number_to_die (decl
, lbl_die
);
24738 else if (! early_dwarf
)
24740 insn
= DECL_RTL_IF_SET (decl
);
24742 /* Deleted labels are programmer specified labels which have been
24743 eliminated because of various optimizations. We still emit them
24744 here so that it is possible to put breakpoints on them. */
24748 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
24750 /* When optimization is enabled (via -O) some parts of the compiler
24751 (e.g. jump.cc and cse.cc) may try to delete CODE_LABEL insns which
24752 represent source-level labels which were explicitly declared by
24753 the user. This really shouldn't be happening though, so catch
24754 it if it ever does happen. */
24755 gcc_assert (!as_a
<rtx_insn
*> (insn
)->deleted ());
24757 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
24758 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
24762 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
24763 && CODE_LABEL_NUMBER (insn
) != -1)
24765 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
24766 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
24771 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
24772 attributes to the DIE for a block STMT, to describe where the inlined
24773 function was called from. This is similar to add_src_coords_attributes. */
24776 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
24778 /* We can end up with BUILTINS_LOCATION here. */
24779 if (RESERVED_LOCATION_P (BLOCK_SOURCE_LOCATION (stmt
)))
24782 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
24784 if (dwarf_version
>= 3 || !dwarf_strict
)
24786 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
24787 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
24788 if (debug_column_info
&& s
.column
)
24789 add_AT_unsigned (die
, DW_AT_call_column
, s
.column
);
24794 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
24795 Add low_pc and high_pc attributes to the DIE for a block STMT. */
24798 add_high_low_attributes (tree stmt
, dw_die_ref die
)
24800 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
24802 if (inline_entry_data
**iedp
24803 = !inline_entry_data_table
? NULL
24804 : inline_entry_data_table
->find_slot_with_hash (stmt
,
24805 htab_hash_pointer (stmt
),
24808 inline_entry_data
*ied
= *iedp
;
24809 gcc_assert (MAY_HAVE_DEBUG_MARKER_INSNS
);
24810 gcc_assert (debug_inline_points
);
24811 gcc_assert (inlined_function_outer_scope_p (stmt
));
24813 ASM_GENERATE_INTERNAL_LABEL (label
, ied
->label_pfx
, ied
->label_num
);
24814 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
24816 if (debug_variable_location_views
&& !ZERO_VIEW_P (ied
->view
)
24819 if (!output_asm_line_debug_info ())
24820 add_AT_unsigned (die
, DW_AT_GNU_entry_view
, ied
->view
);
24823 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", ied
->view
);
24824 /* FIXME: this will resolve to a small number. Could we
24825 possibly emit smaller data? Ideally we'd emit a
24826 uleb128, but that would make the size of DIEs
24827 impossible for the compiler to compute, since it's
24828 the assembler that computes the value of the view
24829 label in this case. Ideally, we'd have a single form
24830 encompassing both the address and the view, and
24831 indirecting them through a table might make things
24832 easier, but even that would be more wasteful,
24833 space-wise, than what we have now. */
24834 add_AT_symview (die
, DW_AT_GNU_entry_view
, label
);
24838 inline_entry_data_table
->clear_slot (iedp
);
24841 if (BLOCK_FRAGMENT_CHAIN (stmt
)
24842 && (dwarf_version
>= 3 || !dwarf_strict
))
24844 tree chain
, superblock
= NULL_TREE
;
24846 dw_attr_node
*attr
= NULL
;
24848 if (!debug_inline_points
&& inlined_function_outer_scope_p (stmt
))
24850 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
24851 BLOCK_NUMBER (stmt
));
24852 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
24855 /* Optimize duplicate .debug_ranges lists or even tails of
24856 lists. If this BLOCK has same ranges as its supercontext,
24857 lookup DW_AT_ranges attribute in the supercontext (and
24858 recursively so), verify that the ranges_table contains the
24859 right values and use it instead of adding a new .debug_range. */
24860 for (chain
= stmt
, pdie
= die
;
24861 BLOCK_SAME_RANGE (chain
);
24862 chain
= BLOCK_SUPERCONTEXT (chain
))
24864 dw_attr_node
*new_attr
;
24866 pdie
= pdie
->die_parent
;
24869 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
24871 new_attr
= get_AT (pdie
, DW_AT_ranges
);
24872 if (new_attr
== NULL
24873 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
24876 superblock
= BLOCK_SUPERCONTEXT (chain
);
24879 && ((*ranges_table
)[attr
->dw_attr_val
.v
.val_offset
].num
24880 == (int)BLOCK_NUMBER (superblock
))
24881 && BLOCK_FRAGMENT_CHAIN (superblock
))
24883 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
;
24884 unsigned long supercnt
= 0, thiscnt
= 0;
24885 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
24886 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
24889 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
].num
24890 == (int)BLOCK_NUMBER (chain
));
24892 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
+ 1].num
== 0);
24893 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
24894 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
24896 gcc_assert (supercnt
>= thiscnt
);
24897 add_AT_range_list (die
, DW_AT_ranges
, off
+ supercnt
- thiscnt
,
24899 note_rnglist_head (off
+ supercnt
- thiscnt
);
24903 unsigned int offset
= add_ranges (stmt
, true);
24904 add_AT_range_list (die
, DW_AT_ranges
, offset
, false);
24905 note_rnglist_head (offset
);
24907 bool prev_in_cold
= BLOCK_IN_COLD_SECTION_P (stmt
);
24908 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
24911 add_ranges (chain
, prev_in_cold
!= BLOCK_IN_COLD_SECTION_P (chain
));
24912 prev_in_cold
= BLOCK_IN_COLD_SECTION_P (chain
);
24913 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
24920 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
24921 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
24922 BLOCK_NUMBER (stmt
));
24923 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
24924 BLOCK_NUMBER (stmt
));
24925 add_AT_low_high_pc (die
, label
, label_high
, false);
24929 /* Generate a DIE for a lexical block. */
24932 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
)
24934 dw_die_ref old_die
= lookup_block_die (stmt
);
24935 dw_die_ref stmt_die
= NULL
;
24938 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
24939 equate_block_to_die (stmt
, stmt_die
);
24942 if (BLOCK_ABSTRACT_ORIGIN (stmt
))
24944 /* If this is an inlined or conrecte instance, create a new lexical
24945 die for anything below to attach DW_AT_abstract_origin to. */
24947 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
24949 tree origin
= block_ultimate_origin (stmt
);
24950 if (origin
!= NULL_TREE
&& (origin
!= stmt
|| old_die
))
24951 add_abstract_origin_attribute (stmt_die
, origin
);
24957 stmt_die
= old_die
;
24959 /* A non abstract block whose blocks have already been reordered
24960 should have the instruction range for this block. If so, set the
24961 high/low attributes. */
24962 if (!early_dwarf
&& TREE_ASM_WRITTEN (stmt
))
24964 gcc_assert (stmt_die
);
24965 add_high_low_attributes (stmt
, stmt_die
);
24968 decls_for_scope (stmt
, stmt_die
);
24971 /* Generate a DIE for an inlined subprogram. */
24974 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
)
24976 tree decl
= block_ultimate_origin (stmt
);
24978 /* Make sure any inlined functions are known to be inlineable. */
24979 gcc_checking_assert (DECL_ABSTRACT_P (decl
)
24980 || cgraph_function_possibly_inlined_p (decl
));
24982 dw_die_ref subr_die
= new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
24984 if (call_arg_locations
|| debug_inline_points
)
24985 equate_block_to_die (stmt
, subr_die
);
24986 add_abstract_origin_attribute (subr_die
, decl
);
24987 if (TREE_ASM_WRITTEN (stmt
))
24988 add_high_low_attributes (stmt
, subr_die
);
24989 add_call_src_coords_attributes (stmt
, subr_die
);
24991 /* The inliner creates an extra BLOCK for the parameter setup,
24992 we want to merge that with the actual outermost BLOCK of the
24993 inlined function to avoid duplicate locals in consumers.
24994 Do that by doing the recursion to subblocks on the single subblock
24996 bool unwrap_one
= false;
24997 if (BLOCK_SUBBLOCKS (stmt
) && !BLOCK_CHAIN (BLOCK_SUBBLOCKS (stmt
)))
24999 tree origin
= block_ultimate_origin (BLOCK_SUBBLOCKS (stmt
));
25001 && TREE_CODE (origin
) == BLOCK
25002 && BLOCK_SUPERCONTEXT (origin
) == decl
)
25005 decls_for_scope (stmt
, subr_die
, !unwrap_one
);
25007 decls_for_scope (BLOCK_SUBBLOCKS (stmt
), subr_die
);
25010 /* Generate a DIE for a field in a record, or structure. CTX is required: see
25011 the comment for VLR_CONTEXT. */
25014 gen_field_die (tree decl
, struct vlr_context
*ctx
, dw_die_ref context_die
)
25016 dw_die_ref decl_die
;
25018 if (TREE_TYPE (decl
) == error_mark_node
)
25021 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
25022 add_name_and_src_coords_attributes (decl_die
, decl
);
25023 add_type_attribute (decl_die
, member_declared_type (decl
), decl_quals (decl
),
25024 TYPE_REVERSE_STORAGE_ORDER (DECL_FIELD_CONTEXT (decl
)),
25027 if (DECL_BIT_FIELD_TYPE (decl
))
25029 add_byte_size_attribute (decl_die
, decl
);
25030 add_bit_size_attribute (decl_die
, decl
);
25031 add_bit_offset_attribute (decl_die
, decl
);
25034 add_alignment_attribute (decl_die
, decl
);
25036 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
25037 add_data_member_location_attribute (decl_die
, decl
, ctx
);
25039 if (DECL_ARTIFICIAL (decl
))
25040 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
25042 add_accessibility_attribute (decl_die
, decl
);
25044 /* Equate decl number to die, so that we can look up this decl later on. */
25045 equate_decl_number_to_die (decl
, decl_die
);
25048 /* Generate a DIE for a pointer to a member type. TYPE can be an
25049 OFFSET_TYPE, for a pointer to data member, or a RECORD_TYPE, for a
25050 pointer to member function. */
25053 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
25055 if (lookup_type_die (type
))
25058 dw_die_ref ptr_die
= new_die (DW_TAG_ptr_to_member_type
,
25059 scope_die_for (type
, context_die
), type
);
25061 equate_type_number_to_die (type
, ptr_die
);
25062 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
25063 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
25064 add_type_attribute (ptr_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
25066 add_alignment_attribute (ptr_die
, type
);
25068 if (TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
25069 && TREE_CODE (TREE_TYPE (type
)) != METHOD_TYPE
)
25071 dw_loc_descr_ref op
= new_loc_descr (DW_OP_plus
, 0, 0);
25072 add_AT_loc (ptr_die
, DW_AT_use_location
, op
);
25076 static char *producer_string
;
25078 /* Given a C and/or C++ language/version string return the "highest".
25079 C++ is assumed to be "higher" than C in this case. Used for merging
25080 LTO translation unit languages. */
25081 static const char *
25082 highest_c_language (const char *lang1
, const char *lang2
)
25084 if (strcmp ("GNU C++23", lang1
) == 0 || strcmp ("GNU C++23", lang2
) == 0)
25085 return "GNU C++23";
25086 if (strcmp ("GNU C++20", lang1
) == 0 || strcmp ("GNU C++20", lang2
) == 0)
25087 return "GNU C++20";
25088 if (strcmp ("GNU C++17", lang1
) == 0 || strcmp ("GNU C++17", lang2
) == 0)
25089 return "GNU C++17";
25090 if (strcmp ("GNU C++14", lang1
) == 0 || strcmp ("GNU C++14", lang2
) == 0)
25091 return "GNU C++14";
25092 if (strcmp ("GNU C++11", lang1
) == 0 || strcmp ("GNU C++11", lang2
) == 0)
25093 return "GNU C++11";
25094 if (strcmp ("GNU C++98", lang1
) == 0 || strcmp ("GNU C++98", lang2
) == 0)
25095 return "GNU C++98";
25097 if (strcmp ("GNU C2X", lang1
) == 0 || strcmp ("GNU C2X", lang2
) == 0)
25099 if (strcmp ("GNU C17", lang1
) == 0 || strcmp ("GNU C17", lang2
) == 0)
25101 if (strcmp ("GNU C11", lang1
) == 0 || strcmp ("GNU C11", lang2
) == 0)
25103 if (strcmp ("GNU C99", lang1
) == 0 || strcmp ("GNU C99", lang2
) == 0)
25105 if (strcmp ("GNU C89", lang1
) == 0 || strcmp ("GNU C89", lang2
) == 0)
25108 gcc_unreachable ();
25112 /* Generate the DIE for the compilation unit. */
25115 gen_compile_unit_die (const char *filename
)
25118 const char *language_string
= lang_hooks
.name
;
25121 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
25125 add_filename_attribute (die
, filename
);
25126 /* Don't add cwd for <built-in>. */
25127 if (filename
[0] != '<')
25128 add_comp_dir_attribute (die
);
25131 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
25133 /* If our producer is LTO try to figure out a common language to use
25134 from the global list of translation units. */
25135 if (strcmp (language_string
, "GNU GIMPLE") == 0)
25139 const char *common_lang
= NULL
;
25141 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
25143 if (!TRANSLATION_UNIT_LANGUAGE (t
))
25146 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
25147 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
25149 else if (startswith (common_lang
, "GNU C")
25150 && startswith (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C"))
25151 /* Mixing C and C++ is ok, use C++ in that case. */
25152 common_lang
= highest_c_language (common_lang
,
25153 TRANSLATION_UNIT_LANGUAGE (t
));
25156 /* Fall back to C. */
25157 common_lang
= NULL
;
25163 language_string
= common_lang
;
25166 language
= DW_LANG_C
;
25167 if (startswith (language_string
, "GNU C")
25168 && ISDIGIT (language_string
[5]))
25170 language
= DW_LANG_C89
;
25171 if (dwarf_version
>= 3 || !dwarf_strict
)
25173 if (strcmp (language_string
, "GNU C89") != 0)
25174 language
= DW_LANG_C99
;
25176 if (dwarf_version
>= 5 /* || !dwarf_strict */)
25177 if (strcmp (language_string
, "GNU C11") == 0
25178 || strcmp (language_string
, "GNU C17") == 0
25179 || strcmp (language_string
, "GNU C2X") == 0)
25180 language
= DW_LANG_C11
;
25183 else if (startswith (language_string
, "GNU C++"))
25185 language
= DW_LANG_C_plus_plus
;
25186 if (dwarf_version
>= 5 /* || !dwarf_strict */)
25188 if (strcmp (language_string
, "GNU C++11") == 0)
25189 language
= DW_LANG_C_plus_plus_11
;
25190 else if (strcmp (language_string
, "GNU C++14") == 0)
25191 language
= DW_LANG_C_plus_plus_14
;
25192 else if (strcmp (language_string
, "GNU C++17") == 0
25193 || strcmp (language_string
, "GNU C++20") == 0
25194 || strcmp (language_string
, "GNU C++23") == 0)
25196 language
= DW_LANG_C_plus_plus_14
;
25199 else if (strcmp (language_string
, "GNU F77") == 0)
25200 language
= DW_LANG_Fortran77
;
25201 else if (dwarf_version
>= 3 || !dwarf_strict
)
25203 if (strcmp (language_string
, "GNU Ada") == 0)
25204 language
= DW_LANG_Ada95
;
25205 else if (startswith (language_string
, "GNU Fortran"))
25207 language
= DW_LANG_Fortran95
;
25208 if (dwarf_version
>= 5 /* || !dwarf_strict */)
25210 if (strcmp (language_string
, "GNU Fortran2003") == 0)
25211 language
= DW_LANG_Fortran03
;
25212 else if (strcmp (language_string
, "GNU Fortran2008") == 0)
25213 language
= DW_LANG_Fortran08
;
25216 else if (strcmp (language_string
, "GNU Objective-C") == 0)
25217 language
= DW_LANG_ObjC
;
25218 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
25219 language
= DW_LANG_ObjC_plus_plus
;
25220 else if (strcmp (language_string
, "GNU D") == 0)
25221 language
= DW_LANG_D
;
25222 else if (dwarf_version
>= 5 || !dwarf_strict
)
25224 if (strcmp (language_string
, "GNU Go") == 0)
25225 language
= DW_LANG_Go
;
25228 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
25229 else if (startswith (language_string
, "GNU Fortran"))
25230 language
= DW_LANG_Fortran90
;
25231 /* Likewise for Ada. */
25232 else if (strcmp (language_string
, "GNU Ada") == 0)
25233 language
= DW_LANG_Ada83
;
25235 add_AT_unsigned (die
, DW_AT_language
, language
);
25239 case DW_LANG_Fortran77
:
25240 case DW_LANG_Fortran90
:
25241 case DW_LANG_Fortran95
:
25242 case DW_LANG_Fortran03
:
25243 case DW_LANG_Fortran08
:
25244 /* Fortran has case insensitive identifiers and the front-end
25245 lowercases everything. */
25246 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
25249 /* The default DW_ID_case_sensitive doesn't need to be specified. */
25255 /* Generate the DIE for a base class. */
25258 gen_inheritance_die (tree binfo
, tree access
, tree type
,
25259 dw_die_ref context_die
)
25261 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
25262 struct vlr_context ctx
= { type
, NULL
};
25264 add_type_attribute (die
, BINFO_TYPE (binfo
), TYPE_UNQUALIFIED
, false,
25266 add_data_member_location_attribute (die
, binfo
, &ctx
);
25268 if (BINFO_VIRTUAL_P (binfo
))
25269 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
25271 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
25272 children, otherwise the default is DW_ACCESS_public. In DWARF2
25273 the default has always been DW_ACCESS_private. */
25274 if (access
== access_public_node
)
25276 if (dwarf_version
== 2
25277 || context_die
->die_tag
== DW_TAG_class_type
)
25278 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
25280 else if (access
== access_protected_node
)
25281 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
25282 else if (dwarf_version
> 2
25283 && context_die
->die_tag
!= DW_TAG_class_type
)
25284 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
25287 /* Return whether DECL is a FIELD_DECL that represents the variant part of a
25291 is_variant_part (tree decl
)
25293 return (TREE_CODE (decl
) == FIELD_DECL
25294 && TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
);
25297 /* Check that OPERAND is a reference to a field in STRUCT_TYPE. If it is,
25298 return the FIELD_DECL. Return NULL_TREE otherwise. */
25301 analyze_discr_in_predicate (tree operand
, tree struct_type
)
25303 while (CONVERT_EXPR_P (operand
))
25304 operand
= TREE_OPERAND (operand
, 0);
25306 /* Match field access to members of struct_type only. */
25307 if (TREE_CODE (operand
) == COMPONENT_REF
25308 && TREE_CODE (TREE_OPERAND (operand
, 0)) == PLACEHOLDER_EXPR
25309 && TREE_TYPE (TREE_OPERAND (operand
, 0)) == struct_type
25310 && TREE_CODE (TREE_OPERAND (operand
, 1)) == FIELD_DECL
)
25311 return TREE_OPERAND (operand
, 1);
25316 /* Check that SRC is a constant integer that can be represented as a native
25317 integer constant (either signed or unsigned). If so, store it into DEST and
25318 return true. Return false otherwise. */
25321 get_discr_value (tree src
, dw_discr_value
*dest
)
25323 tree discr_type
= TREE_TYPE (src
);
25325 if (lang_hooks
.types
.get_debug_type
)
25327 tree debug_type
= lang_hooks
.types
.get_debug_type (discr_type
);
25328 if (debug_type
!= NULL
)
25329 discr_type
= debug_type
;
25332 if (TREE_CODE (src
) != INTEGER_CST
|| !INTEGRAL_TYPE_P (discr_type
))
25335 /* Signedness can vary between the original type and the debug type. This
25336 can happen for character types in Ada for instance: the character type
25337 used for code generation can be signed, to be compatible with the C one,
25338 but from a debugger point of view, it must be unsigned. */
25339 bool is_orig_unsigned
= TYPE_UNSIGNED (TREE_TYPE (src
));
25340 bool is_debug_unsigned
= TYPE_UNSIGNED (discr_type
);
25342 if (is_orig_unsigned
!= is_debug_unsigned
)
25343 src
= fold_convert (discr_type
, src
);
25345 if (!(is_debug_unsigned
? tree_fits_uhwi_p (src
) : tree_fits_shwi_p (src
)))
25348 dest
->pos
= is_debug_unsigned
;
25349 if (is_debug_unsigned
)
25350 dest
->v
.uval
= tree_to_uhwi (src
);
25352 dest
->v
.sval
= tree_to_shwi (src
);
25357 /* Try to extract synthetic properties out of VARIANT_PART_DECL, which is a
25358 FIELD_DECL in STRUCT_TYPE that represents a variant part. If unsuccessful,
25359 store NULL_TREE in DISCR_DECL. Otherwise:
25361 - store the discriminant field in STRUCT_TYPE that controls the variant
25362 part to *DISCR_DECL
25364 - put in *DISCR_LISTS_P an array where for each variant, the item
25365 represents the corresponding matching list of discriminant values.
25367 - put in *DISCR_LISTS_LENGTH the number of variants, which is the size of
25370 Note that when the array is allocated (i.e. when the analysis is
25371 successful), it is up to the caller to free the array. */
25374 analyze_variants_discr (tree variant_part_decl
,
25377 dw_discr_list_ref
**discr_lists_p
,
25378 unsigned *discr_lists_length
)
25380 tree variant_part_type
= TREE_TYPE (variant_part_decl
);
25382 dw_discr_list_ref
*discr_lists
;
25385 /* Compute how many variants there are in this variant part. */
25386 *discr_lists_length
= 0;
25387 for (variant
= TYPE_FIELDS (variant_part_type
);
25388 variant
!= NULL_TREE
;
25389 variant
= DECL_CHAIN (variant
))
25390 ++*discr_lists_length
;
25392 *discr_decl
= NULL_TREE
;
25394 = (dw_discr_list_ref
*) xcalloc (*discr_lists_length
,
25395 sizeof (**discr_lists_p
));
25396 discr_lists
= *discr_lists_p
;
25398 /* And then analyze all variants to extract discriminant information for all
25399 of them. This analysis is conservative: as soon as we detect something we
25400 do not support, abort everything and pretend we found nothing. */
25401 for (variant
= TYPE_FIELDS (variant_part_type
), i
= 0;
25402 variant
!= NULL_TREE
;
25403 variant
= DECL_CHAIN (variant
), ++i
)
25405 tree match_expr
= DECL_QUALIFIER (variant
);
25407 /* Now, try to analyze the predicate and deduce a discriminant for
25409 if (match_expr
== boolean_true_node
)
25410 /* Typically happens for the default variant: it matches all cases that
25411 previous variants rejected. Don't output any matching value for
25415 /* The following loop tries to iterate over each discriminant
25416 possibility: single values or ranges. */
25417 while (match_expr
!= NULL_TREE
)
25419 tree next_round_match_expr
;
25420 tree candidate_discr
= NULL_TREE
;
25421 dw_discr_list_ref new_node
= NULL
;
25423 /* Possibilities are matched one after the other by nested
25424 TRUTH_ORIF_EXPR expressions. Process the current possibility and
25425 continue with the rest at next iteration. */
25426 if (TREE_CODE (match_expr
) == TRUTH_ORIF_EXPR
)
25428 next_round_match_expr
= TREE_OPERAND (match_expr
, 0);
25429 match_expr
= TREE_OPERAND (match_expr
, 1);
25432 next_round_match_expr
= NULL_TREE
;
25434 if (match_expr
== boolean_false_node
)
25435 /* This sub-expression matches nothing: just wait for the next
25439 else if (TREE_CODE (match_expr
) == EQ_EXPR
)
25441 /* We are matching: <discr_field> == <integer_cst>
25442 This sub-expression matches a single value. */
25443 tree integer_cst
= TREE_OPERAND (match_expr
, 1);
25446 = analyze_discr_in_predicate (TREE_OPERAND (match_expr
, 0),
25449 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
25450 if (!get_discr_value (integer_cst
,
25451 &new_node
->dw_discr_lower_bound
))
25453 new_node
->dw_discr_range
= false;
25456 else if (TREE_CODE (match_expr
) == TRUTH_ANDIF_EXPR
)
25458 /* We are matching:
25459 <discr_field> > <integer_cst>
25460 && <discr_field> < <integer_cst>.
25461 This sub-expression matches the range of values between the
25462 two matched integer constants. Note that comparisons can be
25463 inclusive or exclusive. */
25464 tree candidate_discr_1
, candidate_discr_2
;
25465 tree lower_cst
, upper_cst
;
25466 bool lower_cst_included
, upper_cst_included
;
25467 tree lower_op
= TREE_OPERAND (match_expr
, 0);
25468 tree upper_op
= TREE_OPERAND (match_expr
, 1);
25470 /* When the comparison is exclusive, the integer constant is not
25471 the discriminant range bound we are looking for: we will have
25472 to increment or decrement it. */
25473 if (TREE_CODE (lower_op
) == GE_EXPR
)
25474 lower_cst_included
= true;
25475 else if (TREE_CODE (lower_op
) == GT_EXPR
)
25476 lower_cst_included
= false;
25480 if (TREE_CODE (upper_op
) == LE_EXPR
)
25481 upper_cst_included
= true;
25482 else if (TREE_CODE (upper_op
) == LT_EXPR
)
25483 upper_cst_included
= false;
25487 /* Extract the discriminant from the first operand and check it
25488 is consistant with the same analysis in the second
25491 = analyze_discr_in_predicate (TREE_OPERAND (lower_op
, 0),
25494 = analyze_discr_in_predicate (TREE_OPERAND (upper_op
, 0),
25496 if (candidate_discr_1
== candidate_discr_2
)
25497 candidate_discr
= candidate_discr_1
;
25501 /* Extract bounds from both. */
25502 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
25503 lower_cst
= TREE_OPERAND (lower_op
, 1);
25504 upper_cst
= TREE_OPERAND (upper_op
, 1);
25506 if (!lower_cst_included
)
25508 = fold_build2 (PLUS_EXPR
, TREE_TYPE (lower_cst
), lower_cst
,
25509 build_int_cst (TREE_TYPE (lower_cst
), 1));
25510 if (!upper_cst_included
)
25512 = fold_build2 (MINUS_EXPR
, TREE_TYPE (upper_cst
), upper_cst
,
25513 build_int_cst (TREE_TYPE (upper_cst
), 1));
25515 if (!get_discr_value (lower_cst
,
25516 &new_node
->dw_discr_lower_bound
)
25517 || !get_discr_value (upper_cst
,
25518 &new_node
->dw_discr_upper_bound
))
25521 new_node
->dw_discr_range
= true;
25524 else if ((candidate_discr
25525 = analyze_discr_in_predicate (match_expr
, struct_type
))
25526 && (TREE_TYPE (candidate_discr
) == boolean_type_node
25527 || TREE_TYPE (TREE_TYPE (candidate_discr
))
25528 == boolean_type_node
))
25530 /* We are matching: <discr_field> for a boolean discriminant.
25531 This sub-expression matches boolean_true_node. */
25532 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
25533 if (!get_discr_value (boolean_true_node
,
25534 &new_node
->dw_discr_lower_bound
))
25536 new_node
->dw_discr_range
= false;
25540 /* Unsupported sub-expression: we cannot determine the set of
25541 matching discriminant values. Abort everything. */
25544 /* If the discriminant info is not consistant with what we saw so
25545 far, consider the analysis failed and abort everything. */
25546 if (candidate_discr
== NULL_TREE
25547 || (*discr_decl
!= NULL_TREE
&& candidate_discr
!= *discr_decl
))
25550 *discr_decl
= candidate_discr
;
25552 if (new_node
!= NULL
)
25554 new_node
->dw_discr_next
= discr_lists
[i
];
25555 discr_lists
[i
] = new_node
;
25557 match_expr
= next_round_match_expr
;
25561 /* If we reach this point, we could match everything we were interested
25566 /* Clean all data structure and return no result. */
25567 free (*discr_lists_p
);
25568 *discr_lists_p
= NULL
;
25569 *discr_decl
= NULL_TREE
;
25572 /* Generate a DIE to represent VARIANT_PART_DECL, a variant part that is part
25573 of STRUCT_TYPE, a record type. This new DIE is emitted as the next child
25576 Variant parts are supposed to be implemented as a FIELD_DECL whose type is a
25577 QUAL_UNION_TYPE: this is the VARIANT_PART_DECL parameter. The members for
25578 this type, which are record types, represent the available variants and each
25579 has a DECL_QUALIFIER attribute. The discriminant and the discriminant
25580 values are inferred from these attributes.
25582 In trees, the offsets for the fields inside these sub-records are relative
25583 to the variant part itself, whereas the corresponding DIEs should have
25584 offset attributes that are relative to the embedding record base address.
25585 This is why the caller must provide a VARIANT_PART_OFFSET expression: it
25586 must be an expression that computes the offset of the variant part to
25587 describe in DWARF. */
25590 gen_variant_part (tree variant_part_decl
, struct vlr_context
*vlr_ctx
,
25591 dw_die_ref context_die
)
25593 const tree variant_part_type
= TREE_TYPE (variant_part_decl
);
25594 tree variant_part_offset
= vlr_ctx
->variant_part_offset
;
25596 /* The FIELD_DECL node in STRUCT_TYPE that acts as the discriminant, or
25597 NULL_TREE if there is no such field. */
25598 tree discr_decl
= NULL_TREE
;
25599 dw_discr_list_ref
*discr_lists
;
25600 unsigned discr_lists_length
= 0;
25603 dw_die_ref dwarf_proc_die
= NULL
;
25604 dw_die_ref variant_part_die
25605 = new_die (DW_TAG_variant_part
, context_die
, variant_part_type
);
25607 equate_decl_number_to_die (variant_part_decl
, variant_part_die
);
25609 analyze_variants_discr (variant_part_decl
, vlr_ctx
->struct_type
,
25610 &discr_decl
, &discr_lists
, &discr_lists_length
);
25612 if (discr_decl
!= NULL_TREE
)
25614 dw_die_ref discr_die
= lookup_decl_die (discr_decl
);
25617 add_AT_die_ref (variant_part_die
, DW_AT_discr
, discr_die
);
25619 /* We have no DIE for the discriminant, so just discard all
25620 discrimimant information in the output. */
25621 discr_decl
= NULL_TREE
;
25624 /* If the offset for this variant part is more complex than a constant,
25625 create a DWARF procedure for it so that we will not have to generate
25626 DWARF expressions for it for each member. */
25627 if (TREE_CODE (variant_part_offset
) != INTEGER_CST
25628 && (dwarf_version
>= 3 || !dwarf_strict
))
25630 struct loc_descr_context ctx
= {
25631 vlr_ctx
->struct_type
, /* context_type */
25632 NULL_TREE
, /* base_decl */
25634 false, /* placeholder_arg */
25635 false, /* placeholder_seen */
25636 false /* strict_signedness */
25638 const tree dwarf_proc_fndecl
25639 = build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
25640 build_function_type (TREE_TYPE (variant_part_offset
),
25642 const tree dwarf_proc_call
= build_call_expr (dwarf_proc_fndecl
, 0);
25643 const dw_loc_descr_ref dwarf_proc_body
25644 = loc_descriptor_from_tree (variant_part_offset
, 0, &ctx
);
25646 dwarf_proc_die
= new_dwarf_proc_die (dwarf_proc_body
,
25647 dwarf_proc_fndecl
, context_die
);
25648 if (dwarf_proc_die
!= NULL
)
25649 variant_part_offset
= dwarf_proc_call
;
25652 /* Output DIEs for all variants. */
25654 for (tree variant
= TYPE_FIELDS (variant_part_type
);
25655 variant
!= NULL_TREE
;
25656 variant
= DECL_CHAIN (variant
), ++i
)
25658 tree variant_type
= TREE_TYPE (variant
);
25659 dw_die_ref variant_die
;
25661 /* All variants (i.e. members of a variant part) are supposed to be
25662 encoded as structures. Sub-variant parts are QUAL_UNION_TYPE fields
25663 under these records. */
25664 gcc_assert (TREE_CODE (variant_type
) == RECORD_TYPE
);
25666 variant_die
= new_die (DW_TAG_variant
, variant_part_die
, variant_type
);
25667 equate_decl_number_to_die (variant
, variant_die
);
25669 /* Output discriminant values this variant matches, if any. */
25670 if (discr_decl
== NULL
|| discr_lists
[i
] == NULL
)
25671 /* In the case we have discriminant information at all, this is
25672 probably the default variant: as the standard says, don't
25673 output any discriminant value/list attribute. */
25675 else if (discr_lists
[i
]->dw_discr_next
== NULL
25676 && !discr_lists
[i
]->dw_discr_range
)
25677 /* If there is only one accepted value, don't bother outputting a
25679 add_discr_value (variant_die
, &discr_lists
[i
]->dw_discr_lower_bound
);
25681 add_discr_list (variant_die
, discr_lists
[i
]);
25683 for (tree member
= TYPE_FIELDS (variant_type
);
25684 member
!= NULL_TREE
;
25685 member
= DECL_CHAIN (member
))
25687 struct vlr_context vlr_sub_ctx
= {
25688 vlr_ctx
->struct_type
, /* struct_type */
25689 NULL
/* variant_part_offset */
25691 if (is_variant_part (member
))
25693 /* All offsets for fields inside variant parts are relative to
25694 the top-level embedding RECORD_TYPE's base address. On the
25695 other hand, offsets in GCC's types are relative to the
25696 nested-most variant part. So we have to sum offsets each time
25699 vlr_sub_ctx
.variant_part_offset
25700 = fold_build2 (PLUS_EXPR
, TREE_TYPE (variant_part_offset
),
25701 variant_part_offset
, byte_position (member
));
25702 gen_variant_part (member
, &vlr_sub_ctx
, variant_die
);
25706 vlr_sub_ctx
.variant_part_offset
= variant_part_offset
;
25707 gen_decl_die (member
, NULL
, &vlr_sub_ctx
, variant_die
);
25712 free (discr_lists
);
25715 /* Generate a DIE for a class member. */
25718 gen_member_die (tree type
, dw_die_ref context_die
)
25721 tree binfo
= TYPE_BINFO (type
);
25723 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
25725 /* If this is not an incomplete type, output descriptions of each of its
25726 members. Note that as we output the DIEs necessary to represent the
25727 members of this record or union type, we will also be trying to output
25728 DIEs to represent the *types* of those members. However the `type'
25729 function (above) will specifically avoid generating type DIEs for member
25730 types *within* the list of member DIEs for this (containing) type except
25731 for those types (of members) which are explicitly marked as also being
25732 members of this (containing) type themselves. The g++ front- end can
25733 force any given type to be treated as a member of some other (containing)
25734 type by setting the TYPE_CONTEXT of the given (member) type to point to
25735 the TREE node representing the appropriate (containing) type. */
25737 /* First output info about the base classes. */
25738 if (binfo
&& early_dwarf
)
25740 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
25744 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
25745 gen_inheritance_die (base
,
25746 (accesses
? (*accesses
)[i
] : access_public_node
),
25751 /* Now output info about the members. */
25752 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
25754 /* Ignore clones. */
25755 if (DECL_ABSTRACT_ORIGIN (member
))
25758 struct vlr_context vlr_ctx
= { type
, NULL_TREE
};
25759 bool static_inline_p
25761 && TREE_STATIC (member
)
25762 && (lang_hooks
.decls
.decl_dwarf_attribute (member
, DW_AT_inline
)
25765 /* If we thought we were generating minimal debug info for TYPE
25766 and then changed our minds, some of the member declarations
25767 may have already been defined. Don't define them again, but
25768 do put them in the right order. */
25770 if (dw_die_ref child
= lookup_decl_die (member
))
25772 /* Handle inline static data members, which only have in-class
25774 bool splice
= true;
25776 dw_die_ref ref
= NULL
;
25777 if (child
->die_tag
== DW_TAG_variable
25778 && child
->die_parent
== comp_unit_die ())
25780 ref
= get_AT_ref (child
, DW_AT_specification
);
25782 /* For C++17 inline static data members followed by redundant
25783 out of class redeclaration, we might get here with
25784 child being the DIE created for the out of class
25785 redeclaration and with its DW_AT_specification being
25786 the DIE created for in-class definition. We want to
25787 reparent the latter, and don't want to create another
25788 DIE with DW_AT_specification in that case, because
25789 we already have one. */
25792 && ref
->die_tag
== DW_TAG_variable
25793 && ref
->die_parent
== comp_unit_die ()
25794 && get_AT (ref
, DW_AT_specification
) == NULL
)
25798 static_inline_p
= false;
25803 reparent_child (child
, context_die
);
25804 if (dwarf_version
< 5)
25805 child
->die_tag
= DW_TAG_member
;
25809 else if (child
->die_tag
== DW_TAG_enumerator
)
25810 /* Enumerators remain under their enumeration even if
25811 their names are introduced in the enclosing scope. */
25815 splice_child_die (context_die
, child
);
25818 /* Do not generate DWARF for variant parts if we are generating the
25819 corresponding GNAT encodings: DIEs generated for the two schemes
25820 would conflict in our mappings. */
25821 else if (is_variant_part (member
)
25822 && gnat_encodings
!= DWARF_GNAT_ENCODINGS_ALL
)
25824 vlr_ctx
.variant_part_offset
= byte_position (member
);
25825 gen_variant_part (member
, &vlr_ctx
, context_die
);
25829 vlr_ctx
.variant_part_offset
= NULL_TREE
;
25830 gen_decl_die (member
, NULL
, &vlr_ctx
, context_die
);
25833 /* For C++ inline static data members emit immediately a DW_TAG_variable
25834 DIE that will refer to that DW_TAG_member/DW_TAG_variable through
25835 DW_AT_specification. */
25836 if (static_inline_p
)
25838 int old_extern
= DECL_EXTERNAL (member
);
25839 DECL_EXTERNAL (member
) = 0;
25840 gen_decl_die (member
, NULL
, NULL
, comp_unit_die ());
25841 DECL_EXTERNAL (member
) = old_extern
;
25846 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
25847 is set, we pretend that the type was never defined, so we only get the
25848 member DIEs needed by later specification DIEs. */
25851 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
25852 enum debug_info_usage usage
)
25854 if (TREE_ASM_WRITTEN (type
))
25856 /* Fill in the bound of variable-length fields in late dwarf if
25857 still incomplete. */
25858 if (!early_dwarf
&& variably_modified_type_p (type
, NULL
))
25859 for (tree member
= TYPE_FIELDS (type
);
25861 member
= DECL_CHAIN (member
))
25862 fill_variable_array_bounds (TREE_TYPE (member
));
25866 dw_die_ref type_die
= lookup_type_die (type
);
25867 dw_die_ref scope_die
= 0;
25869 int complete
= (TYPE_SIZE (type
)
25870 && (! TYPE_STUB_DECL (type
)
25871 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
25872 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
25873 complete
= complete
&& should_emit_struct_debug (type
, usage
);
25875 if (type_die
&& ! complete
)
25878 if (TYPE_CONTEXT (type
) != NULL_TREE
25879 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
25880 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
25883 scope_die
= scope_die_for (type
, context_die
);
25885 /* Generate child dies for template parameters. */
25886 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
25887 schedule_generic_params_dies_gen (type
);
25889 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
25890 /* First occurrence of type or toplevel definition of nested class. */
25892 dw_die_ref old_die
= type_die
;
25894 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
25895 ? record_type_tag (type
) : DW_TAG_union_type
,
25897 equate_type_number_to_die (type
, type_die
);
25899 add_AT_specification (type_die
, old_die
);
25901 add_name_attribute (type_die
, type_tag (type
));
25904 remove_AT (type_die
, DW_AT_declaration
);
25906 /* If this type has been completed, then give it a byte_size attribute and
25907 then give a list of members. */
25908 if (complete
&& !ns_decl
)
25910 /* Prevent infinite recursion in cases where the type of some member of
25911 this type is expressed in terms of this type itself. */
25912 TREE_ASM_WRITTEN (type
) = 1;
25913 add_byte_size_attribute (type_die
, type
);
25914 add_alignment_attribute (type_die
, type
);
25915 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
25917 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
25918 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
25921 /* If the first reference to this type was as the return type of an
25922 inline function, then it may not have a parent. Fix this now. */
25923 if (type_die
->die_parent
== NULL
)
25924 add_child_die (scope_die
, type_die
);
25926 gen_member_die (type
, type_die
);
25928 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
25929 if (TYPE_ARTIFICIAL (type
))
25930 add_AT_flag (type_die
, DW_AT_artificial
, 1);
25932 /* GNU extension: Record what type our vtable lives in. */
25933 if (TYPE_VFIELD (type
))
25935 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
25937 gen_type_die (vtype
, context_die
);
25938 add_AT_die_ref (type_die
, DW_AT_containing_type
,
25939 lookup_type_die (vtype
));
25944 add_AT_flag (type_die
, DW_AT_declaration
, 1);
25946 /* We don't need to do this for function-local types. */
25947 if (TYPE_STUB_DECL (type
)
25948 && ! decl_function_context (TYPE_STUB_DECL (type
)))
25949 vec_safe_push (incomplete_types
, type
);
25952 if (get_AT (type_die
, DW_AT_name
))
25953 add_pubtype (type
, type_die
);
25956 /* Generate a DIE for a subroutine _type_. */
25959 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
25961 tree return_type
= TREE_TYPE (type
);
25962 dw_die_ref subr_die
25963 = new_die (DW_TAG_subroutine_type
,
25964 scope_die_for (type
, context_die
), type
);
25966 equate_type_number_to_die (type
, subr_die
);
25967 add_prototyped_attribute (subr_die
, type
);
25968 add_type_attribute (subr_die
, return_type
, TYPE_UNQUALIFIED
, false,
25970 add_alignment_attribute (subr_die
, type
);
25971 gen_formal_types_die (type
, subr_die
);
25973 if (get_AT (subr_die
, DW_AT_name
))
25974 add_pubtype (type
, subr_die
);
25975 if ((dwarf_version
>= 5 || !dwarf_strict
)
25976 && lang_hooks
.types
.type_dwarf_attribute (type
, DW_AT_reference
) != -1)
25977 add_AT_flag (subr_die
, DW_AT_reference
, 1);
25978 if ((dwarf_version
>= 5 || !dwarf_strict
)
25979 && lang_hooks
.types
.type_dwarf_attribute (type
,
25980 DW_AT_rvalue_reference
) != -1)
25981 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
25984 /* Generate a DIE for a type definition. */
25987 gen_typedef_die (tree decl
, dw_die_ref context_die
)
25989 dw_die_ref type_die
;
25992 if (TREE_ASM_WRITTEN (decl
))
25994 if (DECL_ORIGINAL_TYPE (decl
))
25995 fill_variable_array_bounds (DECL_ORIGINAL_TYPE (decl
));
25999 /* As we avoid creating DIEs for local typedefs (see decl_ultimate_origin
26000 checks in process_scope_var and modified_type_die), this should be called
26001 only for original types. */
26002 gcc_assert (decl_ultimate_origin (decl
) == NULL
26003 || decl_ultimate_origin (decl
) == decl
);
26005 TREE_ASM_WRITTEN (decl
) = 1;
26006 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
26008 add_name_and_src_coords_attributes (type_die
, decl
);
26009 if (DECL_ORIGINAL_TYPE (decl
))
26011 type
= DECL_ORIGINAL_TYPE (decl
);
26012 if (type
== error_mark_node
)
26015 gcc_assert (type
!= TREE_TYPE (decl
));
26016 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
26020 type
= TREE_TYPE (decl
);
26021 if (type
== error_mark_node
)
26024 if (is_naming_typedef_decl (TYPE_NAME (type
)))
26026 /* Here, we are in the case of decl being a typedef naming
26027 an anonymous type, e.g:
26028 typedef struct {...} foo;
26029 In that case TREE_TYPE (decl) is not a typedef variant
26030 type and TYPE_NAME of the anonymous type is set to the
26031 TYPE_DECL of the typedef. This construct is emitted by
26034 TYPE is the anonymous struct named by the typedef
26035 DECL. As we need the DW_AT_type attribute of the
26036 DW_TAG_typedef to point to the DIE of TYPE, let's
26037 generate that DIE right away. add_type_attribute
26038 called below will then pick (via lookup_type_die) that
26039 anonymous struct DIE. */
26040 if (!TREE_ASM_WRITTEN (type
))
26041 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
26043 /* This is a GNU Extension. We are adding a
26044 DW_AT_linkage_name attribute to the DIE of the
26045 anonymous struct TYPE. The value of that attribute
26046 is the name of the typedef decl naming the anonymous
26047 struct. This greatly eases the work of consumers of
26048 this debug info. */
26049 add_linkage_name_raw (lookup_type_die (type
), decl
);
26053 add_type_attribute (type_die
, type
, decl_quals (decl
), false,
26056 if (is_naming_typedef_decl (decl
))
26057 /* We want that all subsequent calls to lookup_type_die with
26058 TYPE in argument yield the DW_TAG_typedef we have just
26060 equate_type_number_to_die (type
, type_die
);
26062 add_alignment_attribute (type_die
, TREE_TYPE (decl
));
26064 add_accessibility_attribute (type_die
, decl
);
26066 if (DECL_ABSTRACT_P (decl
))
26067 equate_decl_number_to_die (decl
, type_die
);
26069 if (get_AT (type_die
, DW_AT_name
))
26070 add_pubtype (decl
, type_die
);
26073 /* Generate a DIE for a struct, class, enum or union type. */
26076 gen_tagged_type_die (tree type
,
26077 dw_die_ref context_die
,
26078 enum debug_info_usage usage
)
26080 if (type
== NULL_TREE
26081 || !is_tagged_type (type
))
26084 if (TREE_ASM_WRITTEN (type
))
26086 /* If this is a nested type whose containing class hasn't been written
26087 out yet, writing it out will cover this one, too. This does not apply
26088 to instantiations of member class templates; they need to be added to
26089 the containing class as they are generated. FIXME: This hurts the
26090 idea of combining type decls from multiple TUs, since we can't predict
26091 what set of template instantiations we'll get. */
26092 else if (TYPE_CONTEXT (type
)
26093 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
26094 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
26096 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
26098 if (TREE_ASM_WRITTEN (type
))
26101 /* If that failed, attach ourselves to the stub. */
26102 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
26104 else if (TYPE_CONTEXT (type
) != NULL_TREE
26105 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
26107 /* If this type is local to a function that hasn't been written
26108 out yet, use a NULL context for now; it will be fixed up in
26109 decls_for_scope. */
26110 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
26111 /* A declaration DIE doesn't count; nested types need to go in the
26113 if (context_die
&& is_declaration_die (context_die
))
26114 context_die
= NULL
;
26117 context_die
= declare_in_namespace (type
, context_die
);
26119 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
26121 /* This might have been written out by the call to
26122 declare_in_namespace. */
26123 if (!TREE_ASM_WRITTEN (type
))
26124 gen_enumeration_type_die (type
, context_die
);
26127 gen_struct_or_union_type_die (type
, context_die
, usage
);
26129 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
26130 it up if it is ever completed. gen_*_type_die will set it for us
26131 when appropriate. */
26134 /* Generate a type description DIE. */
26137 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
26138 enum debug_info_usage usage
)
26140 struct array_descr_info info
;
26142 if (type
== NULL_TREE
|| type
== error_mark_node
)
26145 if (flag_checking
&& type
)
26146 verify_type (type
);
26148 if (TYPE_NAME (type
) != NULL_TREE
26149 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
26150 && is_redundant_typedef (TYPE_NAME (type
))
26151 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
26152 /* The DECL of this type is a typedef we don't want to emit debug
26153 info for but we want debug info for its underlying typedef.
26154 This can happen for e.g, the injected-class-name of a C++
26156 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
26158 /* If TYPE is a typedef type variant, let's generate debug info
26159 for the parent typedef which TYPE is a type of. */
26160 if (typedef_variant_p (type
))
26162 if (TREE_ASM_WRITTEN (type
))
26165 tree name
= TYPE_NAME (type
);
26166 tree origin
= decl_ultimate_origin (name
);
26167 if (origin
!= NULL
&& origin
!= name
)
26169 gen_decl_die (origin
, NULL
, NULL
, context_die
);
26173 /* Prevent broken recursion; we can't hand off to the same type. */
26174 gcc_assert (DECL_ORIGINAL_TYPE (name
) != type
);
26176 /* Give typedefs the right scope. */
26177 context_die
= scope_die_for (type
, context_die
);
26179 TREE_ASM_WRITTEN (type
) = 1;
26181 gen_decl_die (name
, NULL
, NULL
, context_die
);
26185 /* If type is an anonymous tagged type named by a typedef, let's
26186 generate debug info for the typedef. */
26187 if (is_naming_typedef_decl (TYPE_NAME (type
)))
26189 /* Give typedefs the right scope. */
26190 context_die
= scope_die_for (type
, context_die
);
26192 gen_decl_die (TYPE_NAME (type
), NULL
, NULL
, context_die
);
26196 if (lang_hooks
.types
.get_debug_type
)
26198 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
26200 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
26202 gen_type_die_with_usage (debug_type
, context_die
, usage
);
26207 /* We are going to output a DIE to represent the unqualified version
26208 of this type (i.e. without any const or volatile qualifiers) so
26209 get the main variant (i.e. the unqualified version) of this type
26210 now. (Vectors and arrays are special because the debugging info is in the
26211 cloned type itself. Similarly function/method types can contain extra
26212 ref-qualification). */
26213 if (TREE_CODE (type
) == FUNCTION_TYPE
26214 || TREE_CODE (type
) == METHOD_TYPE
)
26216 /* For function/method types, can't use type_main_variant here,
26217 because that can have different ref-qualifiers for C++,
26218 but try to canonicalize. */
26219 tree main
= TYPE_MAIN_VARIANT (type
);
26220 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
26221 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
26222 && check_base_type (t
, main
)
26223 && check_lang_type (t
, type
))
26229 else if (TREE_CODE (type
) != VECTOR_TYPE
26230 && TREE_CODE (type
) != ARRAY_TYPE
)
26231 type
= type_main_variant (type
);
26233 /* If this is an array type with hidden descriptor, handle it first. */
26234 if (!TREE_ASM_WRITTEN (type
)
26235 && lang_hooks
.types
.get_array_descr_info
)
26237 memset (&info
, 0, sizeof (info
));
26238 if (lang_hooks
.types
.get_array_descr_info (type
, &info
))
26240 /* Fortran sometimes emits array types with no dimension. */
26241 gcc_assert (info
.ndimensions
>= 0
26242 && (info
.ndimensions
26243 <= DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN
));
26244 gen_descr_array_type_die (type
, &info
, context_die
);
26245 TREE_ASM_WRITTEN (type
) = 1;
26250 if (TREE_ASM_WRITTEN (type
))
26252 /* Variable-length types may be incomplete even if
26253 TREE_ASM_WRITTEN. For such types, fall through to
26254 gen_array_type_die() and possibly fill in
26255 DW_AT_{upper,lower}_bound attributes. */
26256 if ((TREE_CODE (type
) != ARRAY_TYPE
26257 && TREE_CODE (type
) != RECORD_TYPE
26258 && TREE_CODE (type
) != UNION_TYPE
26259 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
26260 || !variably_modified_type_p (type
, NULL
))
26264 switch (TREE_CODE (type
))
26270 case REFERENCE_TYPE
:
26271 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
26272 ensures that the gen_type_die recursion will terminate even if the
26273 type is recursive. Recursive types are possible in Ada. */
26274 /* ??? We could perhaps do this for all types before the switch
26276 TREE_ASM_WRITTEN (type
) = 1;
26278 /* For these types, all that is required is that we output a DIE (or a
26279 set of DIEs) to represent the "basis" type. */
26280 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
26281 DINFO_USAGE_IND_USE
);
26285 /* This code is used for C++ pointer-to-data-member types.
26286 Output a description of the relevant class type. */
26287 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
26288 DINFO_USAGE_IND_USE
);
26290 /* Output a description of the type of the object pointed to. */
26291 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
26292 DINFO_USAGE_IND_USE
);
26294 /* Now output a DIE to represent this pointer-to-data-member type
26296 gen_ptr_to_mbr_type_die (type
, context_die
);
26299 case FUNCTION_TYPE
:
26300 /* Force out return type (in case it wasn't forced out already). */
26301 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
26302 DINFO_USAGE_DIR_USE
);
26303 gen_subroutine_type_die (type
, context_die
);
26307 /* Force out return type (in case it wasn't forced out already). */
26308 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
26309 DINFO_USAGE_DIR_USE
);
26310 gen_subroutine_type_die (type
, context_die
);
26315 gen_array_type_die (type
, context_die
);
26318 case ENUMERAL_TYPE
:
26321 case QUAL_UNION_TYPE
:
26322 gen_tagged_type_die (type
, context_die
, usage
);
26329 case FIXED_POINT_TYPE
:
26332 /* No DIEs needed for fundamental types. */
26337 /* Just use DW_TAG_unspecified_type. */
26339 dw_die_ref type_die
= lookup_type_die (type
);
26340 if (type_die
== NULL
)
26342 tree name
= TYPE_IDENTIFIER (type
);
26343 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
26345 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
26346 equate_type_number_to_die (type
, type_die
);
26352 if (is_cxx_auto (type
))
26354 tree name
= TYPE_IDENTIFIER (type
);
26355 dw_die_ref
*die
= (name
== get_identifier ("auto")
26356 ? &auto_die
: &decltype_auto_die
);
26359 *die
= new_die (DW_TAG_unspecified_type
,
26360 comp_unit_die (), NULL_TREE
);
26361 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
26363 equate_type_number_to_die (type
, *die
);
26366 gcc_unreachable ();
26369 TREE_ASM_WRITTEN (type
) = 1;
26373 gen_type_die (tree type
, dw_die_ref context_die
)
26375 if (type
!= error_mark_node
)
26377 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
26380 dw_die_ref die
= lookup_type_die (type
);
26387 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
26388 things which are local to the given block. */
26391 gen_block_die (tree stmt
, dw_die_ref context_die
)
26393 int must_output_die
= 0;
26396 /* Ignore blocks that are NULL. */
26397 if (stmt
== NULL_TREE
)
26400 inlined_func
= inlined_function_outer_scope_p (stmt
);
26402 /* If the block is one fragment of a non-contiguous block, do not
26403 process the variables, since they will have been done by the
26404 origin block. Do process subblocks. */
26405 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
26409 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
26410 gen_block_die (sub
, context_die
);
26415 /* Determine if we need to output any Dwarf DIEs at all to represent this
26418 /* The outer scopes for inlinings *must* always be represented. We
26419 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
26420 must_output_die
= 1;
26421 else if (lookup_block_die (stmt
))
26422 /* If we already have a DIE then it was filled early. Meanwhile
26423 we might have pruned all BLOCK_VARS as optimized out but we
26424 still want to generate high/low PC attributes so output it. */
26425 must_output_die
= 1;
26426 else if (TREE_USED (stmt
)
26427 || TREE_ASM_WRITTEN (stmt
))
26429 /* Determine if this block directly contains any "significant"
26430 local declarations which we will need to output DIEs for. */
26431 if (debug_info_level
> DINFO_LEVEL_TERSE
)
26433 /* We are not in terse mode so any local declaration that
26434 is not ignored for debug purposes counts as being a
26435 "significant" one. */
26436 if (BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
26437 must_output_die
= 1;
26439 for (tree var
= BLOCK_VARS (stmt
); var
; var
= DECL_CHAIN (var
))
26440 if (!DECL_IGNORED_P (var
))
26442 must_output_die
= 1;
26446 else if (!dwarf2out_ignore_block (stmt
))
26447 must_output_die
= 1;
26450 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
26451 DIE for any block which contains no significant local declarations at
26452 all. Rather, in such cases we just call `decls_for_scope' so that any
26453 needed Dwarf info for any sub-blocks will get properly generated. Note
26454 that in terse mode, our definition of what constitutes a "significant"
26455 local declaration gets restricted to include only inlined function
26456 instances and local (nested) function definitions. */
26457 if (must_output_die
)
26460 gen_inlined_subroutine_die (stmt
, context_die
);
26462 gen_lexical_block_die (stmt
, context_die
);
26465 decls_for_scope (stmt
, context_die
);
26468 /* Process variable DECL (or variable with origin ORIGIN) within
26469 block STMT and add it to CONTEXT_DIE. */
26471 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
26474 tree decl_or_origin
= decl
? decl
: origin
;
26476 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
26477 die
= lookup_decl_die (decl_or_origin
);
26478 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
)
26480 if (TYPE_DECL_IS_STUB (decl_or_origin
))
26481 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
26483 die
= lookup_decl_die (decl_or_origin
);
26484 /* Avoid re-creating the DIE late if it was optimized as unused early. */
26485 if (! die
&& ! early_dwarf
)
26491 /* Avoid creating DIEs for local typedefs and concrete static variables that
26492 will only be pruned later. */
26493 if ((origin
|| decl_ultimate_origin (decl
))
26494 && (TREE_CODE (decl_or_origin
) == TYPE_DECL
26495 || (VAR_P (decl_or_origin
) && TREE_STATIC (decl_or_origin
))))
26497 origin
= decl_ultimate_origin (decl_or_origin
);
26498 if (decl
&& VAR_P (decl
) && die
!= NULL
)
26500 die
= lookup_decl_die (origin
);
26502 equate_decl_number_to_die (decl
, die
);
26507 if (die
!= NULL
&& die
->die_parent
== NULL
)
26508 add_child_die (context_die
, die
);
26509 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
26512 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
26513 stmt
, context_die
);
26517 if (decl
&& DECL_P (decl
))
26519 die
= lookup_decl_die (decl
);
26521 /* Early created DIEs do not have a parent as the decls refer
26522 to the function as DECL_CONTEXT rather than the BLOCK. */
26523 if (die
&& die
->die_parent
== NULL
)
26525 gcc_assert (in_lto_p
);
26526 add_child_die (context_die
, die
);
26530 gen_decl_die (decl
, origin
, NULL
, context_die
);
26534 /* Generate all of the decls declared within a given scope and (recursively)
26535 all of its sub-blocks. */
26538 decls_for_scope (tree stmt
, dw_die_ref context_die
, bool recurse
)
26544 /* Ignore NULL blocks. */
26545 if (stmt
== NULL_TREE
)
26548 /* Output the DIEs to represent all of the data objects and typedefs
26549 declared directly within this block but not within any nested
26550 sub-blocks. Also, nested function and tag DIEs have been
26551 generated with a parent of NULL; fix that up now. We don't
26552 have to do this if we're at -g1. */
26553 if (debug_info_level
> DINFO_LEVEL_TERSE
)
26555 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
26556 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
26557 /* BLOCK_NONLOCALIZED_VARs simply generate DIE stubs with abstract
26558 origin - avoid doing this twice as we have no good way to see
26559 if we've done it once already. */
26561 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
26563 decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
26564 if (decl
== current_function_decl
)
26565 /* Ignore declarations of the current function, while they
26566 are declarations, gen_subprogram_die would treat them
26567 as definitions again, because they are equal to
26568 current_function_decl and endlessly recurse. */;
26569 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
26570 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
26572 process_scope_var (stmt
, NULL_TREE
, decl
, context_die
);
26576 /* Even if we're at -g1, we need to process the subblocks in order to get
26577 inlined call information. */
26579 /* Output the DIEs to represent all sub-blocks (and the items declared
26580 therein) of this block. */
26582 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
26584 subblocks
= BLOCK_CHAIN (subblocks
))
26585 gen_block_die (subblocks
, context_die
);
26588 /* Is this a typedef we can avoid emitting? */
26591 is_redundant_typedef (const_tree decl
)
26593 if (TYPE_DECL_IS_STUB (decl
))
26596 if (DECL_ARTIFICIAL (decl
)
26597 && DECL_CONTEXT (decl
)
26598 && is_tagged_type (DECL_CONTEXT (decl
))
26599 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
26600 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
26601 /* Also ignore the artificial member typedef for the class name. */
26607 /* Return TRUE if TYPE is a typedef that names a type for linkage
26608 purposes. This kind of typedefs is produced by the C++ FE for
26611 typedef struct {...} foo;
26613 In that case, there is no typedef variant type produced for foo.
26614 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
26618 is_naming_typedef_decl (const_tree decl
)
26620 if (decl
== NULL_TREE
26621 || TREE_CODE (decl
) != TYPE_DECL
26622 || DECL_NAMELESS (decl
)
26623 || !is_tagged_type (TREE_TYPE (decl
))
26624 || DECL_IS_UNDECLARED_BUILTIN (decl
)
26625 || is_redundant_typedef (decl
)
26626 /* It looks like Ada produces TYPE_DECLs that are very similar
26627 to C++ naming typedefs but that have different
26628 semantics. Let's be specific to c++ for now. */
26632 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
26633 && TYPE_NAME (TREE_TYPE (decl
)) == decl
26634 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
26635 != TYPE_NAME (TREE_TYPE (decl
))));
26638 /* Looks up the DIE for a context. */
26640 static inline dw_die_ref
26641 lookup_context_die (tree context
)
26645 /* Find die that represents this context. */
26646 if (TYPE_P (context
))
26648 context
= TYPE_MAIN_VARIANT (context
);
26649 dw_die_ref ctx
= lookup_type_die (context
);
26652 return strip_naming_typedef (context
, ctx
);
26655 return lookup_decl_die (context
);
26657 return comp_unit_die ();
26660 /* Returns the DIE for a context. */
26662 static inline dw_die_ref
26663 get_context_die (tree context
)
26667 /* Find die that represents this context. */
26668 if (TYPE_P (context
))
26670 context
= TYPE_MAIN_VARIANT (context
);
26671 return strip_naming_typedef (context
, force_type_die (context
));
26674 return force_decl_die (context
);
26676 return comp_unit_die ();
26679 /* Returns the DIE for decl. A DIE will always be returned. */
26682 force_decl_die (tree decl
)
26684 dw_die_ref decl_die
;
26685 unsigned saved_external_flag
;
26686 tree save_fn
= NULL_TREE
;
26687 decl_die
= lookup_decl_die (decl
);
26690 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
26692 decl_die
= lookup_decl_die (decl
);
26696 switch (TREE_CODE (decl
))
26698 case FUNCTION_DECL
:
26699 /* Clear current_function_decl, so that gen_subprogram_die thinks
26700 that this is a declaration. At this point, we just want to force
26701 declaration die. */
26702 save_fn
= current_function_decl
;
26703 current_function_decl
= NULL_TREE
;
26704 gen_subprogram_die (decl
, context_die
);
26705 current_function_decl
= save_fn
;
26709 /* Set external flag to force declaration die. Restore it after
26710 gen_decl_die() call. */
26711 saved_external_flag
= DECL_EXTERNAL (decl
);
26712 DECL_EXTERNAL (decl
) = 1;
26713 gen_decl_die (decl
, NULL
, NULL
, context_die
);
26714 DECL_EXTERNAL (decl
) = saved_external_flag
;
26717 case NAMESPACE_DECL
:
26718 if (dwarf_version
>= 3 || !dwarf_strict
)
26719 dwarf2out_decl (decl
);
26721 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
26722 decl_die
= comp_unit_die ();
26726 /* Enumerators shouldn't need force_decl_die. */
26727 gcc_assert (DECL_CONTEXT (decl
) == NULL_TREE
26728 || TREE_CODE (DECL_CONTEXT (decl
)) != ENUMERAL_TYPE
);
26729 gen_decl_die (decl
, NULL
, NULL
, context_die
);
26732 case TRANSLATION_UNIT_DECL
:
26733 decl_die
= comp_unit_die ();
26737 gcc_unreachable ();
26740 /* We should be able to find the DIE now. */
26742 decl_die
= lookup_decl_die (decl
);
26743 gcc_assert (decl_die
);
26749 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
26750 always returned. */
26753 force_type_die (tree type
)
26755 dw_die_ref type_die
;
26757 type_die
= lookup_type_die (type
);
26760 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
26762 type_die
= modified_type_die (type
, TYPE_QUALS_NO_ADDR_SPACE (type
),
26763 false, context_die
);
26764 gcc_assert (type_die
);
26769 /* Force out any required namespaces to be able to output DECL,
26770 and return the new context_die for it, if it's changed. */
26773 setup_namespace_context (tree thing
, dw_die_ref context_die
)
26775 tree context
= (DECL_P (thing
)
26776 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
26777 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
26778 /* Force out the namespace. */
26779 context_die
= force_decl_die (context
);
26781 return context_die
;
26784 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
26785 type) within its namespace, if appropriate.
26787 For compatibility with older debuggers, namespace DIEs only contain
26788 declarations; all definitions are emitted at CU scope, with
26789 DW_AT_specification pointing to the declaration (like with class
26793 declare_in_namespace (tree thing
, dw_die_ref context_die
)
26795 dw_die_ref ns_context
;
26797 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26798 return context_die
;
26800 /* External declarations in the local scope only need to be emitted
26801 once, not once in the namespace and once in the scope.
26803 This avoids declaring the `extern' below in the
26804 namespace DIE as well as in the innermost scope:
26817 if (DECL_P (thing
) && DECL_EXTERNAL (thing
) && local_scope_p (context_die
))
26818 return context_die
;
26820 /* If this decl is from an inlined function, then don't try to emit it in its
26821 namespace, as we will get confused. It would have already been emitted
26822 when the abstract instance of the inline function was emitted anyways. */
26823 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
26824 return context_die
;
26826 ns_context
= setup_namespace_context (thing
, context_die
);
26828 if (ns_context
!= context_die
)
26830 if (is_fortran () || is_dlang ())
26832 if (DECL_P (thing
))
26833 gen_decl_die (thing
, NULL
, NULL
, ns_context
);
26835 gen_type_die (thing
, ns_context
);
26837 return context_die
;
26840 /* Generate a DIE for a namespace or namespace alias. */
26843 gen_namespace_die (tree decl
, dw_die_ref context_die
)
26845 dw_die_ref namespace_die
;
26847 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
26848 they are an alias of. */
26849 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
26851 /* Output a real namespace or module. */
26852 context_die
= setup_namespace_context (decl
, comp_unit_die ());
26853 namespace_die
= new_die (is_fortran () || is_dlang ()
26854 ? DW_TAG_module
: DW_TAG_namespace
,
26855 context_die
, decl
);
26856 /* For Fortran modules defined in different CU don't add src coords. */
26857 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
26859 const char *name
= dwarf2_name (decl
, 0);
26861 add_name_attribute (namespace_die
, name
);
26864 add_name_and_src_coords_attributes (namespace_die
, decl
);
26865 if (DECL_EXTERNAL (decl
))
26866 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
26867 equate_decl_number_to_die (decl
, namespace_die
);
26871 /* Output a namespace alias. */
26873 /* Force out the namespace we are an alias of, if necessary. */
26874 dw_die_ref origin_die
26875 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
26877 if (DECL_FILE_SCOPE_P (decl
)
26878 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
26879 context_die
= setup_namespace_context (decl
, comp_unit_die ());
26880 /* Now create the namespace alias DIE. */
26881 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
26882 add_name_and_src_coords_attributes (namespace_die
, decl
);
26883 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
26884 equate_decl_number_to_die (decl
, namespace_die
);
26886 if ((dwarf_version
>= 5 || !dwarf_strict
)
26887 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
26888 DW_AT_export_symbols
) == 1)
26889 add_AT_flag (namespace_die
, DW_AT_export_symbols
, 1);
26891 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
26892 if (want_pubnames ())
26893 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
26896 /* Generate Dwarf debug information for a decl described by DECL.
26897 The return value is currently only meaningful for PARM_DECLs,
26898 for all other decls it returns NULL.
26900 If DECL is a FIELD_DECL, CTX is required: see the comment for VLR_CONTEXT.
26901 It can be NULL otherwise. */
26904 gen_decl_die (tree decl
, tree origin
, struct vlr_context
*ctx
,
26905 dw_die_ref context_die
)
26907 tree decl_or_origin
= decl
? decl
: origin
;
26908 tree class_origin
= NULL
, ultimate_origin
;
26910 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
26913 switch (TREE_CODE (decl_or_origin
))
26919 if (!is_fortran () && !is_ada () && !is_dlang ())
26921 /* The individual enumerators of an enum type get output when we output
26922 the Dwarf representation of the relevant enum type itself. */
26926 /* Emit its type. */
26927 gen_type_die (TREE_TYPE (decl
), context_die
);
26929 /* And its containing namespace. */
26930 context_die
= declare_in_namespace (decl
, context_die
);
26932 gen_const_die (decl
, context_die
);
26935 case FUNCTION_DECL
:
26938 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
26939 on local redeclarations of global functions. That seems broken. */
26940 if (current_function_decl
!= decl
)
26941 /* This is only a declaration. */;
26944 /* We should have abstract copies already and should not generate
26945 stray type DIEs in late LTO dumping. */
26949 /* If we're emitting a clone, emit info for the abstract instance. */
26950 else if (origin
|| DECL_ORIGIN (decl
) != decl
)
26951 dwarf2out_abstract_function (origin
26952 ? DECL_ORIGIN (origin
)
26953 : DECL_ABSTRACT_ORIGIN (decl
));
26955 /* If we're emitting a possibly inlined function emit it as
26956 abstract instance. */
26957 else if (cgraph_function_possibly_inlined_p (decl
)
26958 && ! DECL_ABSTRACT_P (decl
)
26959 && ! class_or_namespace_scope_p (context_die
)
26960 /* dwarf2out_abstract_function won't emit a die if this is just
26961 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
26962 that case, because that works only if we have a die. */
26963 && DECL_INITIAL (decl
) != NULL_TREE
)
26964 dwarf2out_abstract_function (decl
);
26966 /* Otherwise we're emitting the primary DIE for this decl. */
26967 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
26969 /* Before we describe the FUNCTION_DECL itself, make sure that we
26970 have its containing type. */
26972 origin
= decl_class_context (decl
);
26973 if (origin
!= NULL_TREE
)
26974 gen_type_die (origin
, context_die
);
26976 /* And its return type. */
26977 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
26979 /* And its virtual context. */
26980 if (DECL_VINDEX (decl
) != NULL_TREE
)
26981 gen_type_die (DECL_CONTEXT (decl
), context_die
);
26983 /* Make sure we have a member DIE for decl. */
26984 if (origin
!= NULL_TREE
)
26985 gen_type_die_for_member (origin
, decl
, context_die
);
26987 /* And its containing namespace. */
26988 context_die
= declare_in_namespace (decl
, context_die
);
26991 /* Now output a DIE to represent the function itself. */
26993 gen_subprogram_die (decl
, context_die
);
26997 /* If we are in terse mode, don't generate any DIEs to represent any
26998 actual typedefs. */
26999 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
27002 /* In the special case of a TYPE_DECL node representing the declaration
27003 of some type tag, if the given TYPE_DECL is marked as having been
27004 instantiated from some other (original) TYPE_DECL node (e.g. one which
27005 was generated within the original definition of an inline function) we
27006 used to generate a special (abbreviated) DW_TAG_structure_type,
27007 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
27008 should be actually referencing those DIEs, as variable DIEs with that
27009 type would be emitted already in the abstract origin, so it was always
27010 removed during unused type prunning. Don't add anything in this
27012 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
27015 if (is_redundant_typedef (decl
))
27016 gen_type_die (TREE_TYPE (decl
), context_die
);
27018 /* Output a DIE to represent the typedef itself. */
27019 gen_typedef_die (decl
, context_die
);
27023 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
27024 gen_label_die (decl
, context_die
);
27029 /* If we are in terse mode, don't generate any DIEs to represent any
27030 variable declarations or definitions unless it is external. */
27031 if (debug_info_level
< DINFO_LEVEL_TERSE
27032 || (debug_info_level
== DINFO_LEVEL_TERSE
27033 && !TREE_PUBLIC (decl_or_origin
)))
27036 if (debug_info_level
> DINFO_LEVEL_TERSE
)
27038 /* Avoid generating stray type DIEs during late dwarf dumping.
27039 All types have been dumped early. */
27041 /* ??? But in LTRANS we cannot annotate early created variably
27042 modified type DIEs without copying them and adjusting all
27043 references to them. Dump them again as happens for inlining
27044 which copies both the decl and the types. */
27045 /* ??? And even non-LTO needs to re-visit type DIEs to fill
27046 in VLA bound information for example. */
27047 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
27048 current_function_decl
)))
27050 /* Output any DIEs that are needed to specify the type of this data
27052 if (decl_by_reference_p (decl_or_origin
))
27053 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
27055 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
27060 /* And its containing type. */
27061 class_origin
= decl_class_context (decl_or_origin
);
27062 if (class_origin
!= NULL_TREE
)
27063 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
27065 /* And its containing namespace. */
27066 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
27070 /* Now output the DIE to represent the data object itself. This gets
27071 complicated because of the possibility that the VAR_DECL really
27072 represents an inlined instance of a formal parameter for an inline
27074 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
27075 if (ultimate_origin
!= NULL_TREE
27076 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
27077 gen_formal_parameter_die (decl
, origin
,
27078 true /* Emit name attribute. */,
27081 gen_variable_die (decl
, origin
, context_die
);
27085 gcc_assert (ctx
!= NULL
&& ctx
->struct_type
!= NULL
);
27086 /* Ignore the nameless fields that are used to skip bits but handle C++
27087 anonymous unions and structs. */
27088 if (DECL_NAME (decl
) != NULL_TREE
27089 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
27090 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
27092 gen_type_die (member_declared_type (decl
), context_die
);
27093 gen_field_die (decl
, ctx
, context_die
);
27098 /* Avoid generating stray type DIEs during late dwarf dumping.
27099 All types have been dumped early. */
27101 /* ??? But in LTRANS we cannot annotate early created variably
27102 modified type DIEs without copying them and adjusting all
27103 references to them. Dump them again as happens for inlining
27104 which copies both the decl and the types. */
27105 /* ??? And even non-LTO needs to re-visit type DIEs to fill
27106 in VLA bound information for example. */
27107 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
27108 current_function_decl
)))
27110 if (DECL_BY_REFERENCE (decl_or_origin
))
27111 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
27113 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
27115 return gen_formal_parameter_die (decl
, origin
,
27116 true /* Emit name attribute. */,
27119 case NAMESPACE_DECL
:
27120 if (dwarf_version
>= 3 || !dwarf_strict
)
27121 gen_namespace_die (decl
, context_die
);
27124 case IMPORTED_DECL
:
27125 dwarf2out_imported_module_or_decl_1 (decl
, DECL_NAME (decl
),
27126 DECL_CONTEXT (decl
), context_die
);
27129 case NAMELIST_DECL
:
27130 gen_namelist_decl (DECL_NAME (decl
), context_die
,
27131 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
27135 /* Probably some frontend-internal decl. Assume we don't care. */
27136 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
27143 /* Output initial debug information for global DECL. Called at the
27144 end of the parsing process.
27146 This is the initial debug generation process. As such, the DIEs
27147 generated may be incomplete. A later debug generation pass
27148 (dwarf2out_late_global_decl) will augment the information generated
27149 in this pass (e.g., with complete location info). */
27152 dwarf2out_early_global_decl (tree decl
)
27156 /* gen_decl_die() will set DECL_ABSTRACT because
27157 cgraph_function_possibly_inlined_p() returns true. This is in
27158 turn will cause DW_AT_inline attributes to be set.
27160 This happens because at early dwarf generation, there is no
27161 cgraph information, causing cgraph_function_possibly_inlined_p()
27162 to return true. Trick cgraph_function_possibly_inlined_p()
27163 while we generate dwarf early. */
27164 bool save
= symtab
->global_info_ready
;
27165 symtab
->global_info_ready
= true;
27167 /* We don't handle TYPE_DECLs. If required, they'll be reached via
27168 other DECLs and they can point to template types or other things
27169 that dwarf2out can't handle when done via dwarf2out_decl. */
27170 if (TREE_CODE (decl
) != TYPE_DECL
27171 && TREE_CODE (decl
) != PARM_DECL
)
27173 if (TREE_CODE (decl
) == FUNCTION_DECL
)
27175 tree save_fndecl
= current_function_decl
;
27177 /* For nested functions, make sure we have DIEs for the parents first
27178 so that all nested DIEs are generated at the proper scope in the
27180 tree context
= decl_function_context (decl
);
27181 if (context
!= NULL
)
27183 dw_die_ref context_die
= lookup_decl_die (context
);
27184 current_function_decl
= context
;
27186 /* Avoid emitting DIEs multiple times, but still process CONTEXT
27187 enough so that it lands in its own context. This avoids type
27188 pruning issues later on. */
27189 if (context_die
== NULL
|| is_declaration_die (context_die
))
27190 dwarf2out_early_global_decl (context
);
27193 /* Emit an abstract origin of a function first. This happens
27194 with C++ constructor clones for example and makes
27195 dwarf2out_abstract_function happy which requires the early
27196 DIE of the abstract instance to be present. */
27197 tree origin
= DECL_ABSTRACT_ORIGIN (decl
);
27198 dw_die_ref origin_die
;
27200 /* Do not emit the DIE multiple times but make sure to
27201 process it fully here in case we just saw a declaration. */
27202 && ((origin_die
= lookup_decl_die (origin
)) == NULL
27203 || is_declaration_die (origin_die
)))
27205 current_function_decl
= origin
;
27206 dwarf2out_decl (origin
);
27209 /* Emit the DIE for decl but avoid doing that multiple times. */
27210 dw_die_ref old_die
;
27211 if ((old_die
= lookup_decl_die (decl
)) == NULL
27212 || is_declaration_die (old_die
))
27214 current_function_decl
= decl
;
27215 dwarf2out_decl (decl
);
27218 current_function_decl
= save_fndecl
;
27221 dwarf2out_decl (decl
);
27223 symtab
->global_info_ready
= save
;
27226 /* Return whether EXPR is an expression with the following pattern:
27227 INDIRECT_REF (NOP_EXPR (INTEGER_CST)). */
27230 is_trivial_indirect_ref (tree expr
)
27232 if (expr
== NULL_TREE
|| TREE_CODE (expr
) != INDIRECT_REF
)
27235 tree nop
= TREE_OPERAND (expr
, 0);
27236 if (nop
== NULL_TREE
|| TREE_CODE (nop
) != NOP_EXPR
)
27239 tree int_cst
= TREE_OPERAND (nop
, 0);
27240 return int_cst
!= NULL_TREE
&& TREE_CODE (int_cst
) == INTEGER_CST
;
27243 /* Output debug information for global decl DECL. Called from
27244 toplev.cc after compilation proper has finished. */
27247 dwarf2out_late_global_decl (tree decl
)
27249 /* Fill-in any location information we were unable to determine
27250 on the first pass. */
27253 dw_die_ref die
= lookup_decl_die (decl
);
27255 /* We may have to generate full debug late for LTO in case debug
27256 was not enabled at compile-time or the target doesn't support
27257 the LTO early debug scheme. */
27258 if (! die
&& in_lto_p
)
27259 dwarf2out_decl (decl
);
27262 /* We get called via the symtab code invoking late_global_decl
27263 for symbols that are optimized out.
27265 Do not add locations for those, except if they have a
27266 DECL_VALUE_EXPR, in which case they are relevant for debuggers.
27267 Still don't add a location if the DECL_VALUE_EXPR is not a trivial
27268 INDIRECT_REF expression, as this could generate relocations to
27269 text symbols in LTO object files, which is invalid. */
27270 varpool_node
*node
= varpool_node::get (decl
);
27271 if ((! node
|| ! node
->definition
)
27272 && ! (DECL_HAS_VALUE_EXPR_P (decl
)
27273 && is_trivial_indirect_ref (DECL_VALUE_EXPR (decl
))))
27274 tree_add_const_value_attribute_for_decl (die
, decl
);
27276 add_location_or_const_value_attribute (die
, decl
, false);
27281 /* Output debug information for type decl DECL. Called from toplev.cc
27282 and from language front ends (to record built-in types). */
27284 dwarf2out_type_decl (tree decl
, int local
)
27289 dwarf2out_decl (decl
);
27293 /* Output debug information for imported module or decl DECL.
27294 NAME is non-NULL name in the lexical block if the decl has been renamed.
27295 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
27296 that DECL belongs to.
27297 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
27299 dwarf2out_imported_module_or_decl_1 (tree decl
,
27301 tree lexical_block
,
27302 dw_die_ref lexical_block_die
)
27304 expanded_location xloc
;
27305 dw_die_ref imported_die
= NULL
;
27306 dw_die_ref at_import_die
;
27308 if (TREE_CODE (decl
) == IMPORTED_DECL
)
27310 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
27311 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
27315 xloc
= expand_location (input_location
);
27317 if (TREE_CODE (decl
) == TYPE_DECL
)
27319 at_import_die
= force_type_die (TREE_TYPE (decl
));
27320 /* For namespace N { typedef void T; } using N::T; base_type_die
27321 returns NULL, but DW_TAG_imported_declaration requires
27322 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
27323 if (!at_import_die
)
27325 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
27326 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
27327 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
27328 gcc_assert (at_import_die
);
27333 at_import_die
= lookup_decl_die (decl
);
27334 if (!at_import_die
)
27336 /* If we're trying to avoid duplicate debug info, we may not have
27337 emitted the member decl for this field. Emit it now. */
27338 if (TREE_CODE (decl
) == FIELD_DECL
)
27340 tree type
= DECL_CONTEXT (decl
);
27342 if (TYPE_CONTEXT (type
)
27343 && TYPE_P (TYPE_CONTEXT (type
))
27344 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
27345 DINFO_USAGE_DIR_USE
))
27347 gen_type_die_for_member (type
, decl
,
27348 get_context_die (TYPE_CONTEXT (type
)));
27350 if (TREE_CODE (decl
) == CONST_DECL
)
27352 /* Individual enumerators of an enum type do not get output here
27353 (see gen_decl_die), so we cannot call force_decl_die. */
27354 if (!is_fortran () && !is_ada () && !is_dlang ())
27357 if (TREE_CODE (decl
) == NAMELIST_DECL
)
27358 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
27359 get_context_die (DECL_CONTEXT (decl
)),
27362 at_import_die
= force_decl_die (decl
);
27366 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
27368 if (dwarf_version
>= 3 || !dwarf_strict
)
27369 imported_die
= new_die (DW_TAG_imported_module
,
27376 imported_die
= new_die (DW_TAG_imported_declaration
,
27380 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
27381 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
27382 if (debug_column_info
&& xloc
.column
)
27383 add_AT_unsigned (imported_die
, DW_AT_decl_column
, xloc
.column
);
27385 add_AT_string (imported_die
, DW_AT_name
,
27386 IDENTIFIER_POINTER (name
));
27387 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
27390 /* Output debug information for imported module or decl DECL.
27391 NAME is non-NULL name in context if the decl has been renamed.
27392 CHILD is true if decl is one of the renamed decls as part of
27393 importing whole module.
27394 IMPLICIT is set if this hook is called for an implicit import
27395 such as inline namespace. */
27398 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
27399 bool child
, bool implicit
)
27401 /* dw_die_ref at_import_die; */
27402 dw_die_ref scope_die
;
27404 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
27409 /* For DWARF5, just DW_AT_export_symbols on the DW_TAG_namespace
27410 should be enough, for DWARF4 and older even if we emit as extension
27411 DW_AT_export_symbols add the implicit DW_TAG_imported_module anyway
27412 for the benefit of consumers unaware of DW_AT_export_symbols. */
27414 && dwarf_version
>= 5
27415 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
27416 DW_AT_export_symbols
) == 1)
27421 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
27422 We need decl DIE for reference and scope die. First, get DIE for the decl
27425 /* Get the scope die for decl context. Use comp_unit_die for global module
27426 or decl. If die is not found for non globals, force new die. */
27428 && TYPE_P (context
)
27429 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
27432 scope_die
= get_context_die (context
);
27436 /* DW_TAG_imported_module was introduced in the DWARFv3 specification, so
27437 there is nothing we can do, here. */
27438 if (dwarf_version
< 3 && dwarf_strict
)
27441 gcc_assert (scope_die
->die_child
);
27442 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
27443 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
27444 scope_die
= scope_die
->die_child
;
27447 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
27448 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
27451 /* Output debug information for namelists. */
27454 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
27456 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
27460 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
27463 gcc_assert (scope_die
!= NULL
);
27464 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
27465 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
27467 /* If there are no item_decls, we have a nondefining namelist, e.g.
27468 with USE association; hence, set DW_AT_declaration. */
27469 if (item_decls
== NULL_TREE
)
27471 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
27475 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
27477 nml_item_ref_die
= lookup_decl_die (value
);
27478 if (!nml_item_ref_die
)
27479 nml_item_ref_die
= force_decl_die (value
);
27481 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
27482 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
27488 /* Write the debugging output for DECL and return the DIE. */
27491 dwarf2out_decl (tree decl
)
27493 dw_die_ref context_die
= comp_unit_die ();
27495 switch (TREE_CODE (decl
))
27500 case FUNCTION_DECL
:
27501 /* If we're a nested function, initially use a parent of NULL; if we're
27502 a plain function, this will be fixed up in decls_for_scope. If
27503 we're a method, it will be ignored, since we already have a DIE.
27504 Avoid doing this late though since clones of class methods may
27505 otherwise end up in limbo and create type DIEs late. */
27507 && decl_function_context (decl
)
27508 /* But if we're in terse mode, we don't care about scope. */
27509 && debug_info_level
> DINFO_LEVEL_TERSE
)
27510 context_die
= NULL
;
27514 /* For local statics lookup proper context die. */
27515 if (local_function_static (decl
))
27516 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
27518 /* If we are in terse mode, don't generate any DIEs to represent any
27519 variable declarations or definitions unless it is external. */
27520 if (debug_info_level
< DINFO_LEVEL_TERSE
27521 || (debug_info_level
== DINFO_LEVEL_TERSE
27522 && !TREE_PUBLIC (decl
)))
27527 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
27529 if (!is_fortran () && !is_ada () && !is_dlang ())
27531 if (TREE_STATIC (decl
) && decl_function_context (decl
))
27532 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
27535 case NAMESPACE_DECL
:
27536 case IMPORTED_DECL
:
27537 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
27539 if (lookup_decl_die (decl
) != NULL
)
27544 /* Don't emit stubs for types unless they are needed by other DIEs. */
27545 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
27548 /* Don't bother trying to generate any DIEs to represent any of the
27549 normal built-in types for the language we are compiling. */
27550 if (DECL_IS_UNDECLARED_BUILTIN (decl
))
27553 /* If we are in terse mode, don't generate any DIEs for types. */
27554 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
27557 /* If we're a function-scope tag, initially use a parent of NULL;
27558 this will be fixed up in decls_for_scope. */
27559 if (decl_function_context (decl
))
27560 context_die
= NULL
;
27564 case NAMELIST_DECL
:
27571 gen_decl_die (decl
, NULL
, NULL
, context_die
);
27575 dw_die_ref die
= lookup_decl_die (decl
);
27581 /* Write the debugging output for DECL. */
27584 dwarf2out_function_decl (tree decl
)
27586 dwarf2out_decl (decl
);
27587 call_arg_locations
= NULL
;
27588 call_arg_loc_last
= NULL
;
27589 call_site_count
= -1;
27590 tail_call_site_count
= -1;
27591 decl_loc_table
->empty ();
27592 cached_dw_loc_list_table
->empty ();
27595 /* Output a marker (i.e. a label) for the beginning of the generated code for
27596 a lexical block. */
27599 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
27600 unsigned int blocknum
)
27602 switch_to_section (current_function_section ());
27603 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
27606 /* Output a marker (i.e. a label) for the end of the generated code for a
27610 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
27612 switch_to_section (current_function_section ());
27613 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
27616 /* Returns nonzero if it is appropriate not to emit any debugging
27617 information for BLOCK, because it doesn't contain any instructions.
27619 Don't allow this for blocks with nested functions or local classes
27620 as we would end up with orphans, and in the presence of scheduling
27621 we may end up calling them anyway. */
27624 dwarf2out_ignore_block (const_tree block
)
27629 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
27630 if (TREE_CODE (decl
) == FUNCTION_DECL
27631 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
27633 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
27635 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
27636 if (TREE_CODE (decl
) == FUNCTION_DECL
27637 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
27644 /* Hash table routines for file_hash. */
27647 dwarf_file_hasher::equal (dwarf_file_data
*p1
, const char *p2
)
27649 return filename_cmp (p1
->key
, p2
) == 0;
27653 dwarf_file_hasher::hash (dwarf_file_data
*p
)
27655 return htab_hash_string (p
->key
);
27658 /* Lookup FILE_NAME (in the list of filenames that we know about here in
27659 dwarf2out.cc) and return its "index". The index of each (known) filename is
27660 just a unique number which is associated with only that one filename. We
27661 need such numbers for the sake of generating labels (in the .debug_sfnames
27662 section) and references to those files numbers (in the .debug_srcinfo
27663 and .debug_macinfo sections). If the filename given as an argument is not
27664 found in our current list, add it to the list and assign it the next
27665 available unique index number. */
27667 static struct dwarf_file_data
*
27668 lookup_filename (const char *file_name
)
27670 struct dwarf_file_data
* created
;
27676 file_name
= "<stdin>";
27678 dwarf_file_data
**slot
27679 = file_table
->find_slot_with_hash (file_name
, htab_hash_string (file_name
),
27684 created
= ggc_alloc
<dwarf_file_data
> ();
27685 created
->key
= file_name
;
27686 created
->filename
= remap_debug_filename (file_name
);
27687 created
->emitted_number
= 0;
27692 /* If the assembler will construct the file table, then translate the compiler
27693 internal file table number into the assembler file table number, and emit
27694 a .file directive if we haven't already emitted one yet. The file table
27695 numbers are different because we prune debug info for unused variables and
27696 types, which may include filenames. */
27699 maybe_emit_file (struct dwarf_file_data
* fd
)
27701 if (! fd
->emitted_number
)
27703 if (last_emitted_file
)
27704 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
27706 fd
->emitted_number
= 1;
27707 last_emitted_file
= fd
;
27709 if (output_asm_line_debug_info ())
27711 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
27712 output_quoted_string (asm_out_file
, fd
->filename
);
27713 fputc ('\n', asm_out_file
);
27717 return fd
->emitted_number
;
27720 /* Schedule generation of a DW_AT_const_value attribute to DIE.
27721 That generation should happen after function debug info has been
27722 generated. The value of the attribute is the constant value of ARG. */
27725 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
27727 die_arg_entry entry
;
27732 gcc_assert (early_dwarf
);
27734 if (!tmpl_value_parm_die_table
)
27735 vec_alloc (tmpl_value_parm_die_table
, 32);
27739 vec_safe_push (tmpl_value_parm_die_table
, entry
);
27742 /* Return TRUE if T is an instance of generic type, FALSE
27746 generic_type_p (tree t
)
27748 if (t
== NULL_TREE
|| !TYPE_P (t
))
27750 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
27753 /* Schedule the generation of the generic parameter dies for the
27754 instance of generic type T. The proper generation itself is later
27755 done by gen_scheduled_generic_parms_dies. */
27758 schedule_generic_params_dies_gen (tree t
)
27760 if (!generic_type_p (t
))
27763 gcc_assert (early_dwarf
);
27765 if (!generic_type_instances
)
27766 vec_alloc (generic_type_instances
, 256);
27768 vec_safe_push (generic_type_instances
, t
);
27771 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
27772 by append_entry_to_tmpl_value_parm_die_table. This function must
27773 be called after function DIEs have been generated. */
27776 gen_remaining_tmpl_value_param_die_attribute (void)
27778 if (tmpl_value_parm_die_table
)
27783 /* We do this in two phases - first get the cases we can
27784 handle during early-finish, preserving those we cannot
27785 (containing symbolic constants where we don't yet know
27786 whether we are going to output the referenced symbols).
27787 For those we try again at late-finish. */
27789 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
27791 if (!e
->die
->removed
27792 && !tree_add_const_value_attribute (e
->die
, e
->arg
))
27794 dw_loc_descr_ref loc
= NULL
;
27796 && (dwarf_version
>= 5 || !dwarf_strict
))
27797 loc
= loc_descriptor_from_tree (e
->arg
, 2, NULL
);
27799 add_AT_loc (e
->die
, DW_AT_location
, loc
);
27801 (*tmpl_value_parm_die_table
)[j
++] = *e
;
27804 tmpl_value_parm_die_table
->truncate (j
);
27808 /* Generate generic parameters DIEs for instances of generic types
27809 that have been previously scheduled by
27810 schedule_generic_params_dies_gen. This function must be called
27811 after all the types of the CU have been laid out. */
27814 gen_scheduled_generic_parms_dies (void)
27819 if (!generic_type_instances
)
27822 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
27823 if (COMPLETE_TYPE_P (t
))
27824 gen_generic_params_dies (t
);
27826 generic_type_instances
= NULL
;
27830 /* Replace DW_AT_name for the decl with name. */
27833 dwarf2out_set_name (tree decl
, tree name
)
27836 dw_attr_node
*attr
;
27839 die
= TYPE_SYMTAB_DIE (decl
);
27843 dname
= dwarf2_name (name
, 0);
27847 attr
= get_AT (die
, DW_AT_name
);
27850 struct indirect_string_node
*node
;
27852 node
= find_AT_string (dname
);
27853 /* replace the string. */
27854 attr
->dw_attr_val
.v
.val_str
= node
;
27858 add_name_attribute (die
, dname
);
27861 /* True if before or during processing of the first function being emitted. */
27862 static bool in_first_function_p
= true;
27863 /* True if loc_note during dwarf2out_var_location call might still be
27864 before first real instruction at address equal to .Ltext0. */
27865 static bool maybe_at_text_label_p
= true;
27866 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
27867 static unsigned int first_loclabel_num_not_at_text_label
;
27869 /* Look ahead for a real insn. */
27872 dwarf2out_next_real_insn (rtx_insn
*loc_note
)
27874 rtx_insn
*next_real
= NEXT_INSN (loc_note
);
27877 if (INSN_P (next_real
))
27880 next_real
= NEXT_INSN (next_real
);
27885 /* Called by the final INSN scan whenever we see a var location. We
27886 use it to drop labels in the right places, and throw the location in
27887 our lookup table. */
27890 dwarf2out_var_location (rtx_insn
*loc_note
)
27892 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
27893 struct var_loc_node
*newloc
;
27894 rtx_insn
*next_real
;
27895 rtx_insn
*call_insn
= NULL
;
27896 static const char *last_label
;
27897 static const char *last_postcall_label
;
27898 static bool last_in_cold_section_p
;
27899 static rtx_insn
*expected_next_loc_note
;
27902 var_loc_view view
= 0;
27904 if (!NOTE_P (loc_note
))
27906 if (CALL_P (loc_note
))
27908 maybe_reset_location_view (loc_note
, cur_line_info_table
);
27910 if (SIBLING_CALL_P (loc_note
))
27911 tail_call_site_count
++;
27912 if (find_reg_note (loc_note
, REG_CALL_ARG_LOCATION
, NULL_RTX
))
27914 call_insn
= loc_note
;
27918 next_real
= dwarf2out_next_real_insn (call_insn
);
27919 cached_next_real_insn
= NULL
;
27922 if (optimize
== 0 && !flag_var_tracking
)
27924 /* When the var-tracking pass is not running, there is no note
27925 for indirect calls whose target is compile-time known. In this
27926 case, process such calls specifically so that we generate call
27927 sites for them anyway. */
27928 rtx x
= PATTERN (loc_note
);
27929 if (GET_CODE (x
) == PARALLEL
)
27930 x
= XVECEXP (x
, 0, 0);
27931 if (GET_CODE (x
) == SET
)
27933 if (GET_CODE (x
) == CALL
)
27936 || GET_CODE (XEXP (x
, 0)) != SYMBOL_REF
27937 || !SYMBOL_REF_DECL (XEXP (x
, 0))
27938 || (TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0)))
27941 call_insn
= loc_note
;
27945 next_real
= dwarf2out_next_real_insn (call_insn
);
27946 cached_next_real_insn
= NULL
;
27951 else if (!debug_variable_location_views
)
27952 gcc_unreachable ();
27954 maybe_reset_location_view (loc_note
, cur_line_info_table
);
27959 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
27960 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
27963 /* Optimize processing a large consecutive sequence of location
27964 notes so we don't spend too much time in next_real_insn. If the
27965 next insn is another location note, remember the next_real_insn
27966 calculation for next time. */
27967 next_real
= cached_next_real_insn
;
27970 if (expected_next_loc_note
!= loc_note
)
27975 next_real
= dwarf2out_next_real_insn (loc_note
);
27979 rtx_insn
*next_note
= NEXT_INSN (loc_note
);
27980 while (next_note
!= next_real
)
27982 if (! next_note
->deleted ()
27983 && NOTE_P (next_note
)
27984 && NOTE_KIND (next_note
) == NOTE_INSN_VAR_LOCATION
)
27986 next_note
= NEXT_INSN (next_note
);
27989 if (next_note
== next_real
)
27990 cached_next_real_insn
= NULL
;
27993 expected_next_loc_note
= next_note
;
27994 cached_next_real_insn
= next_real
;
27998 cached_next_real_insn
= NULL
;
28000 /* If there are no instructions which would be affected by this note,
28001 don't do anything. */
28003 && next_real
== NULL_RTX
28004 && !NOTE_DURING_CALL_P (loc_note
))
28009 if (next_real
== NULL_RTX
)
28010 next_real
= get_last_insn ();
28012 /* If there were any real insns between note we processed last time
28013 and this note (or if it is the first note), clear
28014 last_{,postcall_}label so that they are not reused this time. */
28015 if (last_var_location_insn
== NULL_RTX
28016 || last_var_location_insn
!= next_real
28017 || last_in_cold_section_p
!= in_cold_section_p
)
28020 last_postcall_label
= NULL
;
28026 = NOTE_DURING_CALL_P (loc_note
) ? last_postcall_label
: last_label
;
28027 view
= cur_line_info_table
->view
;
28028 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
28029 newloc
= add_var_loc_to_decl (decl
, loc_note
, label
, view
);
28030 if (newloc
== NULL
)
28039 /* If there were no real insns between note we processed last time
28040 and this note, use the label we emitted last time. Otherwise
28041 create a new label and emit it. */
28042 if (last_label
== NULL
)
28044 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
28045 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
28047 last_label
= ggc_strdup (loclabel
);
28048 /* See if loclabel might be equal to .Ltext0. If yes,
28049 bump first_loclabel_num_not_at_text_label. */
28050 if (!have_multiple_function_sections
28051 && in_first_function_p
28052 && maybe_at_text_label_p
)
28054 static rtx_insn
*last_start
;
28056 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
28057 if (insn
== last_start
)
28059 else if (!NONDEBUG_INSN_P (insn
))
28063 rtx body
= PATTERN (insn
);
28064 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
28066 /* Inline asm could occupy zero bytes. */
28067 else if (GET_CODE (body
) == ASM_INPUT
28068 || asm_noperands (body
) >= 0)
28070 #ifdef HAVE_ATTR_length /* ??? We don't include insn-attr.h. */
28071 else if (HAVE_ATTR_length
&& get_attr_min_length (insn
) == 0)
28076 /* Assume insn has non-zero length. */
28077 maybe_at_text_label_p
= false;
28081 if (maybe_at_text_label_p
)
28083 last_start
= loc_note
;
28084 first_loclabel_num_not_at_text_label
= loclabel_num
;
28089 gcc_assert ((loc_note
== NULL_RTX
&& call_insn
!= NULL_RTX
)
28090 || (loc_note
!= NULL_RTX
&& call_insn
== NULL_RTX
));
28094 struct call_arg_loc_node
*ca_loc
28095 = ggc_cleared_alloc
<call_arg_loc_node
> ();
28096 rtx_insn
*prev
= call_insn
;
28098 ca_loc
->call_arg_loc_note
28099 = find_reg_note (call_insn
, REG_CALL_ARG_LOCATION
, NULL_RTX
);
28100 ca_loc
->next
= NULL
;
28101 ca_loc
->label
= last_label
;
28104 || (NONJUMP_INSN_P (prev
)
28105 && GET_CODE (PATTERN (prev
)) == SEQUENCE
28106 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
28107 if (!CALL_P (prev
))
28108 prev
= as_a
<rtx_sequence
*> (PATTERN (prev
))->insn (0);
28109 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
28111 /* Look for a SYMBOL_REF in the "prev" instruction. */
28112 rtx x
= get_call_rtx_from (prev
);
28115 /* Try to get the call symbol, if any. */
28116 if (MEM_P (XEXP (x
, 0)))
28118 /* First, look for a memory access to a symbol_ref. */
28119 if (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
28120 && SYMBOL_REF_DECL (XEXP (x
, 0))
28121 && TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0))) == FUNCTION_DECL
)
28122 ca_loc
->symbol_ref
= XEXP (x
, 0);
28123 /* Otherwise, look at a compile-time known user-level function
28127 && TREE_CODE (MEM_EXPR (x
)) == FUNCTION_DECL
)
28128 ca_loc
->symbol_ref
= XEXP (DECL_RTL (MEM_EXPR (x
)), 0);
28131 ca_loc
->block
= insn_scope (prev
);
28132 if (call_arg_locations
)
28133 call_arg_loc_last
->next
= ca_loc
;
28135 call_arg_locations
= ca_loc
;
28136 call_arg_loc_last
= ca_loc
;
28138 else if (loc_note
!= NULL_RTX
&& !NOTE_DURING_CALL_P (loc_note
))
28140 newloc
->label
= last_label
;
28141 newloc
->view
= view
;
28145 if (!last_postcall_label
)
28147 sprintf (loclabel
, "%s-1", last_label
);
28148 last_postcall_label
= ggc_strdup (loclabel
);
28150 newloc
->label
= last_postcall_label
;
28151 /* ??? This view is at last_label, not last_label-1, but we
28152 could only assume view at last_label-1 is zero if we could
28153 assume calls always have length greater than one. This is
28154 probably true in general, though there might be a rare
28155 exception to this rule, e.g. if a call insn is optimized out
28156 by target magic. Then, even the -1 in the label will be
28157 wrong, which might invalidate the range. Anyway, using view,
28158 though technically possibly incorrect, will work as far as
28159 ranges go: since L-1 is in the middle of the call insn,
28160 (L-1).0 and (L-1).V shouldn't make any difference, and having
28161 the loclist entry refer to the .loc entry might be useful, so
28162 leave it like this. */
28163 newloc
->view
= view
;
28166 if (var_loc_p
&& flag_debug_asm
)
28168 const char *name
, *sep
, *patstr
;
28169 if (decl
&& DECL_NAME (decl
))
28170 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
28173 if (NOTE_VAR_LOCATION_LOC (loc_note
))
28176 patstr
= str_pattern_slim (NOTE_VAR_LOCATION_LOC (loc_note
));
28183 fprintf (asm_out_file
, "\t%s DEBUG %s%s%s\n", ASM_COMMENT_START
,
28184 name
, sep
, patstr
);
28187 last_var_location_insn
= next_real
;
28188 last_in_cold_section_p
= in_cold_section_p
;
28191 /* Check whether BLOCK, a lexical block, is nested within OUTER, or is
28192 OUTER itself. If BOTHWAYS, check not only that BLOCK can reach
28193 OUTER through BLOCK_SUPERCONTEXT links, but also that there is a
28194 path from OUTER to BLOCK through BLOCK_SUBBLOCKs and
28195 BLOCK_FRAGMENT_ORIGIN links. */
28197 block_within_block_p (tree block
, tree outer
, bool bothways
)
28199 if (block
== outer
)
28202 /* Quickly check that OUTER is up BLOCK's supercontext chain. */
28203 for (tree context
= BLOCK_SUPERCONTEXT (block
);
28205 context
= BLOCK_SUPERCONTEXT (context
))
28206 if (!context
|| TREE_CODE (context
) != BLOCK
)
28212 /* Now check that each block is actually referenced by its
28214 for (tree context
= BLOCK_SUPERCONTEXT (block
); ;
28215 context
= BLOCK_SUPERCONTEXT (context
))
28217 if (BLOCK_FRAGMENT_ORIGIN (context
))
28219 gcc_assert (!BLOCK_SUBBLOCKS (context
));
28220 context
= BLOCK_FRAGMENT_ORIGIN (context
);
28222 for (tree sub
= BLOCK_SUBBLOCKS (context
);
28224 sub
= BLOCK_CHAIN (sub
))
28227 if (context
== outer
)
28234 /* Called during final while assembling the marker of the entry point
28235 for an inlined function. */
28238 dwarf2out_inline_entry (tree block
)
28240 gcc_assert (debug_inline_points
);
28242 /* If we can't represent it, don't bother. */
28243 if (!(dwarf_version
>= 3 || !dwarf_strict
))
28246 gcc_assert (DECL_P (block_ultimate_origin (block
)));
28248 /* Sanity check the block tree. This would catch a case in which
28249 BLOCK got removed from the tree reachable from the outermost
28250 lexical block, but got retained in markers. It would still link
28251 back to its parents, but some ancestor would be missing a link
28252 down the path to the sub BLOCK. If the block got removed, its
28253 BLOCK_NUMBER will not be a usable value. */
28255 gcc_assert (block_within_block_p (block
,
28256 DECL_INITIAL (current_function_decl
),
28259 gcc_assert (inlined_function_outer_scope_p (block
));
28260 gcc_assert (!lookup_block_die (block
));
28262 if (BLOCK_FRAGMENT_ORIGIN (block
))
28263 block
= BLOCK_FRAGMENT_ORIGIN (block
);
28264 /* Can the entry point ever not be at the beginning of an
28265 unfragmented lexical block? */
28266 else if (!(BLOCK_FRAGMENT_CHAIN (block
)
28267 || (cur_line_info_table
28268 && !ZERO_VIEW_P (cur_line_info_table
->view
))))
28271 if (!inline_entry_data_table
)
28272 inline_entry_data_table
28273 = hash_table
<inline_entry_data_hasher
>::create_ggc (10);
28276 inline_entry_data
**iedp
28277 = inline_entry_data_table
->find_slot_with_hash (block
,
28278 htab_hash_pointer (block
),
28281 /* ??? Ideally, we'd record all entry points for the same inlined
28282 function (some may have been duplicated by e.g. unrolling), but
28283 we have no way to represent that ATM. */
28286 inline_entry_data
*ied
= *iedp
= ggc_cleared_alloc
<inline_entry_data
> ();
28287 ied
->block
= block
;
28288 ied
->label_pfx
= BLOCK_INLINE_ENTRY_LABEL
;
28289 ied
->label_num
= BLOCK_NUMBER (block
);
28290 if (cur_line_info_table
)
28291 ied
->view
= cur_line_info_table
->view
;
28293 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_INLINE_ENTRY_LABEL
,
28294 BLOCK_NUMBER (block
));
28297 /* Called from finalize_size_functions for size functions so that their body
28298 can be encoded in the debug info to describe the layout of variable-length
28302 dwarf2out_size_function (tree decl
)
28305 function_to_dwarf_procedure (decl
);
28308 /* Note in one location list that text section has changed. */
28311 var_location_switch_text_section_1 (var_loc_list
**slot
, void *)
28313 var_loc_list
*list
= *slot
;
28315 list
->last_before_switch
28316 = list
->last
->next
? list
->last
->next
: list
->last
;
28320 /* Note in all location lists that text section has changed. */
28323 var_location_switch_text_section (void)
28325 if (decl_loc_table
== NULL
)
28328 decl_loc_table
->traverse
<void *, var_location_switch_text_section_1
> (NULL
);
28331 /* Create a new line number table. */
28333 static dw_line_info_table
*
28334 new_line_info_table (void)
28336 dw_line_info_table
*table
;
28338 table
= ggc_cleared_alloc
<dw_line_info_table
> ();
28339 table
->file_num
= 1;
28340 table
->line_num
= 1;
28341 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
28342 FORCE_RESET_NEXT_VIEW (table
->view
);
28343 table
->symviews_since_reset
= 0;
28348 /* Lookup the "current" table into which we emit line info, so
28349 that we don't have to do it for every source line. */
28352 set_cur_line_info_table (section
*sec
)
28354 dw_line_info_table
*table
;
28356 if (sec
== text_section
)
28357 table
= text_section_line_info
;
28358 else if (sec
== cold_text_section
)
28360 table
= cold_text_section_line_info
;
28363 cold_text_section_line_info
= table
= new_line_info_table ();
28364 table
->end_label
= cold_end_label
;
28369 const char *end_label
;
28371 if (crtl
->has_bb_partition
)
28373 if (in_cold_section_p
)
28374 end_label
= crtl
->subsections
.cold_section_end_label
;
28376 end_label
= crtl
->subsections
.hot_section_end_label
;
28380 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28381 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
28382 current_function_funcdef_no
);
28383 end_label
= ggc_strdup (label
);
28386 table
= new_line_info_table ();
28387 table
->end_label
= end_label
;
28389 vec_safe_push (separate_line_info
, table
);
28392 if (output_asm_line_debug_info ())
28393 table
->is_stmt
= (cur_line_info_table
28394 ? cur_line_info_table
->is_stmt
28395 : DWARF_LINE_DEFAULT_IS_STMT_START
);
28396 cur_line_info_table
= table
;
28400 /* We need to reset the locations at the beginning of each
28401 function. We can't do this in the end_function hook, because the
28402 declarations that use the locations won't have been output when
28403 that hook is called. Also compute have_multiple_function_sections here. */
28406 dwarf2out_begin_function (tree fun
)
28408 section
*sec
= function_section (fun
);
28410 if (sec
!= text_section
)
28411 have_multiple_function_sections
= true;
28413 if (crtl
->has_bb_partition
&& !cold_text_section
)
28415 gcc_assert (current_function_decl
== fun
);
28416 cold_text_section
= unlikely_text_section ();
28417 switch_to_section (cold_text_section
);
28418 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
28419 switch_to_section (sec
);
28422 call_site_count
= 0;
28423 tail_call_site_count
= 0;
28425 set_cur_line_info_table (sec
);
28426 FORCE_RESET_NEXT_VIEW (cur_line_info_table
->view
);
28429 /* Helper function of dwarf2out_end_function, called only after emitting
28430 the very first function into assembly. Check if some .debug_loc range
28431 might end with a .LVL* label that could be equal to .Ltext0.
28432 In that case we must force using absolute addresses in .debug_loc ranges,
28433 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
28434 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
28436 Set have_multiple_function_sections to true in that case and
28437 terminate htab traversal. */
28440 find_empty_loc_ranges_at_text_label (var_loc_list
**slot
, int)
28442 var_loc_list
*entry
= *slot
;
28443 struct var_loc_node
*node
;
28445 node
= entry
->first
;
28446 if (node
&& node
->next
&& node
->next
->label
)
28449 const char *label
= node
->next
->label
;
28450 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
28452 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
28454 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
28455 if (strcmp (label
, loclabel
) == 0)
28457 have_multiple_function_sections
= true;
28465 /* Hook called after emitting a function into assembly.
28466 This does something only for the very first function emitted. */
28469 dwarf2out_end_function (unsigned int)
28471 if (in_first_function_p
28472 && !have_multiple_function_sections
28473 && first_loclabel_num_not_at_text_label
28475 decl_loc_table
->traverse
<int, find_empty_loc_ranges_at_text_label
> (0);
28476 in_first_function_p
= false;
28477 maybe_at_text_label_p
= false;
28480 /* Temporary holder for dwarf2out_register_main_translation_unit. Used to let
28481 front-ends register a translation unit even before dwarf2out_init is
28483 static tree main_translation_unit
= NULL_TREE
;
28485 /* Hook called by front-ends after they built their main translation unit.
28486 Associate comp_unit_die to UNIT. */
28489 dwarf2out_register_main_translation_unit (tree unit
)
28491 gcc_assert (TREE_CODE (unit
) == TRANSLATION_UNIT_DECL
28492 && main_translation_unit
== NULL_TREE
);
28493 main_translation_unit
= unit
;
28494 /* If dwarf2out_init has not been called yet, it will perform the association
28495 itself looking at main_translation_unit. */
28496 if (decl_die_table
!= NULL
)
28497 equate_decl_number_to_die (unit
, comp_unit_die ());
28500 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
28503 push_dw_line_info_entry (dw_line_info_table
*table
,
28504 enum dw_line_info_opcode opcode
, unsigned int val
)
28506 dw_line_info_entry e
;
28509 vec_safe_push (table
->entries
, e
);
28512 /* Output a label to mark the beginning of a source code line entry
28513 and record information relating to this source line, in
28514 'line_info_table' for later output of the .debug_line section. */
28515 /* ??? The discriminator parameter ought to be unsigned. */
28518 dwarf2out_source_line (unsigned int line
, unsigned int column
,
28519 const char *filename
,
28520 int discriminator
, bool is_stmt
)
28522 unsigned int file_num
;
28523 dw_line_info_table
*table
;
28524 static var_loc_view lvugid
;
28526 /* 'line_info_table' information gathering is not needed when the debug
28527 info level is set to the lowest value. Also, the current DWARF-based
28528 debug formats do not use this info. */
28529 if (debug_info_level
< DINFO_LEVEL_TERSE
|| !dwarf_debuginfo_p ())
28532 table
= cur_line_info_table
;
28536 if (debug_variable_location_views
28537 && output_asm_line_debug_info ()
28538 && table
&& !RESETTING_VIEW_P (table
->view
))
28540 /* If we're using the assembler to compute view numbers, we
28541 can't issue a .loc directive for line zero, so we can't
28542 get a view number at this point. We might attempt to
28543 compute it from the previous view, or equate it to a
28544 subsequent view (though it might not be there!), but
28545 since we're omitting the line number entry, we might as
28546 well omit the view number as well. That means pretending
28547 it's a view number zero, which might very well turn out
28548 to be correct. ??? Extend the assembler so that the
28549 compiler could emit e.g. ".locview .LVU#", to output a
28550 view without changing line number information. We'd then
28551 have to count it in symviews_since_reset; when it's omitted,
28552 it doesn't count. */
28554 zero_view_p
= BITMAP_GGC_ALLOC ();
28555 bitmap_set_bit (zero_view_p
, table
->view
);
28556 if (flag_debug_asm
)
28558 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28559 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", table
->view
);
28560 fprintf (asm_out_file
, "\t%s line 0, omitted view ",
28561 ASM_COMMENT_START
);
28562 assemble_name (asm_out_file
, label
);
28563 putc ('\n', asm_out_file
);
28565 table
->view
= ++lvugid
;
28570 /* The discriminator column was added in dwarf4. Simplify the below
28571 by simply removing it if we're not supposed to output it. */
28572 if (dwarf_version
< 4 && dwarf_strict
)
28575 if (!debug_column_info
)
28578 file_num
= maybe_emit_file (lookup_filename (filename
));
28580 /* ??? TODO: Elide duplicate line number entries. Traditionally,
28581 the debugger has used the second (possibly duplicate) line number
28582 at the beginning of the function to mark the end of the prologue.
28583 We could eliminate any other duplicates within the function. For
28584 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
28585 that second line number entry. */
28586 /* Recall that this end-of-prologue indication is *not* the same thing
28587 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
28588 to which the hook corresponds, follows the last insn that was
28589 emitted by gen_prologue. What we need is to precede the first insn
28590 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
28591 insn that corresponds to something the user wrote. These may be
28592 very different locations once scheduling is enabled. */
28594 if (0 && file_num
== table
->file_num
28595 && line
== table
->line_num
28596 && column
== table
->column_num
28597 && discriminator
== table
->discrim_num
28598 && is_stmt
== table
->is_stmt
)
28601 switch_to_section (current_function_section ());
28603 /* If requested, emit something human-readable. */
28604 if (flag_debug_asm
)
28606 if (debug_column_info
)
28607 fprintf (asm_out_file
, "\t%s %s:%d:%d\n", ASM_COMMENT_START
,
28608 filename
, line
, column
);
28610 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
28614 if (output_asm_line_debug_info ())
28616 /* Emit the .loc directive understood by GNU as. */
28617 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
28618 file_num, line, is_stmt, discriminator */
28619 fputs ("\t.loc ", asm_out_file
);
28620 fprint_ul (asm_out_file
, file_num
);
28621 putc (' ', asm_out_file
);
28622 fprint_ul (asm_out_file
, line
);
28623 putc (' ', asm_out_file
);
28624 fprint_ul (asm_out_file
, column
);
28626 if (is_stmt
!= table
->is_stmt
)
28628 #if HAVE_GAS_LOC_STMT
28629 fputs (" is_stmt ", asm_out_file
);
28630 putc (is_stmt
? '1' : '0', asm_out_file
);
28633 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
28635 gcc_assert (discriminator
> 0);
28636 fputs (" discriminator ", asm_out_file
);
28637 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
28639 if (debug_variable_location_views
)
28641 if (!RESETTING_VIEW_P (table
->view
))
28643 table
->symviews_since_reset
++;
28644 if (table
->symviews_since_reset
> symview_upper_bound
)
28645 symview_upper_bound
= table
->symviews_since_reset
;
28646 /* When we're using the assembler to compute view
28647 numbers, we output symbolic labels after "view" in
28648 .loc directives, and the assembler will set them for
28649 us, so that we can refer to the view numbers in
28650 location lists. The only exceptions are when we know
28651 a view will be zero: "-0" is a forced reset, used
28652 e.g. in the beginning of functions, whereas "0" tells
28653 the assembler to check that there was a PC change
28654 since the previous view, in a way that implicitly
28655 resets the next view. */
28656 fputs (" view ", asm_out_file
);
28657 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28658 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", table
->view
);
28659 assemble_name (asm_out_file
, label
);
28660 table
->view
= ++lvugid
;
28664 table
->symviews_since_reset
= 0;
28665 if (FORCE_RESETTING_VIEW_P (table
->view
))
28666 fputs (" view -0", asm_out_file
);
28668 fputs (" view 0", asm_out_file
);
28669 /* Mark the present view as a zero view. Earlier debug
28670 binds may have already added its id to loclists to be
28671 emitted later, so we can't reuse the id for something
28672 else. However, it's good to know whether a view is
28673 known to be zero, because then we may be able to
28674 optimize out locviews that are all zeros, so take
28675 note of it in zero_view_p. */
28677 zero_view_p
= BITMAP_GGC_ALLOC ();
28678 bitmap_set_bit (zero_view_p
, lvugid
);
28679 table
->view
= ++lvugid
;
28682 putc ('\n', asm_out_file
);
28686 unsigned int label_num
= ++line_info_label_num
;
28688 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
28690 if (debug_variable_location_views
&& !RESETTING_VIEW_P (table
->view
))
28691 push_dw_line_info_entry (table
, LI_adv_address
, label_num
);
28693 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
28694 if (debug_variable_location_views
)
28696 bool resetting
= FORCE_RESETTING_VIEW_P (table
->view
);
28700 if (flag_debug_asm
)
28701 fprintf (asm_out_file
, "\t%s view %s%d\n",
28703 resetting
? "-" : "",
28708 if (file_num
!= table
->file_num
)
28709 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
28710 if (discriminator
!= table
->discrim_num
)
28711 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
28712 if (is_stmt
!= table
->is_stmt
)
28713 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
28714 push_dw_line_info_entry (table
, LI_set_line
, line
);
28715 if (debug_column_info
)
28716 push_dw_line_info_entry (table
, LI_set_column
, column
);
28719 table
->file_num
= file_num
;
28720 table
->line_num
= line
;
28721 table
->column_num
= column
;
28722 table
->discrim_num
= discriminator
;
28723 table
->is_stmt
= is_stmt
;
28724 table
->in_use
= true;
28727 /* Record a source file location for a DECL_IGNORED_P function. */
28730 dwarf2out_set_ignored_loc (unsigned int line
, unsigned int column
,
28731 const char *filename
)
28733 dw_fde_ref fde
= cfun
->fde
;
28735 fde
->ignored_debug
= false;
28736 set_cur_line_info_table (function_section (fde
->decl
));
28738 dwarf2out_source_line (line
, column
, filename
, 0, true);
28741 /* Record the beginning of a new source file. */
28744 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
28746 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28749 e
.code
= DW_MACINFO_start_file
;
28751 e
.info
= ggc_strdup (filename
);
28752 vec_safe_push (macinfo_table
, e
);
28756 /* Record the end of a source file. */
28759 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
28761 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28764 e
.code
= DW_MACINFO_end_file
;
28767 vec_safe_push (macinfo_table
, e
);
28771 /* Called from debug_define in toplev.cc. The `buffer' parameter contains
28772 the tail part of the directive line, i.e. the part which is past the
28773 initial whitespace, #, whitespace, directive-name, whitespace part. */
28776 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
28777 const char *buffer ATTRIBUTE_UNUSED
)
28779 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28782 /* Insert a dummy first entry to be able to optimize the whole
28783 predefined macro block using DW_MACRO_import. */
28784 if (macinfo_table
->is_empty () && lineno
<= 1)
28789 vec_safe_push (macinfo_table
, e
);
28791 e
.code
= DW_MACINFO_define
;
28793 e
.info
= ggc_strdup (buffer
);
28794 vec_safe_push (macinfo_table
, e
);
28798 /* Called from debug_undef in toplev.cc. The `buffer' parameter contains
28799 the tail part of the directive line, i.e. the part which is past the
28800 initial whitespace, #, whitespace, directive-name, whitespace part. */
28803 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
28804 const char *buffer ATTRIBUTE_UNUSED
)
28806 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28809 /* Insert a dummy first entry to be able to optimize the whole
28810 predefined macro block using DW_MACRO_import. */
28811 if (macinfo_table
->is_empty () && lineno
<= 1)
28816 vec_safe_push (macinfo_table
, e
);
28818 e
.code
= DW_MACINFO_undef
;
28820 e
.info
= ggc_strdup (buffer
);
28821 vec_safe_push (macinfo_table
, e
);
28825 /* Helpers to manipulate hash table of CUs. */
28827 struct macinfo_entry_hasher
: nofree_ptr_hash
<macinfo_entry
>
28829 static inline hashval_t
hash (const macinfo_entry
*);
28830 static inline bool equal (const macinfo_entry
*, const macinfo_entry
*);
28834 macinfo_entry_hasher::hash (const macinfo_entry
*entry
)
28836 return htab_hash_string (entry
->info
);
28840 macinfo_entry_hasher::equal (const macinfo_entry
*entry1
,
28841 const macinfo_entry
*entry2
)
28843 return !strcmp (entry1
->info
, entry2
->info
);
28846 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
28848 /* Output a single .debug_macinfo entry. */
28851 output_macinfo_op (macinfo_entry
*ref
)
28855 struct indirect_string_node
*node
;
28856 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28857 struct dwarf_file_data
*fd
;
28861 case DW_MACINFO_start_file
:
28862 fd
= lookup_filename (ref
->info
);
28863 file_num
= maybe_emit_file (fd
);
28864 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
28865 dw2_asm_output_data_uleb128 (ref
->lineno
,
28866 "Included from line number %lu",
28867 (unsigned long) ref
->lineno
);
28868 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
28870 case DW_MACINFO_end_file
:
28871 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
28873 case DW_MACINFO_define
:
28874 case DW_MACINFO_undef
:
28875 len
= strlen (ref
->info
) + 1;
28876 if ((!dwarf_strict
|| dwarf_version
>= 5)
28877 && len
> (size_t) dwarf_offset_size
28878 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
28879 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
28881 if (dwarf_split_debug_info
&& dwarf_version
>= 5)
28882 ref
->code
= ref
->code
== DW_MACINFO_define
28883 ? DW_MACRO_define_strx
: DW_MACRO_undef_strx
;
28885 ref
->code
= ref
->code
== DW_MACINFO_define
28886 ? DW_MACRO_define_strp
: DW_MACRO_undef_strp
;
28887 output_macinfo_op (ref
);
28890 dw2_asm_output_data (1, ref
->code
,
28891 ref
->code
== DW_MACINFO_define
28892 ? "Define macro" : "Undefine macro");
28893 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
28894 (unsigned long) ref
->lineno
);
28895 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
28897 case DW_MACRO_define_strp
:
28898 dw2_asm_output_data (1, ref
->code
, "Define macro strp");
28899 goto do_DW_MACRO_define_strpx
;
28900 case DW_MACRO_undef_strp
:
28901 dw2_asm_output_data (1, ref
->code
, "Undefine macro strp");
28902 goto do_DW_MACRO_define_strpx
;
28903 case DW_MACRO_define_strx
:
28904 dw2_asm_output_data (1, ref
->code
, "Define macro strx");
28905 goto do_DW_MACRO_define_strpx
;
28906 case DW_MACRO_undef_strx
:
28907 dw2_asm_output_data (1, ref
->code
, "Undefine macro strx");
28909 do_DW_MACRO_define_strpx
:
28910 /* NB: dwarf2out_finish performs:
28911 1. save_macinfo_strings
28912 2. hash table traverse of index_string
28913 3. output_macinfo -> output_macinfo_op
28914 4. output_indirect_strings
28915 -> hash table traverse of output_index_string
28917 When output_macinfo_op is called, all index strings have been
28918 added to hash table by save_macinfo_strings and we can't pass
28919 INSERT to find_slot_with_hash which may expand hash table, even
28920 if no insertion is needed, and change hash table traverse order
28921 between index_string and output_index_string. */
28922 node
= find_AT_string (ref
->info
, NO_INSERT
);
28924 && (node
->form
== DW_FORM_strp
28925 || node
->form
== dwarf_FORM (DW_FORM_strx
)));
28926 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
28927 (unsigned long) ref
->lineno
);
28928 if (node
->form
== DW_FORM_strp
)
28929 dw2_asm_output_offset (dwarf_offset_size
, node
->label
,
28930 debug_str_section
, "The macro: \"%s\"",
28933 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
28936 case DW_MACRO_import
:
28937 dw2_asm_output_data (1, ref
->code
, "Import");
28938 ASM_GENERATE_INTERNAL_LABEL (label
,
28939 DEBUG_MACRO_SECTION_LABEL
,
28940 ref
->lineno
+ macinfo_label_base
);
28941 dw2_asm_output_offset (dwarf_offset_size
, label
, NULL
, NULL
);
28944 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
28945 ASM_COMMENT_START
, (unsigned long) ref
->code
);
28950 /* Attempt to make a sequence of define/undef macinfo ops shareable with
28951 other compilation unit .debug_macinfo sections. IDX is the first
28952 index of a define/undef, return the number of ops that should be
28953 emitted in a comdat .debug_macinfo section and emit
28954 a DW_MACRO_import entry referencing it.
28955 If the define/undef entry should be emitted normally, return 0. */
28958 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
28959 macinfo_hash_type
**macinfo_htab
)
28961 macinfo_entry
*first
, *second
, *cur
, *inc
;
28962 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
28963 unsigned char checksum
[16];
28964 struct md5_ctx ctx
;
28965 char *grp_name
, *tail
;
28967 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
28968 macinfo_entry
**slot
;
28970 first
= &(*macinfo_table
)[idx
];
28971 second
= &(*macinfo_table
)[idx
+ 1];
28973 /* Optimize only if there are at least two consecutive define/undef ops,
28974 and either all of them are before first DW_MACINFO_start_file
28975 with lineno {0,1} (i.e. predefined macro block), or all of them are
28976 in some included header file. */
28977 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
28979 if (vec_safe_is_empty (files
))
28981 if (first
->lineno
> 1 || second
->lineno
> 1)
28984 else if (first
->lineno
== 0)
28987 /* Find the last define/undef entry that can be grouped together
28988 with first and at the same time compute md5 checksum of their
28989 codes, linenumbers and strings. */
28990 md5_init_ctx (&ctx
);
28991 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
28992 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
28994 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
28998 unsigned char code
= cur
->code
;
28999 md5_process_bytes (&code
, 1, &ctx
);
29000 checksum_uleb128 (cur
->lineno
, &ctx
);
29001 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
29003 md5_finish_ctx (&ctx
, checksum
);
29006 /* From the containing include filename (if any) pick up just
29007 usable characters from its basename. */
29008 if (vec_safe_is_empty (files
))
29011 base
= lbasename (files
->last ().info
);
29012 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
29013 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
29014 encoded_filename_len
++;
29015 /* Count . at the end. */
29016 if (encoded_filename_len
)
29017 encoded_filename_len
++;
29019 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
29020 linebuf_len
= strlen (linebuf
);
29022 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
29023 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
29025 memcpy (grp_name
, dwarf_offset_size
== 4 ? "wm4." : "wm8.", 4);
29026 tail
= grp_name
+ 4;
29027 if (encoded_filename_len
)
29029 for (i
= 0; base
[i
]; i
++)
29030 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
29034 memcpy (tail
, linebuf
, linebuf_len
);
29035 tail
+= linebuf_len
;
29037 for (i
= 0; i
< 16; i
++)
29038 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
29040 /* Construct a macinfo_entry for DW_MACRO_import
29041 in the empty vector entry before the first define/undef. */
29042 inc
= &(*macinfo_table
)[idx
- 1];
29043 inc
->code
= DW_MACRO_import
;
29045 inc
->info
= ggc_strdup (grp_name
);
29046 if (!*macinfo_htab
)
29047 *macinfo_htab
= new macinfo_hash_type (10);
29048 /* Avoid emitting duplicates. */
29049 slot
= (*macinfo_htab
)->find_slot (inc
, INSERT
);
29054 /* If such an entry has been used before, just emit
29055 a DW_MACRO_import op. */
29057 output_macinfo_op (inc
);
29058 /* And clear all macinfo_entry in the range to avoid emitting them
29059 in the second pass. */
29060 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
29069 inc
->lineno
= (*macinfo_htab
)->elements ();
29070 output_macinfo_op (inc
);
29075 /* Save any strings needed by the macinfo table in the debug str
29076 table. All strings must be collected into the table by the time
29077 index_string is called. */
29080 save_macinfo_strings (void)
29084 macinfo_entry
*ref
;
29086 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
29090 /* Match the logic in output_macinfo_op to decide on
29091 indirect strings. */
29092 case DW_MACINFO_define
:
29093 case DW_MACINFO_undef
:
29094 len
= strlen (ref
->info
) + 1;
29095 if ((!dwarf_strict
|| dwarf_version
>= 5)
29096 && len
> (unsigned) dwarf_offset_size
29097 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
29098 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
29099 set_indirect_string (find_AT_string (ref
->info
));
29101 case DW_MACINFO_start_file
:
29102 /* -gsplit-dwarf -g3 will also output filename as indirect
29104 if (!dwarf_split_debug_info
)
29106 /* Fall through. */
29107 case DW_MACRO_define_strp
:
29108 case DW_MACRO_undef_strp
:
29109 case DW_MACRO_define_strx
:
29110 case DW_MACRO_undef_strx
:
29111 set_indirect_string (find_AT_string (ref
->info
));
29119 /* Output macinfo section(s). */
29122 output_macinfo (const char *debug_line_label
, bool early_lto_debug
)
29125 unsigned long length
= vec_safe_length (macinfo_table
);
29126 macinfo_entry
*ref
;
29127 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
29128 macinfo_hash_type
*macinfo_htab
= NULL
;
29129 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
29134 /* output_macinfo* uses these interchangeably. */
29135 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_define
29136 && (int) DW_MACINFO_undef
== (int) DW_MACRO_undef
29137 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_start_file
29138 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_end_file
);
29140 /* AIX Assembler inserts the length, so adjust the reference to match the
29141 offset expected by debuggers. */
29142 strcpy (dl_section_ref
, debug_line_label
);
29143 if (XCOFF_DEBUGGING_INFO
)
29144 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
29146 /* For .debug_macro emit the section header. */
29147 if (!dwarf_strict
|| dwarf_version
>= 5)
29149 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
29150 "DWARF macro version number");
29151 if (dwarf_offset_size
== 8)
29152 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
29154 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
29155 dw2_asm_output_offset (dwarf_offset_size
, debug_line_label
,
29156 debug_line_section
, NULL
);
29159 /* In the first loop, it emits the primary .debug_macinfo section
29160 and after each emitted op the macinfo_entry is cleared.
29161 If a longer range of define/undef ops can be optimized using
29162 DW_MACRO_import, the DW_MACRO_import op is emitted and kept in
29163 the vector before the first define/undef in the range and the
29164 whole range of define/undef ops is not emitted and kept. */
29165 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
29169 case DW_MACINFO_start_file
:
29170 vec_safe_push (files
, *ref
);
29172 case DW_MACINFO_end_file
:
29173 if (!vec_safe_is_empty (files
))
29176 case DW_MACINFO_define
:
29177 case DW_MACINFO_undef
:
29178 if ((!dwarf_strict
|| dwarf_version
>= 5)
29179 && HAVE_COMDAT_GROUP
29180 && vec_safe_length (files
) != 1
29183 && (*macinfo_table
)[i
- 1].code
== 0)
29185 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
29194 /* A dummy entry may be inserted at the beginning to be able
29195 to optimize the whole block of predefined macros. */
29201 output_macinfo_op (ref
);
29209 /* Save the number of transparent includes so we can adjust the
29210 label number for the fat LTO object DWARF. */
29211 unsigned macinfo_label_base_adj
= macinfo_htab
->elements ();
29213 delete macinfo_htab
;
29214 macinfo_htab
= NULL
;
29216 /* If any DW_MACRO_import were used, on those DW_MACRO_import entries
29217 terminate the current chain and switch to a new comdat .debug_macinfo
29218 section and emit the define/undef entries within it. */
29219 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
29224 case DW_MACRO_import
:
29226 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
29227 tree comdat_key
= get_identifier (ref
->info
);
29228 /* Terminate the previous .debug_macinfo section. */
29229 dw2_asm_output_data (1, 0, "End compilation unit");
29230 targetm
.asm_out
.named_section (debug_macinfo_section_name
,
29234 ? SECTION_EXCLUDE
: 0),
29236 ASM_GENERATE_INTERNAL_LABEL (label
,
29237 DEBUG_MACRO_SECTION_LABEL
,
29238 ref
->lineno
+ macinfo_label_base
);
29239 ASM_OUTPUT_LABEL (asm_out_file
, label
);
29242 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
29243 "DWARF macro version number");
29244 if (dwarf_offset_size
== 8)
29245 dw2_asm_output_data (1, 1, "Flags: 64-bit");
29247 dw2_asm_output_data (1, 0, "Flags: 32-bit");
29250 case DW_MACINFO_define
:
29251 case DW_MACINFO_undef
:
29252 output_macinfo_op (ref
);
29257 gcc_unreachable ();
29260 macinfo_label_base
+= macinfo_label_base_adj
;
29263 /* As init_sections_and_labels may get called multiple times, have a
29264 generation count for labels. */
29265 static unsigned init_sections_and_labels_generation
;
29267 /* Initialize the various sections and labels for dwarf output and prefix
29268 them with PREFIX if non-NULL. Returns the generation (zero based
29269 number of times function was called). */
29272 init_sections_and_labels (bool early_lto_debug
)
29274 if (early_lto_debug
)
29276 if (!dwarf_split_debug_info
)
29278 debug_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
29279 SECTION_DEBUG
| SECTION_EXCLUDE
,
29281 debug_abbrev_section
= get_section (DEBUG_LTO_ABBREV_SECTION
,
29282 SECTION_DEBUG
| SECTION_EXCLUDE
,
29284 debug_macinfo_section_name
29285 = ((dwarf_strict
&& dwarf_version
< 5)
29286 ? DEBUG_LTO_MACINFO_SECTION
: DEBUG_LTO_MACRO_SECTION
);
29287 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
29289 | SECTION_EXCLUDE
, NULL
);
29293 /* ??? Which of the following do we need early? */
29294 debug_info_section
= get_section (DEBUG_LTO_DWO_INFO_SECTION
,
29295 SECTION_DEBUG
| SECTION_EXCLUDE
,
29297 debug_abbrev_section
= get_section (DEBUG_LTO_DWO_ABBREV_SECTION
,
29298 SECTION_DEBUG
| SECTION_EXCLUDE
,
29300 debug_skeleton_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
29302 | SECTION_EXCLUDE
, NULL
);
29303 debug_skeleton_abbrev_section
29304 = get_section (DEBUG_LTO_ABBREV_SECTION
,
29305 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
29306 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
29307 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
29308 init_sections_and_labels_generation
);
29310 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
29311 stay in the main .o, but the skeleton_line goes into the split
29313 debug_skeleton_line_section
29314 = get_section (DEBUG_LTO_LINE_SECTION
,
29315 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
29316 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
29317 DEBUG_SKELETON_LINE_SECTION_LABEL
,
29318 init_sections_and_labels_generation
);
29319 debug_str_offsets_section
29320 = get_section (DEBUG_LTO_DWO_STR_OFFSETS_SECTION
,
29321 SECTION_DEBUG
| SECTION_EXCLUDE
,
29323 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
29324 DEBUG_SKELETON_INFO_SECTION_LABEL
,
29325 init_sections_and_labels_generation
);
29326 debug_str_dwo_section
= get_section (DEBUG_LTO_STR_DWO_SECTION
,
29327 DEBUG_STR_DWO_SECTION_FLAGS
,
29329 debug_macinfo_section_name
29330 = ((dwarf_strict
&& dwarf_version
< 5)
29331 ? DEBUG_LTO_DWO_MACINFO_SECTION
: DEBUG_LTO_DWO_MACRO_SECTION
);
29332 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
29333 SECTION_DEBUG
| SECTION_EXCLUDE
,
29336 /* For macro info and the file table we have to refer to a
29337 debug_line section. */
29338 debug_line_section
= get_section (DEBUG_LTO_LINE_SECTION
,
29339 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
29340 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
29341 DEBUG_LINE_SECTION_LABEL
,
29342 init_sections_and_labels_generation
);
29344 debug_str_section
= get_section (DEBUG_LTO_STR_SECTION
,
29345 DEBUG_STR_SECTION_FLAGS
29346 | SECTION_EXCLUDE
, NULL
);
29347 if (!dwarf_split_debug_info
)
29348 debug_line_str_section
29349 = get_section (DEBUG_LTO_LINE_STR_SECTION
,
29350 DEBUG_STR_SECTION_FLAGS
| SECTION_EXCLUDE
, NULL
);
29354 if (!dwarf_split_debug_info
)
29356 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
29357 SECTION_DEBUG
, NULL
);
29358 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
29359 SECTION_DEBUG
, NULL
);
29360 debug_loc_section
= get_section (dwarf_version
>= 5
29361 ? DEBUG_LOCLISTS_SECTION
29362 : DEBUG_LOC_SECTION
,
29363 SECTION_DEBUG
, NULL
);
29364 debug_macinfo_section_name
29365 = ((dwarf_strict
&& dwarf_version
< 5)
29366 ? DEBUG_MACINFO_SECTION
: DEBUG_MACRO_SECTION
);
29367 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
29368 SECTION_DEBUG
, NULL
);
29372 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
29373 SECTION_DEBUG
| SECTION_EXCLUDE
,
29375 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
29376 SECTION_DEBUG
| SECTION_EXCLUDE
,
29378 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
29379 SECTION_DEBUG
, NULL
);
29380 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
29381 SECTION_DEBUG
, NULL
);
29382 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
29383 SECTION_DEBUG
, NULL
);
29384 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
29385 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
29386 init_sections_and_labels_generation
);
29388 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
29389 stay in the main .o, but the skeleton_line goes into the
29391 debug_skeleton_line_section
29392 = get_section (DEBUG_DWO_LINE_SECTION
,
29393 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
29394 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
29395 DEBUG_SKELETON_LINE_SECTION_LABEL
,
29396 init_sections_and_labels_generation
);
29397 debug_str_offsets_section
29398 = get_section (DEBUG_DWO_STR_OFFSETS_SECTION
,
29399 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
29400 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
29401 DEBUG_SKELETON_INFO_SECTION_LABEL
,
29402 init_sections_and_labels_generation
);
29403 debug_loc_section
= get_section (dwarf_version
>= 5
29404 ? DEBUG_DWO_LOCLISTS_SECTION
29405 : DEBUG_DWO_LOC_SECTION
,
29406 SECTION_DEBUG
| SECTION_EXCLUDE
,
29408 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
29409 DEBUG_STR_DWO_SECTION_FLAGS
,
29411 debug_macinfo_section_name
29412 = ((dwarf_strict
&& dwarf_version
< 5)
29413 ? DEBUG_DWO_MACINFO_SECTION
: DEBUG_DWO_MACRO_SECTION
);
29414 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
29415 SECTION_DEBUG
| SECTION_EXCLUDE
,
29417 if (dwarf_version
>= 5)
29418 debug_ranges_dwo_section
29419 = get_section (DEBUG_DWO_RNGLISTS_SECTION
,
29420 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
29422 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
29423 SECTION_DEBUG
, NULL
);
29424 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
29425 SECTION_DEBUG
, NULL
);
29426 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
29427 SECTION_DEBUG
, NULL
);
29428 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
29429 SECTION_DEBUG
, NULL
);
29430 debug_str_section
= get_section (DEBUG_STR_SECTION
,
29431 DEBUG_STR_SECTION_FLAGS
, NULL
);
29432 if ((!dwarf_split_debug_info
&& !output_asm_line_debug_info ())
29433 || asm_outputs_debug_line_str ())
29434 debug_line_str_section
= get_section (DEBUG_LINE_STR_SECTION
,
29435 DEBUG_STR_SECTION_FLAGS
, NULL
);
29437 debug_ranges_section
= get_section (dwarf_version
>= 5
29438 ? DEBUG_RNGLISTS_SECTION
29439 : DEBUG_RANGES_SECTION
,
29440 SECTION_DEBUG
, NULL
);
29441 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
29442 SECTION_DEBUG
, NULL
);
29445 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
29446 DEBUG_ABBREV_SECTION_LABEL
,
29447 init_sections_and_labels_generation
);
29448 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
29449 DEBUG_INFO_SECTION_LABEL
,
29450 init_sections_and_labels_generation
);
29451 info_section_emitted
= false;
29452 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
29453 DEBUG_LINE_SECTION_LABEL
,
29454 init_sections_and_labels_generation
);
29455 /* There are up to 6 unique ranges labels per generation.
29456 See also output_rnglists. */
29457 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
29458 DEBUG_RANGES_SECTION_LABEL
,
29459 init_sections_and_labels_generation
* 6);
29460 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
29461 ASM_GENERATE_INTERNAL_LABEL (ranges_base_label
,
29462 DEBUG_RANGES_SECTION_LABEL
,
29463 1 + init_sections_and_labels_generation
* 6);
29464 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
29465 DEBUG_ADDR_SECTION_LABEL
,
29466 init_sections_and_labels_generation
);
29467 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
29468 (dwarf_strict
&& dwarf_version
< 5)
29469 ? DEBUG_MACINFO_SECTION_LABEL
29470 : DEBUG_MACRO_SECTION_LABEL
,
29471 init_sections_and_labels_generation
);
29472 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
,
29473 init_sections_and_labels_generation
);
29475 ++init_sections_and_labels_generation
;
29476 return init_sections_and_labels_generation
- 1;
29479 /* Set up for Dwarf output at the start of compilation. */
29482 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
29484 /* Allocate the file_table. */
29485 file_table
= hash_table
<dwarf_file_hasher
>::create_ggc (50);
29487 #ifndef DWARF2_LINENO_DEBUGGING_INFO
29488 /* Allocate the decl_die_table. */
29489 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (10);
29491 /* Allocate the decl_loc_table. */
29492 decl_loc_table
= hash_table
<decl_loc_hasher
>::create_ggc (10);
29494 /* Allocate the cached_dw_loc_list_table. */
29495 cached_dw_loc_list_table
= hash_table
<dw_loc_list_hasher
>::create_ggc (10);
29497 /* Allocate the initial hunk of the abbrev_die_table. */
29498 vec_alloc (abbrev_die_table
, 256);
29499 /* Zero-th entry is allocated, but unused. */
29500 abbrev_die_table
->quick_push (NULL
);
29502 /* Allocate the dwarf_proc_stack_usage_map. */
29503 dwarf_proc_stack_usage_map
= new hash_map
<dw_die_ref
, int>;
29505 /* Allocate the pubtypes and pubnames vectors. */
29506 vec_alloc (pubname_table
, 32);
29507 vec_alloc (pubtype_table
, 32);
29509 vec_alloc (incomplete_types
, 64);
29511 vec_alloc (used_rtx_array
, 32);
29513 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
29514 vec_alloc (macinfo_table
, 64);
29517 /* If front-ends already registered a main translation unit but we were not
29518 ready to perform the association, do this now. */
29519 if (main_translation_unit
!= NULL_TREE
)
29520 equate_decl_number_to_die (main_translation_unit
, comp_unit_die ());
29523 /* Called before compile () starts outputtting functions, variables
29524 and toplevel asms into assembly. */
29527 dwarf2out_assembly_start (void)
29529 if (text_section_line_info
)
29532 #ifndef DWARF2_LINENO_DEBUGGING_INFO
29533 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
29534 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
29535 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
29536 COLD_TEXT_SECTION_LABEL
, 0);
29537 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
29539 switch_to_section (text_section
);
29540 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
29543 /* Make sure the line number table for .text always exists. */
29544 text_section_line_info
= new_line_info_table ();
29545 text_section_line_info
->end_label
= text_end_label
;
29547 #ifdef DWARF2_LINENO_DEBUGGING_INFO
29548 cur_line_info_table
= text_section_line_info
;
29551 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
29552 && dwarf2out_do_cfi_asm ()
29553 && !dwarf2out_do_eh_frame ())
29554 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
29556 #if defined(HAVE_AS_GDWARF_5_DEBUG_FLAG) && defined(HAVE_AS_WORKING_DWARF_N_FLAG)
29557 if (output_asm_line_debug_info () && dwarf_version
>= 5)
29559 /* When gas outputs DWARF5 .debug_line[_str] then we have to
29560 tell it the comp_dir and main file name for the zero entry
29562 const char *comp_dir
, *filename0
;
29564 comp_dir
= comp_dir_string ();
29565 if (comp_dir
== NULL
)
29568 filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
29569 if (filename0
== NULL
)
29572 fprintf (asm_out_file
, "\t.file 0 ");
29573 output_quoted_string (asm_out_file
, remap_debug_filename (comp_dir
));
29574 fputc (' ', asm_out_file
);
29575 output_quoted_string (asm_out_file
, remap_debug_filename (filename0
));
29576 fputc ('\n', asm_out_file
);
29580 /* Work around for PR101575: output a dummy .file directive. */
29581 if (!last_emitted_file
&& dwarf_debuginfo_p ()
29582 && debug_info_level
>= DINFO_LEVEL_TERSE
)
29584 const char *filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
29586 if (filename0
== NULL
)
29587 filename0
= "<dummy>";
29588 maybe_emit_file (lookup_filename (filename0
));
29592 /* A helper function for dwarf2out_finish called through
29593 htab_traverse. Assign a string its index. All strings must be
29594 collected into the table by the time index_string is called,
29595 because the indexing code relies on htab_traverse to traverse nodes
29596 in the same order for each run. */
29599 index_string (indirect_string_node
**h
, unsigned int *index
)
29601 indirect_string_node
*node
= *h
;
29603 find_string_form (node
);
29604 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
29606 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
29607 node
->index
= *index
;
29613 /* A helper function for output_indirect_strings called through
29614 htab_traverse. Output the offset to a string and update the
29618 output_index_string_offset (indirect_string_node
**h
, unsigned int *offset
)
29620 indirect_string_node
*node
= *h
;
29622 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
29624 /* Assert that this node has been assigned an index. */
29625 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
29626 && node
->index
!= NOT_INDEXED
);
29627 dw2_asm_output_data (dwarf_offset_size
, *offset
,
29628 "indexed string 0x%x: %s", node
->index
, node
->str
);
29629 *offset
+= strlen (node
->str
) + 1;
29634 /* A helper function for dwarf2out_finish called through
29635 htab_traverse. Output the indexed string. */
29638 output_index_string (indirect_string_node
**h
, unsigned int *cur_idx
)
29640 struct indirect_string_node
*node
= *h
;
29642 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
29644 /* Assert that the strings are output in the same order as their
29645 indexes were assigned. */
29646 gcc_assert (*cur_idx
== node
->index
);
29647 assemble_string (node
->str
, strlen (node
->str
) + 1);
29653 /* A helper function for output_indirect_strings. Counts the number
29654 of index strings offsets. Must match the logic of the functions
29655 output_index_string[_offsets] above. */
29657 count_index_strings (indirect_string_node
**h
, unsigned int *last_idx
)
29659 struct indirect_string_node
*node
= *h
;
29661 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
29666 /* A helper function for dwarf2out_finish called through
29667 htab_traverse. Emit one queued .debug_str string. */
29670 output_indirect_string (indirect_string_node
**h
, enum dwarf_form form
)
29672 struct indirect_string_node
*node
= *h
;
29674 node
->form
= find_string_form (node
);
29675 if (node
->form
== form
&& node
->refcount
> 0)
29677 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
29678 assemble_string (node
->str
, strlen (node
->str
) + 1);
29684 /* Output the indexed string table. */
29687 output_indirect_strings (void)
29689 switch_to_section (debug_str_section
);
29690 if (!dwarf_split_debug_info
)
29691 debug_str_hash
->traverse
<enum dwarf_form
,
29692 output_indirect_string
> (DW_FORM_strp
);
29695 unsigned int offset
= 0;
29696 unsigned int cur_idx
= 0;
29698 if (skeleton_debug_str_hash
)
29699 skeleton_debug_str_hash
->traverse
<enum dwarf_form
,
29700 output_indirect_string
> (DW_FORM_strp
);
29702 switch_to_section (debug_str_offsets_section
);
29703 /* For DWARF5 the .debug_str_offsets[.dwo] section needs a unit
29704 header. Note that we don't need to generate a label to the
29705 actual index table following the header here, because this is
29706 for the split dwarf case only. In an .dwo file there is only
29707 one string offsets table (and one debug info section). But
29708 if we would start using string offset tables for the main (or
29709 skeleton) unit, then we have to add a DW_AT_str_offsets_base
29710 pointing to the actual index after the header. Split dwarf
29711 units will never have a string offsets base attribute. When
29712 a split unit is moved into a .dwp file the string offsets can
29713 be found through the .debug_cu_index section table. */
29714 if (dwarf_version
>= 5)
29716 unsigned int last_idx
= 0;
29717 unsigned long str_offsets_length
;
29719 debug_str_hash
->traverse_noresize
29720 <unsigned int *, count_index_strings
> (&last_idx
);
29721 str_offsets_length
= last_idx
* dwarf_offset_size
+ 4;
29722 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
29723 dw2_asm_output_data (4, 0xffffffff,
29724 "Escape value for 64-bit DWARF extension");
29725 dw2_asm_output_data (dwarf_offset_size
, str_offsets_length
,
29726 "Length of string offsets unit");
29727 dw2_asm_output_data (2, 5, "DWARF string offsets version");
29728 dw2_asm_output_data (2, 0, "Header zero padding");
29730 debug_str_hash
->traverse_noresize
29731 <unsigned int *, output_index_string_offset
> (&offset
);
29732 switch_to_section (debug_str_dwo_section
);
29733 debug_str_hash
->traverse_noresize
<unsigned int *, output_index_string
>
29738 /* Callback for htab_traverse to assign an index to an entry in the
29739 table, and to write that entry to the .debug_addr section. */
29742 output_addr_table_entry (addr_table_entry
**slot
, unsigned int *cur_index
)
29744 addr_table_entry
*entry
= *slot
;
29746 if (entry
->refcount
== 0)
29748 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
29749 || entry
->index
== NOT_INDEXED
);
29753 gcc_assert (entry
->index
== *cur_index
);
29756 switch (entry
->kind
)
29759 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
29760 "0x%x", entry
->index
);
29762 case ate_kind_rtx_dtprel
:
29763 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
29764 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
29767 fputc ('\n', asm_out_file
);
29769 case ate_kind_label
:
29770 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
29771 "0x%x", entry
->index
);
29774 gcc_unreachable ();
29779 /* A helper function for dwarf2out_finish. Counts the number
29780 of indexed addresses. Must match the logic of the functions
29781 output_addr_table_entry above. */
29783 count_index_addrs (addr_table_entry
**slot
, unsigned int *last_idx
)
29785 addr_table_entry
*entry
= *slot
;
29787 if (entry
->refcount
> 0)
29792 /* Produce the .debug_addr section. */
29795 output_addr_table (void)
29797 unsigned int index
= 0;
29798 if (addr_index_table
== NULL
|| addr_index_table
->size () == 0)
29801 switch_to_section (debug_addr_section
);
29802 /* GNU DebugFission https://gcc.gnu.org/wiki/DebugFission
29803 which GCC uses to implement -gsplit-dwarf as DWARF GNU extension
29804 before DWARF5, didn't have a header for .debug_addr units.
29805 DWARF5 specifies a small header when address tables are used. */
29806 if (dwarf_version
>= 5)
29808 unsigned int last_idx
= 0;
29809 unsigned long addrs_length
;
29811 addr_index_table
->traverse_noresize
29812 <unsigned int *, count_index_addrs
> (&last_idx
);
29813 addrs_length
= last_idx
* DWARF2_ADDR_SIZE
+ 4;
29815 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
29816 dw2_asm_output_data (4, 0xffffffff,
29817 "Escape value for 64-bit DWARF extension");
29818 dw2_asm_output_data (dwarf_offset_size
, addrs_length
,
29819 "Length of Address Unit");
29820 dw2_asm_output_data (2, 5, "DWARF addr version");
29821 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
29822 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
29824 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
29827 ->traverse_noresize
<unsigned int *, output_addr_table_entry
> (&index
);
29830 #if ENABLE_ASSERT_CHECKING
29831 /* Verify that all marks are clear. */
29834 verify_marks_clear (dw_die_ref die
)
29838 gcc_assert (! die
->die_mark
);
29839 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
29841 #endif /* ENABLE_ASSERT_CHECKING */
29843 /* Clear the marks for a die and its children.
29844 Be cool if the mark isn't set. */
29847 prune_unmark_dies (dw_die_ref die
)
29853 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
29856 /* Given LOC that is referenced by a DIE we're marking as used, find all
29857 referenced DWARF procedures it references and mark them as used. */
29860 prune_unused_types_walk_loc_descr (dw_loc_descr_ref loc
)
29862 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
29863 switch (loc
->dw_loc_opc
)
29865 case DW_OP_implicit_pointer
:
29866 case DW_OP_convert
:
29867 case DW_OP_reinterpret
:
29868 case DW_OP_GNU_implicit_pointer
:
29869 case DW_OP_GNU_convert
:
29870 case DW_OP_GNU_reinterpret
:
29871 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
)
29872 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
29874 case DW_OP_GNU_variable_value
:
29875 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
29878 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
29881 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
29882 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
29883 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29888 case DW_OP_call_ref
:
29889 case DW_OP_const_type
:
29890 case DW_OP_GNU_const_type
:
29891 case DW_OP_GNU_parameter_ref
:
29892 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
);
29893 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
29895 case DW_OP_regval_type
:
29896 case DW_OP_deref_type
:
29897 case DW_OP_GNU_regval_type
:
29898 case DW_OP_GNU_deref_type
:
29899 gcc_assert (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_die_ref
);
29900 prune_unused_types_mark (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
, 1);
29902 case DW_OP_entry_value
:
29903 case DW_OP_GNU_entry_value
:
29904 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
);
29905 prune_unused_types_walk_loc_descr (loc
->dw_loc_oprnd1
.v
.val_loc
);
29912 /* Given DIE that we're marking as used, find any other dies
29913 it references as attributes and mark them as used. */
29916 prune_unused_types_walk_attribs (dw_die_ref die
)
29921 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29923 switch (AT_class (a
))
29925 /* Make sure DWARF procedures referenced by location descriptions will
29927 case dw_val_class_loc
:
29928 prune_unused_types_walk_loc_descr (AT_loc (a
));
29930 case dw_val_class_loc_list
:
29931 for (dw_loc_list_ref list
= AT_loc_list (a
);
29933 list
= list
->dw_loc_next
)
29934 prune_unused_types_walk_loc_descr (list
->expr
);
29937 case dw_val_class_view_list
:
29938 /* This points to a loc_list in another attribute, so it's
29939 already covered. */
29942 case dw_val_class_die_ref
:
29943 /* A reference to another DIE.
29944 Make sure that it will get emitted.
29945 If it was broken out into a comdat group, don't follow it. */
29946 if (! AT_ref (a
)->comdat_type_p
29947 || a
->dw_attr
== DW_AT_specification
)
29948 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
29951 case dw_val_class_str
:
29952 /* Set the string's refcount to 0 so that prune_unused_types_mark
29953 accounts properly for it. */
29954 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
29963 /* Mark the generic parameters and arguments children DIEs of DIE. */
29966 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
29970 if (die
== NULL
|| die
->die_child
== NULL
)
29972 c
= die
->die_child
;
29975 if (is_template_parameter (c
))
29976 prune_unused_types_mark (c
, 1);
29978 } while (c
&& c
!= die
->die_child
);
29981 /* Mark DIE as being used. If DOKIDS is true, then walk down
29982 to DIE's children. */
29985 prune_unused_types_mark (dw_die_ref die
, int dokids
)
29989 if (die
->die_mark
== 0)
29991 /* We haven't done this node yet. Mark it as used. */
29993 /* If this is the DIE of a generic type instantiation,
29994 mark the children DIEs that describe its generic parms and
29996 prune_unused_types_mark_generic_parms_dies (die
);
29998 /* We also have to mark its parents as used.
29999 (But we don't want to mark our parent's kids due to this,
30000 unless it is a class.) */
30001 if (die
->die_parent
)
30002 prune_unused_types_mark (die
->die_parent
,
30003 class_scope_p (die
->die_parent
));
30005 /* Mark any referenced nodes. */
30006 prune_unused_types_walk_attribs (die
);
30008 /* If this node is a specification,
30009 also mark the definition, if it exists. */
30010 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
30011 prune_unused_types_mark (die
->die_definition
, 1);
30014 if (dokids
&& die
->die_mark
!= 2)
30016 /* We need to walk the children, but haven't done so yet.
30017 Remember that we've walked the kids. */
30020 /* If this is an array type, we need to make sure our
30021 kids get marked, even if they're types. If we're
30022 breaking out types into comdat sections, do this
30023 for all type definitions. */
30024 if (die
->die_tag
== DW_TAG_array_type
30025 || (use_debug_types
30026 && is_type_die (die
) && ! is_declaration_die (die
)))
30027 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
30029 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
30033 /* For local classes, look if any static member functions were emitted
30034 and if so, mark them. */
30037 prune_unused_types_walk_local_classes (dw_die_ref die
)
30041 if (die
->die_mark
== 2)
30044 switch (die
->die_tag
)
30046 case DW_TAG_structure_type
:
30047 case DW_TAG_union_type
:
30048 case DW_TAG_class_type
:
30049 case DW_TAG_interface_type
:
30052 case DW_TAG_subprogram
:
30053 if (!get_AT_flag (die
, DW_AT_declaration
)
30054 || die
->die_definition
!= NULL
)
30055 prune_unused_types_mark (die
, 1);
30062 /* Mark children. */
30063 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
30066 /* Walk the tree DIE and mark types that we actually use. */
30069 prune_unused_types_walk (dw_die_ref die
)
30073 /* Don't do anything if this node is already marked and
30074 children have been marked as well. */
30075 if (die
->die_mark
== 2)
30078 switch (die
->die_tag
)
30080 case DW_TAG_structure_type
:
30081 case DW_TAG_union_type
:
30082 case DW_TAG_class_type
:
30083 case DW_TAG_interface_type
:
30084 if (die
->die_perennial_p
)
30087 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
30088 if (c
->die_tag
== DW_TAG_subprogram
)
30091 /* Finding used static member functions inside of classes
30092 is needed just for local classes, because for other classes
30093 static member function DIEs with DW_AT_specification
30094 are emitted outside of the DW_TAG_*_type. If we ever change
30095 it, we'd need to call this even for non-local classes. */
30097 prune_unused_types_walk_local_classes (die
);
30099 /* It's a type node --- don't mark it. */
30102 case DW_TAG_const_type
:
30103 case DW_TAG_packed_type
:
30104 case DW_TAG_pointer_type
:
30105 case DW_TAG_reference_type
:
30106 case DW_TAG_rvalue_reference_type
:
30107 case DW_TAG_volatile_type
:
30108 case DW_TAG_typedef
:
30109 case DW_TAG_array_type
:
30110 case DW_TAG_friend
:
30111 case DW_TAG_enumeration_type
:
30112 case DW_TAG_subroutine_type
:
30113 case DW_TAG_string_type
:
30114 case DW_TAG_set_type
:
30115 case DW_TAG_subrange_type
:
30116 case DW_TAG_ptr_to_member_type
:
30117 case DW_TAG_file_type
:
30118 /* Type nodes are useful only when other DIEs reference them --- don't
30122 case DW_TAG_dwarf_procedure
:
30123 /* Likewise for DWARF procedures. */
30125 if (die
->die_perennial_p
)
30130 case DW_TAG_variable
:
30131 if (flag_debug_only_used_symbols
)
30133 if (die
->die_perennial_p
)
30136 /* For static data members, the declaration in the class is supposed
30137 to have DW_TAG_member tag in DWARF{3,4} but DW_TAG_variable in
30138 DWARF5. DW_TAG_member will be marked, so mark even such
30139 DW_TAG_variables in DWARF5, as long as it has DW_AT_const_value
30141 if (dwarf_version
>= 5
30142 && class_scope_p (die
->die_parent
)
30143 && get_AT (die
, DW_AT_const_value
))
30146 /* premark_used_variables marks external variables --- don't mark
30147 them here. But function-local externals are always considered
30149 if (get_AT (die
, DW_AT_external
))
30151 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
30152 if (c
->die_tag
== DW_TAG_subprogram
)
30161 /* Mark everything else. */
30165 if (die
->die_mark
== 0)
30169 /* Now, mark any dies referenced from here. */
30170 prune_unused_types_walk_attribs (die
);
30175 /* Mark children. */
30176 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
30179 /* Increment the string counts on strings referred to from DIE's
30183 prune_unused_types_update_strings (dw_die_ref die
)
30188 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30189 if (AT_class (a
) == dw_val_class_str
)
30191 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
30193 /* Avoid unnecessarily putting strings that are used less than
30194 twice in the hash table. */
30195 if (s
->form
!= DW_FORM_line_strp
30197 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2)))
30199 indirect_string_node
**slot
30200 = debug_str_hash
->find_slot_with_hash (s
->str
,
30201 htab_hash_string (s
->str
),
30203 gcc_assert (*slot
== NULL
);
30209 /* Mark DIE and its children as removed. */
30212 mark_removed (dw_die_ref die
)
30215 die
->removed
= true;
30216 FOR_EACH_CHILD (die
, c
, mark_removed (c
));
30219 /* Remove from the tree DIE any dies that aren't marked. */
30222 prune_unused_types_prune (dw_die_ref die
)
30226 gcc_assert (die
->die_mark
);
30227 prune_unused_types_update_strings (die
);
30229 if (! die
->die_child
)
30232 c
= die
->die_child
;
30234 dw_die_ref prev
= c
, next
;
30235 for (c
= c
->die_sib
; ! c
->die_mark
; c
= next
)
30236 if (c
== die
->die_child
)
30238 /* No marked children between 'prev' and the end of the list. */
30240 /* No marked children at all. */
30241 die
->die_child
= NULL
;
30244 prev
->die_sib
= c
->die_sib
;
30245 die
->die_child
= prev
;
30258 if (c
!= prev
->die_sib
)
30260 prune_unused_types_prune (c
);
30261 } while (c
!= die
->die_child
);
30264 /* Remove dies representing declarations that we never use. */
30267 prune_unused_types (void)
30270 limbo_die_node
*node
;
30271 comdat_type_node
*ctnode
;
30272 pubname_entry
*pub
;
30273 dw_die_ref base_type
;
30275 #if ENABLE_ASSERT_CHECKING
30276 /* All the marks should already be clear. */
30277 verify_marks_clear (comp_unit_die ());
30278 for (node
= limbo_die_list
; node
; node
= node
->next
)
30279 verify_marks_clear (node
->die
);
30280 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
30281 verify_marks_clear (ctnode
->root_die
);
30282 #endif /* ENABLE_ASSERT_CHECKING */
30284 /* Mark types that are used in global variables. */
30285 premark_types_used_by_global_vars ();
30287 /* Mark variables used in the symtab. */
30288 if (flag_debug_only_used_symbols
)
30289 premark_used_variables ();
30291 /* Set the mark on nodes that are actually used. */
30292 prune_unused_types_walk (comp_unit_die ());
30293 for (node
= limbo_die_list
; node
; node
= node
->next
)
30294 prune_unused_types_walk (node
->die
);
30295 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
30297 prune_unused_types_walk (ctnode
->root_die
);
30298 prune_unused_types_mark (ctnode
->type_die
, 1);
30301 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
30302 are unusual in that they are pubnames that are the children of pubtypes.
30303 They should only be marked via their parent DW_TAG_enumeration_type die,
30304 not as roots in themselves. */
30305 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
30306 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
30307 prune_unused_types_mark (pub
->die
, 1);
30308 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
30309 prune_unused_types_mark (base_type
, 1);
30311 /* Also set the mark on nodes that could be referenced by
30312 DW_TAG_call_site DW_AT_call_origin (i.e. direct call callees) or
30313 by DW_TAG_inlined_subroutine origins. */
30314 cgraph_node
*cnode
;
30315 FOR_EACH_FUNCTION (cnode
)
30316 if (cnode
->referred_to_p (false))
30318 dw_die_ref die
= lookup_decl_die (cnode
->decl
);
30319 if (die
== NULL
|| die
->die_mark
)
30321 for (cgraph_edge
*e
= cnode
->callers
; e
; e
= e
->next_caller
)
30322 if (e
->caller
!= cnode
)
30324 prune_unused_types_mark (die
, 1);
30329 if (debug_str_hash
)
30330 debug_str_hash
->empty ();
30331 if (skeleton_debug_str_hash
)
30332 skeleton_debug_str_hash
->empty ();
30333 prune_unused_types_prune (comp_unit_die ());
30334 for (limbo_die_node
**pnode
= &limbo_die_list
; *pnode
; )
30337 if (!node
->die
->die_mark
)
30338 *pnode
= node
->next
;
30341 prune_unused_types_prune (node
->die
);
30342 pnode
= &node
->next
;
30345 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
30346 prune_unused_types_prune (ctnode
->root_die
);
30348 /* Leave the marks clear. */
30349 prune_unmark_dies (comp_unit_die ());
30350 for (node
= limbo_die_list
; node
; node
= node
->next
)
30351 prune_unmark_dies (node
->die
);
30352 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
30353 prune_unmark_dies (ctnode
->root_die
);
30356 /* Helpers to manipulate hash table of comdat type units. */
30358 struct comdat_type_hasher
: nofree_ptr_hash
<comdat_type_node
>
30360 static inline hashval_t
hash (const comdat_type_node
*);
30361 static inline bool equal (const comdat_type_node
*, const comdat_type_node
*);
30365 comdat_type_hasher::hash (const comdat_type_node
*type_node
)
30368 memcpy (&h
, type_node
->signature
, sizeof (h
));
30373 comdat_type_hasher::equal (const comdat_type_node
*type_node_1
,
30374 const comdat_type_node
*type_node_2
)
30376 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
30377 DWARF_TYPE_SIGNATURE_SIZE
));
30380 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
30381 to the location it would have been added, should we know its
30382 DECL_ASSEMBLER_NAME when we added other attributes. This will
30383 probably improve compactness of debug info, removing equivalent
30384 abbrevs, and hide any differences caused by deferring the
30385 computation of the assembler name, triggered by e.g. PCH. */
30388 move_linkage_attr (dw_die_ref die
)
30390 unsigned ix
= vec_safe_length (die
->die_attr
);
30391 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
30393 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
30394 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
30398 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
30400 if (prev
->dw_attr
== DW_AT_decl_line
30401 || prev
->dw_attr
== DW_AT_decl_column
30402 || prev
->dw_attr
== DW_AT_name
)
30406 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
30408 die
->die_attr
->pop ();
30409 die
->die_attr
->quick_insert (ix
, linkage
);
30413 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
30414 referenced from typed stack ops and count how often they are used. */
30417 mark_base_types (dw_loc_descr_ref loc
)
30419 dw_die_ref base_type
= NULL
;
30421 for (; loc
; loc
= loc
->dw_loc_next
)
30423 switch (loc
->dw_loc_opc
)
30425 case DW_OP_regval_type
:
30426 case DW_OP_deref_type
:
30427 case DW_OP_GNU_regval_type
:
30428 case DW_OP_GNU_deref_type
:
30429 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
30431 case DW_OP_convert
:
30432 case DW_OP_reinterpret
:
30433 case DW_OP_GNU_convert
:
30434 case DW_OP_GNU_reinterpret
:
30435 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
30438 case DW_OP_const_type
:
30439 case DW_OP_GNU_const_type
:
30440 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30442 case DW_OP_entry_value
:
30443 case DW_OP_GNU_entry_value
:
30444 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
30449 gcc_assert (base_type
->die_parent
== comp_unit_die ());
30450 if (base_type
->die_mark
)
30451 base_type
->die_mark
++;
30454 base_types
.safe_push (base_type
);
30455 base_type
->die_mark
= 1;
30460 /* Stripped-down variant of resolve_addr, mark DW_TAG_base_type nodes
30461 referenced from typed stack ops and count how often they are used. */
30464 mark_base_types (dw_die_ref die
)
30468 dw_loc_list_ref
*curr
;
30471 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30472 switch (AT_class (a
))
30474 case dw_val_class_loc_list
:
30475 curr
= AT_loc_list_ptr (a
);
30478 mark_base_types ((*curr
)->expr
);
30479 curr
= &(*curr
)->dw_loc_next
;
30483 case dw_val_class_loc
:
30484 mark_base_types (AT_loc (a
));
30491 FOR_EACH_CHILD (die
, c
, mark_base_types (c
));
30494 /* Comparison function for sorting marked base types. */
30497 base_type_cmp (const void *x
, const void *y
)
30499 dw_die_ref dx
= *(const dw_die_ref
*) x
;
30500 dw_die_ref dy
= *(const dw_die_ref
*) y
;
30501 unsigned int byte_size1
, byte_size2
;
30502 unsigned int encoding1
, encoding2
;
30503 unsigned int align1
, align2
;
30504 if (dx
->die_mark
> dy
->die_mark
)
30506 if (dx
->die_mark
< dy
->die_mark
)
30508 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
30509 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
30510 if (byte_size1
< byte_size2
)
30512 if (byte_size1
> byte_size2
)
30514 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
30515 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
30516 if (encoding1
< encoding2
)
30518 if (encoding1
> encoding2
)
30520 align1
= get_AT_unsigned (dx
, DW_AT_alignment
);
30521 align2
= get_AT_unsigned (dy
, DW_AT_alignment
);
30522 if (align1
< align2
)
30524 if (align1
> align2
)
30529 /* Move base types marked by mark_base_types as early as possible
30530 in the CU, sorted by decreasing usage count both to make the
30531 uleb128 references as small as possible and to make sure they
30532 will have die_offset already computed by calc_die_sizes when
30533 sizes of typed stack loc ops is computed. */
30536 move_marked_base_types (void)
30539 dw_die_ref base_type
, die
, c
;
30541 if (base_types
.is_empty ())
30544 /* Sort by decreasing usage count, they will be added again in that
30546 base_types
.qsort (base_type_cmp
);
30547 die
= comp_unit_die ();
30548 c
= die
->die_child
;
30551 dw_die_ref prev
= c
;
30553 while (c
->die_mark
)
30555 remove_child_with_prev (c
, prev
);
30556 /* As base types got marked, there must be at least
30557 one node other than DW_TAG_base_type. */
30558 gcc_assert (die
->die_child
!= NULL
);
30562 while (c
!= die
->die_child
);
30563 gcc_assert (die
->die_child
);
30564 c
= die
->die_child
;
30565 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
30567 base_type
->die_mark
= 0;
30568 base_type
->die_sib
= c
->die_sib
;
30569 c
->die_sib
= base_type
;
30574 /* Helper function for resolve_addr, attempt to resolve
30575 one CONST_STRING, return true if successful. Similarly verify that
30576 SYMBOL_REFs refer to variables emitted in the current CU. */
30579 resolve_one_addr (rtx
*addr
)
30583 if (GET_CODE (rtl
) == CONST_STRING
)
30585 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
30586 tree t
= build_string (len
, XSTR (rtl
, 0));
30587 tree tlen
= size_int (len
- 1);
30589 = build_array_type (char_type_node
, build_index_type (tlen
));
30590 rtl
= lookup_constant_def (t
);
30591 if (!rtl
|| !MEM_P (rtl
))
30593 rtl
= XEXP (rtl
, 0);
30594 if (GET_CODE (rtl
) == SYMBOL_REF
30595 && SYMBOL_REF_DECL (rtl
)
30596 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
30598 vec_safe_push (used_rtx_array
, rtl
);
30603 if (GET_CODE (rtl
) == SYMBOL_REF
30604 && SYMBOL_REF_DECL (rtl
))
30606 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
30608 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
30611 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
30615 if (GET_CODE (rtl
) == CONST
)
30617 subrtx_ptr_iterator::array_type array
;
30618 FOR_EACH_SUBRTX_PTR (iter
, array
, &XEXP (rtl
, 0), ALL
)
30619 if (!resolve_one_addr (*iter
))
30626 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
30627 if possible, and create DW_TAG_dwarf_procedure that can be referenced
30628 from DW_OP_implicit_pointer if the string hasn't been seen yet. */
30631 string_cst_pool_decl (tree t
)
30633 rtx rtl
= output_constant_def (t
, 1);
30634 unsigned char *array
;
30635 dw_loc_descr_ref l
;
30640 if (!rtl
|| !MEM_P (rtl
))
30642 rtl
= XEXP (rtl
, 0);
30643 if (GET_CODE (rtl
) != SYMBOL_REF
30644 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
30647 decl
= SYMBOL_REF_DECL (rtl
);
30648 if (!lookup_decl_die (decl
))
30650 len
= TREE_STRING_LENGTH (t
);
30651 vec_safe_push (used_rtx_array
, rtl
);
30652 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
30653 array
= ggc_vec_alloc
<unsigned char> (len
);
30654 memcpy (array
, TREE_STRING_POINTER (t
), len
);
30655 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
30656 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
30657 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
30658 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
30659 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
30660 add_AT_loc (ref
, DW_AT_location
, l
);
30661 equate_decl_number_to_die (decl
, ref
);
30666 /* Helper function of resolve_addr_in_expr. LOC is
30667 a DW_OP_addr followed by DW_OP_stack_value, either at the start
30668 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
30669 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
30670 with DW_OP_implicit_pointer if possible
30671 and return true, if unsuccessful, return false. */
30674 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
30676 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
30677 HOST_WIDE_INT offset
= 0;
30678 dw_die_ref ref
= NULL
;
30681 if (GET_CODE (rtl
) == CONST
30682 && GET_CODE (XEXP (rtl
, 0)) == PLUS
30683 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
30685 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
30686 rtl
= XEXP (XEXP (rtl
, 0), 0);
30688 if (GET_CODE (rtl
) == CONST_STRING
)
30690 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
30691 tree t
= build_string (len
, XSTR (rtl
, 0));
30692 tree tlen
= size_int (len
- 1);
30695 = build_array_type (char_type_node
, build_index_type (tlen
));
30696 rtl
= string_cst_pool_decl (t
);
30700 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
30702 decl
= SYMBOL_REF_DECL (rtl
);
30703 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
30705 ref
= lookup_decl_die (decl
);
30706 if (ref
&& (get_AT (ref
, DW_AT_location
)
30707 || get_AT (ref
, DW_AT_const_value
)))
30709 loc
->dw_loc_opc
= dwarf_OP (DW_OP_implicit_pointer
);
30710 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30711 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
30712 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30713 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30714 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
30715 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
30723 /* Helper function for resolve_addr, handle one location
30724 expression, return false if at least one CONST_STRING or SYMBOL_REF in
30725 the location list couldn't be resolved. */
30728 resolve_addr_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
30730 dw_loc_descr_ref keep
= NULL
;
30731 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
30732 switch (loc
->dw_loc_opc
)
30735 if (!resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
30738 || prev
->dw_loc_opc
== DW_OP_piece
30739 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
30740 && loc
->dw_loc_next
30741 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
30742 && (!dwarf_strict
|| dwarf_version
>= 5)
30743 && optimize_one_addr_into_implicit_ptr (loc
))
30748 case DW_OP_GNU_addr_index
:
30750 case DW_OP_GNU_const_index
:
30752 if ((loc
->dw_loc_opc
== DW_OP_GNU_addr_index
30753 || loc
->dw_loc_opc
== DW_OP_addrx
)
30754 || ((loc
->dw_loc_opc
== DW_OP_GNU_const_index
30755 || loc
->dw_loc_opc
== DW_OP_constx
)
30758 rtx rtl
= loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
;
30759 if (!resolve_one_addr (&rtl
))
30761 remove_addr_table_entry (loc
->dw_loc_oprnd1
.val_entry
);
30762 loc
->dw_loc_oprnd1
.val_entry
30763 = add_addr_table_entry (rtl
, ate_kind_rtx
);
30766 case DW_OP_const4u
:
30767 case DW_OP_const8u
:
30769 && !resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
30772 case DW_OP_plus_uconst
:
30773 if (size_of_loc_descr (loc
)
30774 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
30776 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
30778 dw_loc_descr_ref repl
30779 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
30780 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
30781 add_loc_descr (&repl
, loc
->dw_loc_next
);
30785 case DW_OP_implicit_value
:
30786 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
30787 && !resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
))
30790 case DW_OP_implicit_pointer
:
30791 case DW_OP_GNU_implicit_pointer
:
30792 case DW_OP_GNU_parameter_ref
:
30793 case DW_OP_GNU_variable_value
:
30794 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
30797 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
30800 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30801 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30802 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30804 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
)
30807 && loc
->dw_loc_next
== NULL
30808 && AT_class (a
) == dw_val_class_loc
)
30809 switch (a
->dw_attr
)
30811 /* Following attributes allow both exprloc and reference,
30812 so if the whole expression is DW_OP_GNU_variable_value
30813 alone we could transform it into reference. */
30814 case DW_AT_byte_size
:
30815 case DW_AT_bit_size
:
30816 case DW_AT_lower_bound
:
30817 case DW_AT_upper_bound
:
30818 case DW_AT_bit_stride
:
30820 case DW_AT_allocated
:
30821 case DW_AT_associated
:
30822 case DW_AT_byte_stride
:
30823 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
30824 a
->dw_attr_val
.val_entry
= NULL
;
30825 a
->dw_attr_val
.v
.val_die_ref
.die
30826 = loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30827 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
30836 case DW_OP_const_type
:
30837 case DW_OP_regval_type
:
30838 case DW_OP_deref_type
:
30839 case DW_OP_convert
:
30840 case DW_OP_reinterpret
:
30841 case DW_OP_GNU_const_type
:
30842 case DW_OP_GNU_regval_type
:
30843 case DW_OP_GNU_deref_type
:
30844 case DW_OP_GNU_convert
:
30845 case DW_OP_GNU_reinterpret
:
30846 while (loc
->dw_loc_next
30847 && (loc
->dw_loc_next
->dw_loc_opc
== DW_OP_convert
30848 || loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
))
30850 dw_die_ref base1
, base2
;
30851 unsigned enc1
, enc2
, size1
, size2
;
30852 if (loc
->dw_loc_opc
== DW_OP_regval_type
30853 || loc
->dw_loc_opc
== DW_OP_deref_type
30854 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
30855 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
30856 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
30857 else if (loc
->dw_loc_oprnd1
.val_class
30858 == dw_val_class_unsigned_const
)
30861 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30862 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
30863 == dw_val_class_unsigned_const
)
30865 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30866 gcc_assert (base1
->die_tag
== DW_TAG_base_type
30867 && base2
->die_tag
== DW_TAG_base_type
);
30868 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
30869 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
30870 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
30871 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
30873 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
30874 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
30878 /* Optimize away next DW_OP_convert after
30879 adjusting LOC's base type die reference. */
30880 if (loc
->dw_loc_opc
== DW_OP_regval_type
30881 || loc
->dw_loc_opc
== DW_OP_deref_type
30882 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
30883 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
30884 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
30886 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
30887 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
30890 /* Don't change integer DW_OP_convert after e.g. floating
30891 point typed stack entry. */
30892 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
30893 keep
= loc
->dw_loc_next
;
30903 /* Helper function of resolve_addr. DIE had DW_AT_location of
30904 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
30905 and DW_OP_addr couldn't be resolved. resolve_addr has already
30906 removed the DW_AT_location attribute. This function attempts to
30907 add a new DW_AT_location attribute with DW_OP_implicit_pointer
30908 to it or DW_AT_const_value attribute, if possible. */
30911 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
30914 || lookup_decl_die (decl
) != die
30915 || DECL_EXTERNAL (decl
)
30916 || !TREE_STATIC (decl
)
30917 || DECL_INITIAL (decl
) == NULL_TREE
30918 || DECL_P (DECL_INITIAL (decl
))
30919 || get_AT (die
, DW_AT_const_value
))
30922 tree init
= DECL_INITIAL (decl
);
30923 HOST_WIDE_INT offset
= 0;
30924 /* For variables that have been optimized away and thus
30925 don't have a memory location, see if we can emit
30926 DW_AT_const_value instead. */
30927 if (tree_add_const_value_attribute (die
, init
))
30929 if (dwarf_strict
&& dwarf_version
< 5)
30931 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
30932 and ADDR_EXPR refers to a decl that has DW_AT_location or
30933 DW_AT_const_value (but isn't addressable, otherwise
30934 resolving the original DW_OP_addr wouldn't fail), see if
30935 we can add DW_OP_implicit_pointer. */
30937 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
30938 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
30940 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
30941 init
= TREE_OPERAND (init
, 0);
30944 if (TREE_CODE (init
) != ADDR_EXPR
)
30946 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
30947 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
30948 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
30949 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
30950 && TREE_OPERAND (init
, 0) != decl
))
30953 dw_loc_descr_ref l
;
30955 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
30957 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
30960 decl
= SYMBOL_REF_DECL (rtl
);
30963 decl
= TREE_OPERAND (init
, 0);
30964 ref
= lookup_decl_die (decl
);
30966 || (!get_AT (ref
, DW_AT_location
)
30967 && !get_AT (ref
, DW_AT_const_value
)))
30969 l
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
30970 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30971 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30972 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30973 add_AT_loc (die
, DW_AT_location
, l
);
30977 /* Return NULL if l is a DWARF expression, or first op that is not
30978 valid DWARF expression. */
30980 static dw_loc_descr_ref
30981 non_dwarf_expression (dw_loc_descr_ref l
)
30985 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
30987 switch (l
->dw_loc_opc
)
30990 case DW_OP_implicit_value
:
30991 case DW_OP_stack_value
:
30992 case DW_OP_implicit_pointer
:
30993 case DW_OP_GNU_implicit_pointer
:
30994 case DW_OP_GNU_parameter_ref
:
30996 case DW_OP_bit_piece
:
31001 l
= l
->dw_loc_next
;
31006 /* Return adjusted copy of EXPR:
31007 If it is empty DWARF expression, return it.
31008 If it is valid non-empty DWARF expression,
31009 return copy of EXPR with DW_OP_deref appended to it.
31010 If it is DWARF expression followed by DW_OP_reg{N,x}, return
31011 copy of the DWARF expression with DW_OP_breg{N,x} <0> appended.
31012 If it is DWARF expression followed by DW_OP_stack_value, return
31013 copy of the DWARF expression without anything appended.
31014 Otherwise, return NULL. */
31016 static dw_loc_descr_ref
31017 copy_deref_exprloc (dw_loc_descr_ref expr
)
31019 dw_loc_descr_ref tail
= NULL
;
31024 dw_loc_descr_ref l
= non_dwarf_expression (expr
);
31025 if (l
&& l
->dw_loc_next
)
31030 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
31031 tail
= new_loc_descr ((enum dwarf_location_atom
)
31032 (DW_OP_breg0
+ (l
->dw_loc_opc
- DW_OP_reg0
)),
31035 switch (l
->dw_loc_opc
)
31038 tail
= new_loc_descr (DW_OP_bregx
,
31039 l
->dw_loc_oprnd1
.v
.val_unsigned
, 0);
31041 case DW_OP_stack_value
:
31048 tail
= new_loc_descr (DW_OP_deref
, 0, 0);
31050 dw_loc_descr_ref ret
= NULL
, *p
= &ret
;
31053 *p
= new_loc_descr (expr
->dw_loc_opc
, 0, 0);
31054 (*p
)->dw_loc_oprnd1
= expr
->dw_loc_oprnd1
;
31055 (*p
)->dw_loc_oprnd2
= expr
->dw_loc_oprnd2
;
31056 p
= &(*p
)->dw_loc_next
;
31057 expr
= expr
->dw_loc_next
;
31063 /* For DW_AT_string_length attribute with DW_OP_GNU_variable_value
31064 reference to a variable or argument, adjust it if needed and return:
31065 -1 if the DW_AT_string_length attribute and DW_AT_{string_length_,}byte_size
31066 attribute if present should be removed
31067 0 keep the attribute perhaps with minor modifications, no need to rescan
31068 1 if the attribute has been successfully adjusted. */
31071 optimize_string_length (dw_attr_node
*a
)
31073 dw_loc_descr_ref l
= AT_loc (a
), lv
;
31075 if (l
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
31077 tree decl
= l
->dw_loc_oprnd1
.v
.val_decl_ref
;
31078 die
= lookup_decl_die (decl
);
31081 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31082 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= die
;
31083 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31089 die
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
31091 /* DWARF5 allows reference class, so we can then reference the DIE.
31092 Only do this for DW_OP_GNU_variable_value DW_OP_stack_value. */
31093 if (l
->dw_loc_next
!= NULL
&& dwarf_version
>= 5)
31095 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
31096 a
->dw_attr_val
.val_entry
= NULL
;
31097 a
->dw_attr_val
.v
.val_die_ref
.die
= die
;
31098 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
31102 dw_attr_node
*av
= get_AT (die
, DW_AT_location
);
31104 bool non_dwarf_expr
= false;
31107 return dwarf_strict
? -1 : 0;
31108 switch (AT_class (av
))
31110 case dw_val_class_loc_list
:
31111 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
31112 if (d
->expr
&& non_dwarf_expression (d
->expr
))
31113 non_dwarf_expr
= true;
31115 case dw_val_class_view_list
:
31116 gcc_unreachable ();
31117 case dw_val_class_loc
:
31120 return dwarf_strict
? -1 : 0;
31121 if (non_dwarf_expression (lv
))
31122 non_dwarf_expr
= true;
31125 return dwarf_strict
? -1 : 0;
31128 /* If it is safe to transform DW_OP_GNU_variable_value DW_OP_stack_value
31129 into DW_OP_call4 or DW_OP_GNU_variable_value into
31130 DW_OP_call4 DW_OP_deref, do so. */
31131 if (!non_dwarf_expr
31132 && (l
->dw_loc_next
!= NULL
|| AT_class (av
) == dw_val_class_loc
))
31134 l
->dw_loc_opc
= DW_OP_call4
;
31135 if (l
->dw_loc_next
)
31136 l
->dw_loc_next
= NULL
;
31138 l
->dw_loc_next
= new_loc_descr (DW_OP_deref
, 0, 0);
31142 /* For DW_OP_GNU_variable_value DW_OP_stack_value, we can just
31143 copy over the DW_AT_location attribute from die to a. */
31144 if (l
->dw_loc_next
!= NULL
)
31146 a
->dw_attr_val
= av
->dw_attr_val
;
31150 dw_loc_list_ref list
, *p
;
31151 switch (AT_class (av
))
31153 case dw_val_class_loc_list
:
31156 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
31158 lv
= copy_deref_exprloc (d
->expr
);
31161 *p
= new_loc_list (lv
, d
->begin
, d
->vbegin
, d
->end
, d
->vend
, d
->section
);
31162 p
= &(*p
)->dw_loc_next
;
31164 else if (!dwarf_strict
&& d
->expr
)
31168 return dwarf_strict
? -1 : 0;
31169 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
31171 *AT_loc_list_ptr (a
) = list
;
31173 case dw_val_class_loc
:
31174 lv
= copy_deref_exprloc (AT_loc (av
));
31176 return dwarf_strict
? -1 : 0;
31177 a
->dw_attr_val
.v
.val_loc
= lv
;
31180 gcc_unreachable ();
31184 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
31185 an address in .rodata section if the string literal is emitted there,
31186 or remove the containing location list or replace DW_AT_const_value
31187 with DW_AT_location and empty location expression, if it isn't found
31188 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
31189 to something that has been emitted in the current CU. */
31192 resolve_addr (dw_die_ref die
)
31196 dw_loc_list_ref
*curr
, *start
, loc
;
31198 bool remove_AT_byte_size
= false;
31200 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31201 switch (AT_class (a
))
31203 case dw_val_class_loc_list
:
31204 start
= curr
= AT_loc_list_ptr (a
);
31207 /* The same list can be referenced more than once. See if we have
31208 already recorded the result from a previous pass. */
31210 *curr
= loc
->dw_loc_next
;
31211 else if (!loc
->resolved_addr
)
31213 /* As things stand, we do not expect or allow one die to
31214 reference a suffix of another die's location list chain.
31215 References must be identical or completely separate.
31216 There is therefore no need to cache the result of this
31217 pass on any list other than the first; doing so
31218 would lead to unnecessary writes. */
31221 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
31222 if (!resolve_addr_in_expr (a
, (*curr
)->expr
))
31224 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
31225 dw_loc_descr_ref l
= (*curr
)->expr
;
31227 if (next
&& (*curr
)->ll_symbol
)
31229 gcc_assert (!next
->ll_symbol
);
31230 next
->ll_symbol
= (*curr
)->ll_symbol
;
31231 next
->vl_symbol
= (*curr
)->vl_symbol
;
31233 if (dwarf_split_debug_info
)
31234 remove_loc_list_addr_table_entries (l
);
31239 mark_base_types ((*curr
)->expr
);
31240 curr
= &(*curr
)->dw_loc_next
;
31244 loc
->resolved_addr
= 1;
31248 loc
->dw_loc_next
= *start
;
31253 remove_AT (die
, a
->dw_attr
);
31257 case dw_val_class_view_list
:
31259 gcc_checking_assert (a
->dw_attr
== DW_AT_GNU_locviews
);
31260 gcc_checking_assert (dwarf2out_locviews_in_attribute ());
31261 dw_val_node
*llnode
31262 = view_list_to_loc_list_val_node (&a
->dw_attr_val
);
31263 /* If we no longer have a loclist, or it no longer needs
31264 views, drop this attribute. */
31265 if (!llnode
|| !llnode
->v
.val_loc_list
->vl_symbol
)
31267 remove_AT (die
, a
->dw_attr
);
31272 case dw_val_class_loc
:
31274 dw_loc_descr_ref l
= AT_loc (a
);
31275 /* DW_OP_GNU_variable_value DW_OP_stack_value or
31276 DW_OP_GNU_variable_value in DW_AT_string_length can be converted
31277 into DW_OP_call4 or DW_OP_call4 DW_OP_deref, which is standard
31278 DWARF4 unlike DW_OP_GNU_variable_value. Or for DWARF5
31279 DW_OP_GNU_variable_value DW_OP_stack_value can be replaced
31280 with DW_FORM_ref referencing the same DIE as
31281 DW_OP_GNU_variable_value used to reference. */
31282 if (a
->dw_attr
== DW_AT_string_length
31284 && l
->dw_loc_opc
== DW_OP_GNU_variable_value
31285 && (l
->dw_loc_next
== NULL
31286 || (l
->dw_loc_next
->dw_loc_next
== NULL
31287 && l
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
)))
31289 switch (optimize_string_length (a
))
31292 remove_AT (die
, a
->dw_attr
);
31294 /* If we drop DW_AT_string_length, we need to drop also
31295 DW_AT_{string_length_,}byte_size. */
31296 remove_AT_byte_size
= true;
31301 /* Even if we keep the optimized DW_AT_string_length,
31302 it might have changed AT_class, so process it again. */
31307 /* For -gdwarf-2 don't attempt to optimize
31308 DW_AT_data_member_location containing
31309 DW_OP_plus_uconst - older consumers might
31310 rely on it being that op instead of a more complex,
31311 but shorter, location description. */
31312 if ((dwarf_version
> 2
31313 || a
->dw_attr
!= DW_AT_data_member_location
31315 || l
->dw_loc_opc
!= DW_OP_plus_uconst
31316 || l
->dw_loc_next
!= NULL
)
31317 && !resolve_addr_in_expr (a
, l
))
31319 if (dwarf_split_debug_info
)
31320 remove_loc_list_addr_table_entries (l
);
31322 && l
->dw_loc_next
== NULL
31323 && l
->dw_loc_opc
== DW_OP_addr
31324 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
31325 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
31326 && a
->dw_attr
== DW_AT_location
)
31328 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
31329 remove_AT (die
, a
->dw_attr
);
31331 optimize_location_into_implicit_ptr (die
, decl
);
31334 if (a
->dw_attr
== DW_AT_string_length
)
31335 /* If we drop DW_AT_string_length, we need to drop also
31336 DW_AT_{string_length_,}byte_size. */
31337 remove_AT_byte_size
= true;
31338 remove_AT (die
, a
->dw_attr
);
31342 mark_base_types (l
);
31345 case dw_val_class_addr
:
31346 if (a
->dw_attr
== DW_AT_const_value
31347 && !resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
))
31349 if (AT_index (a
) != NOT_INDEXED
)
31350 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
31351 remove_AT (die
, a
->dw_attr
);
31354 if ((die
->die_tag
== DW_TAG_call_site
31355 && a
->dw_attr
== DW_AT_call_origin
)
31356 || (die
->die_tag
== DW_TAG_GNU_call_site
31357 && a
->dw_attr
== DW_AT_abstract_origin
))
31359 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
31360 dw_die_ref tdie
= lookup_decl_die (tdecl
);
31363 && DECL_EXTERNAL (tdecl
)
31364 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
31365 && (cdie
= lookup_context_die (DECL_CONTEXT (tdecl
))))
31367 dw_die_ref pdie
= cdie
;
31368 /* Make sure we don't add these DIEs into type units.
31369 We could emit skeleton DIEs for context (namespaces,
31370 outer structs/classes) and a skeleton DIE for the
31371 innermost context with DW_AT_signature pointing to the
31372 type unit. See PR78835. */
31373 while (pdie
&& pdie
->die_tag
!= DW_TAG_type_unit
)
31374 pdie
= pdie
->die_parent
;
31377 /* Creating a full DIE for tdecl is overly expensive and
31378 at this point even wrong when in the LTO phase
31379 as it can end up generating new type DIEs we didn't
31380 output and thus optimize_external_refs will crash. */
31381 tdie
= new_die (DW_TAG_subprogram
, cdie
, NULL_TREE
);
31382 add_AT_flag (tdie
, DW_AT_external
, 1);
31383 add_AT_flag (tdie
, DW_AT_declaration
, 1);
31384 add_linkage_attr (tdie
, tdecl
);
31385 add_name_and_src_coords_attributes (tdie
, tdecl
, true);
31386 equate_decl_number_to_die (tdecl
, tdie
);
31391 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
31392 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
31393 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
31397 if (AT_index (a
) != NOT_INDEXED
)
31398 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
31399 remove_AT (die
, a
->dw_attr
);
31408 if (remove_AT_byte_size
)
31409 remove_AT (die
, dwarf_version
>= 5
31410 ? DW_AT_string_length_byte_size
31411 : DW_AT_byte_size
);
31413 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
31416 /* Helper routines for optimize_location_lists.
31417 This pass tries to share identical local lists in .debug_loc
31420 /* Iteratively hash operands of LOC opcode into HSTATE. */
31423 hash_loc_operands (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
31425 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
31426 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
31428 switch (loc
->dw_loc_opc
)
31430 case DW_OP_const4u
:
31431 case DW_OP_const8u
:
31435 case DW_OP_const1u
:
31436 case DW_OP_const1s
:
31437 case DW_OP_const2u
:
31438 case DW_OP_const2s
:
31439 case DW_OP_const4s
:
31440 case DW_OP_const8s
:
31444 case DW_OP_plus_uconst
:
31480 case DW_OP_deref_size
:
31481 case DW_OP_xderef_size
:
31482 hstate
.add_object (val1
->v
.val_int
);
31489 gcc_assert (val1
->val_class
== dw_val_class_loc
);
31490 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
31491 hstate
.add_object (offset
);
31494 case DW_OP_implicit_value
:
31495 hstate
.add_object (val1
->v
.val_unsigned
);
31496 switch (val2
->val_class
)
31498 case dw_val_class_const
:
31499 hstate
.add_object (val2
->v
.val_int
);
31501 case dw_val_class_vec
:
31503 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
31504 unsigned int len
= val2
->v
.val_vec
.length
;
31506 hstate
.add_int (elt_size
);
31507 hstate
.add_int (len
);
31508 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
31511 case dw_val_class_const_double
:
31512 hstate
.add_object (val2
->v
.val_double
.low
);
31513 hstate
.add_object (val2
->v
.val_double
.high
);
31515 case dw_val_class_wide_int
:
31516 hstate
.add (val2
->v
.val_wide
->get_val (),
31517 get_full_len (*val2
->v
.val_wide
)
31518 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
31520 case dw_val_class_addr
:
31521 inchash::add_rtx (val2
->v
.val_addr
, hstate
);
31524 gcc_unreachable ();
31528 case DW_OP_bit_piece
:
31529 hstate
.add_object (val1
->v
.val_int
);
31530 hstate
.add_object (val2
->v
.val_int
);
31536 unsigned char dtprel
= 0xd1;
31537 hstate
.add_object (dtprel
);
31539 inchash::add_rtx (val1
->v
.val_addr
, hstate
);
31541 case DW_OP_GNU_addr_index
:
31543 case DW_OP_GNU_const_index
:
31548 unsigned char dtprel
= 0xd1;
31549 hstate
.add_object (dtprel
);
31551 inchash::add_rtx (val1
->val_entry
->addr
.rtl
, hstate
);
31554 case DW_OP_implicit_pointer
:
31555 case DW_OP_GNU_implicit_pointer
:
31556 hstate
.add_int (val2
->v
.val_int
);
31558 case DW_OP_entry_value
:
31559 case DW_OP_GNU_entry_value
:
31560 hstate
.add_object (val1
->v
.val_loc
);
31562 case DW_OP_regval_type
:
31563 case DW_OP_deref_type
:
31564 case DW_OP_GNU_regval_type
:
31565 case DW_OP_GNU_deref_type
:
31567 unsigned int byte_size
31568 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
31569 unsigned int encoding
31570 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
31571 hstate
.add_object (val1
->v
.val_int
);
31572 hstate
.add_object (byte_size
);
31573 hstate
.add_object (encoding
);
31576 case DW_OP_convert
:
31577 case DW_OP_reinterpret
:
31578 case DW_OP_GNU_convert
:
31579 case DW_OP_GNU_reinterpret
:
31580 if (val1
->val_class
== dw_val_class_unsigned_const
)
31582 hstate
.add_object (val1
->v
.val_unsigned
);
31586 case DW_OP_const_type
:
31587 case DW_OP_GNU_const_type
:
31589 unsigned int byte_size
31590 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
31591 unsigned int encoding
31592 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
31593 hstate
.add_object (byte_size
);
31594 hstate
.add_object (encoding
);
31595 if (loc
->dw_loc_opc
!= DW_OP_const_type
31596 && loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
31598 hstate
.add_object (val2
->val_class
);
31599 switch (val2
->val_class
)
31601 case dw_val_class_const
:
31602 hstate
.add_object (val2
->v
.val_int
);
31604 case dw_val_class_vec
:
31606 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
31607 unsigned int len
= val2
->v
.val_vec
.length
;
31609 hstate
.add_object (elt_size
);
31610 hstate
.add_object (len
);
31611 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
31614 case dw_val_class_const_double
:
31615 hstate
.add_object (val2
->v
.val_double
.low
);
31616 hstate
.add_object (val2
->v
.val_double
.high
);
31618 case dw_val_class_wide_int
:
31619 hstate
.add (val2
->v
.val_wide
->get_val (),
31620 get_full_len (*val2
->v
.val_wide
)
31621 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
31624 gcc_unreachable ();
31630 /* Other codes have no operands. */
31635 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
31638 hash_locs (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
31640 dw_loc_descr_ref l
;
31641 bool sizes_computed
= false;
31642 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
31643 size_of_locs (loc
);
31645 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
31647 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
31648 hstate
.add_object (opc
);
31649 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
31651 size_of_locs (loc
);
31652 sizes_computed
= true;
31654 hash_loc_operands (l
, hstate
);
31658 /* Compute hash of the whole location list LIST_HEAD. */
31661 hash_loc_list (dw_loc_list_ref list_head
)
31663 dw_loc_list_ref curr
= list_head
;
31664 inchash::hash hstate
;
31666 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
31668 hstate
.add (curr
->begin
, strlen (curr
->begin
) + 1);
31669 hstate
.add (curr
->end
, strlen (curr
->end
) + 1);
31670 hstate
.add_object (curr
->vbegin
);
31671 hstate
.add_object (curr
->vend
);
31673 hstate
.add (curr
->section
, strlen (curr
->section
) + 1);
31674 hash_locs (curr
->expr
, hstate
);
31676 list_head
->hash
= hstate
.end ();
31679 /* Return true if X and Y opcodes have the same operands. */
31682 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
31684 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
31685 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
31686 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
31687 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
31689 switch (x
->dw_loc_opc
)
31691 case DW_OP_const4u
:
31692 case DW_OP_const8u
:
31696 case DW_OP_const1u
:
31697 case DW_OP_const1s
:
31698 case DW_OP_const2u
:
31699 case DW_OP_const2s
:
31700 case DW_OP_const4s
:
31701 case DW_OP_const8s
:
31705 case DW_OP_plus_uconst
:
31741 case DW_OP_deref_size
:
31742 case DW_OP_xderef_size
:
31743 return valx1
->v
.val_int
== valy1
->v
.val_int
;
31746 /* If splitting debug info, the use of DW_OP_GNU_addr_index
31747 can cause irrelevant differences in dw_loc_addr. */
31748 gcc_assert (valx1
->val_class
== dw_val_class_loc
31749 && valy1
->val_class
== dw_val_class_loc
31750 && (dwarf_split_debug_info
31751 || x
->dw_loc_addr
== y
->dw_loc_addr
));
31752 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
31753 case DW_OP_implicit_value
:
31754 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
31755 || valx2
->val_class
!= valy2
->val_class
)
31757 switch (valx2
->val_class
)
31759 case dw_val_class_const
:
31760 return valx2
->v
.val_int
== valy2
->v
.val_int
;
31761 case dw_val_class_vec
:
31762 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
31763 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
31764 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
31765 valx2
->v
.val_vec
.elt_size
31766 * valx2
->v
.val_vec
.length
) == 0;
31767 case dw_val_class_const_double
:
31768 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
31769 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
31770 case dw_val_class_wide_int
:
31771 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
31772 case dw_val_class_addr
:
31773 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
31775 gcc_unreachable ();
31778 case DW_OP_bit_piece
:
31779 return valx1
->v
.val_int
== valy1
->v
.val_int
31780 && valx2
->v
.val_int
== valy2
->v
.val_int
;
31783 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
31784 case DW_OP_GNU_addr_index
:
31786 case DW_OP_GNU_const_index
:
31789 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
31790 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
31791 return rtx_equal_p (ax1
, ay1
);
31793 case DW_OP_implicit_pointer
:
31794 case DW_OP_GNU_implicit_pointer
:
31795 return valx1
->val_class
== dw_val_class_die_ref
31796 && valx1
->val_class
== valy1
->val_class
31797 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
31798 && valx2
->v
.val_int
== valy2
->v
.val_int
;
31799 case DW_OP_entry_value
:
31800 case DW_OP_GNU_entry_value
:
31801 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
31802 case DW_OP_const_type
:
31803 case DW_OP_GNU_const_type
:
31804 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
31805 || valx2
->val_class
!= valy2
->val_class
)
31807 switch (valx2
->val_class
)
31809 case dw_val_class_const
:
31810 return valx2
->v
.val_int
== valy2
->v
.val_int
;
31811 case dw_val_class_vec
:
31812 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
31813 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
31814 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
31815 valx2
->v
.val_vec
.elt_size
31816 * valx2
->v
.val_vec
.length
) == 0;
31817 case dw_val_class_const_double
:
31818 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
31819 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
31820 case dw_val_class_wide_int
:
31821 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
31823 gcc_unreachable ();
31825 case DW_OP_regval_type
:
31826 case DW_OP_deref_type
:
31827 case DW_OP_GNU_regval_type
:
31828 case DW_OP_GNU_deref_type
:
31829 return valx1
->v
.val_int
== valy1
->v
.val_int
31830 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
31831 case DW_OP_convert
:
31832 case DW_OP_reinterpret
:
31833 case DW_OP_GNU_convert
:
31834 case DW_OP_GNU_reinterpret
:
31835 if (valx1
->val_class
!= valy1
->val_class
)
31837 if (valx1
->val_class
== dw_val_class_unsigned_const
)
31838 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
31839 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
31840 case DW_OP_GNU_parameter_ref
:
31841 return valx1
->val_class
== dw_val_class_die_ref
31842 && valx1
->val_class
== valy1
->val_class
31843 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
31845 /* Other codes have no operands. */
31850 /* Return true if DWARF location expressions X and Y are the same. */
31853 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
31855 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
31856 if (x
->dw_loc_opc
!= y
->dw_loc_opc
31857 || x
->dtprel
!= y
->dtprel
31858 || !compare_loc_operands (x
, y
))
31860 return x
== NULL
&& y
== NULL
;
31863 /* Hashtable helpers. */
31865 struct loc_list_hasher
: nofree_ptr_hash
<dw_loc_list_struct
>
31867 static inline hashval_t
hash (const dw_loc_list_struct
*);
31868 static inline bool equal (const dw_loc_list_struct
*,
31869 const dw_loc_list_struct
*);
31872 /* Return precomputed hash of location list X. */
31875 loc_list_hasher::hash (const dw_loc_list_struct
*x
)
31880 /* Return true if location lists A and B are the same. */
31883 loc_list_hasher::equal (const dw_loc_list_struct
*a
,
31884 const dw_loc_list_struct
*b
)
31888 if (a
->hash
!= b
->hash
)
31890 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
31891 if (strcmp (a
->begin
, b
->begin
) != 0
31892 || strcmp (a
->end
, b
->end
) != 0
31893 || (a
->section
== NULL
) != (b
->section
== NULL
)
31894 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
31895 || a
->vbegin
!= b
->vbegin
|| a
->vend
!= b
->vend
31896 || !compare_locs (a
->expr
, b
->expr
))
31898 return a
== NULL
&& b
== NULL
;
31901 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
31904 /* Recursively optimize location lists referenced from DIE
31905 children and share them whenever possible. */
31908 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type
*htab
)
31913 dw_loc_list_struct
**slot
;
31914 bool drop_locviews
= false;
31915 bool has_locviews
= false;
31917 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31918 if (AT_class (a
) == dw_val_class_loc_list
)
31920 dw_loc_list_ref list
= AT_loc_list (a
);
31921 /* TODO: perform some optimizations here, before hashing
31922 it and storing into the hash table. */
31923 hash_loc_list (list
);
31924 slot
= htab
->find_slot_with_hash (list
, list
->hash
, INSERT
);
31928 if (loc_list_has_views (list
))
31929 gcc_assert (list
->vl_symbol
);
31930 else if (list
->vl_symbol
)
31932 drop_locviews
= true;
31933 list
->vl_symbol
= NULL
;
31938 if (list
->vl_symbol
&& !(*slot
)->vl_symbol
)
31939 drop_locviews
= true;
31940 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
31943 else if (AT_class (a
) == dw_val_class_view_list
)
31945 gcc_checking_assert (a
->dw_attr
== DW_AT_GNU_locviews
);
31946 has_locviews
= true;
31950 if (drop_locviews
&& has_locviews
)
31951 remove_AT (die
, DW_AT_GNU_locviews
);
31953 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
31957 /* Recursively assign each location list a unique index into the debug_addr
31961 index_location_lists (dw_die_ref die
)
31967 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31968 if (AT_class (a
) == dw_val_class_loc_list
)
31970 dw_loc_list_ref list
= AT_loc_list (a
);
31971 dw_loc_list_ref curr
;
31972 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
31974 /* Don't index an entry that has already been indexed
31975 or won't be output. Make sure skip_loc_list_entry doesn't
31976 call size_of_locs, because that might cause circular dependency,
31977 index_location_lists requiring address table indexes to be
31978 computed, but adding new indexes through add_addr_table_entry
31979 and address table index computation requiring no new additions
31980 to the hash table. In the rare case of DWARF[234] >= 64KB
31981 location expression, we'll just waste unused address table entry
31983 if (curr
->begin_entry
!= NULL
|| skip_loc_list_entry (curr
))
31987 = add_addr_table_entry (xstrdup (curr
->begin
), ate_kind_label
);
31988 if (dwarf_version
>= 5 && !HAVE_AS_LEB128
)
31990 = add_addr_table_entry (xstrdup (curr
->end
), ate_kind_label
);
31994 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
31997 /* Optimize location lists referenced from DIE
31998 children and share them whenever possible. */
32001 optimize_location_lists (dw_die_ref die
)
32003 loc_list_hash_type
htab (500);
32004 optimize_location_lists_1 (die
, &htab
);
32007 /* Traverse the limbo die list, and add parent/child links. The only
32008 dies without parents that should be here are concrete instances of
32009 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
32010 For concrete instances, we can get the parent die from the abstract
32014 flush_limbo_die_list (void)
32016 limbo_die_node
*node
;
32018 /* get_context_die calls force_decl_die, which can put new DIEs on the
32019 limbo list in LTO mode when nested functions are put in a different
32020 partition than that of their parent function. */
32021 while ((node
= limbo_die_list
))
32023 dw_die_ref die
= node
->die
;
32024 limbo_die_list
= node
->next
;
32026 if (die
->die_parent
== NULL
)
32028 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
32030 if (origin
&& origin
->die_parent
)
32031 add_child_die (origin
->die_parent
, die
);
32032 else if (is_cu_die (die
))
32034 else if (seen_error ())
32035 /* It's OK to be confused by errors in the input. */
32036 add_child_die (comp_unit_die (), die
);
32039 /* In certain situations, the lexical block containing a
32040 nested function can be optimized away, which results
32041 in the nested function die being orphaned. Likewise
32042 with the return type of that nested function. Force
32043 this to be a child of the containing function.
32045 It may happen that even the containing function got fully
32046 inlined and optimized out. In that case we are lost and
32047 assign the empty child. This should not be big issue as
32048 the function is likely unreachable too. */
32049 gcc_assert (node
->created_for
);
32051 if (DECL_P (node
->created_for
))
32052 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
32053 else if (TYPE_P (node
->created_for
))
32054 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
32056 origin
= comp_unit_die ();
32058 add_child_die (origin
, die
);
32064 /* Reset DIEs so we can output them again. */
32067 reset_dies (dw_die_ref die
)
32071 /* Remove stuff we re-generate. */
32073 die
->die_offset
= 0;
32074 die
->die_abbrev
= 0;
32075 remove_AT (die
, DW_AT_sibling
);
32077 FOR_EACH_CHILD (die
, c
, reset_dies (c
));
32080 /* reset_indirect_string removed the references coming from DW_AT_name
32081 and DW_AT_comp_dir attributes on compilation unit DIEs. Readd them as
32082 .debug_line_str strings again. */
32085 adjust_name_comp_dir (dw_die_ref die
)
32087 for (int i
= 0; i
< 2; i
++)
32089 dwarf_attribute attr_kind
= i
? DW_AT_comp_dir
: DW_AT_name
;
32090 dw_attr_node
*a
= get_AT (die
, attr_kind
);
32091 if (a
== NULL
|| a
->dw_attr_val
.val_class
!= dw_val_class_str
)
32094 if (!debug_line_str_hash
)
32095 debug_line_str_hash
32096 = hash_table
<indirect_string_hasher
>::create_ggc (10);
32098 struct indirect_string_node
*node
32099 = find_AT_string_in_table (a
->dw_attr_val
.v
.val_str
->str
,
32100 debug_line_str_hash
);
32101 set_indirect_string (node
);
32102 node
->form
= DW_FORM_line_strp
;
32103 a
->dw_attr_val
.v
.val_str
= node
;
32107 /* Output stuff that dwarf requires at the end of every file,
32108 and generate the DWARF-2 debugging info. */
32111 dwarf2out_finish (const char *filename
)
32113 comdat_type_node
*ctnode
;
32114 dw_die_ref main_comp_unit_die
;
32115 unsigned char checksum
[16];
32116 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
32118 /* Generate CTF/BTF debug info. */
32119 if ((ctf_debug_info_level
> CTFINFO_LEVEL_NONE
32120 || btf_debuginfo_p ()) && lang_GNU_C ())
32121 ctf_debug_finish (filename
);
32123 /* Skip emitting DWARF if not required. */
32124 if (!dwarf_debuginfo_p ())
32127 /* Flush out any latecomers to the limbo party. */
32128 flush_limbo_die_list ();
32130 if (inline_entry_data_table
)
32131 gcc_assert (inline_entry_data_table
->is_empty ());
32135 verify_die (comp_unit_die ());
32136 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
32137 verify_die (node
->die
);
32140 /* We shouldn't have any symbols with delayed asm names for
32141 DIEs generated after early finish. */
32142 gcc_assert (deferred_asm_name
== NULL
);
32144 gen_remaining_tmpl_value_param_die_attribute ();
32146 if (flag_generate_lto
|| flag_generate_offload
)
32148 gcc_assert (flag_fat_lto_objects
|| flag_generate_offload
);
32150 /* Prune stuff so that dwarf2out_finish runs successfully
32151 for the fat part of the object. */
32152 reset_dies (comp_unit_die ());
32153 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
32154 reset_dies (node
->die
);
32156 hash_table
<comdat_type_hasher
> comdat_type_table (100);
32157 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
32159 comdat_type_node
**slot
32160 = comdat_type_table
.find_slot (ctnode
, INSERT
);
32162 /* Don't reset types twice. */
32163 if (*slot
!= HTAB_EMPTY_ENTRY
)
32166 /* Remove the pointer to the line table. */
32167 remove_AT (ctnode
->root_die
, DW_AT_stmt_list
);
32169 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32170 reset_dies (ctnode
->root_die
);
32175 /* Reset die CU symbol so we don't output it twice. */
32176 comp_unit_die ()->die_id
.die_symbol
= NULL
;
32178 /* Remove DW_AT_macro and DW_AT_stmt_list from the early output. */
32179 remove_AT (comp_unit_die (), DW_AT_stmt_list
);
32181 remove_AT (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
);
32183 /* Remove indirect string decisions. */
32184 debug_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
32185 if (debug_line_str_hash
)
32187 debug_line_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
32188 debug_line_str_hash
= NULL
;
32189 if (asm_outputs_debug_line_str ())
32191 adjust_name_comp_dir (comp_unit_die ());
32192 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
32193 adjust_name_comp_dir (node
->die
);
32198 #if ENABLE_ASSERT_CHECKING
32200 dw_die_ref die
= comp_unit_die (), c
;
32201 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
32204 base_types
.truncate (0);
32205 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
32206 resolve_addr (ctnode
->root_die
);
32207 resolve_addr (comp_unit_die ());
32208 move_marked_base_types ();
32212 fprintf (dump_file
, "DWARF for %s\n", filename
);
32213 print_die (comp_unit_die (), dump_file
);
32216 /* Initialize sections and labels used for actual assembler output. */
32217 unsigned generation
= init_sections_and_labels (false);
32219 /* Traverse the DIE's and add sibling attributes to those DIE's that
32221 add_sibling_attributes (comp_unit_die ());
32222 limbo_die_node
*node
;
32223 for (node
= cu_die_list
; node
; node
= node
->next
)
32224 add_sibling_attributes (node
->die
);
32225 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
32226 add_sibling_attributes (ctnode
->root_die
);
32228 /* When splitting DWARF info, we put some attributes in the
32229 skeleton compile_unit DIE that remains in the .o, while
32230 most attributes go in the DWO compile_unit_die. */
32231 if (dwarf_split_debug_info
)
32233 limbo_die_node
*cu
;
32234 main_comp_unit_die
= gen_compile_unit_die (NULL
);
32235 if (dwarf_version
>= 5)
32236 main_comp_unit_die
->die_tag
= DW_TAG_skeleton_unit
;
32237 cu
= limbo_die_list
;
32238 gcc_assert (cu
->die
== main_comp_unit_die
);
32239 limbo_die_list
= limbo_die_list
->next
;
32240 cu
->next
= cu_die_list
;
32244 main_comp_unit_die
= comp_unit_die ();
32246 /* Output a terminator label for the .text section. */
32247 switch_to_section (text_section
);
32248 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
32249 if (cold_text_section
)
32251 switch_to_section (cold_text_section
);
32252 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
32255 /* We can only use the low/high_pc attributes if all of the code was
32257 if ((!have_multiple_function_sections
32258 && vec_safe_length (switch_text_ranges
) < 2)
32259 || (dwarf_version
< 3 && dwarf_strict
))
32261 const char *end_label
= text_end_label
;
32262 if (vec_safe_length (switch_text_ranges
) == 1)
32263 end_label
= (*switch_text_ranges
)[0];
32264 /* Don't add if the CU has no associated code. */
32265 if (switch_text_ranges
)
32266 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
32273 bool range_list_added
= false;
32274 if (switch_text_ranges
)
32276 const char *prev_loc
= text_section_label
;
32280 FOR_EACH_VEC_ELT (*switch_text_ranges
, idx
, loc
)
32283 add_ranges_by_labels (main_comp_unit_die
, prev_loc
,
32284 loc
, &range_list_added
, true);
32291 add_ranges_by_labels (main_comp_unit_die
, prev_loc
,
32292 text_end_label
, &range_list_added
, true);
32295 if (switch_cold_ranges
)
32297 const char *prev_loc
= cold_text_section_label
;
32301 FOR_EACH_VEC_ELT (*switch_cold_ranges
, idx
, loc
)
32304 add_ranges_by_labels (main_comp_unit_die
, prev_loc
,
32305 loc
, &range_list_added
, true);
32312 add_ranges_by_labels (main_comp_unit_die
, prev_loc
,
32313 cold_end_label
, &range_list_added
, true);
32316 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
32318 if (fde
->ignored_debug
)
32320 if (!fde
->in_std_section
)
32321 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
32322 fde
->dw_fde_end
, &range_list_added
,
32324 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
32325 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
32326 fde
->dw_fde_second_end
, &range_list_added
,
32330 if (range_list_added
)
32332 /* We need to give .debug_loc and .debug_ranges an appropriate
32333 "base address". Use zero so that these addresses become
32334 absolute. Historically, we've emitted the unexpected
32335 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
32336 Emit both to give time for other tools to adapt. */
32337 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
32338 if (! dwarf_strict
&& dwarf_version
< 4)
32339 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
32342 have_multiple_function_sections
= true;
32346 /* AIX Assembler inserts the length, so adjust the reference to match the
32347 offset expected by debuggers. */
32348 strcpy (dl_section_ref
, debug_line_section_label
);
32349 if (XCOFF_DEBUGGING_INFO
)
32350 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
32352 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32353 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
32357 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
32358 macinfo_section_label
);
32360 if (dwarf_split_debug_info
)
32362 if (have_location_lists
)
32364 /* Since we generate the loclists in the split DWARF .dwo
32365 file itself, we don't need to generate a loclists_base
32366 attribute for the split compile unit DIE. That attribute
32367 (and using relocatable sec_offset FORMs) isn't allowed
32368 for a split compile unit. Only if the .debug_loclists
32369 section was in the main file, would we need to generate a
32370 loclists_base attribute here (for the full or skeleton
32373 /* optimize_location_lists calculates the size of the lists,
32374 so index them first, and assign indices to the entries.
32375 Although optimize_location_lists will remove entries from
32376 the table, it only does so for duplicates, and therefore
32377 only reduces ref_counts to 1. */
32378 index_location_lists (comp_unit_die ());
32381 if (dwarf_version
>= 5 && !vec_safe_is_empty (ranges_table
))
32384 if (addr_index_table
!= NULL
)
32386 unsigned int index
= 0;
32388 ->traverse_noresize
<unsigned int *, index_addr_table_entry
>
32394 if (have_location_lists
)
32396 optimize_location_lists (comp_unit_die ());
32397 /* And finally assign indexes to the entries for -gsplit-dwarf. */
32398 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
32399 assign_location_list_indexes (comp_unit_die ());
32402 save_macinfo_strings ();
32404 if (dwarf_split_debug_info
)
32406 unsigned int index
= 0;
32408 /* Add attributes common to skeleton compile_units and
32409 type_units. Because these attributes include strings, it
32410 must be done before freezing the string table. Top-level
32411 skeleton die attrs are added when the skeleton type unit is
32412 created, so ensure it is created by this point. */
32413 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
32414 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
32417 /* Output all of the compilation units. We put the main one last so that
32418 the offsets are available to output_pubnames. */
32419 for (node
= cu_die_list
; node
; node
= node
->next
)
32420 output_comp_unit (node
->die
, 0, NULL
);
32422 hash_table
<comdat_type_hasher
> comdat_type_table (100);
32423 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
32425 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
32427 /* Don't output duplicate types. */
32428 if (*slot
!= HTAB_EMPTY_ENTRY
)
32431 /* Add a pointer to the line table for the main compilation unit
32432 so that the debugger can make sense of DW_AT_decl_file
32434 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32435 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
32436 (!dwarf_split_debug_info
32438 : debug_skeleton_line_section_label
));
32440 output_comdat_type_unit (ctnode
, false);
32444 if (dwarf_split_debug_info
)
32447 struct md5_ctx ctx
;
32449 /* Compute a checksum of the comp_unit to use as the dwo_id. */
32450 md5_init_ctx (&ctx
);
32452 die_checksum (comp_unit_die (), &ctx
, &mark
);
32453 unmark_all_dies (comp_unit_die ());
32454 md5_finish_ctx (&ctx
, checksum
);
32456 if (dwarf_version
< 5)
32458 /* Use the first 8 bytes of the checksum as the dwo_id,
32459 and add it to both comp-unit DIEs. */
32460 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
32461 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
32464 /* Add the base offset of the ranges table to the skeleton
32466 if (!vec_safe_is_empty (ranges_table
))
32468 if (dwarf_version
< 5)
32469 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
32470 ranges_section_label
);
32473 output_addr_table ();
32476 /* Output the main compilation unit if non-empty or if .debug_macinfo
32477 or .debug_macro will be emitted. */
32478 output_comp_unit (comp_unit_die (), have_macinfo
,
32479 dwarf_split_debug_info
? checksum
: NULL
);
32481 if (dwarf_split_debug_info
&& info_section_emitted
)
32482 output_skeleton_debug_sections (main_comp_unit_die
, checksum
);
32484 /* Output the abbreviation table. */
32485 if (vec_safe_length (abbrev_die_table
) != 1)
32487 switch_to_section (debug_abbrev_section
);
32488 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
32489 output_abbrev_section ();
32492 /* Output location list section if necessary. */
32493 if (have_location_lists
)
32495 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
32496 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
32497 /* Output the location lists info. */
32498 switch_to_section (debug_loc_section
);
32499 if (dwarf_version
>= 5)
32501 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_LOC_SECTION_LABEL
, 2);
32502 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_LOC_SECTION_LABEL
, 3);
32503 if (DWARF_INITIAL_LENGTH_SIZE
- dwarf_offset_size
== 4)
32504 dw2_asm_output_data (4, 0xffffffff,
32505 "Initial length escape value indicating "
32506 "64-bit DWARF extension");
32507 dw2_asm_output_delta (dwarf_offset_size
, l2
, l1
,
32508 "Length of Location Lists");
32509 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
32510 output_dwarf_version ();
32511 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
32512 dw2_asm_output_data (1, 0, "Segment Size");
32513 dw2_asm_output_data (4, dwarf_split_debug_info
? loc_list_idx
: 0,
32514 "Offset Entry Count");
32516 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
32517 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
32519 unsigned int save_loc_list_idx
= loc_list_idx
;
32521 output_loclists_offsets (comp_unit_die ());
32522 gcc_assert (save_loc_list_idx
== loc_list_idx
);
32524 output_location_lists (comp_unit_die ());
32525 if (dwarf_version
>= 5)
32526 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
32529 output_pubtables ();
32531 /* Output the address range information if a CU (.debug_info section)
32532 was emitted. We output an empty table even if we had no functions
32533 to put in it. This because the consumer has no way to tell the
32534 difference between an empty table that we omitted and failure to
32535 generate a table that would have contained data. */
32536 if (info_section_emitted
)
32538 switch_to_section (debug_aranges_section
);
32542 /* Output ranges section if necessary. */
32543 if (!vec_safe_is_empty (ranges_table
))
32545 if (dwarf_version
>= 5)
32547 if (dwarf_split_debug_info
)
32549 /* We don't know right now whether there are any
32550 ranges for .debug_rnglists and any for .debug_rnglists.dwo.
32551 Depending on into which of those two belongs the first
32552 ranges_table entry, emit that section first and that
32553 output_rnglists call will return true if the other kind of
32554 ranges needs to be emitted as well. */
32555 bool dwo
= (*ranges_table
)[0].idx
!= DW_RANGES_IDX_SKELETON
;
32556 if (output_rnglists (generation
, dwo
))
32557 output_rnglists (generation
, !dwo
);
32560 output_rnglists (generation
, false);
32566 /* Have to end the macro section. */
32569 switch_to_section (debug_macinfo_section
);
32570 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
32571 output_macinfo (!dwarf_split_debug_info
? debug_line_section_label
32572 : debug_skeleton_line_section_label
, false);
32573 dw2_asm_output_data (1, 0, "End compilation unit");
32576 /* Output the source line correspondence table. We must do this
32577 even if there is no line information. Otherwise, on an empty
32578 translation unit, we will generate a present, but empty,
32579 .debug_info section. IRIX 6.5 `nm' will then complain when
32580 examining the file. This is done late so that any filenames
32581 used by the debug_info section are marked as 'used'. */
32582 switch_to_section (debug_line_section
);
32583 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
32584 if (! output_asm_line_debug_info ())
32585 output_line_info (false);
32587 if (dwarf_split_debug_info
&& info_section_emitted
)
32589 switch_to_section (debug_skeleton_line_section
);
32590 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
32591 output_line_info (true);
32594 /* If we emitted any indirect strings, output the string table too. */
32595 if (debug_str_hash
|| skeleton_debug_str_hash
)
32596 output_indirect_strings ();
32597 if (debug_line_str_hash
)
32599 switch_to_section (debug_line_str_section
);
32600 const enum dwarf_form form
= DW_FORM_line_strp
;
32601 debug_line_str_hash
->traverse
<enum dwarf_form
,
32602 output_indirect_string
> (form
);
32605 /* ??? Move lvugid out of dwarf2out_source_line and reset it too? */
32606 symview_upper_bound
= 0;
32608 bitmap_clear (zero_view_p
);
32611 /* Returns a hash value for X (which really is a variable_value_struct). */
32614 variable_value_hasher::hash (variable_value_struct
*x
)
32616 return (hashval_t
) x
->decl_id
;
32619 /* Return nonzero if decl_id of variable_value_struct X is the same as
32623 variable_value_hasher::equal (variable_value_struct
*x
, tree y
)
32625 return x
->decl_id
== DECL_UID (y
);
32628 /* Helper function for resolve_variable_value, handle
32629 DW_OP_GNU_variable_value in one location expression.
32630 Return true if exprloc has been changed into loclist. */
32633 resolve_variable_value_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
32635 dw_loc_descr_ref next
;
32636 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= next
)
32638 next
= loc
->dw_loc_next
;
32639 if (loc
->dw_loc_opc
!= DW_OP_GNU_variable_value
32640 || loc
->dw_loc_oprnd1
.val_class
!= dw_val_class_decl_ref
)
32643 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
32644 if (DECL_CONTEXT (decl
) != current_function_decl
)
32647 dw_die_ref ref
= lookup_decl_die (decl
);
32650 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
32651 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
32652 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
32655 dw_loc_list_ref l
= loc_list_from_tree (decl
, 0, NULL
);
32658 if (l
->dw_loc_next
)
32660 if (AT_class (a
) != dw_val_class_loc
)
32662 switch (a
->dw_attr
)
32664 /* Following attributes allow both exprloc and loclist
32665 classes, so we can change them into a loclist. */
32666 case DW_AT_location
:
32667 case DW_AT_string_length
:
32668 case DW_AT_return_addr
:
32669 case DW_AT_data_member_location
:
32670 case DW_AT_frame_base
:
32671 case DW_AT_segment
:
32672 case DW_AT_static_link
:
32673 case DW_AT_use_location
:
32674 case DW_AT_vtable_elem_location
:
32677 prev
->dw_loc_next
= NULL
;
32678 prepend_loc_descr_to_each (l
, AT_loc (a
));
32681 add_loc_descr_to_each (l
, next
);
32682 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
32683 a
->dw_attr_val
.val_entry
= NULL
;
32684 a
->dw_attr_val
.v
.val_loc_list
= l
;
32685 have_location_lists
= true;
32687 /* Following attributes allow both exprloc and reference,
32688 so if the whole expression is DW_OP_GNU_variable_value alone
32689 we could transform it into reference. */
32690 case DW_AT_byte_size
:
32691 case DW_AT_bit_size
:
32692 case DW_AT_lower_bound
:
32693 case DW_AT_upper_bound
:
32694 case DW_AT_bit_stride
:
32696 case DW_AT_allocated
:
32697 case DW_AT_associated
:
32698 case DW_AT_byte_stride
:
32699 if (prev
== NULL
&& next
== NULL
)
32707 /* Create DW_TAG_variable that we can refer to. */
32708 gen_decl_die (decl
, NULL_TREE
, NULL
,
32709 lookup_decl_die (current_function_decl
));
32710 ref
= lookup_decl_die (decl
);
32713 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
32714 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
32715 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
32721 prev
->dw_loc_next
= l
->expr
;
32722 add_loc_descr (&prev
->dw_loc_next
, next
);
32723 free_loc_descr (loc
, NULL
);
32724 next
= prev
->dw_loc_next
;
32728 memcpy (loc
, l
->expr
, sizeof (dw_loc_descr_node
));
32729 add_loc_descr (&loc
, next
);
32737 /* Attempt to resolve DW_OP_GNU_variable_value using loc_list_from_tree. */
32740 resolve_variable_value (dw_die_ref die
)
32743 dw_loc_list_ref loc
;
32746 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
32747 switch (AT_class (a
))
32749 case dw_val_class_loc
:
32750 if (!resolve_variable_value_in_expr (a
, AT_loc (a
)))
32753 case dw_val_class_loc_list
:
32754 loc
= AT_loc_list (a
);
32756 for (; loc
; loc
= loc
->dw_loc_next
)
32757 resolve_variable_value_in_expr (a
, loc
->expr
);
32764 /* Attempt to optimize DW_OP_GNU_variable_value refering to
32765 temporaries in the current function. */
32768 resolve_variable_values (void)
32770 if (!variable_value_hash
|| !current_function_decl
)
32773 struct variable_value_struct
*node
32774 = variable_value_hash
->find_with_hash (current_function_decl
,
32775 DECL_UID (current_function_decl
));
32782 FOR_EACH_VEC_SAFE_ELT (node
->dies
, i
, die
)
32783 resolve_variable_value (die
);
32786 /* Helper function for note_variable_value, handle one location
32790 note_variable_value_in_expr (dw_die_ref die
, dw_loc_descr_ref loc
)
32792 for (; loc
; loc
= loc
->dw_loc_next
)
32793 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
32794 && loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
32796 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
32797 dw_die_ref ref
= lookup_decl_die (decl
);
32798 if (! ref
&& (flag_generate_lto
|| flag_generate_offload
))
32800 /* ??? This is somewhat a hack because we do not create DIEs
32801 for variables not in BLOCK trees early but when generating
32802 early LTO output we need the dw_val_class_decl_ref to be
32803 fully resolved. For fat LTO objects we'd also like to
32804 undo this after LTO dwarf output. */
32805 gcc_assert (DECL_CONTEXT (decl
));
32806 dw_die_ref ctx
= lookup_decl_die (DECL_CONTEXT (decl
));
32807 gcc_assert (ctx
!= NULL
);
32808 gen_decl_die (decl
, NULL_TREE
, NULL
, ctx
);
32809 ref
= lookup_decl_die (decl
);
32810 gcc_assert (ref
!= NULL
);
32814 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
32815 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
32816 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
32820 && DECL_CONTEXT (decl
)
32821 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
32822 && lookup_decl_die (DECL_CONTEXT (decl
)))
32824 if (!variable_value_hash
)
32825 variable_value_hash
32826 = hash_table
<variable_value_hasher
>::create_ggc (10);
32828 tree fndecl
= DECL_CONTEXT (decl
);
32829 struct variable_value_struct
*node
;
32830 struct variable_value_struct
**slot
32831 = variable_value_hash
->find_slot_with_hash (fndecl
,
32836 node
= ggc_cleared_alloc
<variable_value_struct
> ();
32837 node
->decl_id
= DECL_UID (fndecl
);
32843 vec_safe_push (node
->dies
, die
);
32848 /* Walk the tree DIE and note DIEs with DW_OP_GNU_variable_value still
32849 with dw_val_class_decl_ref operand. */
32852 note_variable_value (dw_die_ref die
)
32856 dw_loc_list_ref loc
;
32859 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
32860 switch (AT_class (a
))
32862 case dw_val_class_loc_list
:
32863 loc
= AT_loc_list (a
);
32865 if (!loc
->noted_variable_value
)
32867 loc
->noted_variable_value
= 1;
32868 for (; loc
; loc
= loc
->dw_loc_next
)
32869 note_variable_value_in_expr (die
, loc
->expr
);
32872 case dw_val_class_loc
:
32873 note_variable_value_in_expr (die
, AT_loc (a
));
32879 /* Mark children. */
32880 FOR_EACH_CHILD (die
, c
, note_variable_value (c
));
32883 /* Process DWARF dies for CTF generation. */
32886 ctf_debug_do_cu (dw_die_ref die
)
32890 if (!ctf_do_die (die
))
32893 FOR_EACH_CHILD (die
, c
, ctf_do_die (c
));
32896 /* Perform any cleanups needed after the early debug generation pass
32900 dwarf2out_early_finish (const char *filename
)
32902 comdat_type_node
*ctnode
;
32904 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
32906 /* PCH might result in DW_AT_producer string being restored from the
32907 header compilation, so always fill it with empty string initially
32908 and overwrite only here. */
32909 dw_attr_node
*producer
= get_AT (comp_unit_die (), DW_AT_producer
);
32911 if (dwarf_record_gcc_switches
)
32912 producer_string
= gen_producer_string (lang_hooks
.name
,
32913 save_decoded_options
,
32914 save_decoded_options_count
);
32916 producer_string
= concat (lang_hooks
.name
, " ", version_string
, NULL
);
32918 producer
->dw_attr_val
.v
.val_str
->refcount
--;
32919 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
32921 /* Add the name for the main input file now. We delayed this from
32922 dwarf2out_init to avoid complications with PCH. */
32923 add_filename_attribute (comp_unit_die (), remap_debug_filename (filename
));
32924 add_comp_dir_attribute (comp_unit_die ());
32926 /* With LTO early dwarf was really finished at compile-time, so make
32927 sure to adjust the phase after annotating the LTRANS CU DIE. */
32930 early_dwarf_finished
= true;
32933 fprintf (dump_file
, "LTO EARLY DWARF for %s\n", filename
);
32934 print_die (comp_unit_die (), dump_file
);
32939 /* Walk through the list of incomplete types again, trying once more to
32940 emit full debugging info for them. */
32941 retry_incomplete_types ();
32943 gen_scheduled_generic_parms_dies ();
32944 gen_remaining_tmpl_value_param_die_attribute ();
32946 /* The point here is to flush out the limbo list so that it is empty
32947 and we don't need to stream it for LTO. */
32948 flush_limbo_die_list ();
32950 /* Add DW_AT_linkage_name for all deferred DIEs. */
32951 for (limbo_die_node
*node
= deferred_asm_name
; node
; node
= node
->next
)
32953 tree decl
= node
->created_for
;
32954 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
32955 /* A missing DECL_ASSEMBLER_NAME can be a constant DIE that
32956 ended up in deferred_asm_name before we knew it was
32957 constant and never written to disk. */
32958 && DECL_ASSEMBLER_NAME (decl
))
32960 add_linkage_attr (node
->die
, decl
);
32961 move_linkage_attr (node
->die
);
32964 deferred_asm_name
= NULL
;
32966 if (flag_eliminate_unused_debug_types
)
32967 prune_unused_types ();
32969 /* Generate separate COMDAT sections for type DIEs. */
32970 if (use_debug_types
)
32972 break_out_comdat_types (comp_unit_die ());
32974 /* Each new type_unit DIE was added to the limbo die list when created.
32975 Since these have all been added to comdat_type_list, clear the
32977 limbo_die_list
= NULL
;
32979 /* For each new comdat type unit, copy declarations for incomplete
32980 types to make the new unit self-contained (i.e., no direct
32981 references to the main compile unit). */
32982 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
32983 copy_decls_for_unworthy_types (ctnode
->root_die
);
32984 copy_decls_for_unworthy_types (comp_unit_die ());
32986 /* In the process of copying declarations from one unit to another,
32987 we may have left some declarations behind that are no longer
32988 referenced. Prune them. */
32989 prune_unused_types ();
32992 /* Traverse the DIE's and note DIEs with DW_OP_GNU_variable_value still
32993 with dw_val_class_decl_ref operand. */
32994 note_variable_value (comp_unit_die ());
32995 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
32996 note_variable_value (node
->die
);
32997 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
32998 note_variable_value (ctnode
->root_die
);
32999 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
33000 note_variable_value (node
->die
);
33002 /* The AT_pubnames attribute needs to go in all skeleton dies, including
33003 both the main_cu and all skeleton TUs. Making this call unconditional
33004 would end up either adding a second copy of the AT_pubnames attribute, or
33005 requiring a special case in add_top_level_skeleton_die_attrs. */
33006 if (!dwarf_split_debug_info
)
33007 add_AT_pubnames (comp_unit_die ());
33009 /* The early debug phase is now finished. */
33010 early_dwarf_finished
= true;
33013 fprintf (dump_file
, "EARLY DWARF for %s\n", filename
);
33014 print_die (comp_unit_die (), dump_file
);
33017 /* Generate CTF/BTF debug info. */
33018 if ((ctf_debug_info_level
> CTFINFO_LEVEL_NONE
33019 || btf_debuginfo_p ()) && lang_GNU_C ())
33022 ctf_debug_do_cu (comp_unit_die ());
33023 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
33024 ctf_debug_do_cu (node
->die
);
33025 /* Post process the debug data in the CTF container if necessary. */
33026 ctf_debug_init_postprocess (btf_debuginfo_p ());
33028 ctf_debug_early_finish (filename
);
33031 /* Do not generate DWARF assembler now when not producing LTO bytecode. */
33032 if ((!flag_generate_lto
&& !flag_generate_offload
)
33033 /* FIXME: Disable debug info generation for (PE-)COFF targets since the
33034 copy_lto_debug_sections operation of the simple object support in
33035 libiberty is not implemented for them yet. */
33036 || TARGET_PECOFF
|| TARGET_COFF
)
33039 /* Now as we are going to output for LTO initialize sections and labels
33040 to the LTO variants. We don't need a random-seed postfix as other
33041 LTO sections as linking the LTO debug sections into one in a partial
33043 init_sections_and_labels (true);
33045 /* The output below is modeled after dwarf2out_finish with all
33046 location related output removed and some LTO specific changes.
33047 Some refactoring might make both smaller and easier to match up. */
33049 base_types
.truncate (0);
33050 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
33051 mark_base_types (ctnode
->root_die
);
33052 mark_base_types (comp_unit_die ());
33053 move_marked_base_types ();
33055 /* Traverse the DIE's and add sibling attributes to those DIE's
33056 that have children. */
33057 add_sibling_attributes (comp_unit_die ());
33058 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
33059 add_sibling_attributes (node
->die
);
33060 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
33061 add_sibling_attributes (ctnode
->root_die
);
33063 /* AIX Assembler inserts the length, so adjust the reference to match the
33064 offset expected by debuggers. */
33065 strcpy (dl_section_ref
, debug_line_section_label
);
33066 if (XCOFF_DEBUGGING_INFO
)
33067 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
33069 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
33070 add_AT_lineptr (comp_unit_die (), DW_AT_stmt_list
, dl_section_ref
);
33073 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
33074 macinfo_section_label
);
33076 save_macinfo_strings ();
33078 if (dwarf_split_debug_info
)
33080 unsigned int index
= 0;
33081 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
33084 /* Output all of the compilation units. We put the main one last so that
33085 the offsets are available to output_pubnames. */
33086 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
33087 output_comp_unit (node
->die
, 0, NULL
);
33089 hash_table
<comdat_type_hasher
> comdat_type_table (100);
33090 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
33092 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
33094 /* Don't output duplicate types. */
33095 if (*slot
!= HTAB_EMPTY_ENTRY
)
33098 /* Add a pointer to the line table for the main compilation unit
33099 so that the debugger can make sense of DW_AT_decl_file
33101 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
33102 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
33103 (!dwarf_split_debug_info
33104 ? debug_line_section_label
33105 : debug_skeleton_line_section_label
));
33107 output_comdat_type_unit (ctnode
, true);
33111 /* Stick a unique symbol to the main debuginfo section. */
33112 compute_comp_unit_symbol (comp_unit_die ());
33114 /* Output the main compilation unit. We always need it if only for
33116 output_comp_unit (comp_unit_die (), true, NULL
);
33118 /* Output the abbreviation table. */
33119 if (vec_safe_length (abbrev_die_table
) != 1)
33121 switch_to_section (debug_abbrev_section
);
33122 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
33123 output_abbrev_section ();
33126 /* Have to end the macro section. */
33129 /* We have to save macinfo state if we need to output it again
33130 for the FAT part of the object. */
33131 vec
<macinfo_entry
, va_gc
> *saved_macinfo_table
= macinfo_table
;
33132 if (flag_fat_lto_objects
)
33133 macinfo_table
= macinfo_table
->copy ();
33135 switch_to_section (debug_macinfo_section
);
33136 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
33137 output_macinfo (debug_line_section_label
, true);
33138 dw2_asm_output_data (1, 0, "End compilation unit");
33140 if (flag_fat_lto_objects
)
33142 vec_free (macinfo_table
);
33143 macinfo_table
= saved_macinfo_table
;
33147 /* Emit a skeleton debug_line section. */
33148 switch_to_section (debug_line_section
);
33149 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
33150 output_line_info (true);
33152 /* If we emitted any indirect strings, output the string table too. */
33153 if (debug_str_hash
|| skeleton_debug_str_hash
)
33154 output_indirect_strings ();
33155 if (debug_line_str_hash
)
33157 switch_to_section (debug_line_str_section
);
33158 const enum dwarf_form form
= DW_FORM_line_strp
;
33159 debug_line_str_hash
->traverse
<enum dwarf_form
,
33160 output_indirect_string
> (form
);
33163 /* Switch back to the text section. */
33164 switch_to_section (text_section
);
33167 /* Reset all state within dwarf2out.cc so that we can rerun the compiler
33168 within the same process. For use by toplev::finalize. */
33171 dwarf2out_cc_finalize (void)
33173 last_var_location_insn
= NULL
;
33174 cached_next_real_insn
= NULL
;
33175 used_rtx_array
= NULL
;
33176 incomplete_types
= NULL
;
33177 debug_info_section
= NULL
;
33178 debug_skeleton_info_section
= NULL
;
33179 debug_abbrev_section
= NULL
;
33180 debug_skeleton_abbrev_section
= NULL
;
33181 debug_aranges_section
= NULL
;
33182 debug_addr_section
= NULL
;
33183 debug_macinfo_section
= NULL
;
33184 debug_line_section
= NULL
;
33185 debug_skeleton_line_section
= NULL
;
33186 debug_loc_section
= NULL
;
33187 debug_pubnames_section
= NULL
;
33188 debug_pubtypes_section
= NULL
;
33189 debug_str_section
= NULL
;
33190 debug_line_str_section
= NULL
;
33191 debug_str_dwo_section
= NULL
;
33192 debug_str_offsets_section
= NULL
;
33193 debug_ranges_section
= NULL
;
33194 debug_ranges_dwo_section
= NULL
;
33195 debug_frame_section
= NULL
;
33197 debug_str_hash
= NULL
;
33198 debug_line_str_hash
= NULL
;
33199 skeleton_debug_str_hash
= NULL
;
33200 dw2_string_counter
= 0;
33201 have_multiple_function_sections
= false;
33202 in_text_section_p
= false;
33203 cold_text_section
= NULL
;
33204 last_text_label
= NULL
;
33205 last_cold_label
= NULL
;
33206 switch_text_ranges
= NULL
;
33207 switch_cold_ranges
= NULL
;
33208 current_unit_personality
= NULL
;
33210 early_dwarf
= false;
33211 early_dwarf_finished
= false;
33213 next_die_offset
= 0;
33214 single_comp_unit_die
= NULL
;
33215 comdat_type_list
= NULL
;
33216 limbo_die_list
= NULL
;
33218 decl_die_table
= NULL
;
33219 common_block_die_table
= NULL
;
33220 decl_loc_table
= NULL
;
33221 call_arg_locations
= NULL
;
33222 call_arg_loc_last
= NULL
;
33223 call_site_count
= -1;
33224 tail_call_site_count
= -1;
33225 cached_dw_loc_list_table
= NULL
;
33226 abbrev_die_table
= NULL
;
33227 delete dwarf_proc_stack_usage_map
;
33228 dwarf_proc_stack_usage_map
= NULL
;
33229 line_info_label_num
= 0;
33230 cur_line_info_table
= NULL
;
33231 text_section_line_info
= NULL
;
33232 cold_text_section_line_info
= NULL
;
33233 separate_line_info
= NULL
;
33234 info_section_emitted
= false;
33235 pubname_table
= NULL
;
33236 pubtype_table
= NULL
;
33237 macinfo_table
= NULL
;
33238 ranges_table
= NULL
;
33239 ranges_by_label
= NULL
;
33241 have_location_lists
= false;
33244 last_emitted_file
= NULL
;
33246 tmpl_value_parm_die_table
= NULL
;
33247 generic_type_instances
= NULL
;
33248 frame_pointer_fb_offset
= 0;
33249 frame_pointer_fb_offset_valid
= false;
33250 base_types
.release ();
33251 XDELETEVEC (producer_string
);
33252 producer_string
= NULL
;
33253 output_line_info_generation
= 0;
33254 init_sections_and_labels_generation
= 0;
33257 #include "gt-dwarf2out.h"