1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992-2018 Free Software Foundation, Inc.
3 Contributed by Gary Funck (gary@intrepid.com).
4 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
5 Extensively modified by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* TODO: Emit .debug_line header even when there are no functions, since
24 the file numbers are used by .debug_info. Alternately, leave
25 out locations for types and decls.
26 Avoid talking about ctors and op= for PODs.
27 Factor out common prologue sequences into multiple CIEs. */
29 /* The first part of this file deals with the DWARF 2 frame unwind
30 information, which is also used by the GCC efficient exception handling
31 mechanism. The second part, controlled only by an #ifdef
32 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
35 /* DWARF2 Abbreviation Glossary:
37 CFA = Canonical Frame Address
38 a fixed address on the stack which identifies a call frame.
39 We define it to be the value of SP just before the call insn.
40 The CFA register and offset, which may change during the course
41 of the function, are used to calculate its value at runtime.
43 CFI = Call Frame Instruction
44 an instruction for the DWARF2 abstract machine
46 CIE = Common Information Entry
47 information describing information common to one or more FDEs
49 DIE = Debugging Information Entry
51 FDE = Frame Description Entry
52 information describing the stack call frame, in particular,
53 how to restore registers
55 DW_CFA_... = DWARF2 CFA call frame instruction
56 DW_TAG_... = DWARF2 DIE tag */
60 #include "coretypes.h"
67 #include "stringpool.h"
68 #include "insn-config.h"
71 #include "diagnostic.h"
72 #include "fold-const.h"
73 #include "stor-layout.h"
81 #include "dwarf2out.h"
82 #include "dwarf2asm.h"
85 #include "tree-pretty-print.h"
86 #include "print-rtl.h"
88 #include "common/common-target.h"
89 #include "langhooks.h"
94 #include "gdb/gdb-index.h"
96 #include "stringpool.h"
98 #include "file-prefix-map.h" /* remap_debug_filename() */
100 static void dwarf2out_source_line (unsigned int, unsigned int, const char *,
102 static rtx_insn
*last_var_location_insn
;
103 static rtx_insn
*cached_next_real_insn
;
104 static void dwarf2out_decl (tree
);
106 #ifndef XCOFF_DEBUGGING_INFO
107 #define XCOFF_DEBUGGING_INFO 0
110 #ifndef HAVE_XCOFF_DWARF_EXTRAS
111 #define HAVE_XCOFF_DWARF_EXTRAS 0
114 #ifdef VMS_DEBUGGING_INFO
115 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
117 /* Define this macro to be a nonzero value if the directory specifications
118 which are output in the debug info should end with a separator. */
119 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
120 /* Define this macro to evaluate to a nonzero value if GCC should refrain
121 from generating indirect strings in DWARF2 debug information, for instance
122 if your target is stuck with an old version of GDB that is unable to
123 process them properly or uses VMS Debug. */
124 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
126 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
127 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
130 /* ??? Poison these here until it can be done generically. They've been
131 totally replaced in this file; make sure it stays that way. */
132 #undef DWARF2_UNWIND_INFO
133 #undef DWARF2_FRAME_INFO
134 #if (GCC_VERSION >= 3000)
135 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
138 /* The size of the target's pointer type. */
140 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
143 /* Array of RTXes referenced by the debugging information, which therefore
144 must be kept around forever. */
145 static GTY(()) vec
<rtx
, va_gc
> *used_rtx_array
;
147 /* A pointer to the base of a list of incomplete types which might be
148 completed at some later time. incomplete_types_list needs to be a
149 vec<tree, va_gc> *because we want to tell the garbage collector about
151 static GTY(()) vec
<tree
, va_gc
> *incomplete_types
;
153 /* Pointers to various DWARF2 sections. */
154 static GTY(()) section
*debug_info_section
;
155 static GTY(()) section
*debug_skeleton_info_section
;
156 static GTY(()) section
*debug_abbrev_section
;
157 static GTY(()) section
*debug_skeleton_abbrev_section
;
158 static GTY(()) section
*debug_aranges_section
;
159 static GTY(()) section
*debug_addr_section
;
160 static GTY(()) section
*debug_macinfo_section
;
161 static const char *debug_macinfo_section_name
;
162 static unsigned macinfo_label_base
= 1;
163 static GTY(()) section
*debug_line_section
;
164 static GTY(()) section
*debug_skeleton_line_section
;
165 static GTY(()) section
*debug_loc_section
;
166 static GTY(()) section
*debug_pubnames_section
;
167 static GTY(()) section
*debug_pubtypes_section
;
168 static GTY(()) section
*debug_str_section
;
169 static GTY(()) section
*debug_line_str_section
;
170 static GTY(()) section
*debug_str_dwo_section
;
171 static GTY(()) section
*debug_str_offsets_section
;
172 static GTY(()) section
*debug_ranges_section
;
173 static GTY(()) section
*debug_frame_section
;
175 /* Maximum size (in bytes) of an artificially generated label. */
176 #define MAX_ARTIFICIAL_LABEL_BYTES 40
178 /* According to the (draft) DWARF 3 specification, the initial length
179 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
180 bytes are 0xffffffff, followed by the length stored in the next 8
183 However, the SGI/MIPS ABI uses an initial length which is equal to
184 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
186 #ifndef DWARF_INITIAL_LENGTH_SIZE
187 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
190 #ifndef DWARF_INITIAL_LENGTH_SIZE_STR
191 #define DWARF_INITIAL_LENGTH_SIZE_STR (DWARF_OFFSET_SIZE == 4 ? "-4" : "-12")
194 /* Round SIZE up to the nearest BOUNDARY. */
195 #define DWARF_ROUND(SIZE,BOUNDARY) \
196 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
198 /* CIE identifier. */
199 #if HOST_BITS_PER_WIDE_INT >= 64
200 #define DWARF_CIE_ID \
201 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
203 #define DWARF_CIE_ID DW_CIE_ID
207 /* A vector for a table that contains frame description
208 information for each routine. */
209 #define NOT_INDEXED (-1U)
210 #define NO_INDEX_ASSIGNED (-2U)
212 static GTY(()) vec
<dw_fde_ref
, va_gc
> *fde_vec
;
214 struct GTY((for_user
)) indirect_string_node
{
216 unsigned int refcount
;
217 enum dwarf_form form
;
222 struct indirect_string_hasher
: ggc_ptr_hash
<indirect_string_node
>
224 typedef const char *compare_type
;
226 static hashval_t
hash (indirect_string_node
*);
227 static bool equal (indirect_string_node
*, const char *);
230 static GTY (()) hash_table
<indirect_string_hasher
> *debug_str_hash
;
232 static GTY (()) hash_table
<indirect_string_hasher
> *debug_line_str_hash
;
234 /* With split_debug_info, both the comp_dir and dwo_name go in the
235 main object file, rather than the dwo, similar to the force_direct
236 parameter elsewhere but with additional complications:
238 1) The string is needed in both the main object file and the dwo.
239 That is, the comp_dir and dwo_name will appear in both places.
241 2) Strings can use four forms: DW_FORM_string, DW_FORM_strp,
242 DW_FORM_line_strp or DW_FORM_strx/GNU_str_index.
244 3) GCC chooses the form to use late, depending on the size and
247 Rather than forcing the all debug string handling functions and
248 callers to deal with these complications, simply use a separate,
249 special-cased string table for any attribute that should go in the
250 main object file. This limits the complexity to just the places
253 static GTY (()) hash_table
<indirect_string_hasher
> *skeleton_debug_str_hash
;
255 static GTY(()) int dw2_string_counter
;
257 /* True if the compilation unit places functions in more than one section. */
258 static GTY(()) bool have_multiple_function_sections
= false;
260 /* Whether the default text and cold text sections have been used at all. */
261 static GTY(()) bool text_section_used
= false;
262 static GTY(()) bool cold_text_section_used
= false;
264 /* The default cold text section. */
265 static GTY(()) section
*cold_text_section
;
267 /* The DIE for C++14 'auto' in a function return type. */
268 static GTY(()) dw_die_ref auto_die
;
270 /* The DIE for C++14 'decltype(auto)' in a function return type. */
271 static GTY(()) dw_die_ref decltype_auto_die
;
273 /* Forward declarations for functions defined in this file. */
275 static void output_call_frame_info (int);
276 static void dwarf2out_note_section_used (void);
278 /* Personality decl of current unit. Used only when assembler does not support
280 static GTY(()) rtx current_unit_personality
;
282 /* Whether an eh_frame section is required. */
283 static GTY(()) bool do_eh_frame
= false;
285 /* .debug_rnglists next index. */
286 static unsigned int rnglist_idx
;
288 /* Data and reference forms for relocatable data. */
289 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
290 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
292 #ifndef DEBUG_FRAME_SECTION
293 #define DEBUG_FRAME_SECTION ".debug_frame"
296 #ifndef FUNC_BEGIN_LABEL
297 #define FUNC_BEGIN_LABEL "LFB"
300 #ifndef FUNC_END_LABEL
301 #define FUNC_END_LABEL "LFE"
304 #ifndef PROLOGUE_END_LABEL
305 #define PROLOGUE_END_LABEL "LPE"
308 #ifndef EPILOGUE_BEGIN_LABEL
309 #define EPILOGUE_BEGIN_LABEL "LEB"
312 #ifndef FRAME_BEGIN_LABEL
313 #define FRAME_BEGIN_LABEL "Lframe"
315 #define CIE_AFTER_SIZE_LABEL "LSCIE"
316 #define CIE_END_LABEL "LECIE"
317 #define FDE_LABEL "LSFDE"
318 #define FDE_AFTER_SIZE_LABEL "LASFDE"
319 #define FDE_END_LABEL "LEFDE"
320 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
321 #define LINE_NUMBER_END_LABEL "LELT"
322 #define LN_PROLOG_AS_LABEL "LASLTP"
323 #define LN_PROLOG_END_LABEL "LELTP"
324 #define DIE_LABEL_PREFIX "DW"
326 /* Match the base name of a file to the base name of a compilation unit. */
329 matches_main_base (const char *path
)
331 /* Cache the last query. */
332 static const char *last_path
= NULL
;
333 static int last_match
= 0;
334 if (path
!= last_path
)
337 int length
= base_of_path (path
, &base
);
339 last_match
= (length
== main_input_baselength
340 && memcmp (base
, main_input_basename
, length
) == 0);
345 #ifdef DEBUG_DEBUG_STRUCT
348 dump_struct_debug (tree type
, enum debug_info_usage usage
,
349 enum debug_struct_file criterion
, int generic
,
350 int matches
, int result
)
352 /* Find the type name. */
353 tree type_decl
= TYPE_STUB_DECL (type
);
355 const char *name
= 0;
356 if (TREE_CODE (t
) == TYPE_DECL
)
359 name
= IDENTIFIER_POINTER (t
);
361 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
363 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
364 matches
? "bas" : "hdr",
365 generic
? "gen" : "ord",
366 usage
== DINFO_USAGE_DFN
? ";" :
367 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
369 (void*) type_decl
, name
);
372 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
373 dump_struct_debug (type, usage, criterion, generic, matches, result)
377 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
382 /* Get the number of HOST_WIDE_INTs needed to represent the precision
383 of the number. Some constants have a large uniform precision, so
384 we get the precision needed for the actual value of the number. */
387 get_full_len (const wide_int
&op
)
389 int prec
= wi::min_precision (op
, UNSIGNED
);
390 return ((prec
+ HOST_BITS_PER_WIDE_INT
- 1)
391 / HOST_BITS_PER_WIDE_INT
);
395 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
397 enum debug_struct_file criterion
;
399 bool generic
= lang_hooks
.types
.generic_p (type
);
402 criterion
= debug_struct_generic
[usage
];
404 criterion
= debug_struct_ordinary
[usage
];
406 if (criterion
== DINFO_STRUCT_FILE_NONE
)
407 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
408 if (criterion
== DINFO_STRUCT_FILE_ANY
)
409 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
411 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
413 if (type_decl
!= NULL
)
415 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
416 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
418 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
419 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
422 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
425 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
426 switch to the data section instead, and write out a synthetic start label
427 for collect2 the first time around. */
430 switch_to_eh_frame_section (bool back ATTRIBUTE_UNUSED
)
432 if (eh_frame_section
== 0)
436 if (EH_TABLES_CAN_BE_READ_ONLY
)
442 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
444 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
446 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
449 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
450 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
451 && (per_encoding
& 0x70) != DW_EH_PE_absptr
452 && (per_encoding
& 0x70) != DW_EH_PE_aligned
453 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
454 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
455 ? 0 : SECTION_WRITE
);
458 flags
= SECTION_WRITE
;
460 #ifdef EH_FRAME_SECTION_NAME
461 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
463 eh_frame_section
= ((flags
== SECTION_WRITE
)
464 ? data_section
: readonly_data_section
);
465 #endif /* EH_FRAME_SECTION_NAME */
468 switch_to_section (eh_frame_section
);
470 #ifdef EH_FRAME_THROUGH_COLLECT2
471 /* We have no special eh_frame section. Emit special labels to guide
475 tree label
= get_file_function_name ("F");
476 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
477 targetm
.asm_out
.globalize_label (asm_out_file
,
478 IDENTIFIER_POINTER (label
));
479 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
484 /* Switch [BACK] to the eh or debug frame table section, depending on
488 switch_to_frame_table_section (int for_eh
, bool back
)
491 switch_to_eh_frame_section (back
);
494 if (!debug_frame_section
)
495 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
496 SECTION_DEBUG
, NULL
);
497 switch_to_section (debug_frame_section
);
501 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
503 enum dw_cfi_oprnd_type
504 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
509 case DW_CFA_GNU_window_save
:
510 case DW_CFA_remember_state
:
511 case DW_CFA_restore_state
:
512 return dw_cfi_oprnd_unused
;
515 case DW_CFA_advance_loc1
:
516 case DW_CFA_advance_loc2
:
517 case DW_CFA_advance_loc4
:
518 case DW_CFA_MIPS_advance_loc8
:
519 return dw_cfi_oprnd_addr
;
522 case DW_CFA_offset_extended
:
524 case DW_CFA_offset_extended_sf
:
525 case DW_CFA_def_cfa_sf
:
527 case DW_CFA_restore_extended
:
528 case DW_CFA_undefined
:
529 case DW_CFA_same_value
:
530 case DW_CFA_def_cfa_register
:
531 case DW_CFA_register
:
532 case DW_CFA_expression
:
533 case DW_CFA_val_expression
:
534 return dw_cfi_oprnd_reg_num
;
536 case DW_CFA_def_cfa_offset
:
537 case DW_CFA_GNU_args_size
:
538 case DW_CFA_def_cfa_offset_sf
:
539 return dw_cfi_oprnd_offset
;
541 case DW_CFA_def_cfa_expression
:
542 return dw_cfi_oprnd_loc
;
549 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
551 enum dw_cfi_oprnd_type
552 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
557 case DW_CFA_def_cfa_sf
:
559 case DW_CFA_offset_extended_sf
:
560 case DW_CFA_offset_extended
:
561 return dw_cfi_oprnd_offset
;
563 case DW_CFA_register
:
564 return dw_cfi_oprnd_reg_num
;
566 case DW_CFA_expression
:
567 case DW_CFA_val_expression
:
568 return dw_cfi_oprnd_loc
;
570 case DW_CFA_def_cfa_expression
:
571 return dw_cfi_oprnd_cfa_loc
;
574 return dw_cfi_oprnd_unused
;
578 /* Output one FDE. */
581 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
582 char *section_start_label
, int fde_encoding
, char *augmentation
,
583 bool any_lsda_needed
, int lsda_encoding
)
585 const char *begin
, *end
;
586 static unsigned int j
;
587 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
589 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
591 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
593 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
594 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
595 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
597 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
598 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
599 " indicating 64-bit DWARF extension");
600 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
603 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
606 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
608 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
609 debug_frame_section
, "FDE CIE offset");
611 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
612 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
616 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
617 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
618 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
619 "FDE initial location");
620 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
621 end
, begin
, "FDE address range");
625 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
626 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
633 int size
= size_of_encoded_value (lsda_encoding
);
635 if (lsda_encoding
== DW_EH_PE_aligned
)
637 int offset
= ( 4 /* Length */
639 + 2 * size_of_encoded_value (fde_encoding
)
640 + 1 /* Augmentation size */ );
641 int pad
= -offset
& (PTR_SIZE
- 1);
644 gcc_assert (size_of_uleb128 (size
) == 1);
647 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
649 if (fde
->uses_eh_lsda
)
651 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
652 fde
->funcdef_number
);
653 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
654 gen_rtx_SYMBOL_REF (Pmode
, l1
),
656 "Language Specific Data Area");
660 if (lsda_encoding
== DW_EH_PE_aligned
)
661 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
662 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
663 "Language Specific Data Area (none)");
667 dw2_asm_output_data_uleb128 (0, "Augmentation size");
670 /* Loop through the Call Frame Instructions associated with this FDE. */
671 fde
->dw_fde_current_label
= begin
;
673 size_t from
, until
, i
;
676 until
= vec_safe_length (fde
->dw_fde_cfi
);
678 if (fde
->dw_fde_second_begin
== NULL
)
681 until
= fde
->dw_fde_switch_cfi_index
;
683 from
= fde
->dw_fde_switch_cfi_index
;
685 for (i
= from
; i
< until
; i
++)
686 output_cfi ((*fde
->dw_fde_cfi
)[i
], fde
, for_eh
);
689 /* If we are to emit a ref/link from function bodies to their frame tables,
690 do it now. This is typically performed to make sure that tables
691 associated with functions are dragged with them and not discarded in
692 garbage collecting links. We need to do this on a per function basis to
693 cope with -ffunction-sections. */
695 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
696 /* Switch to the function section, emit the ref to the tables, and
697 switch *back* into the table section. */
698 switch_to_section (function_section (fde
->decl
));
699 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
700 switch_to_frame_table_section (for_eh
, true);
703 /* Pad the FDE out to an address sized boundary. */
704 ASM_OUTPUT_ALIGN (asm_out_file
,
705 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
706 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
711 /* Return true if frame description entry FDE is needed for EH. */
714 fde_needed_for_eh_p (dw_fde_ref fde
)
716 if (flag_asynchronous_unwind_tables
)
719 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
722 if (fde
->uses_eh_lsda
)
725 /* If exceptions are enabled, we have collected nothrow info. */
726 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
732 /* Output the call frame information used to record information
733 that relates to calculating the frame pointer, and records the
734 location of saved registers. */
737 output_call_frame_info (int for_eh
)
742 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
743 char section_start_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
744 bool any_lsda_needed
= false;
745 char augmentation
[6];
746 int augmentation_size
;
747 int fde_encoding
= DW_EH_PE_absptr
;
748 int per_encoding
= DW_EH_PE_absptr
;
749 int lsda_encoding
= DW_EH_PE_absptr
;
751 rtx personality
= NULL
;
754 /* Don't emit a CIE if there won't be any FDEs. */
758 /* Nothing to do if the assembler's doing it all. */
759 if (dwarf2out_do_cfi_asm ())
762 /* If we don't have any functions we'll want to unwind out of, don't emit
763 any EH unwind information. If we make FDEs linkonce, we may have to
764 emit an empty label for an FDE that wouldn't otherwise be emitted. We
765 want to avoid having an FDE kept around when the function it refers to
766 is discarded. Example where this matters: a primary function template
767 in C++ requires EH information, an explicit specialization doesn't. */
770 bool any_eh_needed
= false;
772 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
774 if (fde
->uses_eh_lsda
)
775 any_eh_needed
= any_lsda_needed
= true;
776 else if (fde_needed_for_eh_p (fde
))
777 any_eh_needed
= true;
778 else if (TARGET_USES_WEAK_UNWIND_INFO
)
779 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, 1, 1);
786 /* We're going to be generating comments, so turn on app. */
790 /* Switch to the proper frame section, first time. */
791 switch_to_frame_table_section (for_eh
, false);
793 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
794 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
796 /* Output the CIE. */
797 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
798 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
799 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
801 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
802 dw2_asm_output_data (4, 0xffffffff,
803 "Initial length escape value indicating 64-bit DWARF extension");
804 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
805 "Length of Common Information Entry");
807 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
809 /* Now that the CIE pointer is PC-relative for EH,
810 use 0 to identify the CIE. */
811 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
812 (for_eh
? 0 : DWARF_CIE_ID
),
813 "CIE Identifier Tag");
815 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
816 use CIE version 1, unless that would produce incorrect results
817 due to overflowing the return register column. */
818 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
820 if (return_reg
>= 256 || dwarf_version
> 2)
822 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
825 augmentation_size
= 0;
827 personality
= current_unit_personality
;
833 z Indicates that a uleb128 is present to size the
834 augmentation section.
835 L Indicates the encoding (and thus presence) of
836 an LSDA pointer in the FDE augmentation.
837 R Indicates a non-default pointer encoding for
839 P Indicates the presence of an encoding + language
840 personality routine in the CIE augmentation. */
842 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
843 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
844 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
846 p
= augmentation
+ 1;
850 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
851 assemble_external_libcall (personality
);
856 augmentation_size
+= 1;
858 if (fde_encoding
!= DW_EH_PE_absptr
)
861 augmentation_size
+= 1;
863 if (p
> augmentation
+ 1)
865 augmentation
[0] = 'z';
869 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
870 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
872 int offset
= ( 4 /* Length */
874 + 1 /* CIE version */
875 + strlen (augmentation
) + 1 /* Augmentation */
876 + size_of_uleb128 (1) /* Code alignment */
877 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
879 + 1 /* Augmentation size */
880 + 1 /* Personality encoding */ );
881 int pad
= -offset
& (PTR_SIZE
- 1);
883 augmentation_size
+= pad
;
885 /* Augmentations should be small, so there's scarce need to
886 iterate for a solution. Die if we exceed one uleb128 byte. */
887 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
891 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
892 if (dw_cie_version
>= 4)
894 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
895 dw2_asm_output_data (1, 0, "CIE Segment Size");
897 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
898 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
899 "CIE Data Alignment Factor");
901 if (dw_cie_version
== 1)
902 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
904 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
908 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
911 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
912 eh_data_format_name (per_encoding
));
913 dw2_asm_output_encoded_addr_rtx (per_encoding
,
919 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
920 eh_data_format_name (lsda_encoding
));
922 if (fde_encoding
!= DW_EH_PE_absptr
)
923 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
924 eh_data_format_name (fde_encoding
));
927 FOR_EACH_VEC_ELT (*cie_cfi_vec
, i
, cfi
)
928 output_cfi (cfi
, NULL
, for_eh
);
930 /* Pad the CIE out to an address sized boundary. */
931 ASM_OUTPUT_ALIGN (asm_out_file
,
932 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
933 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
935 /* Loop through all of the FDE's. */
936 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
940 /* Don't emit EH unwind info for leaf functions that don't need it. */
941 if (for_eh
&& !fde_needed_for_eh_p (fde
))
944 for (k
= 0; k
< (fde
->dw_fde_second_begin
? 2 : 1); k
++)
945 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
946 augmentation
, any_lsda_needed
, lsda_encoding
);
949 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
950 dw2_asm_output_data (4, 0, "End of Table");
952 /* Turn off app to make assembly quicker. */
957 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
960 dwarf2out_do_cfi_startproc (bool second
)
965 fprintf (asm_out_file
, "\t.cfi_startproc\n");
967 /* .cfi_personality and .cfi_lsda are only relevant to DWARF2
969 if (targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
)
972 rtx personality
= get_personality_function (current_function_decl
);
976 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
979 /* ??? The GAS support isn't entirely consistent. We have to
980 handle indirect support ourselves, but PC-relative is done
981 in the assembler. Further, the assembler can't handle any
982 of the weirder relocation types. */
983 if (enc
& DW_EH_PE_indirect
)
984 ref
= dw2_force_const_mem (ref
, true);
986 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
987 output_addr_const (asm_out_file
, ref
);
988 fputc ('\n', asm_out_file
);
991 if (crtl
->uses_eh_lsda
)
993 char lab
[MAX_ARTIFICIAL_LABEL_BYTES
];
995 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
996 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
997 current_function_funcdef_no
);
998 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
999 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
1001 if (enc
& DW_EH_PE_indirect
)
1002 ref
= dw2_force_const_mem (ref
, true);
1004 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
1005 output_addr_const (asm_out_file
, ref
);
1006 fputc ('\n', asm_out_file
);
1010 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
1011 this allocation may be done before pass_final. */
1014 dwarf2out_alloc_current_fde (void)
1018 fde
= ggc_cleared_alloc
<dw_fde_node
> ();
1019 fde
->decl
= current_function_decl
;
1020 fde
->funcdef_number
= current_function_funcdef_no
;
1021 fde
->fde_index
= vec_safe_length (fde_vec
);
1022 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
1023 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
1024 fde
->nothrow
= crtl
->nothrow
;
1025 fde
->drap_reg
= INVALID_REGNUM
;
1026 fde
->vdrap_reg
= INVALID_REGNUM
;
1028 /* Record the FDE associated with this function. */
1030 vec_safe_push (fde_vec
, fde
);
1035 /* Output a marker (i.e. a label) for the beginning of a function, before
1039 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1040 unsigned int column ATTRIBUTE_UNUSED
,
1041 const char *file ATTRIBUTE_UNUSED
)
1043 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1049 current_function_func_begin_label
= NULL
;
1051 do_frame
= dwarf2out_do_frame ();
1053 /* ??? current_function_func_begin_label is also used by except.c for
1054 call-site information. We must emit this label if it might be used. */
1056 && (!flag_exceptions
1057 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1060 fnsec
= function_section (current_function_decl
);
1061 switch_to_section (fnsec
);
1062 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1063 current_function_funcdef_no
);
1064 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1065 current_function_funcdef_no
);
1066 dup_label
= xstrdup (label
);
1067 current_function_func_begin_label
= dup_label
;
1069 /* We can elide FDE allocation if we're not emitting frame unwind info. */
1073 /* Unlike the debug version, the EH version of frame unwind info is a per-
1074 function setting so we need to record whether we need it for the unit. */
1075 do_eh_frame
|= dwarf2out_do_eh_frame ();
1077 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1078 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1079 would include pass_dwarf2_frame. If we've not created the FDE yet,
1083 fde
= dwarf2out_alloc_current_fde ();
1085 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1086 fde
->dw_fde_begin
= dup_label
;
1087 fde
->dw_fde_current_label
= dup_label
;
1088 fde
->in_std_section
= (fnsec
== text_section
1089 || (cold_text_section
&& fnsec
== cold_text_section
));
1091 /* We only want to output line number information for the genuine dwarf2
1092 prologue case, not the eh frame case. */
1093 #ifdef DWARF2_DEBUGGING_INFO
1095 dwarf2out_source_line (line
, column
, file
, 0, true);
1098 if (dwarf2out_do_cfi_asm ())
1099 dwarf2out_do_cfi_startproc (false);
1102 rtx personality
= get_personality_function (current_function_decl
);
1103 if (!current_unit_personality
)
1104 current_unit_personality
= personality
;
1106 /* We cannot keep a current personality per function as without CFI
1107 asm, at the point where we emit the CFI data, there is no current
1108 function anymore. */
1109 if (personality
&& current_unit_personality
!= personality
)
1110 sorry ("multiple EH personalities are supported only with assemblers "
1111 "supporting .cfi_personality directive");
1115 /* Output a marker (i.e. a label) for the end of the generated code
1116 for a function prologue. This gets called *after* the prologue code has
1120 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1121 const char *file ATTRIBUTE_UNUSED
)
1123 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1125 /* Output a label to mark the endpoint of the code generated for this
1127 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1128 current_function_funcdef_no
);
1129 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1130 current_function_funcdef_no
);
1131 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1134 /* Output a marker (i.e. a label) for the beginning of the generated code
1135 for a function epilogue. This gets called *before* the prologue code has
1139 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1140 const char *file ATTRIBUTE_UNUSED
)
1142 dw_fde_ref fde
= cfun
->fde
;
1143 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1145 if (fde
->dw_fde_vms_begin_epilogue
)
1148 /* Output a label to mark the endpoint of the code generated for this
1150 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1151 current_function_funcdef_no
);
1152 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1153 current_function_funcdef_no
);
1154 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1157 /* Output a marker (i.e. a label) for the absolute end of the generated code
1158 for a function definition. This gets called *after* the epilogue code has
1162 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1163 const char *file ATTRIBUTE_UNUSED
)
1166 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1168 last_var_location_insn
= NULL
;
1169 cached_next_real_insn
= NULL
;
1171 if (dwarf2out_do_cfi_asm ())
1172 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1174 /* Output a label to mark the endpoint of the code generated for this
1176 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1177 current_function_funcdef_no
);
1178 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1180 gcc_assert (fde
!= NULL
);
1181 if (fde
->dw_fde_second_begin
== NULL
)
1182 fde
->dw_fde_end
= xstrdup (label
);
1186 dwarf2out_frame_finish (void)
1188 /* Output call frame information. */
1189 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1190 output_call_frame_info (0);
1192 /* Output another copy for the unwinder. */
1194 output_call_frame_info (1);
1197 /* Note that the current function section is being used for code. */
1200 dwarf2out_note_section_used (void)
1202 section
*sec
= current_function_section ();
1203 if (sec
== text_section
)
1204 text_section_used
= true;
1205 else if (sec
== cold_text_section
)
1206 cold_text_section_used
= true;
1209 static void var_location_switch_text_section (void);
1210 static void set_cur_line_info_table (section
*);
1213 dwarf2out_switch_text_section (void)
1216 dw_fde_ref fde
= cfun
->fde
;
1218 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1220 if (!in_cold_section_p
)
1222 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1223 fde
->dw_fde_second_begin
= crtl
->subsections
.hot_section_label
;
1224 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1228 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1229 fde
->dw_fde_second_begin
= crtl
->subsections
.cold_section_label
;
1230 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1232 have_multiple_function_sections
= true;
1234 /* There is no need to mark used sections when not debugging. */
1235 if (cold_text_section
!= NULL
)
1236 dwarf2out_note_section_used ();
1238 if (dwarf2out_do_cfi_asm ())
1239 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1241 /* Now do the real section switch. */
1242 sect
= current_function_section ();
1243 switch_to_section (sect
);
1245 fde
->second_in_std_section
1246 = (sect
== text_section
1247 || (cold_text_section
&& sect
== cold_text_section
));
1249 if (dwarf2out_do_cfi_asm ())
1250 dwarf2out_do_cfi_startproc (true);
1252 var_location_switch_text_section ();
1254 if (cold_text_section
!= NULL
)
1255 set_cur_line_info_table (sect
);
1258 /* And now, the subset of the debugging information support code necessary
1259 for emitting location expressions. */
1261 /* Data about a single source file. */
1262 struct GTY((for_user
)) dwarf_file_data
{
1263 const char * filename
;
1267 /* Describe an entry into the .debug_addr section. */
1271 ate_kind_rtx_dtprel
,
1275 struct GTY((for_user
)) addr_table_entry
{
1277 unsigned int refcount
;
1279 union addr_table_entry_struct_union
1281 rtx
GTY ((tag ("0"))) rtl
;
1282 char * GTY ((tag ("1"))) label
;
1284 GTY ((desc ("%1.kind"))) addr
;
1287 typedef unsigned int var_loc_view
;
1289 /* Location lists are ranges + location descriptions for that range,
1290 so you can track variables that are in different places over
1291 their entire life. */
1292 typedef struct GTY(()) dw_loc_list_struct
{
1293 dw_loc_list_ref dw_loc_next
;
1294 const char *begin
; /* Label and addr_entry for start of range */
1295 addr_table_entry
*begin_entry
;
1296 const char *end
; /* Label for end of range */
1297 char *ll_symbol
; /* Label for beginning of location list.
1298 Only on head of list. */
1299 char *vl_symbol
; /* Label for beginning of view list. Ditto. */
1300 const char *section
; /* Section this loclist is relative to */
1301 dw_loc_descr_ref expr
;
1302 var_loc_view vbegin
, vend
;
1304 /* True if all addresses in this and subsequent lists are known to be
1307 /* True if this list has been replaced by dw_loc_next. */
1309 /* True if it has been emitted into .debug_loc* / .debug_loclists*
1311 unsigned char emitted
: 1;
1312 /* True if hash field is index rather than hash value. */
1313 unsigned char num_assigned
: 1;
1314 /* True if .debug_loclists.dwo offset has been emitted for it already. */
1315 unsigned char offset_emitted
: 1;
1316 /* True if note_variable_value_in_expr has been called on it. */
1317 unsigned char noted_variable_value
: 1;
1318 /* True if the range should be emitted even if begin and end
1323 static dw_loc_descr_ref
int_loc_descriptor (poly_int64
);
1324 static dw_loc_descr_ref
uint_loc_descriptor (unsigned HOST_WIDE_INT
);
1326 /* Convert a DWARF stack opcode into its string name. */
1329 dwarf_stack_op_name (unsigned int op
)
1331 const char *name
= get_DW_OP_name (op
);
1336 return "OP_<unknown>";
1339 /* Return TRUE iff we're to output location view lists as a separate
1340 attribute next to the location lists, as an extension compatible
1341 with DWARF 2 and above. */
1344 dwarf2out_locviews_in_attribute ()
1346 return debug_variable_location_views
== 1;
1349 /* Return TRUE iff we're to output location view lists as part of the
1350 location lists, as proposed for standardization after DWARF 5. */
1353 dwarf2out_locviews_in_loclist ()
1355 #ifndef DW_LLE_view_pair
1358 return debug_variable_location_views
== -1;
1362 /* Return a pointer to a newly allocated location description. Location
1363 descriptions are simple expression terms that can be strung
1364 together to form more complicated location (address) descriptions. */
1366 static inline dw_loc_descr_ref
1367 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1368 unsigned HOST_WIDE_INT oprnd2
)
1370 dw_loc_descr_ref descr
= ggc_cleared_alloc
<dw_loc_descr_node
> ();
1372 descr
->dw_loc_opc
= op
;
1373 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1374 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1375 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1376 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1377 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1378 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1383 /* Add a location description term to a location description expression. */
1386 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1388 dw_loc_descr_ref
*d
;
1390 /* Find the end of the chain. */
1391 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1397 /* Compare two location operands for exact equality. */
1400 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1402 if (a
->val_class
!= b
->val_class
)
1404 switch (a
->val_class
)
1406 case dw_val_class_none
:
1408 case dw_val_class_addr
:
1409 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1411 case dw_val_class_offset
:
1412 case dw_val_class_unsigned_const
:
1413 case dw_val_class_const
:
1414 case dw_val_class_unsigned_const_implicit
:
1415 case dw_val_class_const_implicit
:
1416 case dw_val_class_range_list
:
1417 /* These are all HOST_WIDE_INT, signed or unsigned. */
1418 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1420 case dw_val_class_loc
:
1421 return a
->v
.val_loc
== b
->v
.val_loc
;
1422 case dw_val_class_loc_list
:
1423 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1424 case dw_val_class_view_list
:
1425 return a
->v
.val_view_list
== b
->v
.val_view_list
;
1426 case dw_val_class_die_ref
:
1427 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1428 case dw_val_class_fde_ref
:
1429 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1430 case dw_val_class_symview
:
1431 return strcmp (a
->v
.val_symbolic_view
, b
->v
.val_symbolic_view
) == 0;
1432 case dw_val_class_lbl_id
:
1433 case dw_val_class_lineptr
:
1434 case dw_val_class_macptr
:
1435 case dw_val_class_loclistsptr
:
1436 case dw_val_class_high_pc
:
1437 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1438 case dw_val_class_str
:
1439 return a
->v
.val_str
== b
->v
.val_str
;
1440 case dw_val_class_flag
:
1441 return a
->v
.val_flag
== b
->v
.val_flag
;
1442 case dw_val_class_file
:
1443 case dw_val_class_file_implicit
:
1444 return a
->v
.val_file
== b
->v
.val_file
;
1445 case dw_val_class_decl_ref
:
1446 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1448 case dw_val_class_const_double
:
1449 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1450 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1452 case dw_val_class_wide_int
:
1453 return *a
->v
.val_wide
== *b
->v
.val_wide
;
1455 case dw_val_class_vec
:
1457 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1458 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1460 return (a_len
== b_len
1461 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1464 case dw_val_class_data8
:
1465 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1467 case dw_val_class_vms_delta
:
1468 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1469 && !strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
));
1471 case dw_val_class_discr_value
:
1472 return (a
->v
.val_discr_value
.pos
== b
->v
.val_discr_value
.pos
1473 && a
->v
.val_discr_value
.v
.uval
== b
->v
.val_discr_value
.v
.uval
);
1474 case dw_val_class_discr_list
:
1475 /* It makes no sense comparing two discriminant value lists. */
1481 /* Compare two location atoms for exact equality. */
1484 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1486 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1489 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1490 address size, but since we always allocate cleared storage it
1491 should be zero for other types of locations. */
1492 if (a
->dtprel
!= b
->dtprel
)
1495 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1496 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1499 /* Compare two complete location expressions for exact equality. */
1502 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1508 if (a
== NULL
|| b
== NULL
)
1510 if (!loc_descr_equal_p_1 (a
, b
))
1519 /* Add a constant POLY_OFFSET to a location expression. */
1522 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, poly_int64 poly_offset
)
1524 dw_loc_descr_ref loc
;
1527 gcc_assert (*list_head
!= NULL
);
1529 if (known_eq (poly_offset
, 0))
1532 /* Find the end of the chain. */
1533 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1536 HOST_WIDE_INT offset
;
1537 if (!poly_offset
.is_constant (&offset
))
1539 loc
->dw_loc_next
= int_loc_descriptor (poly_offset
);
1540 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_plus
, 0, 0));
1545 if (loc
->dw_loc_opc
== DW_OP_fbreg
1546 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1547 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1548 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1549 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1551 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1552 offset. Don't optimize if an signed integer overflow would happen. */
1554 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1555 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1558 else if (offset
> 0)
1559 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1564 = uint_loc_descriptor (-(unsigned HOST_WIDE_INT
) offset
);
1565 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1569 /* Return a pointer to a newly allocated location description for
1572 static inline dw_loc_descr_ref
1573 new_reg_loc_descr (unsigned int reg
, poly_int64 offset
)
1575 HOST_WIDE_INT const_offset
;
1576 if (offset
.is_constant (&const_offset
))
1579 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1582 return new_loc_descr (DW_OP_bregx
, reg
, const_offset
);
1586 dw_loc_descr_ref ret
= new_reg_loc_descr (reg
, 0);
1587 loc_descr_plus_const (&ret
, offset
);
1592 /* Add a constant OFFSET to a location list. */
1595 loc_list_plus_const (dw_loc_list_ref list_head
, poly_int64 offset
)
1598 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1599 loc_descr_plus_const (&d
->expr
, offset
);
1602 #define DWARF_REF_SIZE \
1603 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1605 /* The number of bits that can be encoded by largest DW_FORM_dataN.
1606 In DWARF4 and earlier it is DW_FORM_data8 with 64 bits, in DWARF5
1607 DW_FORM_data16 with 128 bits. */
1608 #define DWARF_LARGEST_DATA_FORM_BITS \
1609 (dwarf_version >= 5 ? 128 : 64)
1611 /* Utility inline function for construction of ops that were GNU extension
1613 static inline enum dwarf_location_atom
1614 dwarf_OP (enum dwarf_location_atom op
)
1618 case DW_OP_implicit_pointer
:
1619 if (dwarf_version
< 5)
1620 return DW_OP_GNU_implicit_pointer
;
1623 case DW_OP_entry_value
:
1624 if (dwarf_version
< 5)
1625 return DW_OP_GNU_entry_value
;
1628 case DW_OP_const_type
:
1629 if (dwarf_version
< 5)
1630 return DW_OP_GNU_const_type
;
1633 case DW_OP_regval_type
:
1634 if (dwarf_version
< 5)
1635 return DW_OP_GNU_regval_type
;
1638 case DW_OP_deref_type
:
1639 if (dwarf_version
< 5)
1640 return DW_OP_GNU_deref_type
;
1644 if (dwarf_version
< 5)
1645 return DW_OP_GNU_convert
;
1648 case DW_OP_reinterpret
:
1649 if (dwarf_version
< 5)
1650 return DW_OP_GNU_reinterpret
;
1654 if (dwarf_version
< 5)
1655 return DW_OP_GNU_addr_index
;
1659 if (dwarf_version
< 5)
1660 return DW_OP_GNU_const_index
;
1669 /* Similarly for attributes. */
1670 static inline enum dwarf_attribute
1671 dwarf_AT (enum dwarf_attribute at
)
1675 case DW_AT_call_return_pc
:
1676 if (dwarf_version
< 5)
1677 return DW_AT_low_pc
;
1680 case DW_AT_call_tail_call
:
1681 if (dwarf_version
< 5)
1682 return DW_AT_GNU_tail_call
;
1685 case DW_AT_call_origin
:
1686 if (dwarf_version
< 5)
1687 return DW_AT_abstract_origin
;
1690 case DW_AT_call_target
:
1691 if (dwarf_version
< 5)
1692 return DW_AT_GNU_call_site_target
;
1695 case DW_AT_call_target_clobbered
:
1696 if (dwarf_version
< 5)
1697 return DW_AT_GNU_call_site_target_clobbered
;
1700 case DW_AT_call_parameter
:
1701 if (dwarf_version
< 5)
1702 return DW_AT_abstract_origin
;
1705 case DW_AT_call_value
:
1706 if (dwarf_version
< 5)
1707 return DW_AT_GNU_call_site_value
;
1710 case DW_AT_call_data_value
:
1711 if (dwarf_version
< 5)
1712 return DW_AT_GNU_call_site_data_value
;
1715 case DW_AT_call_all_calls
:
1716 if (dwarf_version
< 5)
1717 return DW_AT_GNU_all_call_sites
;
1720 case DW_AT_call_all_tail_calls
:
1721 if (dwarf_version
< 5)
1722 return DW_AT_GNU_all_tail_call_sites
;
1725 case DW_AT_dwo_name
:
1726 if (dwarf_version
< 5)
1727 return DW_AT_GNU_dwo_name
;
1730 case DW_AT_addr_base
:
1731 if (dwarf_version
< 5)
1732 return DW_AT_GNU_addr_base
;
1741 /* And similarly for tags. */
1742 static inline enum dwarf_tag
1743 dwarf_TAG (enum dwarf_tag tag
)
1747 case DW_TAG_call_site
:
1748 if (dwarf_version
< 5)
1749 return DW_TAG_GNU_call_site
;
1752 case DW_TAG_call_site_parameter
:
1753 if (dwarf_version
< 5)
1754 return DW_TAG_GNU_call_site_parameter
;
1763 /* And similarly for forms. */
1764 static inline enum dwarf_form
1765 dwarf_FORM (enum dwarf_form form
)
1770 if (dwarf_version
< 5)
1771 return DW_FORM_GNU_addr_index
;
1775 if (dwarf_version
< 5)
1776 return DW_FORM_GNU_str_index
;
1785 static unsigned long int get_base_type_offset (dw_die_ref
);
1787 /* Return the size of a location descriptor. */
1789 static unsigned long
1790 size_of_loc_descr (dw_loc_descr_ref loc
)
1792 unsigned long size
= 1;
1794 switch (loc
->dw_loc_opc
)
1797 size
+= DWARF2_ADDR_SIZE
;
1799 case DW_OP_GNU_addr_index
:
1801 case DW_OP_GNU_const_index
:
1803 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1804 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1823 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1826 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1831 case DW_OP_plus_uconst
:
1832 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1870 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1873 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1876 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1879 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1880 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1883 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1885 case DW_OP_bit_piece
:
1886 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1887 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1889 case DW_OP_deref_size
:
1890 case DW_OP_xderef_size
:
1899 case DW_OP_call_ref
:
1900 case DW_OP_GNU_variable_value
:
1901 size
+= DWARF_REF_SIZE
;
1903 case DW_OP_implicit_value
:
1904 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1905 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1907 case DW_OP_implicit_pointer
:
1908 case DW_OP_GNU_implicit_pointer
:
1909 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1911 case DW_OP_entry_value
:
1912 case DW_OP_GNU_entry_value
:
1914 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1915 size
+= size_of_uleb128 (op_size
) + op_size
;
1918 case DW_OP_const_type
:
1919 case DW_OP_GNU_const_type
:
1922 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1923 size
+= size_of_uleb128 (o
) + 1;
1924 switch (loc
->dw_loc_oprnd2
.val_class
)
1926 case dw_val_class_vec
:
1927 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1928 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1930 case dw_val_class_const
:
1931 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1933 case dw_val_class_const_double
:
1934 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
1936 case dw_val_class_wide_int
:
1937 size
+= (get_full_len (*loc
->dw_loc_oprnd2
.v
.val_wide
)
1938 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
1945 case DW_OP_regval_type
:
1946 case DW_OP_GNU_regval_type
:
1949 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1950 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1951 + size_of_uleb128 (o
);
1954 case DW_OP_deref_type
:
1955 case DW_OP_GNU_deref_type
:
1958 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1959 size
+= 1 + size_of_uleb128 (o
);
1963 case DW_OP_reinterpret
:
1964 case DW_OP_GNU_convert
:
1965 case DW_OP_GNU_reinterpret
:
1966 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
1967 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1971 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1972 size
+= size_of_uleb128 (o
);
1975 case DW_OP_GNU_parameter_ref
:
1985 /* Return the size of a series of location descriptors. */
1988 size_of_locs (dw_loc_descr_ref loc
)
1993 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1994 field, to avoid writing to a PCH file. */
1995 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1997 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
1999 size
+= size_of_loc_descr (l
);
2004 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
2006 l
->dw_loc_addr
= size
;
2007 size
+= size_of_loc_descr (l
);
2013 /* Return the size of the value in a DW_AT_discr_value attribute. */
2016 size_of_discr_value (dw_discr_value
*discr_value
)
2018 if (discr_value
->pos
)
2019 return size_of_uleb128 (discr_value
->v
.uval
);
2021 return size_of_sleb128 (discr_value
->v
.sval
);
2024 /* Return the size of the value in a DW_AT_discr_list attribute. */
2027 size_of_discr_list (dw_discr_list_ref discr_list
)
2031 for (dw_discr_list_ref list
= discr_list
;
2033 list
= list
->dw_discr_next
)
2035 /* One byte for the discriminant value descriptor, and then one or two
2036 LEB128 numbers, depending on whether it's a single case label or a
2039 size
+= size_of_discr_value (&list
->dw_discr_lower_bound
);
2040 if (list
->dw_discr_range
!= 0)
2041 size
+= size_of_discr_value (&list
->dw_discr_upper_bound
);
2046 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
2047 static void get_ref_die_offset_label (char *, dw_die_ref
);
2048 static unsigned long int get_ref_die_offset (dw_die_ref
);
2050 /* Output location description stack opcode's operands (if any).
2051 The for_eh_or_skip parameter controls whether register numbers are
2052 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2053 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2054 info). This should be suppressed for the cases that have not been converted
2055 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2058 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2060 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2061 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2063 switch (loc
->dw_loc_opc
)
2065 #ifdef DWARF2_DEBUGGING_INFO
2068 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
2073 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2074 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
2076 fputc ('\n', asm_out_file
);
2081 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
2086 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2087 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
2089 fputc ('\n', asm_out_file
);
2094 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2095 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
2102 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2103 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2105 dw2_asm_output_data (2, offset
, NULL
);
2108 case DW_OP_implicit_value
:
2109 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2110 switch (val2
->val_class
)
2112 case dw_val_class_const
:
2113 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
2115 case dw_val_class_vec
:
2117 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2118 unsigned int len
= val2
->v
.val_vec
.length
;
2122 if (elt_size
> sizeof (HOST_WIDE_INT
))
2127 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2130 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2131 "fp or vector constant word %u", i
);
2134 case dw_val_class_const_double
:
2136 unsigned HOST_WIDE_INT first
, second
;
2138 if (WORDS_BIG_ENDIAN
)
2140 first
= val2
->v
.val_double
.high
;
2141 second
= val2
->v
.val_double
.low
;
2145 first
= val2
->v
.val_double
.low
;
2146 second
= val2
->v
.val_double
.high
;
2148 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2150 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2154 case dw_val_class_wide_int
:
2157 int len
= get_full_len (*val2
->v
.val_wide
);
2158 if (WORDS_BIG_ENDIAN
)
2159 for (i
= len
- 1; i
>= 0; --i
)
2160 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2161 val2
->v
.val_wide
->elt (i
), NULL
);
2163 for (i
= 0; i
< len
; ++i
)
2164 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2165 val2
->v
.val_wide
->elt (i
), NULL
);
2168 case dw_val_class_addr
:
2169 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
2170 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
2185 case DW_OP_implicit_value
:
2186 /* We currently don't make any attempt to make sure these are
2187 aligned properly like we do for the main unwind info, so
2188 don't support emitting things larger than a byte if we're
2189 only doing unwinding. */
2194 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2197 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2200 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2203 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2205 case DW_OP_plus_uconst
:
2206 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2240 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2244 unsigned r
= val1
->v
.val_unsigned
;
2245 if (for_eh_or_skip
>= 0)
2246 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2247 gcc_assert (size_of_uleb128 (r
)
2248 == size_of_uleb128 (val1
->v
.val_unsigned
));
2249 dw2_asm_output_data_uleb128 (r
, NULL
);
2253 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2257 unsigned r
= val1
->v
.val_unsigned
;
2258 if (for_eh_or_skip
>= 0)
2259 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2260 gcc_assert (size_of_uleb128 (r
)
2261 == size_of_uleb128 (val1
->v
.val_unsigned
));
2262 dw2_asm_output_data_uleb128 (r
, NULL
);
2263 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2267 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2269 case DW_OP_bit_piece
:
2270 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2271 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
2273 case DW_OP_deref_size
:
2274 case DW_OP_xderef_size
:
2275 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2281 if (targetm
.asm_out
.output_dwarf_dtprel
)
2283 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
2286 fputc ('\n', asm_out_file
);
2293 #ifdef DWARF2_DEBUGGING_INFO
2294 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
2301 case DW_OP_GNU_addr_index
:
2303 case DW_OP_GNU_const_index
:
2305 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
2306 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
2307 "(index into .debug_addr)");
2313 unsigned long die_offset
2314 = get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2315 /* Make sure the offset has been computed and that we can encode it as
2317 gcc_assert (die_offset
> 0
2318 && die_offset
<= (loc
->dw_loc_opc
== DW_OP_call2
2321 dw2_asm_output_data ((loc
->dw_loc_opc
== DW_OP_call2
) ? 2 : 4,
2326 case DW_OP_call_ref
:
2327 case DW_OP_GNU_variable_value
:
2329 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2330 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2331 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2332 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2333 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2337 case DW_OP_implicit_pointer
:
2338 case DW_OP_GNU_implicit_pointer
:
2340 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2341 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2342 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2343 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2344 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2345 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2349 case DW_OP_entry_value
:
2350 case DW_OP_GNU_entry_value
:
2351 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
2352 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
2355 case DW_OP_const_type
:
2356 case DW_OP_GNU_const_type
:
2358 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
2360 dw2_asm_output_data_uleb128 (o
, NULL
);
2361 switch (val2
->val_class
)
2363 case dw_val_class_const
:
2364 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2365 dw2_asm_output_data (1, l
, NULL
);
2366 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
2368 case dw_val_class_vec
:
2370 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2371 unsigned int len
= val2
->v
.val_vec
.length
;
2376 dw2_asm_output_data (1, l
, NULL
);
2377 if (elt_size
> sizeof (HOST_WIDE_INT
))
2382 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2385 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2386 "fp or vector constant word %u", i
);
2389 case dw_val_class_const_double
:
2391 unsigned HOST_WIDE_INT first
, second
;
2392 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2394 dw2_asm_output_data (1, 2 * l
, NULL
);
2395 if (WORDS_BIG_ENDIAN
)
2397 first
= val2
->v
.val_double
.high
;
2398 second
= val2
->v
.val_double
.low
;
2402 first
= val2
->v
.val_double
.low
;
2403 second
= val2
->v
.val_double
.high
;
2405 dw2_asm_output_data (l
, first
, NULL
);
2406 dw2_asm_output_data (l
, second
, NULL
);
2409 case dw_val_class_wide_int
:
2412 int len
= get_full_len (*val2
->v
.val_wide
);
2413 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2415 dw2_asm_output_data (1, len
* l
, NULL
);
2416 if (WORDS_BIG_ENDIAN
)
2417 for (i
= len
- 1; i
>= 0; --i
)
2418 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2420 for (i
= 0; i
< len
; ++i
)
2421 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2429 case DW_OP_regval_type
:
2430 case DW_OP_GNU_regval_type
:
2432 unsigned r
= val1
->v
.val_unsigned
;
2433 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2435 if (for_eh_or_skip
>= 0)
2437 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2438 gcc_assert (size_of_uleb128 (r
)
2439 == size_of_uleb128 (val1
->v
.val_unsigned
));
2441 dw2_asm_output_data_uleb128 (r
, NULL
);
2442 dw2_asm_output_data_uleb128 (o
, NULL
);
2445 case DW_OP_deref_type
:
2446 case DW_OP_GNU_deref_type
:
2448 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2450 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2451 dw2_asm_output_data_uleb128 (o
, NULL
);
2455 case DW_OP_reinterpret
:
2456 case DW_OP_GNU_convert
:
2457 case DW_OP_GNU_reinterpret
:
2458 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2459 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2462 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2464 dw2_asm_output_data_uleb128 (o
, NULL
);
2468 case DW_OP_GNU_parameter_ref
:
2471 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2472 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2473 dw2_asm_output_data (4, o
, NULL
);
2478 /* Other codes have no operands. */
2483 /* Output a sequence of location operations.
2484 The for_eh_or_skip parameter controls whether register numbers are
2485 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2486 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2487 info). This should be suppressed for the cases that have not been converted
2488 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2491 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2493 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2495 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2496 /* Output the opcode. */
2497 if (for_eh_or_skip
>= 0
2498 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2500 unsigned r
= (opc
- DW_OP_breg0
);
2501 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2502 gcc_assert (r
<= 31);
2503 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2505 else if (for_eh_or_skip
>= 0
2506 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2508 unsigned r
= (opc
- DW_OP_reg0
);
2509 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2510 gcc_assert (r
<= 31);
2511 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2514 dw2_asm_output_data (1, opc
,
2515 "%s", dwarf_stack_op_name (opc
));
2517 /* Output the operand(s) (if any). */
2518 output_loc_operands (loc
, for_eh_or_skip
);
2522 /* Output location description stack opcode's operands (if any).
2523 The output is single bytes on a line, suitable for .cfi_escape. */
2526 output_loc_operands_raw (dw_loc_descr_ref loc
)
2528 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2529 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2531 switch (loc
->dw_loc_opc
)
2534 case DW_OP_GNU_addr_index
:
2536 case DW_OP_GNU_const_index
:
2538 case DW_OP_implicit_value
:
2539 /* We cannot output addresses in .cfi_escape, only bytes. */
2545 case DW_OP_deref_size
:
2546 case DW_OP_xderef_size
:
2547 fputc (',', asm_out_file
);
2548 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2553 fputc (',', asm_out_file
);
2554 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2559 fputc (',', asm_out_file
);
2560 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2565 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2566 fputc (',', asm_out_file
);
2567 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2575 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2576 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2578 fputc (',', asm_out_file
);
2579 dw2_asm_output_data_raw (2, offset
);
2585 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2586 gcc_assert (size_of_uleb128 (r
)
2587 == size_of_uleb128 (val1
->v
.val_unsigned
));
2588 fputc (',', asm_out_file
);
2589 dw2_asm_output_data_uleb128_raw (r
);
2594 case DW_OP_plus_uconst
:
2596 fputc (',', asm_out_file
);
2597 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2600 case DW_OP_bit_piece
:
2601 fputc (',', asm_out_file
);
2602 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2603 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2640 fputc (',', asm_out_file
);
2641 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2646 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2647 gcc_assert (size_of_uleb128 (r
)
2648 == size_of_uleb128 (val1
->v
.val_unsigned
));
2649 fputc (',', asm_out_file
);
2650 dw2_asm_output_data_uleb128_raw (r
);
2651 fputc (',', asm_out_file
);
2652 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2656 case DW_OP_implicit_pointer
:
2657 case DW_OP_entry_value
:
2658 case DW_OP_const_type
:
2659 case DW_OP_regval_type
:
2660 case DW_OP_deref_type
:
2662 case DW_OP_reinterpret
:
2663 case DW_OP_GNU_implicit_pointer
:
2664 case DW_OP_GNU_entry_value
:
2665 case DW_OP_GNU_const_type
:
2666 case DW_OP_GNU_regval_type
:
2667 case DW_OP_GNU_deref_type
:
2668 case DW_OP_GNU_convert
:
2669 case DW_OP_GNU_reinterpret
:
2670 case DW_OP_GNU_parameter_ref
:
2675 /* Other codes have no operands. */
2681 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2685 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2686 /* Output the opcode. */
2687 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2689 unsigned r
= (opc
- DW_OP_breg0
);
2690 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2691 gcc_assert (r
<= 31);
2692 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2694 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2696 unsigned r
= (opc
- DW_OP_reg0
);
2697 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2698 gcc_assert (r
<= 31);
2699 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2701 /* Output the opcode. */
2702 fprintf (asm_out_file
, "%#x", opc
);
2703 output_loc_operands_raw (loc
);
2705 if (!loc
->dw_loc_next
)
2707 loc
= loc
->dw_loc_next
;
2709 fputc (',', asm_out_file
);
2713 /* This function builds a dwarf location descriptor sequence from a
2714 dw_cfa_location, adding the given OFFSET to the result of the
2717 struct dw_loc_descr_node
*
2718 build_cfa_loc (dw_cfa_location
*cfa
, poly_int64 offset
)
2720 struct dw_loc_descr_node
*head
, *tmp
;
2722 offset
+= cfa
->offset
;
2726 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
2727 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2728 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2729 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2730 add_loc_descr (&head
, tmp
);
2731 loc_descr_plus_const (&head
, offset
);
2734 head
= new_reg_loc_descr (cfa
->reg
, offset
);
2739 /* This function builds a dwarf location descriptor sequence for
2740 the address at OFFSET from the CFA when stack is aligned to
2743 struct dw_loc_descr_node
*
2744 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2745 poly_int64 offset
, HOST_WIDE_INT alignment
)
2747 struct dw_loc_descr_node
*head
;
2748 unsigned int dwarf_fp
2749 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2751 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2752 if (cfa
->reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2754 head
= new_reg_loc_descr (dwarf_fp
, 0);
2755 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2756 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2757 loc_descr_plus_const (&head
, offset
);
2760 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2764 /* And now, the support for symbolic debugging information. */
2766 /* .debug_str support. */
2768 static void dwarf2out_init (const char *);
2769 static void dwarf2out_finish (const char *);
2770 static void dwarf2out_early_finish (const char *);
2771 static void dwarf2out_assembly_start (void);
2772 static void dwarf2out_define (unsigned int, const char *);
2773 static void dwarf2out_undef (unsigned int, const char *);
2774 static void dwarf2out_start_source_file (unsigned, const char *);
2775 static void dwarf2out_end_source_file (unsigned);
2776 static void dwarf2out_function_decl (tree
);
2777 static void dwarf2out_begin_block (unsigned, unsigned);
2778 static void dwarf2out_end_block (unsigned, unsigned);
2779 static bool dwarf2out_ignore_block (const_tree
);
2780 static void dwarf2out_early_global_decl (tree
);
2781 static void dwarf2out_late_global_decl (tree
);
2782 static void dwarf2out_type_decl (tree
, int);
2783 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool, bool);
2784 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2786 static void dwarf2out_abstract_function (tree
);
2787 static void dwarf2out_var_location (rtx_insn
*);
2788 static void dwarf2out_inline_entry (tree
);
2789 static void dwarf2out_size_function (tree
);
2790 static void dwarf2out_begin_function (tree
);
2791 static void dwarf2out_end_function (unsigned int);
2792 static void dwarf2out_register_main_translation_unit (tree unit
);
2793 static void dwarf2out_set_name (tree
, tree
);
2794 static void dwarf2out_register_external_die (tree decl
, const char *sym
,
2795 unsigned HOST_WIDE_INT off
);
2796 static bool dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
2797 unsigned HOST_WIDE_INT
*off
);
2799 /* The debug hooks structure. */
2801 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2805 dwarf2out_early_finish
,
2806 dwarf2out_assembly_start
,
2809 dwarf2out_start_source_file
,
2810 dwarf2out_end_source_file
,
2811 dwarf2out_begin_block
,
2812 dwarf2out_end_block
,
2813 dwarf2out_ignore_block
,
2814 dwarf2out_source_line
,
2815 dwarf2out_begin_prologue
,
2816 #if VMS_DEBUGGING_INFO
2817 dwarf2out_vms_end_prologue
,
2818 dwarf2out_vms_begin_epilogue
,
2820 debug_nothing_int_charstar
,
2821 debug_nothing_int_charstar
,
2823 dwarf2out_end_epilogue
,
2824 dwarf2out_begin_function
,
2825 dwarf2out_end_function
, /* end_function */
2826 dwarf2out_register_main_translation_unit
,
2827 dwarf2out_function_decl
, /* function_decl */
2828 dwarf2out_early_global_decl
,
2829 dwarf2out_late_global_decl
,
2830 dwarf2out_type_decl
, /* type_decl */
2831 dwarf2out_imported_module_or_decl
,
2832 dwarf2out_die_ref_for_decl
,
2833 dwarf2out_register_external_die
,
2834 debug_nothing_tree
, /* deferred_inline_function */
2835 /* The DWARF 2 backend tries to reduce debugging bloat by not
2836 emitting the abstract description of inline functions until
2837 something tries to reference them. */
2838 dwarf2out_abstract_function
, /* outlining_inline_function */
2839 debug_nothing_rtx_code_label
, /* label */
2840 debug_nothing_int
, /* handle_pch */
2841 dwarf2out_var_location
,
2842 dwarf2out_inline_entry
, /* inline_entry */
2843 dwarf2out_size_function
, /* size_function */
2844 dwarf2out_switch_text_section
,
2846 1, /* start_end_main_source_file */
2847 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2850 const struct gcc_debug_hooks dwarf2_lineno_debug_hooks
=
2853 debug_nothing_charstar
,
2854 debug_nothing_charstar
,
2855 dwarf2out_assembly_start
,
2856 debug_nothing_int_charstar
,
2857 debug_nothing_int_charstar
,
2858 debug_nothing_int_charstar
,
2860 debug_nothing_int_int
, /* begin_block */
2861 debug_nothing_int_int
, /* end_block */
2862 debug_true_const_tree
, /* ignore_block */
2863 dwarf2out_source_line
, /* source_line */
2864 debug_nothing_int_int_charstar
, /* begin_prologue */
2865 debug_nothing_int_charstar
, /* end_prologue */
2866 debug_nothing_int_charstar
, /* begin_epilogue */
2867 debug_nothing_int_charstar
, /* end_epilogue */
2868 debug_nothing_tree
, /* begin_function */
2869 debug_nothing_int
, /* end_function */
2870 debug_nothing_tree
, /* register_main_translation_unit */
2871 debug_nothing_tree
, /* function_decl */
2872 debug_nothing_tree
, /* early_global_decl */
2873 debug_nothing_tree
, /* late_global_decl */
2874 debug_nothing_tree_int
, /* type_decl */
2875 debug_nothing_tree_tree_tree_bool_bool
,/* imported_module_or_decl */
2876 debug_false_tree_charstarstar_uhwistar
,/* die_ref_for_decl */
2877 debug_nothing_tree_charstar_uhwi
, /* register_external_die */
2878 debug_nothing_tree
, /* deferred_inline_function */
2879 debug_nothing_tree
, /* outlining_inline_function */
2880 debug_nothing_rtx_code_label
, /* label */
2881 debug_nothing_int
, /* handle_pch */
2882 debug_nothing_rtx_insn
, /* var_location */
2883 debug_nothing_tree
, /* inline_entry */
2884 debug_nothing_tree
, /* size_function */
2885 debug_nothing_void
, /* switch_text_section */
2886 debug_nothing_tree_tree
, /* set_name */
2887 0, /* start_end_main_source_file */
2888 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
2891 /* NOTE: In the comments in this file, many references are made to
2892 "Debugging Information Entries". This term is abbreviated as `DIE'
2893 throughout the remainder of this file. */
2895 /* An internal representation of the DWARF output is built, and then
2896 walked to generate the DWARF debugging info. The walk of the internal
2897 representation is done after the entire program has been compiled.
2898 The types below are used to describe the internal representation. */
2900 /* Whether to put type DIEs into their own section .debug_types instead
2901 of making them part of the .debug_info section. Only supported for
2902 Dwarf V4 or higher and the user didn't disable them through
2903 -fno-debug-types-section. It is more efficient to put them in a
2904 separate comdat sections since the linker will then be able to
2905 remove duplicates. But not all tools support .debug_types sections
2906 yet. For Dwarf V5 or higher .debug_types doesn't exist any more,
2907 it is DW_UT_type unit type in .debug_info section. */
2909 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2911 /* Various DIE's use offsets relative to the beginning of the
2912 .debug_info section to refer to each other. */
2914 typedef long int dw_offset
;
2916 struct comdat_type_node
;
2918 /* The entries in the line_info table more-or-less mirror the opcodes
2919 that are used in the real dwarf line table. Arrays of these entries
2920 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2923 enum dw_line_info_opcode
{
2924 /* Emit DW_LNE_set_address; the operand is the label index. */
2927 /* Emit a row to the matrix with the given line. This may be done
2928 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2932 /* Emit a DW_LNS_set_file. */
2935 /* Emit a DW_LNS_set_column. */
2938 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2941 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2942 LI_set_prologue_end
,
2943 LI_set_epilogue_begin
,
2945 /* Emit a DW_LNE_set_discriminator. */
2946 LI_set_discriminator
,
2948 /* Output a Fixed Advance PC; the target PC is the label index; the
2949 base PC is the previous LI_adv_address or LI_set_address entry.
2950 We only use this when emitting debug views without assembler
2951 support, at explicit user request. Ideally, we should only use
2952 it when the offset might be zero but we can't tell: it's the only
2953 way to maybe change the PC without resetting the view number. */
2957 typedef struct GTY(()) dw_line_info_struct
{
2958 enum dw_line_info_opcode opcode
;
2960 } dw_line_info_entry
;
2963 struct GTY(()) dw_line_info_table
{
2964 /* The label that marks the end of this section. */
2965 const char *end_label
;
2967 /* The values for the last row of the matrix, as collected in the table.
2968 These are used to minimize the changes to the next row. */
2969 unsigned int file_num
;
2970 unsigned int line_num
;
2971 unsigned int column_num
;
2976 /* This denotes the NEXT view number.
2978 If it is 0, it is known that the NEXT view will be the first view
2981 If it is -1, we're forcing the view number to be reset, e.g. at a
2984 The meaning of other nonzero values depends on whether we're
2985 computing views internally or leaving it for the assembler to do
2986 so. If we're emitting them internally, view denotes the view
2987 number since the last known advance of PC. If we're leaving it
2988 for the assembler, it denotes the LVU label number that we're
2989 going to ask the assembler to assign. */
2992 /* This counts the number of symbolic views emitted in this table
2993 since the latest view reset. Its max value, over all tables,
2994 sets symview_upper_bound. */
2995 var_loc_view symviews_since_reset
;
2997 #define FORCE_RESET_NEXT_VIEW(x) ((x) = (var_loc_view)-1)
2998 #define RESET_NEXT_VIEW(x) ((x) = (var_loc_view)0)
2999 #define FORCE_RESETTING_VIEW_P(x) ((x) == (var_loc_view)-1)
3000 #define RESETTING_VIEW_P(x) ((x) == (var_loc_view)0 || FORCE_RESETTING_VIEW_P (x))
3002 vec
<dw_line_info_entry
, va_gc
> *entries
;
3005 /* This is an upper bound for view numbers that the assembler may
3006 assign to symbolic views output in this translation. It is used to
3007 decide how big a field to use to represent view numbers in
3008 symview-classed attributes. */
3010 static var_loc_view symview_upper_bound
;
3012 /* If we're keep track of location views and their reset points, and
3013 INSN is a reset point (i.e., it necessarily advances the PC), mark
3014 the next view in TABLE as reset. */
3017 maybe_reset_location_view (rtx_insn
*insn
, dw_line_info_table
*table
)
3019 if (!debug_internal_reset_location_views
)
3022 /* Maybe turn (part of?) this test into a default target hook. */
3025 if (targetm
.reset_location_view
)
3026 reset
= targetm
.reset_location_view (insn
);
3030 else if (JUMP_TABLE_DATA_P (insn
))
3032 else if (GET_CODE (insn
) == USE
3033 || GET_CODE (insn
) == CLOBBER
3034 || GET_CODE (insn
) == ASM_INPUT
3035 || asm_noperands (insn
) >= 0)
3037 else if (get_attr_min_length (insn
) > 0)
3040 if (reset
> 0 && !RESETTING_VIEW_P (table
->view
))
3041 RESET_NEXT_VIEW (table
->view
);
3044 /* Each DIE attribute has a field specifying the attribute kind,
3045 a link to the next attribute in the chain, and an attribute value.
3046 Attributes are typically linked below the DIE they modify. */
3048 typedef struct GTY(()) dw_attr_struct
{
3049 enum dwarf_attribute dw_attr
;
3050 dw_val_node dw_attr_val
;
3055 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
3056 The children of each node form a circular list linked by
3057 die_sib. die_child points to the node *before* the "first" child node. */
3059 typedef struct GTY((chain_circular ("%h.die_sib"), for_user
)) die_struct
{
3060 union die_symbol_or_type_node
3062 const char * GTY ((tag ("0"))) die_symbol
;
3063 comdat_type_node
*GTY ((tag ("1"))) die_type_node
;
3065 GTY ((desc ("%0.comdat_type_p"))) die_id
;
3066 vec
<dw_attr_node
, va_gc
> *die_attr
;
3067 dw_die_ref die_parent
;
3068 dw_die_ref die_child
;
3070 dw_die_ref die_definition
; /* ref from a specification to its definition */
3071 dw_offset die_offset
;
3072 unsigned long die_abbrev
;
3074 unsigned int decl_id
;
3075 enum dwarf_tag die_tag
;
3076 /* Die is used and must not be pruned as unused. */
3077 BOOL_BITFIELD die_perennial_p
: 1;
3078 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
3079 /* For an external ref to die_symbol if die_offset contains an extra
3080 offset to that symbol. */
3081 BOOL_BITFIELD with_offset
: 1;
3082 /* Whether this DIE was removed from the DIE tree, for example via
3083 prune_unused_types. We don't consider those present from the
3084 DIE lookup routines. */
3085 BOOL_BITFIELD removed
: 1;
3086 /* Lots of spare bits. */
3090 /* Set to TRUE while dwarf2out_early_global_decl is running. */
3091 static bool early_dwarf
;
3092 static bool early_dwarf_finished
;
3093 struct set_early_dwarf
{
3095 set_early_dwarf () : saved(early_dwarf
)
3097 gcc_assert (! early_dwarf_finished
);
3100 ~set_early_dwarf () { early_dwarf
= saved
; }
3103 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
3104 #define FOR_EACH_CHILD(die, c, expr) do { \
3105 c = die->die_child; \
3109 } while (c != die->die_child); \
3112 /* The pubname structure */
3114 typedef struct GTY(()) pubname_struct
{
3121 struct GTY(()) dw_ranges
{
3123 /* If this is positive, it's a block number, otherwise it's a
3124 bitwise-negated index into dw_ranges_by_label. */
3126 /* Index for the range list for DW_FORM_rnglistx. */
3127 unsigned int idx
: 31;
3128 /* True if this range might be possibly in a different section
3129 from previous entry. */
3130 unsigned int maybe_new_sec
: 1;
3133 /* A structure to hold a macinfo entry. */
3135 typedef struct GTY(()) macinfo_struct
{
3137 unsigned HOST_WIDE_INT lineno
;
3143 struct GTY(()) dw_ranges_by_label
{
3148 /* The comdat type node structure. */
3149 struct GTY(()) comdat_type_node
3151 dw_die_ref root_die
;
3152 dw_die_ref type_die
;
3153 dw_die_ref skeleton_die
;
3154 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
3155 comdat_type_node
*next
;
3158 /* A list of DIEs for which we can't determine ancestry (parent_die
3159 field) just yet. Later in dwarf2out_finish we will fill in the
3161 typedef struct GTY(()) limbo_die_struct
{
3163 /* The tree for which this DIE was created. We use this to
3164 determine ancestry later. */
3166 struct limbo_die_struct
*next
;
3170 typedef struct skeleton_chain_struct
3174 struct skeleton_chain_struct
*parent
;
3176 skeleton_chain_node
;
3178 /* Define a macro which returns nonzero for a TYPE_DECL which was
3179 implicitly generated for a type.
3181 Note that, unlike the C front-end (which generates a NULL named
3182 TYPE_DECL node for each complete tagged type, each array type,
3183 and each function type node created) the C++ front-end generates
3184 a _named_ TYPE_DECL node for each tagged type node created.
3185 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3186 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
3187 front-end, but for each type, tagged or not. */
3189 #define TYPE_DECL_IS_STUB(decl) \
3190 (DECL_NAME (decl) == NULL_TREE \
3191 || (DECL_ARTIFICIAL (decl) \
3192 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3193 /* This is necessary for stub decls that \
3194 appear in nested inline functions. */ \
3195 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3196 && (decl_ultimate_origin (decl) \
3197 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3199 /* Information concerning the compilation unit's programming
3200 language, and compiler version. */
3202 /* Fixed size portion of the DWARF compilation unit header. */
3203 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3204 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE \
3205 + (dwarf_version >= 5 ? 4 : 3))
3207 /* Fixed size portion of the DWARF comdat type unit header. */
3208 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
3209 (DWARF_COMPILE_UNIT_HEADER_SIZE \
3210 + DWARF_TYPE_SIGNATURE_SIZE + DWARF_OFFSET_SIZE)
3212 /* Fixed size portion of the DWARF skeleton compilation unit header. */
3213 #define DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE \
3214 (DWARF_COMPILE_UNIT_HEADER_SIZE + (dwarf_version >= 5 ? 8 : 0))
3216 /* Fixed size portion of public names info. */
3217 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3219 /* Fixed size portion of the address range info. */
3220 #define DWARF_ARANGES_HEADER_SIZE \
3221 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3222 DWARF2_ADDR_SIZE * 2) \
3223 - DWARF_INITIAL_LENGTH_SIZE)
3225 /* Size of padding portion in the address range info. It must be
3226 aligned to twice the pointer size. */
3227 #define DWARF_ARANGES_PAD_SIZE \
3228 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3229 DWARF2_ADDR_SIZE * 2) \
3230 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3232 /* Use assembler line directives if available. */
3233 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3234 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3235 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3237 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3241 /* Use assembler views in line directives if available. */
3242 #ifndef DWARF2_ASM_VIEW_DEBUG_INFO
3243 #ifdef HAVE_AS_DWARF2_DEBUG_VIEW
3244 #define DWARF2_ASM_VIEW_DEBUG_INFO 1
3246 #define DWARF2_ASM_VIEW_DEBUG_INFO 0
3250 /* Return true if GCC configure detected assembler support for .loc. */
3253 dwarf2out_default_as_loc_support (void)
3255 return DWARF2_ASM_LINE_DEBUG_INFO
;
3256 #if (GCC_VERSION >= 3000)
3257 # undef DWARF2_ASM_LINE_DEBUG_INFO
3258 # pragma GCC poison DWARF2_ASM_LINE_DEBUG_INFO
3262 /* Return true if GCC configure detected assembler support for views
3263 in .loc directives. */
3266 dwarf2out_default_as_locview_support (void)
3268 return DWARF2_ASM_VIEW_DEBUG_INFO
;
3269 #if (GCC_VERSION >= 3000)
3270 # undef DWARF2_ASM_VIEW_DEBUG_INFO
3271 # pragma GCC poison DWARF2_ASM_VIEW_DEBUG_INFO
3275 /* A bit is set in ZERO_VIEW_P if we are using the assembler-supported
3276 view computation, and it refers to a view identifier for which we
3277 will not emit a label because it is known to map to a view number
3278 zero. We won't allocate the bitmap if we're not using assembler
3279 support for location views, but we have to make the variable
3280 visible for GGC and for code that will be optimized out for lack of
3281 support but that's still parsed and compiled. We could abstract it
3282 out with macros, but it's not worth it. */
3283 static GTY(()) bitmap zero_view_p
;
3285 /* Evaluate to TRUE iff N is known to identify the first location view
3286 at its PC. When not using assembler location view computation,
3287 that must be view number zero. Otherwise, ZERO_VIEW_P is allocated
3288 and views label numbers recorded in it are the ones known to be
3290 #define ZERO_VIEW_P(N) ((N) == (var_loc_view)0 \
3291 || (N) == (var_loc_view)-1 \
3293 && bitmap_bit_p (zero_view_p, (N))))
3295 /* Return true iff we're to emit .loc directives for the assembler to
3296 generate line number sections.
3298 When we're not emitting views, all we need from the assembler is
3299 support for .loc directives.
3301 If we are emitting views, we can only use the assembler's .loc
3302 support if it also supports views.
3304 When the compiler is emitting the line number programs and
3305 computing view numbers itself, it resets view numbers at known PC
3306 changes and counts from that, and then it emits view numbers as
3307 literal constants in locviewlists. There are cases in which the
3308 compiler is not sure about PC changes, e.g. when extra alignment is
3309 requested for a label. In these cases, the compiler may not reset
3310 the view counter, and the potential PC advance in the line number
3311 program will use an opcode that does not reset the view counter
3312 even if the PC actually changes, so that compiler and debug info
3313 consumer can keep view numbers in sync.
3315 When the compiler defers view computation to the assembler, it
3316 emits symbolic view numbers in locviewlists, with the exception of
3317 views known to be zero (forced resets, or reset after
3318 compiler-visible PC changes): instead of emitting symbols for
3319 these, we emit literal zero and assert the assembler agrees with
3320 the compiler's assessment. We could use symbolic views everywhere,
3321 instead of special-casing zero views, but then we'd be unable to
3322 optimize out locviewlists that contain only zeros. */
3325 output_asm_line_debug_info (void)
3327 return (dwarf2out_as_loc_support
3328 && (dwarf2out_as_locview_support
3329 || !debug_variable_location_views
));
3332 /* Minimum line offset in a special line info. opcode.
3333 This value was chosen to give a reasonable range of values. */
3334 #define DWARF_LINE_BASE -10
3336 /* First special line opcode - leave room for the standard opcodes. */
3337 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
3339 /* Range of line offsets in a special line info. opcode. */
3340 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3342 /* Flag that indicates the initial value of the is_stmt_start flag.
3343 In the present implementation, we do not mark any lines as
3344 the beginning of a source statement, because that information
3345 is not made available by the GCC front-end. */
3346 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3348 /* Maximum number of operations per instruction bundle. */
3349 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
3350 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
3353 /* This location is used by calc_die_sizes() to keep track
3354 the offset of each DIE within the .debug_info section. */
3355 static unsigned long next_die_offset
;
3357 /* Record the root of the DIE's built for the current compilation unit. */
3358 static GTY(()) dw_die_ref single_comp_unit_die
;
3360 /* A list of type DIEs that have been separated into comdat sections. */
3361 static GTY(()) comdat_type_node
*comdat_type_list
;
3363 /* A list of CU DIEs that have been separated. */
3364 static GTY(()) limbo_die_node
*cu_die_list
;
3366 /* A list of DIEs with a NULL parent waiting to be relocated. */
3367 static GTY(()) limbo_die_node
*limbo_die_list
;
3369 /* A list of DIEs for which we may have to generate
3370 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
3371 static GTY(()) limbo_die_node
*deferred_asm_name
;
3373 struct dwarf_file_hasher
: ggc_ptr_hash
<dwarf_file_data
>
3375 typedef const char *compare_type
;
3377 static hashval_t
hash (dwarf_file_data
*);
3378 static bool equal (dwarf_file_data
*, const char *);
3381 /* Filenames referenced by this compilation unit. */
3382 static GTY(()) hash_table
<dwarf_file_hasher
> *file_table
;
3384 struct decl_die_hasher
: ggc_ptr_hash
<die_node
>
3386 typedef tree compare_type
;
3388 static hashval_t
hash (die_node
*);
3389 static bool equal (die_node
*, tree
);
3391 /* A hash table of references to DIE's that describe declarations.
3392 The key is a DECL_UID() which is a unique number identifying each decl. */
3393 static GTY (()) hash_table
<decl_die_hasher
> *decl_die_table
;
3395 struct GTY ((for_user
)) variable_value_struct
{
3396 unsigned int decl_id
;
3397 vec
<dw_die_ref
, va_gc
> *dies
;
3400 struct variable_value_hasher
: ggc_ptr_hash
<variable_value_struct
>
3402 typedef tree compare_type
;
3404 static hashval_t
hash (variable_value_struct
*);
3405 static bool equal (variable_value_struct
*, tree
);
3407 /* A hash table of DIEs that contain DW_OP_GNU_variable_value with
3408 dw_val_class_decl_ref class, indexed by FUNCTION_DECLs which is
3409 DECL_CONTEXT of the referenced VAR_DECLs. */
3410 static GTY (()) hash_table
<variable_value_hasher
> *variable_value_hash
;
3412 struct block_die_hasher
: ggc_ptr_hash
<die_struct
>
3414 static hashval_t
hash (die_struct
*);
3415 static bool equal (die_struct
*, die_struct
*);
3418 /* A hash table of references to DIE's that describe COMMON blocks.
3419 The key is DECL_UID() ^ die_parent. */
3420 static GTY (()) hash_table
<block_die_hasher
> *common_block_die_table
;
3422 typedef struct GTY(()) die_arg_entry_struct
{
3428 /* Node of the variable location list. */
3429 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
3430 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
3431 EXPR_LIST chain. For small bitsizes, bitsize is encoded
3432 in mode of the EXPR_LIST node and first EXPR_LIST operand
3433 is either NOTE_INSN_VAR_LOCATION for a piece with a known
3434 location or NULL for padding. For larger bitsizes,
3435 mode is 0 and first operand is a CONCAT with bitsize
3436 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
3437 NULL as second operand. */
3439 const char * GTY (()) label
;
3440 struct var_loc_node
* GTY (()) next
;
3444 /* Variable location list. */
3445 struct GTY ((for_user
)) var_loc_list_def
{
3446 struct var_loc_node
* GTY (()) first
;
3448 /* Pointer to the last but one or last element of the
3449 chained list. If the list is empty, both first and
3450 last are NULL, if the list contains just one node
3451 or the last node certainly is not redundant, it points
3452 to the last node, otherwise points to the last but one.
3453 Do not mark it for GC because it is marked through the chain. */
3454 struct var_loc_node
* GTY ((skip ("%h"))) last
;
3456 /* Pointer to the last element before section switch,
3457 if NULL, either sections weren't switched or first
3458 is after section switch. */
3459 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
3461 /* DECL_UID of the variable decl. */
3462 unsigned int decl_id
;
3464 typedef struct var_loc_list_def var_loc_list
;
3466 /* Call argument location list. */
3467 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
3468 rtx
GTY (()) call_arg_loc_note
;
3469 const char * GTY (()) label
;
3470 tree
GTY (()) block
;
3472 rtx
GTY (()) symbol_ref
;
3473 struct call_arg_loc_node
* GTY (()) next
;
3477 struct decl_loc_hasher
: ggc_ptr_hash
<var_loc_list
>
3479 typedef const_tree compare_type
;
3481 static hashval_t
hash (var_loc_list
*);
3482 static bool equal (var_loc_list
*, const_tree
);
3485 /* Table of decl location linked lists. */
3486 static GTY (()) hash_table
<decl_loc_hasher
> *decl_loc_table
;
3488 /* Head and tail of call_arg_loc chain. */
3489 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
3490 static struct call_arg_loc_node
*call_arg_loc_last
;
3492 /* Number of call sites in the current function. */
3493 static int call_site_count
= -1;
3494 /* Number of tail call sites in the current function. */
3495 static int tail_call_site_count
= -1;
3497 /* A cached location list. */
3498 struct GTY ((for_user
)) cached_dw_loc_list_def
{
3499 /* The DECL_UID of the decl that this entry describes. */
3500 unsigned int decl_id
;
3502 /* The cached location list. */
3503 dw_loc_list_ref loc_list
;
3505 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
3507 struct dw_loc_list_hasher
: ggc_ptr_hash
<cached_dw_loc_list
>
3510 typedef const_tree compare_type
;
3512 static hashval_t
hash (cached_dw_loc_list
*);
3513 static bool equal (cached_dw_loc_list
*, const_tree
);
3516 /* Table of cached location lists. */
3517 static GTY (()) hash_table
<dw_loc_list_hasher
> *cached_dw_loc_list_table
;
3519 /* A vector of references to DIE's that are uniquely identified by their tag,
3520 presence/absence of children DIE's, and list of attribute/value pairs. */
3521 static GTY(()) vec
<dw_die_ref
, va_gc
> *abbrev_die_table
;
3523 /* A hash map to remember the stack usage for DWARF procedures. The value
3524 stored is the stack size difference between before the DWARF procedure
3525 invokation and after it returned. In other words, for a DWARF procedure
3526 that consumes N stack slots and that pushes M ones, this stores M - N. */
3527 static hash_map
<dw_die_ref
, int> *dwarf_proc_stack_usage_map
;
3529 /* A global counter for generating labels for line number data. */
3530 static unsigned int line_info_label_num
;
3532 /* The current table to which we should emit line number information
3533 for the current function. This will be set up at the beginning of
3534 assembly for the function. */
3535 static GTY(()) dw_line_info_table
*cur_line_info_table
;
3537 /* The two default tables of line number info. */
3538 static GTY(()) dw_line_info_table
*text_section_line_info
;
3539 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
3541 /* The set of all non-default tables of line number info. */
3542 static GTY(()) vec
<dw_line_info_table
*, va_gc
> *separate_line_info
;
3544 /* A flag to tell pubnames/types export if there is an info section to
3546 static bool info_section_emitted
;
3548 /* A pointer to the base of a table that contains a list of publicly
3549 accessible names. */
3550 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
3552 /* A pointer to the base of a table that contains a list of publicly
3553 accessible types. */
3554 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
3556 /* A pointer to the base of a table that contains a list of macro
3557 defines/undefines (and file start/end markers). */
3558 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
3560 /* True if .debug_macinfo or .debug_macros section is going to be
3562 #define have_macinfo \
3563 ((!XCOFF_DEBUGGING_INFO || HAVE_XCOFF_DWARF_EXTRAS) \
3564 && debug_info_level >= DINFO_LEVEL_VERBOSE \
3565 && !macinfo_table->is_empty ())
3567 /* Vector of dies for which we should generate .debug_ranges info. */
3568 static GTY (()) vec
<dw_ranges
, va_gc
> *ranges_table
;
3570 /* Vector of pairs of labels referenced in ranges_table. */
3571 static GTY (()) vec
<dw_ranges_by_label
, va_gc
> *ranges_by_label
;
3573 /* Whether we have location lists that need outputting */
3574 static GTY(()) bool have_location_lists
;
3576 /* Unique label counter. */
3577 static GTY(()) unsigned int loclabel_num
;
3579 /* Unique label counter for point-of-call tables. */
3580 static GTY(()) unsigned int poc_label_num
;
3582 /* The last file entry emitted by maybe_emit_file(). */
3583 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
3585 /* Number of internal labels generated by gen_internal_sym(). */
3586 static GTY(()) int label_num
;
3588 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
3590 /* Instances of generic types for which we need to generate debug
3591 info that describe their generic parameters and arguments. That
3592 generation needs to happen once all types are properly laid out so
3593 we do it at the end of compilation. */
3594 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
3596 /* Offset from the "steady-state frame pointer" to the frame base,
3597 within the current function. */
3598 static poly_int64 frame_pointer_fb_offset
;
3599 static bool frame_pointer_fb_offset_valid
;
3601 static vec
<dw_die_ref
> base_types
;
3603 /* Flags to represent a set of attribute classes for attributes that represent
3604 a scalar value (bounds, pointers, ...). */
3607 dw_scalar_form_constant
= 0x01,
3608 dw_scalar_form_exprloc
= 0x02,
3609 dw_scalar_form_reference
= 0x04
3612 /* Forward declarations for functions defined in this file. */
3614 static int is_pseudo_reg (const_rtx
);
3615 static tree
type_main_variant (tree
);
3616 static int is_tagged_type (const_tree
);
3617 static const char *dwarf_tag_name (unsigned);
3618 static const char *dwarf_attr_name (unsigned);
3619 static const char *dwarf_form_name (unsigned);
3620 static tree
decl_ultimate_origin (const_tree
);
3621 static tree
decl_class_context (tree
);
3622 static void add_dwarf_attr (dw_die_ref
, dw_attr_node
*);
3623 static inline enum dw_val_class
AT_class (dw_attr_node
*);
3624 static inline unsigned int AT_index (dw_attr_node
*);
3625 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3626 static inline unsigned AT_flag (dw_attr_node
*);
3627 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3628 static inline HOST_WIDE_INT
AT_int (dw_attr_node
*);
3629 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3630 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_node
*);
3631 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
3632 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
3633 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3634 unsigned int, unsigned char *);
3635 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
3636 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3637 static inline const char *AT_string (dw_attr_node
*);
3638 static enum dwarf_form
AT_string_form (dw_attr_node
*);
3639 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3640 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3641 static inline dw_die_ref
AT_ref (dw_attr_node
*);
3642 static inline int AT_ref_external (dw_attr_node
*);
3643 static inline void set_AT_ref_external (dw_attr_node
*, int);
3644 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
3645 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3646 static inline dw_loc_descr_ref
AT_loc (dw_attr_node
*);
3647 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3649 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3650 static void add_AT_view_list (dw_die_ref
, enum dwarf_attribute
);
3651 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3652 static addr_table_entry
*add_addr_table_entry (void *, enum ate_kind
);
3653 static void remove_addr_table_entry (addr_table_entry
*);
3654 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
, bool);
3655 static inline rtx
AT_addr (dw_attr_node
*);
3656 static void add_AT_symview (dw_die_ref
, enum dwarf_attribute
, const char *);
3657 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3658 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3659 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3660 static void add_AT_loclistsptr (dw_die_ref
, enum dwarf_attribute
,
3662 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
3663 unsigned HOST_WIDE_INT
);
3664 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3665 unsigned long, bool);
3666 static inline const char *AT_lbl (dw_attr_node
*);
3667 static dw_attr_node
*get_AT (dw_die_ref
, enum dwarf_attribute
);
3668 static const char *get_AT_low_pc (dw_die_ref
);
3669 static const char *get_AT_hi_pc (dw_die_ref
);
3670 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
3671 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
3672 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
3673 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
3674 static bool is_cxx (void);
3675 static bool is_cxx (const_tree
);
3676 static bool is_fortran (void);
3677 static bool is_ada (void);
3678 static bool remove_AT (dw_die_ref
, enum dwarf_attribute
);
3679 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3680 static void add_child_die (dw_die_ref
, dw_die_ref
);
3681 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3682 static dw_die_ref
lookup_type_die (tree
);
3683 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3684 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3685 static void equate_type_number_to_die (tree
, dw_die_ref
);
3686 static dw_die_ref
lookup_decl_die (tree
);
3687 static var_loc_list
*lookup_decl_loc (const_tree
);
3688 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3689 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *, var_loc_view
);
3690 static void print_spaces (FILE *);
3691 static void print_die (dw_die_ref
, FILE *);
3692 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3693 static void attr_checksum (dw_attr_node
*, struct md5_ctx
*, int *);
3694 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3695 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3696 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3697 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3698 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_node
*,
3699 struct md5_ctx
*, int *);
3700 struct checksum_attributes
;
3701 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3702 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3703 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3704 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3705 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3706 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3707 static int same_attr_p (dw_attr_node
*, dw_attr_node
*, int *);
3708 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3709 static int is_type_die (dw_die_ref
);
3710 static int is_comdat_die (dw_die_ref
);
3711 static inline bool is_template_instantiation (dw_die_ref
);
3712 static int is_declaration_die (dw_die_ref
);
3713 static int should_move_die_to_comdat (dw_die_ref
);
3714 static dw_die_ref
clone_as_declaration (dw_die_ref
);
3715 static dw_die_ref
clone_die (dw_die_ref
);
3716 static dw_die_ref
clone_tree (dw_die_ref
);
3717 static dw_die_ref
copy_declaration_context (dw_die_ref
, dw_die_ref
);
3718 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
3719 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
3720 static dw_die_ref
generate_skeleton (dw_die_ref
);
3721 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
3724 static void break_out_comdat_types (dw_die_ref
);
3725 static void copy_decls_for_unworthy_types (dw_die_ref
);
3727 static void add_sibling_attributes (dw_die_ref
);
3728 static void output_location_lists (dw_die_ref
);
3729 static int constant_size (unsigned HOST_WIDE_INT
);
3730 static unsigned long size_of_die (dw_die_ref
);
3731 static void calc_die_sizes (dw_die_ref
);
3732 static void calc_base_type_die_sizes (void);
3733 static void mark_dies (dw_die_ref
);
3734 static void unmark_dies (dw_die_ref
);
3735 static void unmark_all_dies (dw_die_ref
);
3736 static unsigned long size_of_pubnames (vec
<pubname_entry
, va_gc
> *);
3737 static unsigned long size_of_aranges (void);
3738 static enum dwarf_form
value_format (dw_attr_node
*);
3739 static void output_value_format (dw_attr_node
*);
3740 static void output_abbrev_section (void);
3741 static void output_die_abbrevs (unsigned long, dw_die_ref
);
3742 static void output_die (dw_die_ref
);
3743 static void output_compilation_unit_header (enum dwarf_unit_type
);
3744 static void output_comp_unit (dw_die_ref
, int, const unsigned char *);
3745 static void output_comdat_type_unit (comdat_type_node
*);
3746 static const char *dwarf2_name (tree
, int);
3747 static void add_pubname (tree
, dw_die_ref
);
3748 static void add_enumerator_pubname (const char *, dw_die_ref
);
3749 static void add_pubname_string (const char *, dw_die_ref
);
3750 static void add_pubtype (tree
, dw_die_ref
);
3751 static void output_pubnames (vec
<pubname_entry
, va_gc
> *);
3752 static void output_aranges (void);
3753 static unsigned int add_ranges (const_tree
, bool = false);
3754 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
3756 static void output_ranges (void);
3757 static dw_line_info_table
*new_line_info_table (void);
3758 static void output_line_info (bool);
3759 static void output_file_names (void);
3760 static dw_die_ref
base_type_die (tree
, bool);
3761 static int is_base_type (tree
);
3762 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, tree
, dw_die_ref
);
3763 static int decl_quals (const_tree
);
3764 static dw_die_ref
modified_type_die (tree
, int, bool, dw_die_ref
);
3765 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
3766 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
3767 static int type_is_enum (const_tree
);
3768 static unsigned int dbx_reg_number (const_rtx
);
3769 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3770 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3771 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3772 enum var_init_status
);
3773 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3774 enum var_init_status
);
3775 static dw_loc_descr_ref
based_loc_descr (rtx
, poly_int64
,
3776 enum var_init_status
);
3777 static int is_based_loc (const_rtx
);
3778 static bool resolve_one_addr (rtx
*);
3779 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3780 enum var_init_status
);
3781 static dw_loc_descr_ref
loc_descriptor (rtx
, machine_mode mode
,
3782 enum var_init_status
);
3783 struct loc_descr_context
;
3784 static void add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
);
3785 static void add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
);
3786 static dw_loc_list_ref
loc_list_from_tree (tree
, int,
3787 struct loc_descr_context
*);
3788 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int,
3789 struct loc_descr_context
*);
3790 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
3791 static tree
field_type (const_tree
);
3792 static unsigned int simple_type_align_in_bits (const_tree
);
3793 static unsigned int simple_decl_align_in_bits (const_tree
);
3794 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3796 static dw_loc_descr_ref
field_byte_offset (const_tree
, struct vlr_context
*,
3798 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3800 static void add_data_member_location_attribute (dw_die_ref
, tree
,
3801 struct vlr_context
*);
3802 static bool add_const_value_attribute (dw_die_ref
, rtx
);
3803 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3804 static void insert_wide_int (const wide_int
&, unsigned char *, int);
3805 static void insert_float (const_rtx
, unsigned char *);
3806 static rtx
rtl_for_decl_location (tree
);
3807 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool);
3808 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3809 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3810 static void add_name_attribute (dw_die_ref
, const char *);
3811 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3812 static void add_comp_dir_attribute (dw_die_ref
);
3813 static void add_scalar_info (dw_die_ref
, enum dwarf_attribute
, tree
, int,
3814 struct loc_descr_context
*);
3815 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
,
3816 struct loc_descr_context
*);
3817 static void add_subscript_info (dw_die_ref
, tree
, bool);
3818 static void add_byte_size_attribute (dw_die_ref
, tree
);
3819 static void add_alignment_attribute (dw_die_ref
, tree
);
3820 static inline void add_bit_offset_attribute (dw_die_ref
, tree
,
3821 struct vlr_context
*);
3822 static void add_bit_size_attribute (dw_die_ref
, tree
);
3823 static void add_prototyped_attribute (dw_die_ref
, tree
);
3824 static dw_die_ref
add_abstract_origin_attribute (dw_die_ref
, tree
);
3825 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3826 static void add_src_coords_attributes (dw_die_ref
, tree
);
3827 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
, bool = false);
3828 static void add_discr_value (dw_die_ref
, dw_discr_value
*);
3829 static void add_discr_list (dw_die_ref
, dw_discr_list_ref
);
3830 static inline dw_discr_list_ref
AT_discr_list (dw_attr_node
*);
3831 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3832 static inline int local_scope_p (dw_die_ref
);
3833 static inline int class_scope_p (dw_die_ref
);
3834 static inline int class_or_namespace_scope_p (dw_die_ref
);
3835 static void add_type_attribute (dw_die_ref
, tree
, int, bool, dw_die_ref
);
3836 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3837 static const char *type_tag (const_tree
);
3838 static tree
member_declared_type (const_tree
);
3840 static const char *decl_start_label (tree
);
3842 static void gen_array_type_die (tree
, dw_die_ref
);
3843 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3845 static void gen_entry_point_die (tree
, dw_die_ref
);
3847 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3848 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3849 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3850 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3851 static void gen_formal_types_die (tree
, dw_die_ref
);
3852 static void gen_subprogram_die (tree
, dw_die_ref
);
3853 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3854 static void gen_const_die (tree
, dw_die_ref
);
3855 static void gen_label_die (tree
, dw_die_ref
);
3856 static void gen_lexical_block_die (tree
, dw_die_ref
);
3857 static void gen_inlined_subroutine_die (tree
, dw_die_ref
);
3858 static void gen_field_die (tree
, struct vlr_context
*, dw_die_ref
);
3859 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3860 static dw_die_ref
gen_compile_unit_die (const char *);
3861 static void gen_inheritance_die (tree
, tree
, tree
, dw_die_ref
);
3862 static void gen_member_die (tree
, dw_die_ref
);
3863 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3864 enum debug_info_usage
);
3865 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3866 static void gen_typedef_die (tree
, dw_die_ref
);
3867 static void gen_type_die (tree
, dw_die_ref
);
3868 static void gen_block_die (tree
, dw_die_ref
);
3869 static void decls_for_scope (tree
, dw_die_ref
);
3870 static bool is_naming_typedef_decl (const_tree
);
3871 static inline dw_die_ref
get_context_die (tree
);
3872 static void gen_namespace_die (tree
, dw_die_ref
);
3873 static dw_die_ref
gen_namelist_decl (tree
, dw_die_ref
, tree
);
3874 static dw_die_ref
gen_decl_die (tree
, tree
, struct vlr_context
*, dw_die_ref
);
3875 static dw_die_ref
force_decl_die (tree
);
3876 static dw_die_ref
force_type_die (tree
);
3877 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3878 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3879 static struct dwarf_file_data
* lookup_filename (const char *);
3880 static void retry_incomplete_types (void);
3881 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3882 static void gen_generic_params_dies (tree
);
3883 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3884 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3885 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3886 static int file_info_cmp (const void *, const void *);
3887 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *, var_loc_view
,
3888 const char *, var_loc_view
, const char *);
3889 static void output_loc_list (dw_loc_list_ref
);
3890 static char *gen_internal_sym (const char *);
3891 static bool want_pubnames (void);
3893 static void prune_unmark_dies (dw_die_ref
);
3894 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3895 static void prune_unused_types_mark (dw_die_ref
, int);
3896 static void prune_unused_types_walk (dw_die_ref
);
3897 static void prune_unused_types_walk_attribs (dw_die_ref
);
3898 static void prune_unused_types_prune (dw_die_ref
);
3899 static void prune_unused_types (void);
3900 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3901 static inline const char *AT_vms_delta1 (dw_attr_node
*);
3902 static inline const char *AT_vms_delta2 (dw_attr_node
*);
3903 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
3904 const char *, const char *);
3905 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
3906 static void gen_remaining_tmpl_value_param_die_attribute (void);
3907 static bool generic_type_p (tree
);
3908 static void schedule_generic_params_dies_gen (tree t
);
3909 static void gen_scheduled_generic_parms_dies (void);
3910 static void resolve_variable_values (void);
3912 static const char *comp_dir_string (void);
3914 static void hash_loc_operands (dw_loc_descr_ref
, inchash::hash
&);
3916 /* enum for tracking thread-local variables whose address is really an offset
3917 relative to the TLS pointer, which will need link-time relocation, but will
3918 not need relocation by the DWARF consumer. */
3926 /* Return the operator to use for an address of a variable. For dtprel_true, we
3927 use DW_OP_const*. For regular variables, which need both link-time
3928 relocation and consumer-level relocation (e.g., to account for shared objects
3929 loaded at a random address), we use DW_OP_addr*. */
3931 static inline enum dwarf_location_atom
3932 dw_addr_op (enum dtprel_bool dtprel
)
3934 if (dtprel
== dtprel_true
)
3935 return (dwarf_split_debug_info
? dwarf_OP (DW_OP_constx
)
3936 : (DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
));
3938 return dwarf_split_debug_info
? dwarf_OP (DW_OP_addrx
) : DW_OP_addr
;
3941 /* Return a pointer to a newly allocated address location description. If
3942 dwarf_split_debug_info is true, then record the address with the appropriate
3944 static inline dw_loc_descr_ref
3945 new_addr_loc_descr (rtx addr
, enum dtprel_bool dtprel
)
3947 dw_loc_descr_ref ref
= new_loc_descr (dw_addr_op (dtprel
), 0, 0);
3949 ref
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
3950 ref
->dw_loc_oprnd1
.v
.val_addr
= addr
;
3951 ref
->dtprel
= dtprel
;
3952 if (dwarf_split_debug_info
)
3953 ref
->dw_loc_oprnd1
.val_entry
3954 = add_addr_table_entry (addr
,
3955 dtprel
? ate_kind_rtx_dtprel
: ate_kind_rtx
);
3957 ref
->dw_loc_oprnd1
.val_entry
= NULL
;
3962 /* Section names used to hold DWARF debugging information. */
3964 #ifndef DEBUG_INFO_SECTION
3965 #define DEBUG_INFO_SECTION ".debug_info"
3967 #ifndef DEBUG_DWO_INFO_SECTION
3968 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3970 #ifndef DEBUG_LTO_INFO_SECTION
3971 #define DEBUG_LTO_INFO_SECTION ".gnu.debuglto_.debug_info"
3973 #ifndef DEBUG_LTO_DWO_INFO_SECTION
3974 #define DEBUG_LTO_DWO_INFO_SECTION ".gnu.debuglto_.debug_info.dwo"
3976 #ifndef DEBUG_ABBREV_SECTION
3977 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3979 #ifndef DEBUG_LTO_ABBREV_SECTION
3980 #define DEBUG_LTO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev"
3982 #ifndef DEBUG_DWO_ABBREV_SECTION
3983 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3985 #ifndef DEBUG_LTO_DWO_ABBREV_SECTION
3986 #define DEBUG_LTO_DWO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev.dwo"
3988 #ifndef DEBUG_ARANGES_SECTION
3989 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3991 #ifndef DEBUG_ADDR_SECTION
3992 #define DEBUG_ADDR_SECTION ".debug_addr"
3994 #ifndef DEBUG_MACINFO_SECTION
3995 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
3997 #ifndef DEBUG_LTO_MACINFO_SECTION
3998 #define DEBUG_LTO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo"
4000 #ifndef DEBUG_DWO_MACINFO_SECTION
4001 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
4003 #ifndef DEBUG_LTO_DWO_MACINFO_SECTION
4004 #define DEBUG_LTO_DWO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo.dwo"
4006 #ifndef DEBUG_MACRO_SECTION
4007 #define DEBUG_MACRO_SECTION ".debug_macro"
4009 #ifndef DEBUG_LTO_MACRO_SECTION
4010 #define DEBUG_LTO_MACRO_SECTION ".gnu.debuglto_.debug_macro"
4012 #ifndef DEBUG_DWO_MACRO_SECTION
4013 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
4015 #ifndef DEBUG_LTO_DWO_MACRO_SECTION
4016 #define DEBUG_LTO_DWO_MACRO_SECTION ".gnu.debuglto_.debug_macro.dwo"
4018 #ifndef DEBUG_LINE_SECTION
4019 #define DEBUG_LINE_SECTION ".debug_line"
4021 #ifndef DEBUG_LTO_LINE_SECTION
4022 #define DEBUG_LTO_LINE_SECTION ".gnu.debuglto_.debug_line"
4024 #ifndef DEBUG_DWO_LINE_SECTION
4025 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
4027 #ifndef DEBUG_LTO_DWO_LINE_SECTION
4028 #define DEBUG_LTO_DWO_LINE_SECTION ".gnu.debuglto_.debug_line.dwo"
4030 #ifndef DEBUG_LOC_SECTION
4031 #define DEBUG_LOC_SECTION ".debug_loc"
4033 #ifndef DEBUG_DWO_LOC_SECTION
4034 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
4036 #ifndef DEBUG_LOCLISTS_SECTION
4037 #define DEBUG_LOCLISTS_SECTION ".debug_loclists"
4039 #ifndef DEBUG_DWO_LOCLISTS_SECTION
4040 #define DEBUG_DWO_LOCLISTS_SECTION ".debug_loclists.dwo"
4042 #ifndef DEBUG_PUBNAMES_SECTION
4043 #define DEBUG_PUBNAMES_SECTION \
4044 ((debug_generate_pub_sections == 2) \
4045 ? ".debug_gnu_pubnames" : ".debug_pubnames")
4047 #ifndef DEBUG_PUBTYPES_SECTION
4048 #define DEBUG_PUBTYPES_SECTION \
4049 ((debug_generate_pub_sections == 2) \
4050 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
4052 #ifndef DEBUG_STR_OFFSETS_SECTION
4053 #define DEBUG_STR_OFFSETS_SECTION ".debug_str_offsets"
4055 #ifndef DEBUG_DWO_STR_OFFSETS_SECTION
4056 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
4058 #ifndef DEBUG_LTO_DWO_STR_OFFSETS_SECTION
4059 #define DEBUG_LTO_DWO_STR_OFFSETS_SECTION ".gnu.debuglto_.debug_str_offsets.dwo"
4061 #ifndef DEBUG_STR_SECTION
4062 #define DEBUG_STR_SECTION ".debug_str"
4064 #ifndef DEBUG_LTO_STR_SECTION
4065 #define DEBUG_LTO_STR_SECTION ".gnu.debuglto_.debug_str"
4067 #ifndef DEBUG_STR_DWO_SECTION
4068 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
4070 #ifndef DEBUG_LTO_STR_DWO_SECTION
4071 #define DEBUG_LTO_STR_DWO_SECTION ".gnu.debuglto_.debug_str.dwo"
4073 #ifndef DEBUG_RANGES_SECTION
4074 #define DEBUG_RANGES_SECTION ".debug_ranges"
4076 #ifndef DEBUG_RNGLISTS_SECTION
4077 #define DEBUG_RNGLISTS_SECTION ".debug_rnglists"
4079 #ifndef DEBUG_LINE_STR_SECTION
4080 #define DEBUG_LINE_STR_SECTION ".debug_line_str"
4082 #ifndef DEBUG_LTO_LINE_STR_SECTION
4083 #define DEBUG_LTO_LINE_STR_SECTION ".gnu.debuglto_.debug_line_str"
4086 /* Standard ELF section names for compiled code and data. */
4087 #ifndef TEXT_SECTION_NAME
4088 #define TEXT_SECTION_NAME ".text"
4091 /* Section flags for .debug_str section. */
4092 #define DEBUG_STR_SECTION_FLAGS \
4093 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
4094 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4097 /* Section flags for .debug_str.dwo section. */
4098 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
4100 /* Attribute used to refer to the macro section. */
4101 #define DEBUG_MACRO_ATTRIBUTE (dwarf_version >= 5 ? DW_AT_macros \
4102 : dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros)
4104 /* Labels we insert at beginning sections we can reference instead of
4105 the section names themselves. */
4107 #ifndef TEXT_SECTION_LABEL
4108 #define TEXT_SECTION_LABEL "Ltext"
4110 #ifndef COLD_TEXT_SECTION_LABEL
4111 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
4113 #ifndef DEBUG_LINE_SECTION_LABEL
4114 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4116 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
4117 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
4119 #ifndef DEBUG_INFO_SECTION_LABEL
4120 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4122 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
4123 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
4125 #ifndef DEBUG_ABBREV_SECTION_LABEL
4126 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4128 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
4129 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
4131 #ifndef DEBUG_ADDR_SECTION_LABEL
4132 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
4134 #ifndef DEBUG_LOC_SECTION_LABEL
4135 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4137 #ifndef DEBUG_RANGES_SECTION_LABEL
4138 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4140 #ifndef DEBUG_MACINFO_SECTION_LABEL
4141 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4143 #ifndef DEBUG_MACRO_SECTION_LABEL
4144 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
4146 #define SKELETON_COMP_DIE_ABBREV 1
4147 #define SKELETON_TYPE_DIE_ABBREV 2
4149 /* Definitions of defaults for formats and names of various special
4150 (artificial) labels which may be generated within this file (when the -g
4151 options is used and DWARF2_DEBUGGING_INFO is in effect.
4152 If necessary, these may be overridden from within the tm.h file, but
4153 typically, overriding these defaults is unnecessary. */
4155 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4156 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4157 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4158 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4159 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4160 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4161 static char debug_skeleton_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4162 static char debug_skeleton_abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4163 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4164 static char debug_addr_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4165 static char debug_skeleton_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4166 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4167 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4168 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4169 static char ranges_base_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4171 #ifndef TEXT_END_LABEL
4172 #define TEXT_END_LABEL "Letext"
4174 #ifndef COLD_END_LABEL
4175 #define COLD_END_LABEL "Letext_cold"
4177 #ifndef BLOCK_BEGIN_LABEL
4178 #define BLOCK_BEGIN_LABEL "LBB"
4180 #ifndef BLOCK_INLINE_ENTRY_LABEL
4181 #define BLOCK_INLINE_ENTRY_LABEL "LBI"
4183 #ifndef BLOCK_END_LABEL
4184 #define BLOCK_END_LABEL "LBE"
4186 #ifndef LINE_CODE_LABEL
4187 #define LINE_CODE_LABEL "LM"
4191 /* Return the root of the DIE's built for the current compilation unit. */
4193 comp_unit_die (void)
4195 if (!single_comp_unit_die
)
4196 single_comp_unit_die
= gen_compile_unit_die (NULL
);
4197 return single_comp_unit_die
;
4200 /* We allow a language front-end to designate a function that is to be
4201 called to "demangle" any name before it is put into a DIE. */
4203 static const char *(*demangle_name_func
) (const char *);
4206 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
4208 demangle_name_func
= func
;
4211 /* Test if rtl node points to a pseudo register. */
4214 is_pseudo_reg (const_rtx rtl
)
4216 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
4217 || (GET_CODE (rtl
) == SUBREG
4218 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
4221 /* Return a reference to a type, with its const and volatile qualifiers
4225 type_main_variant (tree type
)
4227 type
= TYPE_MAIN_VARIANT (type
);
4229 /* ??? There really should be only one main variant among any group of
4230 variants of a given type (and all of the MAIN_VARIANT values for all
4231 members of the group should point to that one type) but sometimes the C
4232 front-end messes this up for array types, so we work around that bug
4234 if (TREE_CODE (type
) == ARRAY_TYPE
)
4235 while (type
!= TYPE_MAIN_VARIANT (type
))
4236 type
= TYPE_MAIN_VARIANT (type
);
4241 /* Return nonzero if the given type node represents a tagged type. */
4244 is_tagged_type (const_tree type
)
4246 enum tree_code code
= TREE_CODE (type
);
4248 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
4249 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
4252 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
4255 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
4257 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
4260 /* Return die_offset of a DIE reference to a base type. */
4262 static unsigned long int
4263 get_base_type_offset (dw_die_ref ref
)
4265 if (ref
->die_offset
)
4266 return ref
->die_offset
;
4267 if (comp_unit_die ()->die_abbrev
)
4269 calc_base_type_die_sizes ();
4270 gcc_assert (ref
->die_offset
);
4272 return ref
->die_offset
;
4275 /* Return die_offset of a DIE reference other than base type. */
4277 static unsigned long int
4278 get_ref_die_offset (dw_die_ref ref
)
4280 gcc_assert (ref
->die_offset
);
4281 return ref
->die_offset
;
4284 /* Convert a DIE tag into its string name. */
4287 dwarf_tag_name (unsigned int tag
)
4289 const char *name
= get_DW_TAG_name (tag
);
4294 return "DW_TAG_<unknown>";
4297 /* Convert a DWARF attribute code into its string name. */
4300 dwarf_attr_name (unsigned int attr
)
4306 #if VMS_DEBUGGING_INFO
4307 case DW_AT_HP_prologue
:
4308 return "DW_AT_HP_prologue";
4310 case DW_AT_MIPS_loop_unroll_factor
:
4311 return "DW_AT_MIPS_loop_unroll_factor";
4314 #if VMS_DEBUGGING_INFO
4315 case DW_AT_HP_epilogue
:
4316 return "DW_AT_HP_epilogue";
4318 case DW_AT_MIPS_stride
:
4319 return "DW_AT_MIPS_stride";
4323 name
= get_DW_AT_name (attr
);
4328 return "DW_AT_<unknown>";
4331 /* Convert a DWARF value form code into its string name. */
4334 dwarf_form_name (unsigned int form
)
4336 const char *name
= get_DW_FORM_name (form
);
4341 return "DW_FORM_<unknown>";
4344 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4345 instance of an inlined instance of a decl which is local to an inline
4346 function, so we have to trace all of the way back through the origin chain
4347 to find out what sort of node actually served as the original seed for the
4351 decl_ultimate_origin (const_tree decl
)
4353 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
4356 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
4357 we're trying to output the abstract instance of this function. */
4358 if (DECL_ABSTRACT_P (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
4361 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4362 most distant ancestor, this should never happen. */
4363 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
4365 return DECL_ABSTRACT_ORIGIN (decl
);
4368 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4369 of a virtual function may refer to a base class, so we check the 'this'
4373 decl_class_context (tree decl
)
4375 tree context
= NULL_TREE
;
4377 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
4378 context
= DECL_CONTEXT (decl
);
4380 context
= TYPE_MAIN_VARIANT
4381 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
4383 if (context
&& !TYPE_P (context
))
4384 context
= NULL_TREE
;
4389 /* Add an attribute/value pair to a DIE. */
4392 add_dwarf_attr (dw_die_ref die
, dw_attr_node
*attr
)
4394 /* Maybe this should be an assert? */
4400 /* Check we do not add duplicate attrs. Can't use get_AT here
4401 because that recurses to the specification/abstract origin DIE. */
4404 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4405 gcc_assert (a
->dw_attr
!= attr
->dw_attr
);
4408 vec_safe_reserve (die
->die_attr
, 1);
4409 vec_safe_push (die
->die_attr
, *attr
);
4412 static inline enum dw_val_class
4413 AT_class (dw_attr_node
*a
)
4415 return a
->dw_attr_val
.val_class
;
4418 /* Return the index for any attribute that will be referenced with a
4419 DW_FORM_addrx/GNU_addr_index or DW_FORM_strx/GNU_str_index. String
4420 indices are stored in dw_attr_val.v.val_str for reference counting
4423 static inline unsigned int
4424 AT_index (dw_attr_node
*a
)
4426 if (AT_class (a
) == dw_val_class_str
)
4427 return a
->dw_attr_val
.v
.val_str
->index
;
4428 else if (a
->dw_attr_val
.val_entry
!= NULL
)
4429 return a
->dw_attr_val
.val_entry
->index
;
4433 /* Add a flag value attribute to a DIE. */
4436 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
4440 attr
.dw_attr
= attr_kind
;
4441 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
4442 attr
.dw_attr_val
.val_entry
= NULL
;
4443 attr
.dw_attr_val
.v
.val_flag
= flag
;
4444 add_dwarf_attr (die
, &attr
);
4447 static inline unsigned
4448 AT_flag (dw_attr_node
*a
)
4450 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
4451 return a
->dw_attr_val
.v
.val_flag
;
4454 /* Add a signed integer attribute value to a DIE. */
4457 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
4461 attr
.dw_attr
= attr_kind
;
4462 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
4463 attr
.dw_attr_val
.val_entry
= NULL
;
4464 attr
.dw_attr_val
.v
.val_int
= int_val
;
4465 add_dwarf_attr (die
, &attr
);
4468 static inline HOST_WIDE_INT
4469 AT_int (dw_attr_node
*a
)
4471 gcc_assert (a
&& (AT_class (a
) == dw_val_class_const
4472 || AT_class (a
) == dw_val_class_const_implicit
));
4473 return a
->dw_attr_val
.v
.val_int
;
4476 /* Add an unsigned integer attribute value to a DIE. */
4479 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4480 unsigned HOST_WIDE_INT unsigned_val
)
4484 attr
.dw_attr
= attr_kind
;
4485 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
4486 attr
.dw_attr_val
.val_entry
= NULL
;
4487 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
4488 add_dwarf_attr (die
, &attr
);
4491 static inline unsigned HOST_WIDE_INT
4492 AT_unsigned (dw_attr_node
*a
)
4494 gcc_assert (a
&& (AT_class (a
) == dw_val_class_unsigned_const
4495 || AT_class (a
) == dw_val_class_unsigned_const_implicit
));
4496 return a
->dw_attr_val
.v
.val_unsigned
;
4499 /* Add an unsigned wide integer attribute value to a DIE. */
4502 add_AT_wide (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4507 attr
.dw_attr
= attr_kind
;
4508 attr
.dw_attr_val
.val_class
= dw_val_class_wide_int
;
4509 attr
.dw_attr_val
.val_entry
= NULL
;
4510 attr
.dw_attr_val
.v
.val_wide
= ggc_alloc
<wide_int
> ();
4511 *attr
.dw_attr_val
.v
.val_wide
= w
;
4512 add_dwarf_attr (die
, &attr
);
4515 /* Add an unsigned double integer attribute value to a DIE. */
4518 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4519 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
4523 attr
.dw_attr
= attr_kind
;
4524 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
4525 attr
.dw_attr_val
.val_entry
= NULL
;
4526 attr
.dw_attr_val
.v
.val_double
.high
= high
;
4527 attr
.dw_attr_val
.v
.val_double
.low
= low
;
4528 add_dwarf_attr (die
, &attr
);
4531 /* Add a floating point attribute value to a DIE and return it. */
4534 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4535 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
4539 attr
.dw_attr
= attr_kind
;
4540 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
4541 attr
.dw_attr_val
.val_entry
= NULL
;
4542 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
4543 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
4544 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
4545 add_dwarf_attr (die
, &attr
);
4548 /* Add an 8-byte data attribute value to a DIE. */
4551 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4552 unsigned char data8
[8])
4556 attr
.dw_attr
= attr_kind
;
4557 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
4558 attr
.dw_attr_val
.val_entry
= NULL
;
4559 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
4560 add_dwarf_attr (die
, &attr
);
4563 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
4564 dwarf_split_debug_info, address attributes in dies destined for the
4565 final executable have force_direct set to avoid using indexed
4569 add_AT_low_high_pc (dw_die_ref die
, const char *lbl_low
, const char *lbl_high
,
4575 lbl_id
= xstrdup (lbl_low
);
4576 attr
.dw_attr
= DW_AT_low_pc
;
4577 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4578 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4579 if (dwarf_split_debug_info
&& !force_direct
)
4580 attr
.dw_attr_val
.val_entry
4581 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4583 attr
.dw_attr_val
.val_entry
= NULL
;
4584 add_dwarf_attr (die
, &attr
);
4586 attr
.dw_attr
= DW_AT_high_pc
;
4587 if (dwarf_version
< 4)
4588 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4590 attr
.dw_attr_val
.val_class
= dw_val_class_high_pc
;
4591 lbl_id
= xstrdup (lbl_high
);
4592 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4593 if (attr
.dw_attr_val
.val_class
== dw_val_class_lbl_id
4594 && dwarf_split_debug_info
&& !force_direct
)
4595 attr
.dw_attr_val
.val_entry
4596 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4598 attr
.dw_attr_val
.val_entry
= NULL
;
4599 add_dwarf_attr (die
, &attr
);
4602 /* Hash and equality functions for debug_str_hash. */
4605 indirect_string_hasher::hash (indirect_string_node
*x
)
4607 return htab_hash_string (x
->str
);
4611 indirect_string_hasher::equal (indirect_string_node
*x1
, const char *x2
)
4613 return strcmp (x1
->str
, x2
) == 0;
4616 /* Add STR to the given string hash table. */
4618 static struct indirect_string_node
*
4619 find_AT_string_in_table (const char *str
,
4620 hash_table
<indirect_string_hasher
> *table
)
4622 struct indirect_string_node
*node
;
4624 indirect_string_node
**slot
4625 = table
->find_slot_with_hash (str
, htab_hash_string (str
), INSERT
);
4628 node
= ggc_cleared_alloc
<indirect_string_node
> ();
4629 node
->str
= ggc_strdup (str
);
4639 /* Add STR to the indirect string hash table. */
4641 static struct indirect_string_node
*
4642 find_AT_string (const char *str
)
4644 if (! debug_str_hash
)
4645 debug_str_hash
= hash_table
<indirect_string_hasher
>::create_ggc (10);
4647 return find_AT_string_in_table (str
, debug_str_hash
);
4650 /* Add a string attribute value to a DIE. */
4653 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
4656 struct indirect_string_node
*node
;
4658 node
= find_AT_string (str
);
4660 attr
.dw_attr
= attr_kind
;
4661 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
4662 attr
.dw_attr_val
.val_entry
= NULL
;
4663 attr
.dw_attr_val
.v
.val_str
= node
;
4664 add_dwarf_attr (die
, &attr
);
4667 static inline const char *
4668 AT_string (dw_attr_node
*a
)
4670 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4671 return a
->dw_attr_val
.v
.val_str
->str
;
4674 /* Call this function directly to bypass AT_string_form's logic to put
4675 the string inline in the die. */
4678 set_indirect_string (struct indirect_string_node
*node
)
4680 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4681 /* Already indirect is a no op. */
4682 if (node
->form
== DW_FORM_strp
4683 || node
->form
== DW_FORM_line_strp
4684 || node
->form
== dwarf_FORM (DW_FORM_strx
))
4686 gcc_assert (node
->label
);
4689 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4690 ++dw2_string_counter
;
4691 node
->label
= xstrdup (label
);
4693 if (!dwarf_split_debug_info
)
4695 node
->form
= DW_FORM_strp
;
4696 node
->index
= NOT_INDEXED
;
4700 node
->form
= dwarf_FORM (DW_FORM_strx
);
4701 node
->index
= NO_INDEX_ASSIGNED
;
4705 /* A helper function for dwarf2out_finish, called to reset indirect
4706 string decisions done for early LTO dwarf output before fat object
4710 reset_indirect_string (indirect_string_node
**h
, void *)
4712 struct indirect_string_node
*node
= *h
;
4713 if (node
->form
== DW_FORM_strp
|| node
->form
== dwarf_FORM (DW_FORM_strx
))
4717 node
->form
= (dwarf_form
) 0;
4723 /* Find out whether a string should be output inline in DIE
4724 or out-of-line in .debug_str section. */
4726 static enum dwarf_form
4727 find_string_form (struct indirect_string_node
*node
)
4734 len
= strlen (node
->str
) + 1;
4736 /* If the string is shorter or equal to the size of the reference, it is
4737 always better to put it inline. */
4738 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
4739 return node
->form
= DW_FORM_string
;
4741 /* If we cannot expect the linker to merge strings in .debug_str
4742 section, only put it into .debug_str if it is worth even in this
4744 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4745 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
4746 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
))
4747 return node
->form
= DW_FORM_string
;
4749 set_indirect_string (node
);
4754 /* Find out whether the string referenced from the attribute should be
4755 output inline in DIE or out-of-line in .debug_str section. */
4757 static enum dwarf_form
4758 AT_string_form (dw_attr_node
*a
)
4760 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4761 return find_string_form (a
->dw_attr_val
.v
.val_str
);
4764 /* Add a DIE reference attribute value to a DIE. */
4767 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4770 gcc_checking_assert (targ_die
!= NULL
);
4772 /* With LTO we can end up trying to reference something we didn't create
4773 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4774 if (targ_die
== NULL
)
4777 attr
.dw_attr
= attr_kind
;
4778 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
4779 attr
.dw_attr_val
.val_entry
= NULL
;
4780 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4781 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
4782 add_dwarf_attr (die
, &attr
);
4785 /* Change DIE reference REF to point to NEW_DIE instead. */
4788 change_AT_die_ref (dw_attr_node
*ref
, dw_die_ref new_die
)
4790 gcc_assert (ref
->dw_attr_val
.val_class
== dw_val_class_die_ref
);
4791 ref
->dw_attr_val
.v
.val_die_ref
.die
= new_die
;
4792 ref
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4795 /* Add an AT_specification attribute to a DIE, and also make the back
4796 pointer from the specification to the definition. */
4799 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4801 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4802 gcc_assert (!targ_die
->die_definition
);
4803 targ_die
->die_definition
= die
;
4806 static inline dw_die_ref
4807 AT_ref (dw_attr_node
*a
)
4809 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4810 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4814 AT_ref_external (dw_attr_node
*a
)
4816 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4817 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4823 set_AT_ref_external (dw_attr_node
*a
, int i
)
4825 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4826 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4829 /* Add an FDE reference attribute value to a DIE. */
4832 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
4836 attr
.dw_attr
= attr_kind
;
4837 attr
.dw_attr_val
.val_class
= dw_val_class_fde_ref
;
4838 attr
.dw_attr_val
.val_entry
= NULL
;
4839 attr
.dw_attr_val
.v
.val_fde_index
= targ_fde
;
4840 add_dwarf_attr (die
, &attr
);
4843 /* Add a location description attribute value to a DIE. */
4846 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4850 attr
.dw_attr
= attr_kind
;
4851 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4852 attr
.dw_attr_val
.val_entry
= NULL
;
4853 attr
.dw_attr_val
.v
.val_loc
= loc
;
4854 add_dwarf_attr (die
, &attr
);
4857 static inline dw_loc_descr_ref
4858 AT_loc (dw_attr_node
*a
)
4860 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4861 return a
->dw_attr_val
.v
.val_loc
;
4865 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4869 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4872 attr
.dw_attr
= attr_kind
;
4873 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
4874 attr
.dw_attr_val
.val_entry
= NULL
;
4875 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
4876 add_dwarf_attr (die
, &attr
);
4877 have_location_lists
= true;
4880 static inline dw_loc_list_ref
4881 AT_loc_list (dw_attr_node
*a
)
4883 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4884 return a
->dw_attr_val
.v
.val_loc_list
;
4887 /* Add a view list attribute to DIE. It must have a DW_AT_location
4888 attribute, because the view list complements the location list. */
4891 add_AT_view_list (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4895 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4898 attr
.dw_attr
= attr_kind
;
4899 attr
.dw_attr_val
.val_class
= dw_val_class_view_list
;
4900 attr
.dw_attr_val
.val_entry
= NULL
;
4901 attr
.dw_attr_val
.v
.val_view_list
= die
;
4902 add_dwarf_attr (die
, &attr
);
4903 gcc_checking_assert (get_AT (die
, DW_AT_location
));
4904 gcc_assert (have_location_lists
);
4907 /* Return a pointer to the location list referenced by the attribute.
4908 If the named attribute is a view list, look up the corresponding
4909 DW_AT_location attribute and return its location list. */
4911 static inline dw_loc_list_ref
*
4912 AT_loc_list_ptr (dw_attr_node
*a
)
4915 switch (AT_class (a
))
4917 case dw_val_class_loc_list
:
4918 return &a
->dw_attr_val
.v
.val_loc_list
;
4919 case dw_val_class_view_list
:
4922 l
= get_AT (a
->dw_attr_val
.v
.val_view_list
, DW_AT_location
);
4925 gcc_checking_assert (l
+ 1 == a
);
4926 return AT_loc_list_ptr (l
);
4933 /* Return the location attribute value associated with a view list
4936 static inline dw_val_node
*
4937 view_list_to_loc_list_val_node (dw_val_node
*val
)
4939 gcc_assert (val
->val_class
== dw_val_class_view_list
);
4940 dw_attr_node
*loc
= get_AT (val
->v
.val_view_list
, DW_AT_location
);
4943 gcc_checking_assert (&(loc
+ 1)->dw_attr_val
== val
);
4944 gcc_assert (AT_class (loc
) == dw_val_class_loc_list
);
4945 return &loc
->dw_attr_val
;
4948 struct addr_hasher
: ggc_ptr_hash
<addr_table_entry
>
4950 static hashval_t
hash (addr_table_entry
*);
4951 static bool equal (addr_table_entry
*, addr_table_entry
*);
4954 /* Table of entries into the .debug_addr section. */
4956 static GTY (()) hash_table
<addr_hasher
> *addr_index_table
;
4958 /* Hash an address_table_entry. */
4961 addr_hasher::hash (addr_table_entry
*a
)
4963 inchash::hash hstate
;
4969 case ate_kind_rtx_dtprel
:
4972 case ate_kind_label
:
4973 return htab_hash_string (a
->addr
.label
);
4977 inchash::add_rtx (a
->addr
.rtl
, hstate
);
4978 return hstate
.end ();
4981 /* Determine equality for two address_table_entries. */
4984 addr_hasher::equal (addr_table_entry
*a1
, addr_table_entry
*a2
)
4986 if (a1
->kind
!= a2
->kind
)
4991 case ate_kind_rtx_dtprel
:
4992 return rtx_equal_p (a1
->addr
.rtl
, a2
->addr
.rtl
);
4993 case ate_kind_label
:
4994 return strcmp (a1
->addr
.label
, a2
->addr
.label
) == 0;
5000 /* Initialize an addr_table_entry. */
5003 init_addr_table_entry (addr_table_entry
*e
, enum ate_kind kind
, void *addr
)
5009 case ate_kind_rtx_dtprel
:
5010 e
->addr
.rtl
= (rtx
) addr
;
5012 case ate_kind_label
:
5013 e
->addr
.label
= (char *) addr
;
5017 e
->index
= NO_INDEX_ASSIGNED
;
5020 /* Add attr to the address table entry to the table. Defer setting an
5021 index until output time. */
5023 static addr_table_entry
*
5024 add_addr_table_entry (void *addr
, enum ate_kind kind
)
5026 addr_table_entry
*node
;
5027 addr_table_entry finder
;
5029 gcc_assert (dwarf_split_debug_info
);
5030 if (! addr_index_table
)
5031 addr_index_table
= hash_table
<addr_hasher
>::create_ggc (10);
5032 init_addr_table_entry (&finder
, kind
, addr
);
5033 addr_table_entry
**slot
= addr_index_table
->find_slot (&finder
, INSERT
);
5035 if (*slot
== HTAB_EMPTY_ENTRY
)
5037 node
= ggc_cleared_alloc
<addr_table_entry
> ();
5038 init_addr_table_entry (node
, kind
, addr
);
5048 /* Remove an entry from the addr table by decrementing its refcount.
5049 Strictly, decrementing the refcount would be enough, but the
5050 assertion that the entry is actually in the table has found
5054 remove_addr_table_entry (addr_table_entry
*entry
)
5056 gcc_assert (dwarf_split_debug_info
&& addr_index_table
);
5057 /* After an index is assigned, the table is frozen. */
5058 gcc_assert (entry
->refcount
> 0 && entry
->index
== NO_INDEX_ASSIGNED
);
5062 /* Given a location list, remove all addresses it refers to from the
5066 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr
)
5068 for (; descr
; descr
= descr
->dw_loc_next
)
5069 if (descr
->dw_loc_oprnd1
.val_entry
!= NULL
)
5071 gcc_assert (descr
->dw_loc_oprnd1
.val_entry
->index
== NO_INDEX_ASSIGNED
);
5072 remove_addr_table_entry (descr
->dw_loc_oprnd1
.val_entry
);
5076 /* A helper function for dwarf2out_finish called through
5077 htab_traverse. Assign an addr_table_entry its index. All entries
5078 must be collected into the table when this function is called,
5079 because the indexing code relies on htab_traverse to traverse nodes
5080 in the same order for each run. */
5083 index_addr_table_entry (addr_table_entry
**h
, unsigned int *index
)
5085 addr_table_entry
*node
= *h
;
5087 /* Don't index unreferenced nodes. */
5088 if (node
->refcount
== 0)
5091 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
5092 node
->index
= *index
;
5098 /* Add an address constant attribute value to a DIE. When using
5099 dwarf_split_debug_info, address attributes in dies destined for the
5100 final executable should be direct references--setting the parameter
5101 force_direct ensures this behavior. */
5104 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
,
5109 attr
.dw_attr
= attr_kind
;
5110 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
5111 attr
.dw_attr_val
.v
.val_addr
= addr
;
5112 if (dwarf_split_debug_info
&& !force_direct
)
5113 attr
.dw_attr_val
.val_entry
= add_addr_table_entry (addr
, ate_kind_rtx
);
5115 attr
.dw_attr_val
.val_entry
= NULL
;
5116 add_dwarf_attr (die
, &attr
);
5119 /* Get the RTX from to an address DIE attribute. */
5122 AT_addr (dw_attr_node
*a
)
5124 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
5125 return a
->dw_attr_val
.v
.val_addr
;
5128 /* Add a file attribute value to a DIE. */
5131 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5132 struct dwarf_file_data
*fd
)
5136 attr
.dw_attr
= attr_kind
;
5137 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
5138 attr
.dw_attr_val
.val_entry
= NULL
;
5139 attr
.dw_attr_val
.v
.val_file
= fd
;
5140 add_dwarf_attr (die
, &attr
);
5143 /* Get the dwarf_file_data from a file DIE attribute. */
5145 static inline struct dwarf_file_data
*
5146 AT_file (dw_attr_node
*a
)
5148 gcc_assert (a
&& (AT_class (a
) == dw_val_class_file
5149 || AT_class (a
) == dw_val_class_file_implicit
));
5150 return a
->dw_attr_val
.v
.val_file
;
5153 /* Add a vms delta attribute value to a DIE. */
5156 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5157 const char *lbl1
, const char *lbl2
)
5161 attr
.dw_attr
= attr_kind
;
5162 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
5163 attr
.dw_attr_val
.val_entry
= NULL
;
5164 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
5165 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
5166 add_dwarf_attr (die
, &attr
);
5169 /* Add a symbolic view identifier attribute value to a DIE. */
5172 add_AT_symview (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5173 const char *view_label
)
5177 attr
.dw_attr
= attr_kind
;
5178 attr
.dw_attr_val
.val_class
= dw_val_class_symview
;
5179 attr
.dw_attr_val
.val_entry
= NULL
;
5180 attr
.dw_attr_val
.v
.val_symbolic_view
= xstrdup (view_label
);
5181 add_dwarf_attr (die
, &attr
);
5184 /* Add a label identifier attribute value to a DIE. */
5187 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5192 attr
.dw_attr
= attr_kind
;
5193 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
5194 attr
.dw_attr_val
.val_entry
= NULL
;
5195 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
5196 if (dwarf_split_debug_info
)
5197 attr
.dw_attr_val
.val_entry
5198 = add_addr_table_entry (attr
.dw_attr_val
.v
.val_lbl_id
,
5200 add_dwarf_attr (die
, &attr
);
5203 /* Add a section offset attribute value to a DIE, an offset into the
5204 debug_line section. */
5207 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5212 attr
.dw_attr
= attr_kind
;
5213 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
5214 attr
.dw_attr_val
.val_entry
= NULL
;
5215 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5216 add_dwarf_attr (die
, &attr
);
5219 /* Add a section offset attribute value to a DIE, an offset into the
5220 debug_loclists section. */
5223 add_AT_loclistsptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5228 attr
.dw_attr
= attr_kind
;
5229 attr
.dw_attr_val
.val_class
= dw_val_class_loclistsptr
;
5230 attr
.dw_attr_val
.val_entry
= NULL
;
5231 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5232 add_dwarf_attr (die
, &attr
);
5235 /* Add a section offset attribute value to a DIE, an offset into the
5236 debug_macinfo section. */
5239 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5244 attr
.dw_attr
= attr_kind
;
5245 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
5246 attr
.dw_attr_val
.val_entry
= NULL
;
5247 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5248 add_dwarf_attr (die
, &attr
);
5251 /* Add an offset attribute value to a DIE. */
5254 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5255 unsigned HOST_WIDE_INT offset
)
5259 attr
.dw_attr
= attr_kind
;
5260 attr
.dw_attr_val
.val_class
= dw_val_class_offset
;
5261 attr
.dw_attr_val
.val_entry
= NULL
;
5262 attr
.dw_attr_val
.v
.val_offset
= offset
;
5263 add_dwarf_attr (die
, &attr
);
5266 /* Add a range_list attribute value to a DIE. When using
5267 dwarf_split_debug_info, address attributes in dies destined for the
5268 final executable should be direct references--setting the parameter
5269 force_direct ensures this behavior. */
5271 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
5272 #define RELOCATED_OFFSET (NULL)
5275 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5276 long unsigned int offset
, bool force_direct
)
5280 attr
.dw_attr
= attr_kind
;
5281 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
5282 /* For the range_list attribute, use val_entry to store whether the
5283 offset should follow split-debug-info or normal semantics. This
5284 value is read in output_range_list_offset. */
5285 if (dwarf_split_debug_info
&& !force_direct
)
5286 attr
.dw_attr_val
.val_entry
= UNRELOCATED_OFFSET
;
5288 attr
.dw_attr_val
.val_entry
= RELOCATED_OFFSET
;
5289 attr
.dw_attr_val
.v
.val_offset
= offset
;
5290 add_dwarf_attr (die
, &attr
);
5293 /* Return the start label of a delta attribute. */
5295 static inline const char *
5296 AT_vms_delta1 (dw_attr_node
*a
)
5298 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5299 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
5302 /* Return the end label of a delta attribute. */
5304 static inline const char *
5305 AT_vms_delta2 (dw_attr_node
*a
)
5307 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5308 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
5311 static inline const char *
5312 AT_lbl (dw_attr_node
*a
)
5314 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
5315 || AT_class (a
) == dw_val_class_lineptr
5316 || AT_class (a
) == dw_val_class_macptr
5317 || AT_class (a
) == dw_val_class_loclistsptr
5318 || AT_class (a
) == dw_val_class_high_pc
));
5319 return a
->dw_attr_val
.v
.val_lbl_id
;
5322 /* Get the attribute of type attr_kind. */
5324 static dw_attr_node
*
5325 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5329 dw_die_ref spec
= NULL
;
5334 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5335 if (a
->dw_attr
== attr_kind
)
5337 else if (a
->dw_attr
== DW_AT_specification
5338 || a
->dw_attr
== DW_AT_abstract_origin
)
5342 return get_AT (spec
, attr_kind
);
5347 /* Returns the parent of the declaration of DIE. */
5350 get_die_parent (dw_die_ref die
)
5357 if ((t
= get_AT_ref (die
, DW_AT_abstract_origin
))
5358 || (t
= get_AT_ref (die
, DW_AT_specification
)))
5361 return die
->die_parent
;
5364 /* Return the "low pc" attribute value, typically associated with a subprogram
5365 DIE. Return null if the "low pc" attribute is either not present, or if it
5366 cannot be represented as an assembler label identifier. */
5368 static inline const char *
5369 get_AT_low_pc (dw_die_ref die
)
5371 dw_attr_node
*a
= get_AT (die
, DW_AT_low_pc
);
5373 return a
? AT_lbl (a
) : NULL
;
5376 /* Return the "high pc" attribute value, typically associated with a subprogram
5377 DIE. Return null if the "high pc" attribute is either not present, or if it
5378 cannot be represented as an assembler label identifier. */
5380 static inline const char *
5381 get_AT_hi_pc (dw_die_ref die
)
5383 dw_attr_node
*a
= get_AT (die
, DW_AT_high_pc
);
5385 return a
? AT_lbl (a
) : NULL
;
5388 /* Return the value of the string attribute designated by ATTR_KIND, or
5389 NULL if it is not present. */
5391 static inline const char *
5392 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5394 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5396 return a
? AT_string (a
) : NULL
;
5399 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5400 if it is not present. */
5403 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5405 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5407 return a
? AT_flag (a
) : 0;
5410 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5411 if it is not present. */
5413 static inline unsigned
5414 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5416 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5418 return a
? AT_unsigned (a
) : 0;
5421 static inline dw_die_ref
5422 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5424 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5426 return a
? AT_ref (a
) : NULL
;
5429 static inline struct dwarf_file_data
*
5430 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5432 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5434 return a
? AT_file (a
) : NULL
;
5437 /* Return TRUE if the language is C++. */
5442 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5444 return (lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
5445 || lang
== DW_LANG_C_plus_plus_11
|| lang
== DW_LANG_C_plus_plus_14
);
5448 /* Return TRUE if DECL was created by the C++ frontend. */
5451 is_cxx (const_tree decl
)
5455 const_tree context
= get_ultimate_context (decl
);
5456 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5457 return strncmp (TRANSLATION_UNIT_LANGUAGE (context
), "GNU C++", 7) == 0;
5462 /* Return TRUE if the language is Fortran. */
5467 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5469 return (lang
== DW_LANG_Fortran77
5470 || lang
== DW_LANG_Fortran90
5471 || lang
== DW_LANG_Fortran95
5472 || lang
== DW_LANG_Fortran03
5473 || lang
== DW_LANG_Fortran08
);
5477 is_fortran (const_tree decl
)
5481 const_tree context
= get_ultimate_context (decl
);
5482 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5483 return (strncmp (TRANSLATION_UNIT_LANGUAGE (context
),
5484 "GNU Fortran", 11) == 0
5485 || strcmp (TRANSLATION_UNIT_LANGUAGE (context
),
5488 return is_fortran ();
5491 /* Return TRUE if the language is Ada. */
5496 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5498 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
5501 /* Remove the specified attribute if present. Return TRUE if removal
5505 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5513 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5514 if (a
->dw_attr
== attr_kind
)
5516 if (AT_class (a
) == dw_val_class_str
)
5517 if (a
->dw_attr_val
.v
.val_str
->refcount
)
5518 a
->dw_attr_val
.v
.val_str
->refcount
--;
5520 /* vec::ordered_remove should help reduce the number of abbrevs
5522 die
->die_attr
->ordered_remove (ix
);
5528 /* Remove CHILD from its parent. PREV must have the property that
5529 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
5532 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
5534 gcc_assert (child
->die_parent
== prev
->die_parent
);
5535 gcc_assert (prev
->die_sib
== child
);
5538 gcc_assert (child
->die_parent
->die_child
== child
);
5542 prev
->die_sib
= child
->die_sib
;
5543 if (child
->die_parent
->die_child
== child
)
5544 child
->die_parent
->die_child
= prev
;
5545 child
->die_sib
= NULL
;
5548 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
5549 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
5552 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
5554 dw_die_ref parent
= old_child
->die_parent
;
5556 gcc_assert (parent
== prev
->die_parent
);
5557 gcc_assert (prev
->die_sib
== old_child
);
5559 new_child
->die_parent
= parent
;
5560 if (prev
== old_child
)
5562 gcc_assert (parent
->die_child
== old_child
);
5563 new_child
->die_sib
= new_child
;
5567 prev
->die_sib
= new_child
;
5568 new_child
->die_sib
= old_child
->die_sib
;
5570 if (old_child
->die_parent
->die_child
== old_child
)
5571 old_child
->die_parent
->die_child
= new_child
;
5572 old_child
->die_sib
= NULL
;
5575 /* Move all children from OLD_PARENT to NEW_PARENT. */
5578 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
5581 new_parent
->die_child
= old_parent
->die_child
;
5582 old_parent
->die_child
= NULL
;
5583 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
5586 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
5590 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
5596 dw_die_ref prev
= c
;
5598 while (c
->die_tag
== tag
)
5600 remove_child_with_prev (c
, prev
);
5601 c
->die_parent
= NULL
;
5602 /* Might have removed every child. */
5603 if (die
->die_child
== NULL
)
5607 } while (c
!= die
->die_child
);
5610 /* Add a CHILD_DIE as the last child of DIE. */
5613 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
5615 /* FIXME this should probably be an assert. */
5616 if (! die
|| ! child_die
)
5618 gcc_assert (die
!= child_die
);
5620 child_die
->die_parent
= die
;
5623 child_die
->die_sib
= die
->die_child
->die_sib
;
5624 die
->die_child
->die_sib
= child_die
;
5627 child_die
->die_sib
= child_die
;
5628 die
->die_child
= child_die
;
5631 /* Like add_child_die, but put CHILD_DIE after AFTER_DIE. */
5634 add_child_die_after (dw_die_ref die
, dw_die_ref child_die
,
5635 dw_die_ref after_die
)
5641 && die
!= child_die
);
5643 child_die
->die_parent
= die
;
5644 child_die
->die_sib
= after_die
->die_sib
;
5645 after_die
->die_sib
= child_die
;
5646 if (die
->die_child
== after_die
)
5647 die
->die_child
= child_die
;
5650 /* Unassociate CHILD from its parent, and make its parent be
5654 reparent_child (dw_die_ref child
, dw_die_ref new_parent
)
5656 for (dw_die_ref p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
5657 if (p
->die_sib
== child
)
5659 remove_child_with_prev (child
, p
);
5662 add_child_die (new_parent
, child
);
5665 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5666 is the specification, to the end of PARENT's list of children.
5667 This is done by removing and re-adding it. */
5670 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
5672 /* We want the declaration DIE from inside the class, not the
5673 specification DIE at toplevel. */
5674 if (child
->die_parent
!= parent
)
5676 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5682 gcc_assert (child
->die_parent
== parent
5683 || (child
->die_parent
5684 == get_AT_ref (parent
, DW_AT_specification
)));
5686 reparent_child (child
, parent
);
5689 /* Create and return a new die with TAG_VALUE as tag. */
5691 static inline dw_die_ref
5692 new_die_raw (enum dwarf_tag tag_value
)
5694 dw_die_ref die
= ggc_cleared_alloc
<die_node
> ();
5695 die
->die_tag
= tag_value
;
5699 /* Create and return a new die with a parent of PARENT_DIE. If
5700 PARENT_DIE is NULL, the new DIE is placed in limbo and an
5701 associated tree T must be supplied to determine parenthood
5704 static inline dw_die_ref
5705 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5707 dw_die_ref die
= new_die_raw (tag_value
);
5709 if (parent_die
!= NULL
)
5710 add_child_die (parent_die
, die
);
5713 limbo_die_node
*limbo_node
;
5715 /* No DIEs created after early dwarf should end up in limbo,
5716 because the limbo list should not persist past LTO
5718 if (tag_value
!= DW_TAG_compile_unit
5719 /* These are allowed because they're generated while
5720 breaking out COMDAT units late. */
5721 && tag_value
!= DW_TAG_type_unit
5722 && tag_value
!= DW_TAG_skeleton_unit
5724 /* Allow nested functions to live in limbo because they will
5725 only temporarily live there, as decls_for_scope will fix
5727 && (TREE_CODE (t
) != FUNCTION_DECL
5728 || !decl_function_context (t
))
5729 /* Same as nested functions above but for types. Types that
5730 are local to a function will be fixed in
5732 && (!RECORD_OR_UNION_TYPE_P (t
)
5733 || !TYPE_CONTEXT (t
)
5734 || TREE_CODE (TYPE_CONTEXT (t
)) != FUNCTION_DECL
)
5735 /* FIXME debug-early: Allow late limbo DIE creation for LTO,
5736 especially in the ltrans stage, but once we implement LTO
5737 dwarf streaming, we should remove this exception. */
5740 fprintf (stderr
, "symbol ended up in limbo too late:");
5741 debug_generic_stmt (t
);
5745 limbo_node
= ggc_cleared_alloc
<limbo_die_node
> ();
5746 limbo_node
->die
= die
;
5747 limbo_node
->created_for
= t
;
5748 limbo_node
->next
= limbo_die_list
;
5749 limbo_die_list
= limbo_node
;
5755 /* Return the DIE associated with the given type specifier. */
5757 static inline dw_die_ref
5758 lookup_type_die (tree type
)
5760 dw_die_ref die
= TYPE_SYMTAB_DIE (type
);
5761 if (die
&& die
->removed
)
5763 TYPE_SYMTAB_DIE (type
) = NULL
;
5769 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
5770 anonymous type named by the typedef TYPE_DIE, return the DIE of the
5771 anonymous type instead the one of the naming typedef. */
5773 static inline dw_die_ref
5774 strip_naming_typedef (tree type
, dw_die_ref type_die
)
5777 && TREE_CODE (type
) == RECORD_TYPE
5779 && type_die
->die_tag
== DW_TAG_typedef
5780 && is_naming_typedef_decl (TYPE_NAME (type
)))
5781 type_die
= get_AT_ref (type_die
, DW_AT_type
);
5785 /* Like lookup_type_die, but if type is an anonymous type named by a
5786 typedef[1], return the DIE of the anonymous type instead the one of
5787 the naming typedef. This is because in gen_typedef_die, we did
5788 equate the anonymous struct named by the typedef with the DIE of
5789 the naming typedef. So by default, lookup_type_die on an anonymous
5790 struct yields the DIE of the naming typedef.
5792 [1]: Read the comment of is_naming_typedef_decl to learn about what
5793 a naming typedef is. */
5795 static inline dw_die_ref
5796 lookup_type_die_strip_naming_typedef (tree type
)
5798 dw_die_ref die
= lookup_type_die (type
);
5799 return strip_naming_typedef (type
, die
);
5802 /* Equate a DIE to a given type specifier. */
5805 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5807 TYPE_SYMTAB_DIE (type
) = type_die
;
5810 /* Returns a hash value for X (which really is a die_struct). */
5813 decl_die_hasher::hash (die_node
*x
)
5815 return (hashval_t
) x
->decl_id
;
5818 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5821 decl_die_hasher::equal (die_node
*x
, tree y
)
5823 return (x
->decl_id
== DECL_UID (y
));
5826 /* Return the DIE associated with a given declaration. */
5828 static inline dw_die_ref
5829 lookup_decl_die (tree decl
)
5831 dw_die_ref
*die
= decl_die_table
->find_slot_with_hash (decl
, DECL_UID (decl
),
5835 if ((*die
)->removed
)
5837 decl_die_table
->clear_slot (die
);
5844 /* For DECL which might have early dwarf output query a SYMBOL + OFFSET
5845 style reference. Return true if we found one refering to a DIE for
5846 DECL, otherwise return false. */
5849 dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
5850 unsigned HOST_WIDE_INT
*off
)
5854 if (in_lto_p
&& !decl_die_table
)
5857 if (TREE_CODE (decl
) == BLOCK
)
5858 die
= BLOCK_DIE (decl
);
5860 die
= lookup_decl_die (decl
);
5864 /* During WPA stage and incremental linking we currently use DIEs
5865 to store the decl <-> label + offset map. That's quite inefficient
5866 but it works for now. */
5869 dw_die_ref ref
= get_AT_ref (die
, DW_AT_abstract_origin
);
5872 gcc_assert (die
== comp_unit_die ());
5875 *off
= ref
->die_offset
;
5876 *sym
= ref
->die_id
.die_symbol
;
5880 /* Similar to get_ref_die_offset_label, but using the "correct"
5882 *off
= die
->die_offset
;
5883 while (die
->die_parent
)
5884 die
= die
->die_parent
;
5885 /* For the containing CU DIE we compute a die_symbol in
5886 compute_comp_unit_symbol. */
5887 gcc_assert (die
->die_tag
== DW_TAG_compile_unit
5888 && die
->die_id
.die_symbol
!= NULL
);
5889 *sym
= die
->die_id
.die_symbol
;
5893 /* Add a reference of kind ATTR_KIND to a DIE at SYMBOL + OFFSET to DIE. */
5896 add_AT_external_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5897 const char *symbol
, HOST_WIDE_INT offset
)
5899 /* Create a fake DIE that contains the reference. Don't use
5900 new_die because we don't want to end up in the limbo list. */
5901 dw_die_ref ref
= new_die_raw (die
->die_tag
);
5902 ref
->die_id
.die_symbol
= IDENTIFIER_POINTER (get_identifier (symbol
));
5903 ref
->die_offset
= offset
;
5904 ref
->with_offset
= 1;
5905 add_AT_die_ref (die
, attr_kind
, ref
);
5908 /* Create a DIE for DECL if required and add a reference to a DIE
5909 at SYMBOL + OFFSET which contains attributes dumped early. */
5912 dwarf2out_register_external_die (tree decl
, const char *sym
,
5913 unsigned HOST_WIDE_INT off
)
5915 if (debug_info_level
== DINFO_LEVEL_NONE
)
5919 || flag_incremental_link
== INCREMENTAL_LINK_LTO
) && !decl_die_table
)
5920 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (1000);
5923 = TREE_CODE (decl
) == BLOCK
? BLOCK_DIE (decl
) : lookup_decl_die (decl
);
5927 dw_die_ref parent
= NULL
;
5928 /* Need to lookup a DIE for the decls context - the containing
5929 function or translation unit. */
5930 if (TREE_CODE (decl
) == BLOCK
)
5932 ctx
= BLOCK_SUPERCONTEXT (decl
);
5933 /* ??? We do not output DIEs for all scopes thus skip as
5934 many DIEs as needed. */
5935 while (TREE_CODE (ctx
) == BLOCK
5936 && !BLOCK_DIE (ctx
))
5937 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5940 ctx
= DECL_CONTEXT (decl
);
5941 /* Peel types in the context stack. */
5942 while (ctx
&& TYPE_P (ctx
))
5943 ctx
= TYPE_CONTEXT (ctx
);
5944 /* Likewise namespaces in case we do not want to emit DIEs for them. */
5945 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
5946 while (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5947 ctx
= DECL_CONTEXT (ctx
);
5950 if (TREE_CODE (ctx
) == BLOCK
)
5951 parent
= BLOCK_DIE (ctx
);
5952 else if (TREE_CODE (ctx
) == TRANSLATION_UNIT_DECL
5953 /* Keep the 1:1 association during WPA. */
5955 && flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
5956 /* Otherwise all late annotations go to the main CU which
5957 imports the original CUs. */
5958 parent
= comp_unit_die ();
5959 else if (TREE_CODE (ctx
) == FUNCTION_DECL
5960 && TREE_CODE (decl
) != FUNCTION_DECL
5961 && TREE_CODE (decl
) != PARM_DECL
5962 && TREE_CODE (decl
) != RESULT_DECL
5963 && TREE_CODE (decl
) != BLOCK
)
5964 /* Leave function local entities parent determination to when
5965 we process scope vars. */
5968 parent
= lookup_decl_die (ctx
);
5971 /* In some cases the FEs fail to set DECL_CONTEXT properly.
5972 Handle this case gracefully by globalizing stuff. */
5973 parent
= comp_unit_die ();
5974 /* Create a DIE "stub". */
5975 switch (TREE_CODE (decl
))
5977 case TRANSLATION_UNIT_DECL
:
5978 if (! flag_wpa
&& flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
5980 die
= comp_unit_die ();
5981 dw_die_ref import
= new_die (DW_TAG_imported_unit
, die
, NULL_TREE
);
5982 add_AT_external_die_ref (import
, DW_AT_import
, sym
, off
);
5983 /* We re-target all CU decls to the LTRANS CU DIE, so no need
5984 to create a DIE for the original CUs. */
5987 /* Keep the 1:1 association during WPA. */
5988 die
= new_die (DW_TAG_compile_unit
, NULL
, decl
);
5990 case NAMESPACE_DECL
:
5991 if (is_fortran (decl
))
5992 die
= new_die (DW_TAG_module
, parent
, decl
);
5994 die
= new_die (DW_TAG_namespace
, parent
, decl
);
5997 die
= new_die (DW_TAG_subprogram
, parent
, decl
);
6000 die
= new_die (DW_TAG_variable
, parent
, decl
);
6003 die
= new_die (DW_TAG_variable
, parent
, decl
);
6006 die
= new_die (DW_TAG_formal_parameter
, parent
, decl
);
6009 die
= new_die (DW_TAG_constant
, parent
, decl
);
6012 die
= new_die (DW_TAG_label
, parent
, decl
);
6015 die
= new_die (DW_TAG_lexical_block
, parent
, decl
);
6020 if (TREE_CODE (decl
) == BLOCK
)
6021 BLOCK_DIE (decl
) = die
;
6023 equate_decl_number_to_die (decl
, die
);
6025 /* Add a reference to the DIE providing early debug at $sym + off. */
6026 add_AT_external_die_ref (die
, DW_AT_abstract_origin
, sym
, off
);
6029 /* Returns a hash value for X (which really is a var_loc_list). */
6032 decl_loc_hasher::hash (var_loc_list
*x
)
6034 return (hashval_t
) x
->decl_id
;
6037 /* Return nonzero if decl_id of var_loc_list X is the same as
6041 decl_loc_hasher::equal (var_loc_list
*x
, const_tree y
)
6043 return (x
->decl_id
== DECL_UID (y
));
6046 /* Return the var_loc list associated with a given declaration. */
6048 static inline var_loc_list
*
6049 lookup_decl_loc (const_tree decl
)
6051 if (!decl_loc_table
)
6053 return decl_loc_table
->find_with_hash (decl
, DECL_UID (decl
));
6056 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
6059 dw_loc_list_hasher::hash (cached_dw_loc_list
*x
)
6061 return (hashval_t
) x
->decl_id
;
6064 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
6068 dw_loc_list_hasher::equal (cached_dw_loc_list
*x
, const_tree y
)
6070 return (x
->decl_id
== DECL_UID (y
));
6073 /* Equate a DIE to a particular declaration. */
6076 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
6078 unsigned int decl_id
= DECL_UID (decl
);
6080 *decl_die_table
->find_slot_with_hash (decl
, decl_id
, INSERT
) = decl_die
;
6081 decl_die
->decl_id
= decl_id
;
6084 /* Return how many bits covers PIECE EXPR_LIST. */
6086 static HOST_WIDE_INT
6087 decl_piece_bitsize (rtx piece
)
6089 int ret
= (int) GET_MODE (piece
);
6092 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
6093 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
6094 return INTVAL (XEXP (XEXP (piece
, 0), 0));
6097 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
6100 decl_piece_varloc_ptr (rtx piece
)
6102 if ((int) GET_MODE (piece
))
6103 return &XEXP (piece
, 0);
6105 return &XEXP (XEXP (piece
, 0), 1);
6108 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
6109 Next is the chain of following piece nodes. */
6111 static rtx_expr_list
*
6112 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
6114 if (bitsize
> 0 && bitsize
<= (int) MAX_MACHINE_MODE
)
6115 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
6117 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
6122 /* Return rtx that should be stored into loc field for
6123 LOC_NOTE and BITPOS/BITSIZE. */
6126 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
6127 HOST_WIDE_INT bitsize
)
6131 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
6133 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
6138 /* This function either modifies location piece list *DEST in
6139 place (if SRC and INNER is NULL), or copies location piece list
6140 *SRC to *DEST while modifying it. Location BITPOS is modified
6141 to contain LOC_NOTE, any pieces overlapping it are removed resp.
6142 not copied and if needed some padding around it is added.
6143 When modifying in place, DEST should point to EXPR_LIST where
6144 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
6145 to the start of the whole list and INNER points to the EXPR_LIST
6146 where earlier pieces cover PIECE_BITPOS bits. */
6149 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
6150 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
6151 HOST_WIDE_INT bitsize
, rtx loc_note
)
6154 bool copy
= inner
!= NULL
;
6158 /* First copy all nodes preceding the current bitpos. */
6159 while (src
!= inner
)
6161 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
6162 decl_piece_bitsize (*src
), NULL_RTX
);
6163 dest
= &XEXP (*dest
, 1);
6164 src
= &XEXP (*src
, 1);
6167 /* Add padding if needed. */
6168 if (bitpos
!= piece_bitpos
)
6170 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
6171 copy
? NULL_RTX
: *dest
);
6172 dest
= &XEXP (*dest
, 1);
6174 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
6177 /* A piece with correct bitpos and bitsize already exist,
6178 just update the location for it and return. */
6179 *decl_piece_varloc_ptr (*dest
) = loc_note
;
6182 /* Add the piece that changed. */
6183 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
6184 dest
= &XEXP (*dest
, 1);
6185 /* Skip over pieces that overlap it. */
6186 diff
= bitpos
- piece_bitpos
+ bitsize
;
6189 while (diff
> 0 && *src
)
6192 diff
-= decl_piece_bitsize (piece
);
6194 src
= &XEXP (piece
, 1);
6197 *src
= XEXP (piece
, 1);
6198 free_EXPR_LIST_node (piece
);
6201 /* Add padding if needed. */
6202 if (diff
< 0 && *src
)
6206 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
6207 dest
= &XEXP (*dest
, 1);
6211 /* Finally copy all nodes following it. */
6214 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
6215 decl_piece_bitsize (*src
), NULL_RTX
);
6216 dest
= &XEXP (*dest
, 1);
6217 src
= &XEXP (*src
, 1);
6221 /* Add a variable location node to the linked list for DECL. */
6223 static struct var_loc_node
*
6224 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
, var_loc_view view
)
6226 unsigned int decl_id
;
6228 struct var_loc_node
*loc
= NULL
;
6229 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
6231 if (VAR_P (decl
) && DECL_HAS_DEBUG_EXPR_P (decl
))
6233 tree realdecl
= DECL_DEBUG_EXPR (decl
);
6234 if (handled_component_p (realdecl
)
6235 || (TREE_CODE (realdecl
) == MEM_REF
6236 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
6239 tree innerdecl
= get_ref_base_and_extent_hwi (realdecl
, &bitpos
,
6240 &bitsize
, &reverse
);
6242 || !DECL_P (innerdecl
)
6243 || DECL_IGNORED_P (innerdecl
)
6244 || TREE_STATIC (innerdecl
)
6246 || bitpos
+ bitsize
> 256)
6252 decl_id
= DECL_UID (decl
);
6254 = decl_loc_table
->find_slot_with_hash (decl
, decl_id
, INSERT
);
6257 temp
= ggc_cleared_alloc
<var_loc_list
> ();
6258 temp
->decl_id
= decl_id
;
6264 /* For PARM_DECLs try to keep around the original incoming value,
6265 even if that means we'll emit a zero-range .debug_loc entry. */
6267 && temp
->first
== temp
->last
6268 && TREE_CODE (decl
) == PARM_DECL
6269 && NOTE_P (temp
->first
->loc
)
6270 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
6271 && DECL_INCOMING_RTL (decl
)
6272 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
6273 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
6274 == GET_CODE (DECL_INCOMING_RTL (decl
))
6275 && prev_real_insn (as_a
<rtx_insn
*> (temp
->first
->loc
)) == NULL_RTX
6277 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
6278 NOTE_VAR_LOCATION_LOC (loc_note
))
6279 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
6280 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
6282 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6283 temp
->first
->next
= loc
;
6285 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6287 else if (temp
->last
)
6289 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
6290 rtx
*piece_loc
= NULL
, last_loc_note
;
6291 HOST_WIDE_INT piece_bitpos
= 0;
6295 gcc_assert (last
->next
== NULL
);
6297 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
6299 piece_loc
= &last
->loc
;
6302 HOST_WIDE_INT cur_bitsize
= decl_piece_bitsize (*piece_loc
);
6303 if (piece_bitpos
+ cur_bitsize
> bitpos
)
6305 piece_bitpos
+= cur_bitsize
;
6306 piece_loc
= &XEXP (*piece_loc
, 1);
6310 /* TEMP->LAST here is either pointer to the last but one or
6311 last element in the chained list, LAST is pointer to the
6313 if (label
&& strcmp (last
->label
, label
) == 0 && last
->view
== view
)
6315 /* For SRA optimized variables if there weren't any real
6316 insns since last note, just modify the last node. */
6317 if (piece_loc
!= NULL
)
6319 adjust_piece_list (piece_loc
, NULL
, NULL
,
6320 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6323 /* If the last note doesn't cover any instructions, remove it. */
6324 if (temp
->last
!= last
)
6326 temp
->last
->next
= NULL
;
6329 gcc_assert (strcmp (last
->label
, label
) != 0 || last
->view
!= view
);
6333 gcc_assert (temp
->first
== temp
->last
6334 || (temp
->first
->next
== temp
->last
6335 && TREE_CODE (decl
) == PARM_DECL
));
6336 memset (temp
->last
, '\0', sizeof (*temp
->last
));
6337 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6341 if (bitsize
== -1 && NOTE_P (last
->loc
))
6342 last_loc_note
= last
->loc
;
6343 else if (piece_loc
!= NULL
6344 && *piece_loc
!= NULL_RTX
6345 && piece_bitpos
== bitpos
6346 && decl_piece_bitsize (*piece_loc
) == bitsize
)
6347 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
6349 last_loc_note
= NULL_RTX
;
6350 /* If the current location is the same as the end of the list,
6351 and either both or neither of the locations is uninitialized,
6352 we have nothing to do. */
6353 if (last_loc_note
== NULL_RTX
6354 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
6355 NOTE_VAR_LOCATION_LOC (loc_note
)))
6356 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6357 != NOTE_VAR_LOCATION_STATUS (loc_note
))
6358 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6359 == VAR_INIT_STATUS_UNINITIALIZED
)
6360 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
6361 == VAR_INIT_STATUS_UNINITIALIZED
))))
6363 /* Add LOC to the end of list and update LAST. If the last
6364 element of the list has been removed above, reuse its
6365 memory for the new node, otherwise allocate a new one. */
6369 memset (loc
, '\0', sizeof (*loc
));
6372 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6373 if (bitsize
== -1 || piece_loc
== NULL
)
6374 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6376 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
6377 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6379 /* Ensure TEMP->LAST will point either to the new last but one
6380 element of the chain, or to the last element in it. */
6381 if (last
!= temp
->last
)
6389 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6392 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6397 /* Keep track of the number of spaces used to indent the
6398 output of the debugging routines that print the structure of
6399 the DIE internal representation. */
6400 static int print_indent
;
6402 /* Indent the line the number of spaces given by print_indent. */
6405 print_spaces (FILE *outfile
)
6407 fprintf (outfile
, "%*s", print_indent
, "");
6410 /* Print a type signature in hex. */
6413 print_signature (FILE *outfile
, char *sig
)
6417 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
6418 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
6422 print_discr_value (FILE *outfile
, dw_discr_value
*discr_value
)
6424 if (discr_value
->pos
)
6425 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, discr_value
->v
.sval
);
6427 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, discr_value
->v
.uval
);
6430 static void print_loc_descr (dw_loc_descr_ref
, FILE *);
6432 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
6433 RECURSE, output location descriptor operations. */
6436 print_dw_val (dw_val_node
*val
, bool recurse
, FILE *outfile
)
6438 switch (val
->val_class
)
6440 case dw_val_class_addr
:
6441 fprintf (outfile
, "address");
6443 case dw_val_class_offset
:
6444 fprintf (outfile
, "offset");
6446 case dw_val_class_loc
:
6447 fprintf (outfile
, "location descriptor");
6448 if (val
->v
.val_loc
== NULL
)
6449 fprintf (outfile
, " -> <null>\n");
6452 fprintf (outfile
, ":\n");
6454 print_loc_descr (val
->v
.val_loc
, outfile
);
6458 fprintf (outfile
, " (%p)\n", (void *) val
->v
.val_loc
);
6460 case dw_val_class_loc_list
:
6461 fprintf (outfile
, "location list -> label:%s",
6462 val
->v
.val_loc_list
->ll_symbol
);
6464 case dw_val_class_view_list
:
6465 val
= view_list_to_loc_list_val_node (val
);
6466 fprintf (outfile
, "location list with views -> labels:%s and %s",
6467 val
->v
.val_loc_list
->ll_symbol
,
6468 val
->v
.val_loc_list
->vl_symbol
);
6470 case dw_val_class_range_list
:
6471 fprintf (outfile
, "range list");
6473 case dw_val_class_const
:
6474 case dw_val_class_const_implicit
:
6475 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, val
->v
.val_int
);
6477 case dw_val_class_unsigned_const
:
6478 case dw_val_class_unsigned_const_implicit
:
6479 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, val
->v
.val_unsigned
);
6481 case dw_val_class_const_double
:
6482 fprintf (outfile
, "constant (" HOST_WIDE_INT_PRINT_DEC
","\
6483 HOST_WIDE_INT_PRINT_UNSIGNED
")",
6484 val
->v
.val_double
.high
,
6485 val
->v
.val_double
.low
);
6487 case dw_val_class_wide_int
:
6489 int i
= val
->v
.val_wide
->get_len ();
6490 fprintf (outfile
, "constant (");
6492 if (val
->v
.val_wide
->elt (i
- 1) == 0)
6493 fprintf (outfile
, "0x");
6494 fprintf (outfile
, HOST_WIDE_INT_PRINT_HEX
,
6495 val
->v
.val_wide
->elt (--i
));
6497 fprintf (outfile
, HOST_WIDE_INT_PRINT_PADDED_HEX
,
6498 val
->v
.val_wide
->elt (i
));
6499 fprintf (outfile
, ")");
6502 case dw_val_class_vec
:
6503 fprintf (outfile
, "floating-point or vector constant");
6505 case dw_val_class_flag
:
6506 fprintf (outfile
, "%u", val
->v
.val_flag
);
6508 case dw_val_class_die_ref
:
6509 if (val
->v
.val_die_ref
.die
!= NULL
)
6511 dw_die_ref die
= val
->v
.val_die_ref
.die
;
6513 if (die
->comdat_type_p
)
6515 fprintf (outfile
, "die -> signature: ");
6516 print_signature (outfile
,
6517 die
->die_id
.die_type_node
->signature
);
6519 else if (die
->die_id
.die_symbol
)
6521 fprintf (outfile
, "die -> label: %s", die
->die_id
.die_symbol
);
6522 if (die
->with_offset
)
6523 fprintf (outfile
, " + %ld", die
->die_offset
);
6526 fprintf (outfile
, "die -> %ld", die
->die_offset
);
6527 fprintf (outfile
, " (%p)", (void *) die
);
6530 fprintf (outfile
, "die -> <null>");
6532 case dw_val_class_vms_delta
:
6533 fprintf (outfile
, "delta: @slotcount(%s-%s)",
6534 val
->v
.val_vms_delta
.lbl2
, val
->v
.val_vms_delta
.lbl1
);
6536 case dw_val_class_symview
:
6537 fprintf (outfile
, "view: %s", val
->v
.val_symbolic_view
);
6539 case dw_val_class_lbl_id
:
6540 case dw_val_class_lineptr
:
6541 case dw_val_class_macptr
:
6542 case dw_val_class_loclistsptr
:
6543 case dw_val_class_high_pc
:
6544 fprintf (outfile
, "label: %s", val
->v
.val_lbl_id
);
6546 case dw_val_class_str
:
6547 if (val
->v
.val_str
->str
!= NULL
)
6548 fprintf (outfile
, "\"%s\"", val
->v
.val_str
->str
);
6550 fprintf (outfile
, "<null>");
6552 case dw_val_class_file
:
6553 case dw_val_class_file_implicit
:
6554 fprintf (outfile
, "\"%s\" (%d)", val
->v
.val_file
->filename
,
6555 val
->v
.val_file
->emitted_number
);
6557 case dw_val_class_data8
:
6561 for (i
= 0; i
< 8; i
++)
6562 fprintf (outfile
, "%02x", val
->v
.val_data8
[i
]);
6565 case dw_val_class_discr_value
:
6566 print_discr_value (outfile
, &val
->v
.val_discr_value
);
6568 case dw_val_class_discr_list
:
6569 for (dw_discr_list_ref node
= val
->v
.val_discr_list
;
6571 node
= node
->dw_discr_next
)
6573 if (node
->dw_discr_range
)
6575 fprintf (outfile
, " .. ");
6576 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6577 print_discr_value (outfile
, &node
->dw_discr_upper_bound
);
6580 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6582 if (node
->dw_discr_next
!= NULL
)
6583 fprintf (outfile
, " | ");
6590 /* Likewise, for a DIE attribute. */
6593 print_attribute (dw_attr_node
*a
, bool recurse
, FILE *outfile
)
6595 print_dw_val (&a
->dw_attr_val
, recurse
, outfile
);
6599 /* Print the list of operands in the LOC location description to OUTFILE. This
6600 routine is a debugging aid only. */
6603 print_loc_descr (dw_loc_descr_ref loc
, FILE *outfile
)
6605 dw_loc_descr_ref l
= loc
;
6609 print_spaces (outfile
);
6610 fprintf (outfile
, "<null>\n");
6614 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
6616 print_spaces (outfile
);
6617 fprintf (outfile
, "(%p) %s",
6619 dwarf_stack_op_name (l
->dw_loc_opc
));
6620 if (l
->dw_loc_oprnd1
.val_class
!= dw_val_class_none
)
6622 fprintf (outfile
, " ");
6623 print_dw_val (&l
->dw_loc_oprnd1
, false, outfile
);
6625 if (l
->dw_loc_oprnd2
.val_class
!= dw_val_class_none
)
6627 fprintf (outfile
, ", ");
6628 print_dw_val (&l
->dw_loc_oprnd2
, false, outfile
);
6630 fprintf (outfile
, "\n");
6634 /* Print the information associated with a given DIE, and its children.
6635 This routine is a debugging aid only. */
6638 print_die (dw_die_ref die
, FILE *outfile
)
6644 print_spaces (outfile
);
6645 fprintf (outfile
, "DIE %4ld: %s (%p)\n",
6646 die
->die_offset
, dwarf_tag_name (die
->die_tag
),
6648 print_spaces (outfile
);
6649 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
6650 fprintf (outfile
, " offset: %ld", die
->die_offset
);
6651 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
6653 if (die
->comdat_type_p
)
6655 print_spaces (outfile
);
6656 fprintf (outfile
, " signature: ");
6657 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
6658 fprintf (outfile
, "\n");
6661 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6663 print_spaces (outfile
);
6664 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
6666 print_attribute (a
, true, outfile
);
6667 fprintf (outfile
, "\n");
6670 if (die
->die_child
!= NULL
)
6673 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
6676 if (print_indent
== 0)
6677 fprintf (outfile
, "\n");
6680 /* Print the list of operations in the LOC location description. */
6683 debug_dwarf_loc_descr (dw_loc_descr_ref loc
)
6685 print_loc_descr (loc
, stderr
);
6688 /* Print the information collected for a given DIE. */
6691 debug_dwarf_die (dw_die_ref die
)
6693 print_die (die
, stderr
);
6697 debug (die_struct
&ref
)
6699 print_die (&ref
, stderr
);
6703 debug (die_struct
*ptr
)
6708 fprintf (stderr
, "<nil>\n");
6712 /* Print all DWARF information collected for the compilation unit.
6713 This routine is a debugging aid only. */
6719 print_die (comp_unit_die (), stderr
);
6722 /* Verify the DIE tree structure. */
6725 verify_die (dw_die_ref die
)
6727 gcc_assert (!die
->die_mark
);
6728 if (die
->die_parent
== NULL
6729 && die
->die_sib
== NULL
)
6731 /* Verify the die_sib list is cyclic. */
6738 while (x
&& !x
->die_mark
);
6739 gcc_assert (x
== die
);
6743 /* Verify all dies have the same parent. */
6744 gcc_assert (x
->die_parent
== die
->die_parent
);
6747 /* Verify the child has the proper parent and recurse. */
6748 gcc_assert (x
->die_child
->die_parent
== x
);
6749 verify_die (x
->die_child
);
6754 while (x
&& x
->die_mark
);
6757 /* Sanity checks on DIEs. */
6760 check_die (dw_die_ref die
)
6764 bool inline_found
= false;
6765 int n_location
= 0, n_low_pc
= 0, n_high_pc
= 0, n_artificial
= 0;
6766 int n_decl_line
= 0, n_decl_column
= 0, n_decl_file
= 0;
6767 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6772 if (a
->dw_attr_val
.v
.val_unsigned
)
6773 inline_found
= true;
6775 case DW_AT_location
:
6784 case DW_AT_artificial
:
6787 case DW_AT_decl_column
:
6790 case DW_AT_decl_line
:
6793 case DW_AT_decl_file
:
6800 if (n_location
> 1 || n_low_pc
> 1 || n_high_pc
> 1 || n_artificial
> 1
6801 || n_decl_column
> 1 || n_decl_line
> 1 || n_decl_file
> 1)
6803 fprintf (stderr
, "Duplicate attributes in DIE:\n");
6804 debug_dwarf_die (die
);
6809 /* A debugging information entry that is a member of an abstract
6810 instance tree [that has DW_AT_inline] should not contain any
6811 attributes which describe aspects of the subroutine which vary
6812 between distinct inlined expansions or distinct out-of-line
6814 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6815 gcc_assert (a
->dw_attr
!= DW_AT_low_pc
6816 && a
->dw_attr
!= DW_AT_high_pc
6817 && a
->dw_attr
!= DW_AT_location
6818 && a
->dw_attr
!= DW_AT_frame_base
6819 && a
->dw_attr
!= DW_AT_call_all_calls
6820 && a
->dw_attr
!= DW_AT_GNU_all_call_sites
);
6824 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6825 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6826 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
6828 /* Calculate the checksum of a location expression. */
6831 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
6834 inchash::hash hstate
;
6837 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
6839 hash_loc_operands (loc
, hstate
);
6840 hash
= hstate
.end();
6844 /* Calculate the checksum of an attribute. */
6847 attr_checksum (dw_attr_node
*at
, struct md5_ctx
*ctx
, int *mark
)
6849 dw_loc_descr_ref loc
;
6852 CHECKSUM (at
->dw_attr
);
6854 /* We don't care that this was compiled with a different compiler
6855 snapshot; if the output is the same, that's what matters. */
6856 if (at
->dw_attr
== DW_AT_producer
)
6859 switch (AT_class (at
))
6861 case dw_val_class_const
:
6862 case dw_val_class_const_implicit
:
6863 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
6865 case dw_val_class_unsigned_const
:
6866 case dw_val_class_unsigned_const_implicit
:
6867 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
6869 case dw_val_class_const_double
:
6870 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
6872 case dw_val_class_wide_int
:
6873 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
6874 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
6875 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
6877 case dw_val_class_vec
:
6878 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
6879 (at
->dw_attr_val
.v
.val_vec
.length
6880 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
6882 case dw_val_class_flag
:
6883 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
6885 case dw_val_class_str
:
6886 CHECKSUM_STRING (AT_string (at
));
6889 case dw_val_class_addr
:
6891 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
6892 CHECKSUM_STRING (XSTR (r
, 0));
6895 case dw_val_class_offset
:
6896 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
6899 case dw_val_class_loc
:
6900 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
6901 loc_checksum (loc
, ctx
);
6904 case dw_val_class_die_ref
:
6905 die_checksum (AT_ref (at
), ctx
, mark
);
6908 case dw_val_class_fde_ref
:
6909 case dw_val_class_vms_delta
:
6910 case dw_val_class_symview
:
6911 case dw_val_class_lbl_id
:
6912 case dw_val_class_lineptr
:
6913 case dw_val_class_macptr
:
6914 case dw_val_class_loclistsptr
:
6915 case dw_val_class_high_pc
:
6918 case dw_val_class_file
:
6919 case dw_val_class_file_implicit
:
6920 CHECKSUM_STRING (AT_file (at
)->filename
);
6923 case dw_val_class_data8
:
6924 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
6932 /* Calculate the checksum of a DIE. */
6935 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6941 /* To avoid infinite recursion. */
6944 CHECKSUM (die
->die_mark
);
6947 die
->die_mark
= ++(*mark
);
6949 CHECKSUM (die
->die_tag
);
6951 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6952 attr_checksum (a
, ctx
, mark
);
6954 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
6958 #undef CHECKSUM_BLOCK
6959 #undef CHECKSUM_STRING
6961 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
6962 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6963 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6964 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
6965 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
6966 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
6967 #define CHECKSUM_ATTR(FOO) \
6968 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
6970 /* Calculate the checksum of a number in signed LEB128 format. */
6973 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
6980 byte
= (value
& 0x7f);
6982 more
= !((value
== 0 && (byte
& 0x40) == 0)
6983 || (value
== -1 && (byte
& 0x40) != 0));
6992 /* Calculate the checksum of a number in unsigned LEB128 format. */
6995 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
6999 unsigned char byte
= (value
& 0x7f);
7002 /* More bytes to follow. */
7010 /* Checksum the context of the DIE. This adds the names of any
7011 surrounding namespaces or structures to the checksum. */
7014 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
7018 int tag
= die
->die_tag
;
7020 if (tag
!= DW_TAG_namespace
7021 && tag
!= DW_TAG_structure_type
7022 && tag
!= DW_TAG_class_type
)
7025 name
= get_AT_string (die
, DW_AT_name
);
7027 spec
= get_AT_ref (die
, DW_AT_specification
);
7031 if (die
->die_parent
!= NULL
)
7032 checksum_die_context (die
->die_parent
, ctx
);
7034 CHECKSUM_ULEB128 ('C');
7035 CHECKSUM_ULEB128 (tag
);
7037 CHECKSUM_STRING (name
);
7040 /* Calculate the checksum of a location expression. */
7043 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
7045 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
7046 were emitted as a DW_FORM_sdata instead of a location expression. */
7047 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
7049 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7050 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
7054 /* Otherwise, just checksum the raw location expression. */
7057 inchash::hash hstate
;
7060 CHECKSUM_ULEB128 (loc
->dtprel
);
7061 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
7062 hash_loc_operands (loc
, hstate
);
7063 hash
= hstate
.end ();
7065 loc
= loc
->dw_loc_next
;
7069 /* Calculate the checksum of an attribute. */
7072 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_node
*at
,
7073 struct md5_ctx
*ctx
, int *mark
)
7075 dw_loc_descr_ref loc
;
7078 if (AT_class (at
) == dw_val_class_die_ref
)
7080 dw_die_ref target_die
= AT_ref (at
);
7082 /* For pointer and reference types, we checksum only the (qualified)
7083 name of the target type (if there is a name). For friend entries,
7084 we checksum only the (qualified) name of the target type or function.
7085 This allows the checksum to remain the same whether the target type
7086 is complete or not. */
7087 if ((at
->dw_attr
== DW_AT_type
7088 && (tag
== DW_TAG_pointer_type
7089 || tag
== DW_TAG_reference_type
7090 || tag
== DW_TAG_rvalue_reference_type
7091 || tag
== DW_TAG_ptr_to_member_type
))
7092 || (at
->dw_attr
== DW_AT_friend
7093 && tag
== DW_TAG_friend
))
7095 dw_attr_node
*name_attr
= get_AT (target_die
, DW_AT_name
);
7097 if (name_attr
!= NULL
)
7099 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
7103 CHECKSUM_ULEB128 ('N');
7104 CHECKSUM_ULEB128 (at
->dw_attr
);
7105 if (decl
->die_parent
!= NULL
)
7106 checksum_die_context (decl
->die_parent
, ctx
);
7107 CHECKSUM_ULEB128 ('E');
7108 CHECKSUM_STRING (AT_string (name_attr
));
7113 /* For all other references to another DIE, we check to see if the
7114 target DIE has already been visited. If it has, we emit a
7115 backward reference; if not, we descend recursively. */
7116 if (target_die
->die_mark
> 0)
7118 CHECKSUM_ULEB128 ('R');
7119 CHECKSUM_ULEB128 (at
->dw_attr
);
7120 CHECKSUM_ULEB128 (target_die
->die_mark
);
7124 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
7128 target_die
->die_mark
= ++(*mark
);
7129 CHECKSUM_ULEB128 ('T');
7130 CHECKSUM_ULEB128 (at
->dw_attr
);
7131 if (decl
->die_parent
!= NULL
)
7132 checksum_die_context (decl
->die_parent
, ctx
);
7133 die_checksum_ordered (target_die
, ctx
, mark
);
7138 CHECKSUM_ULEB128 ('A');
7139 CHECKSUM_ULEB128 (at
->dw_attr
);
7141 switch (AT_class (at
))
7143 case dw_val_class_const
:
7144 case dw_val_class_const_implicit
:
7145 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7146 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
7149 case dw_val_class_unsigned_const
:
7150 case dw_val_class_unsigned_const_implicit
:
7151 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7152 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
7155 case dw_val_class_const_double
:
7156 CHECKSUM_ULEB128 (DW_FORM_block
);
7157 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
7158 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
7161 case dw_val_class_wide_int
:
7162 CHECKSUM_ULEB128 (DW_FORM_block
);
7163 CHECKSUM_ULEB128 (get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7164 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
7165 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
7166 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7167 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
7170 case dw_val_class_vec
:
7171 CHECKSUM_ULEB128 (DW_FORM_block
);
7172 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_vec
.length
7173 * at
->dw_attr_val
.v
.val_vec
.elt_size
);
7174 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
7175 (at
->dw_attr_val
.v
.val_vec
.length
7176 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
7179 case dw_val_class_flag
:
7180 CHECKSUM_ULEB128 (DW_FORM_flag
);
7181 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
7184 case dw_val_class_str
:
7185 CHECKSUM_ULEB128 (DW_FORM_string
);
7186 CHECKSUM_STRING (AT_string (at
));
7189 case dw_val_class_addr
:
7191 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
7192 CHECKSUM_ULEB128 (DW_FORM_string
);
7193 CHECKSUM_STRING (XSTR (r
, 0));
7196 case dw_val_class_offset
:
7197 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7198 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
7201 case dw_val_class_loc
:
7202 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
7203 loc_checksum_ordered (loc
, ctx
);
7206 case dw_val_class_fde_ref
:
7207 case dw_val_class_symview
:
7208 case dw_val_class_lbl_id
:
7209 case dw_val_class_lineptr
:
7210 case dw_val_class_macptr
:
7211 case dw_val_class_loclistsptr
:
7212 case dw_val_class_high_pc
:
7215 case dw_val_class_file
:
7216 case dw_val_class_file_implicit
:
7217 CHECKSUM_ULEB128 (DW_FORM_string
);
7218 CHECKSUM_STRING (AT_file (at
)->filename
);
7221 case dw_val_class_data8
:
7222 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
7230 struct checksum_attributes
7232 dw_attr_node
*at_name
;
7233 dw_attr_node
*at_type
;
7234 dw_attr_node
*at_friend
;
7235 dw_attr_node
*at_accessibility
;
7236 dw_attr_node
*at_address_class
;
7237 dw_attr_node
*at_alignment
;
7238 dw_attr_node
*at_allocated
;
7239 dw_attr_node
*at_artificial
;
7240 dw_attr_node
*at_associated
;
7241 dw_attr_node
*at_binary_scale
;
7242 dw_attr_node
*at_bit_offset
;
7243 dw_attr_node
*at_bit_size
;
7244 dw_attr_node
*at_bit_stride
;
7245 dw_attr_node
*at_byte_size
;
7246 dw_attr_node
*at_byte_stride
;
7247 dw_attr_node
*at_const_value
;
7248 dw_attr_node
*at_containing_type
;
7249 dw_attr_node
*at_count
;
7250 dw_attr_node
*at_data_location
;
7251 dw_attr_node
*at_data_member_location
;
7252 dw_attr_node
*at_decimal_scale
;
7253 dw_attr_node
*at_decimal_sign
;
7254 dw_attr_node
*at_default_value
;
7255 dw_attr_node
*at_digit_count
;
7256 dw_attr_node
*at_discr
;
7257 dw_attr_node
*at_discr_list
;
7258 dw_attr_node
*at_discr_value
;
7259 dw_attr_node
*at_encoding
;
7260 dw_attr_node
*at_endianity
;
7261 dw_attr_node
*at_explicit
;
7262 dw_attr_node
*at_is_optional
;
7263 dw_attr_node
*at_location
;
7264 dw_attr_node
*at_lower_bound
;
7265 dw_attr_node
*at_mutable
;
7266 dw_attr_node
*at_ordering
;
7267 dw_attr_node
*at_picture_string
;
7268 dw_attr_node
*at_prototyped
;
7269 dw_attr_node
*at_small
;
7270 dw_attr_node
*at_segment
;
7271 dw_attr_node
*at_string_length
;
7272 dw_attr_node
*at_string_length_bit_size
;
7273 dw_attr_node
*at_string_length_byte_size
;
7274 dw_attr_node
*at_threads_scaled
;
7275 dw_attr_node
*at_upper_bound
;
7276 dw_attr_node
*at_use_location
;
7277 dw_attr_node
*at_use_UTF8
;
7278 dw_attr_node
*at_variable_parameter
;
7279 dw_attr_node
*at_virtuality
;
7280 dw_attr_node
*at_visibility
;
7281 dw_attr_node
*at_vtable_elem_location
;
7284 /* Collect the attributes that we will want to use for the checksum. */
7287 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
7292 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7303 attrs
->at_friend
= a
;
7305 case DW_AT_accessibility
:
7306 attrs
->at_accessibility
= a
;
7308 case DW_AT_address_class
:
7309 attrs
->at_address_class
= a
;
7311 case DW_AT_alignment
:
7312 attrs
->at_alignment
= a
;
7314 case DW_AT_allocated
:
7315 attrs
->at_allocated
= a
;
7317 case DW_AT_artificial
:
7318 attrs
->at_artificial
= a
;
7320 case DW_AT_associated
:
7321 attrs
->at_associated
= a
;
7323 case DW_AT_binary_scale
:
7324 attrs
->at_binary_scale
= a
;
7326 case DW_AT_bit_offset
:
7327 attrs
->at_bit_offset
= a
;
7329 case DW_AT_bit_size
:
7330 attrs
->at_bit_size
= a
;
7332 case DW_AT_bit_stride
:
7333 attrs
->at_bit_stride
= a
;
7335 case DW_AT_byte_size
:
7336 attrs
->at_byte_size
= a
;
7338 case DW_AT_byte_stride
:
7339 attrs
->at_byte_stride
= a
;
7341 case DW_AT_const_value
:
7342 attrs
->at_const_value
= a
;
7344 case DW_AT_containing_type
:
7345 attrs
->at_containing_type
= a
;
7348 attrs
->at_count
= a
;
7350 case DW_AT_data_location
:
7351 attrs
->at_data_location
= a
;
7353 case DW_AT_data_member_location
:
7354 attrs
->at_data_member_location
= a
;
7356 case DW_AT_decimal_scale
:
7357 attrs
->at_decimal_scale
= a
;
7359 case DW_AT_decimal_sign
:
7360 attrs
->at_decimal_sign
= a
;
7362 case DW_AT_default_value
:
7363 attrs
->at_default_value
= a
;
7365 case DW_AT_digit_count
:
7366 attrs
->at_digit_count
= a
;
7369 attrs
->at_discr
= a
;
7371 case DW_AT_discr_list
:
7372 attrs
->at_discr_list
= a
;
7374 case DW_AT_discr_value
:
7375 attrs
->at_discr_value
= a
;
7377 case DW_AT_encoding
:
7378 attrs
->at_encoding
= a
;
7380 case DW_AT_endianity
:
7381 attrs
->at_endianity
= a
;
7383 case DW_AT_explicit
:
7384 attrs
->at_explicit
= a
;
7386 case DW_AT_is_optional
:
7387 attrs
->at_is_optional
= a
;
7389 case DW_AT_location
:
7390 attrs
->at_location
= a
;
7392 case DW_AT_lower_bound
:
7393 attrs
->at_lower_bound
= a
;
7396 attrs
->at_mutable
= a
;
7398 case DW_AT_ordering
:
7399 attrs
->at_ordering
= a
;
7401 case DW_AT_picture_string
:
7402 attrs
->at_picture_string
= a
;
7404 case DW_AT_prototyped
:
7405 attrs
->at_prototyped
= a
;
7408 attrs
->at_small
= a
;
7411 attrs
->at_segment
= a
;
7413 case DW_AT_string_length
:
7414 attrs
->at_string_length
= a
;
7416 case DW_AT_string_length_bit_size
:
7417 attrs
->at_string_length_bit_size
= a
;
7419 case DW_AT_string_length_byte_size
:
7420 attrs
->at_string_length_byte_size
= a
;
7422 case DW_AT_threads_scaled
:
7423 attrs
->at_threads_scaled
= a
;
7425 case DW_AT_upper_bound
:
7426 attrs
->at_upper_bound
= a
;
7428 case DW_AT_use_location
:
7429 attrs
->at_use_location
= a
;
7431 case DW_AT_use_UTF8
:
7432 attrs
->at_use_UTF8
= a
;
7434 case DW_AT_variable_parameter
:
7435 attrs
->at_variable_parameter
= a
;
7437 case DW_AT_virtuality
:
7438 attrs
->at_virtuality
= a
;
7440 case DW_AT_visibility
:
7441 attrs
->at_visibility
= a
;
7443 case DW_AT_vtable_elem_location
:
7444 attrs
->at_vtable_elem_location
= a
;
7452 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
7455 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
7459 struct checksum_attributes attrs
;
7461 CHECKSUM_ULEB128 ('D');
7462 CHECKSUM_ULEB128 (die
->die_tag
);
7464 memset (&attrs
, 0, sizeof (attrs
));
7466 decl
= get_AT_ref (die
, DW_AT_specification
);
7468 collect_checksum_attributes (&attrs
, decl
);
7469 collect_checksum_attributes (&attrs
, die
);
7471 CHECKSUM_ATTR (attrs
.at_name
);
7472 CHECKSUM_ATTR (attrs
.at_accessibility
);
7473 CHECKSUM_ATTR (attrs
.at_address_class
);
7474 CHECKSUM_ATTR (attrs
.at_allocated
);
7475 CHECKSUM_ATTR (attrs
.at_artificial
);
7476 CHECKSUM_ATTR (attrs
.at_associated
);
7477 CHECKSUM_ATTR (attrs
.at_binary_scale
);
7478 CHECKSUM_ATTR (attrs
.at_bit_offset
);
7479 CHECKSUM_ATTR (attrs
.at_bit_size
);
7480 CHECKSUM_ATTR (attrs
.at_bit_stride
);
7481 CHECKSUM_ATTR (attrs
.at_byte_size
);
7482 CHECKSUM_ATTR (attrs
.at_byte_stride
);
7483 CHECKSUM_ATTR (attrs
.at_const_value
);
7484 CHECKSUM_ATTR (attrs
.at_containing_type
);
7485 CHECKSUM_ATTR (attrs
.at_count
);
7486 CHECKSUM_ATTR (attrs
.at_data_location
);
7487 CHECKSUM_ATTR (attrs
.at_data_member_location
);
7488 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
7489 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
7490 CHECKSUM_ATTR (attrs
.at_default_value
);
7491 CHECKSUM_ATTR (attrs
.at_digit_count
);
7492 CHECKSUM_ATTR (attrs
.at_discr
);
7493 CHECKSUM_ATTR (attrs
.at_discr_list
);
7494 CHECKSUM_ATTR (attrs
.at_discr_value
);
7495 CHECKSUM_ATTR (attrs
.at_encoding
);
7496 CHECKSUM_ATTR (attrs
.at_endianity
);
7497 CHECKSUM_ATTR (attrs
.at_explicit
);
7498 CHECKSUM_ATTR (attrs
.at_is_optional
);
7499 CHECKSUM_ATTR (attrs
.at_location
);
7500 CHECKSUM_ATTR (attrs
.at_lower_bound
);
7501 CHECKSUM_ATTR (attrs
.at_mutable
);
7502 CHECKSUM_ATTR (attrs
.at_ordering
);
7503 CHECKSUM_ATTR (attrs
.at_picture_string
);
7504 CHECKSUM_ATTR (attrs
.at_prototyped
);
7505 CHECKSUM_ATTR (attrs
.at_small
);
7506 CHECKSUM_ATTR (attrs
.at_segment
);
7507 CHECKSUM_ATTR (attrs
.at_string_length
);
7508 CHECKSUM_ATTR (attrs
.at_string_length_bit_size
);
7509 CHECKSUM_ATTR (attrs
.at_string_length_byte_size
);
7510 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
7511 CHECKSUM_ATTR (attrs
.at_upper_bound
);
7512 CHECKSUM_ATTR (attrs
.at_use_location
);
7513 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
7514 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
7515 CHECKSUM_ATTR (attrs
.at_virtuality
);
7516 CHECKSUM_ATTR (attrs
.at_visibility
);
7517 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
7518 CHECKSUM_ATTR (attrs
.at_type
);
7519 CHECKSUM_ATTR (attrs
.at_friend
);
7520 CHECKSUM_ATTR (attrs
.at_alignment
);
7522 /* Checksum the child DIEs. */
7525 dw_attr_node
*name_attr
;
7528 name_attr
= get_AT (c
, DW_AT_name
);
7529 if (is_template_instantiation (c
))
7531 /* Ignore instantiations of member type and function templates. */
7533 else if (name_attr
!= NULL
7534 && (is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
))
7536 /* Use a shallow checksum for named nested types and member
7538 CHECKSUM_ULEB128 ('S');
7539 CHECKSUM_ULEB128 (c
->die_tag
);
7540 CHECKSUM_STRING (AT_string (name_attr
));
7544 /* Use a deep checksum for other children. */
7545 /* Mark this DIE so it gets processed when unmarking. */
7546 if (c
->die_mark
== 0)
7548 die_checksum_ordered (c
, ctx
, mark
);
7550 } while (c
!= die
->die_child
);
7552 CHECKSUM_ULEB128 (0);
7555 /* Add a type name and tag to a hash. */
7557 die_odr_checksum (int tag
, const char *name
, md5_ctx
*ctx
)
7559 CHECKSUM_ULEB128 (tag
);
7560 CHECKSUM_STRING (name
);
7564 #undef CHECKSUM_STRING
7565 #undef CHECKSUM_ATTR
7566 #undef CHECKSUM_LEB128
7567 #undef CHECKSUM_ULEB128
7569 /* Generate the type signature for DIE. This is computed by generating an
7570 MD5 checksum over the DIE's tag, its relevant attributes, and its
7571 children. Attributes that are references to other DIEs are processed
7572 by recursion, using the MARK field to prevent infinite recursion.
7573 If the DIE is nested inside a namespace or another type, we also
7574 need to include that context in the signature. The lower 64 bits
7575 of the resulting MD5 checksum comprise the signature. */
7578 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
7582 unsigned char checksum
[16];
7587 name
= get_AT_string (die
, DW_AT_name
);
7588 decl
= get_AT_ref (die
, DW_AT_specification
);
7589 parent
= get_die_parent (die
);
7591 /* First, compute a signature for just the type name (and its surrounding
7592 context, if any. This is stored in the type unit DIE for link-time
7593 ODR (one-definition rule) checking. */
7595 if (is_cxx () && name
!= NULL
)
7597 md5_init_ctx (&ctx
);
7599 /* Checksum the names of surrounding namespaces and structures. */
7601 checksum_die_context (parent
, &ctx
);
7603 /* Checksum the current DIE. */
7604 die_odr_checksum (die
->die_tag
, name
, &ctx
);
7605 md5_finish_ctx (&ctx
, checksum
);
7607 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
7610 /* Next, compute the complete type signature. */
7612 md5_init_ctx (&ctx
);
7614 die
->die_mark
= mark
;
7616 /* Checksum the names of surrounding namespaces and structures. */
7618 checksum_die_context (parent
, &ctx
);
7620 /* Checksum the DIE and its children. */
7621 die_checksum_ordered (die
, &ctx
, &mark
);
7622 unmark_all_dies (die
);
7623 md5_finish_ctx (&ctx
, checksum
);
7625 /* Store the signature in the type node and link the type DIE and the
7626 type node together. */
7627 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
7628 DWARF_TYPE_SIGNATURE_SIZE
);
7629 die
->comdat_type_p
= true;
7630 die
->die_id
.die_type_node
= type_node
;
7631 type_node
->type_die
= die
;
7633 /* If the DIE is a specification, link its declaration to the type node
7637 decl
->comdat_type_p
= true;
7638 decl
->die_id
.die_type_node
= type_node
;
7642 /* Do the location expressions look same? */
7644 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
7646 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
7647 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
7648 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
7651 /* Do the values look the same? */
7653 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
7655 dw_loc_descr_ref loc1
, loc2
;
7658 if (v1
->val_class
!= v2
->val_class
)
7661 switch (v1
->val_class
)
7663 case dw_val_class_const
:
7664 case dw_val_class_const_implicit
:
7665 return v1
->v
.val_int
== v2
->v
.val_int
;
7666 case dw_val_class_unsigned_const
:
7667 case dw_val_class_unsigned_const_implicit
:
7668 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
7669 case dw_val_class_const_double
:
7670 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
7671 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
7672 case dw_val_class_wide_int
:
7673 return *v1
->v
.val_wide
== *v2
->v
.val_wide
;
7674 case dw_val_class_vec
:
7675 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
7676 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
7678 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
7679 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
7682 case dw_val_class_flag
:
7683 return v1
->v
.val_flag
== v2
->v
.val_flag
;
7684 case dw_val_class_str
:
7685 return !strcmp (v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
7687 case dw_val_class_addr
:
7688 r1
= v1
->v
.val_addr
;
7689 r2
= v2
->v
.val_addr
;
7690 if (GET_CODE (r1
) != GET_CODE (r2
))
7692 return !rtx_equal_p (r1
, r2
);
7694 case dw_val_class_offset
:
7695 return v1
->v
.val_offset
== v2
->v
.val_offset
;
7697 case dw_val_class_loc
:
7698 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
7700 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
7701 if (!same_loc_p (loc1
, loc2
, mark
))
7703 return !loc1
&& !loc2
;
7705 case dw_val_class_die_ref
:
7706 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
7708 case dw_val_class_symview
:
7709 return strcmp (v1
->v
.val_symbolic_view
, v2
->v
.val_symbolic_view
) == 0;
7711 case dw_val_class_fde_ref
:
7712 case dw_val_class_vms_delta
:
7713 case dw_val_class_lbl_id
:
7714 case dw_val_class_lineptr
:
7715 case dw_val_class_macptr
:
7716 case dw_val_class_loclistsptr
:
7717 case dw_val_class_high_pc
:
7720 case dw_val_class_file
:
7721 case dw_val_class_file_implicit
:
7722 return v1
->v
.val_file
== v2
->v
.val_file
;
7724 case dw_val_class_data8
:
7725 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
7732 /* Do the attributes look the same? */
7735 same_attr_p (dw_attr_node
*at1
, dw_attr_node
*at2
, int *mark
)
7737 if (at1
->dw_attr
!= at2
->dw_attr
)
7740 /* We don't care that this was compiled with a different compiler
7741 snapshot; if the output is the same, that's what matters. */
7742 if (at1
->dw_attr
== DW_AT_producer
)
7745 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
7748 /* Do the dies look the same? */
7751 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
7757 /* To avoid infinite recursion. */
7759 return die1
->die_mark
== die2
->die_mark
;
7760 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
7762 if (die1
->die_tag
!= die2
->die_tag
)
7765 if (vec_safe_length (die1
->die_attr
) != vec_safe_length (die2
->die_attr
))
7768 FOR_EACH_VEC_SAFE_ELT (die1
->die_attr
, ix
, a1
)
7769 if (!same_attr_p (a1
, &(*die2
->die_attr
)[ix
], mark
))
7772 c1
= die1
->die_child
;
7773 c2
= die2
->die_child
;
7782 if (!same_die_p (c1
, c2
, mark
))
7786 if (c1
== die1
->die_child
)
7788 if (c2
== die2
->die_child
)
7798 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7799 children, and set die_symbol. */
7802 compute_comp_unit_symbol (dw_die_ref unit_die
)
7804 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
7805 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
7806 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
7809 unsigned char checksum
[16];
7812 /* Compute the checksum of the DIE, then append part of it as hex digits to
7813 the name filename of the unit. */
7815 md5_init_ctx (&ctx
);
7817 die_checksum (unit_die
, &ctx
, &mark
);
7818 unmark_all_dies (unit_die
);
7819 md5_finish_ctx (&ctx
, checksum
);
7821 /* When we this for comp_unit_die () we have a DW_AT_name that might
7822 not start with a letter but with anything valid for filenames and
7823 clean_symbol_name doesn't fix that up. Prepend 'g' if the first
7824 character is not a letter. */
7825 sprintf (name
, "%s%s.", ISALPHA (*base
) ? "" : "g", base
);
7826 clean_symbol_name (name
);
7828 p
= name
+ strlen (name
);
7829 for (i
= 0; i
< 4; i
++)
7831 sprintf (p
, "%.2x", checksum
[i
]);
7835 unit_die
->die_id
.die_symbol
= xstrdup (name
);
7838 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7841 is_type_die (dw_die_ref die
)
7843 switch (die
->die_tag
)
7845 case DW_TAG_array_type
:
7846 case DW_TAG_class_type
:
7847 case DW_TAG_interface_type
:
7848 case DW_TAG_enumeration_type
:
7849 case DW_TAG_pointer_type
:
7850 case DW_TAG_reference_type
:
7851 case DW_TAG_rvalue_reference_type
:
7852 case DW_TAG_string_type
:
7853 case DW_TAG_structure_type
:
7854 case DW_TAG_subroutine_type
:
7855 case DW_TAG_union_type
:
7856 case DW_TAG_ptr_to_member_type
:
7857 case DW_TAG_set_type
:
7858 case DW_TAG_subrange_type
:
7859 case DW_TAG_base_type
:
7860 case DW_TAG_const_type
:
7861 case DW_TAG_file_type
:
7862 case DW_TAG_packed_type
:
7863 case DW_TAG_volatile_type
:
7864 case DW_TAG_typedef
:
7871 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
7872 Basically, we want to choose the bits that are likely to be shared between
7873 compilations (types) and leave out the bits that are specific to individual
7874 compilations (functions). */
7877 is_comdat_die (dw_die_ref c
)
7879 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
7880 we do for stabs. The advantage is a greater likelihood of sharing between
7881 objects that don't include headers in the same order (and therefore would
7882 put the base types in a different comdat). jason 8/28/00 */
7884 if (c
->die_tag
== DW_TAG_base_type
)
7887 if (c
->die_tag
== DW_TAG_pointer_type
7888 || c
->die_tag
== DW_TAG_reference_type
7889 || c
->die_tag
== DW_TAG_rvalue_reference_type
7890 || c
->die_tag
== DW_TAG_const_type
7891 || c
->die_tag
== DW_TAG_volatile_type
)
7893 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
7895 return t
? is_comdat_die (t
) : 0;
7898 return is_type_die (c
);
7901 /* Returns true iff C is a compile-unit DIE. */
7904 is_cu_die (dw_die_ref c
)
7906 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7907 || c
->die_tag
== DW_TAG_skeleton_unit
);
7910 /* Returns true iff C is a unit DIE of some sort. */
7913 is_unit_die (dw_die_ref c
)
7915 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7916 || c
->die_tag
== DW_TAG_partial_unit
7917 || c
->die_tag
== DW_TAG_type_unit
7918 || c
->die_tag
== DW_TAG_skeleton_unit
);
7921 /* Returns true iff C is a namespace DIE. */
7924 is_namespace_die (dw_die_ref c
)
7926 return c
&& c
->die_tag
== DW_TAG_namespace
;
7929 /* Returns true iff C is a class or structure DIE. */
7932 is_class_die (dw_die_ref c
)
7934 return c
&& (c
->die_tag
== DW_TAG_class_type
7935 || c
->die_tag
== DW_TAG_structure_type
);
7938 /* Return non-zero if this DIE is a template parameter. */
7941 is_template_parameter (dw_die_ref die
)
7943 switch (die
->die_tag
)
7945 case DW_TAG_template_type_param
:
7946 case DW_TAG_template_value_param
:
7947 case DW_TAG_GNU_template_template_param
:
7948 case DW_TAG_GNU_template_parameter_pack
:
7955 /* Return non-zero if this DIE represents a template instantiation. */
7958 is_template_instantiation (dw_die_ref die
)
7962 if (!is_type_die (die
) && die
->die_tag
!= DW_TAG_subprogram
)
7964 FOR_EACH_CHILD (die
, c
, if (is_template_parameter (c
)) return true);
7969 gen_internal_sym (const char *prefix
)
7971 char buf
[MAX_ARTIFICIAL_LABEL_BYTES
];
7973 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
7974 return xstrdup (buf
);
7977 /* Return non-zero if this DIE is a declaration. */
7980 is_declaration_die (dw_die_ref die
)
7985 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7986 if (a
->dw_attr
== DW_AT_declaration
)
7992 /* Return non-zero if this DIE is nested inside a subprogram. */
7995 is_nested_in_subprogram (dw_die_ref die
)
7997 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
8001 return local_scope_p (decl
);
8004 /* Return non-zero if this DIE contains a defining declaration of a
8008 contains_subprogram_definition (dw_die_ref die
)
8012 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
8014 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
8018 /* Return non-zero if this is a type DIE that should be moved to a
8019 COMDAT .debug_types section or .debug_info section with DW_UT_*type
8023 should_move_die_to_comdat (dw_die_ref die
)
8025 switch (die
->die_tag
)
8027 case DW_TAG_class_type
:
8028 case DW_TAG_structure_type
:
8029 case DW_TAG_enumeration_type
:
8030 case DW_TAG_union_type
:
8031 /* Don't move declarations, inlined instances, types nested in a
8032 subprogram, or types that contain subprogram definitions. */
8033 if (is_declaration_die (die
)
8034 || get_AT (die
, DW_AT_abstract_origin
)
8035 || is_nested_in_subprogram (die
)
8036 || contains_subprogram_definition (die
))
8039 case DW_TAG_array_type
:
8040 case DW_TAG_interface_type
:
8041 case DW_TAG_pointer_type
:
8042 case DW_TAG_reference_type
:
8043 case DW_TAG_rvalue_reference_type
:
8044 case DW_TAG_string_type
:
8045 case DW_TAG_subroutine_type
:
8046 case DW_TAG_ptr_to_member_type
:
8047 case DW_TAG_set_type
:
8048 case DW_TAG_subrange_type
:
8049 case DW_TAG_base_type
:
8050 case DW_TAG_const_type
:
8051 case DW_TAG_file_type
:
8052 case DW_TAG_packed_type
:
8053 case DW_TAG_volatile_type
:
8054 case DW_TAG_typedef
:
8060 /* Make a clone of DIE. */
8063 clone_die (dw_die_ref die
)
8065 dw_die_ref clone
= new_die_raw (die
->die_tag
);
8069 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8070 add_dwarf_attr (clone
, a
);
8075 /* Make a clone of the tree rooted at DIE. */
8078 clone_tree (dw_die_ref die
)
8081 dw_die_ref clone
= clone_die (die
);
8083 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
8088 /* Make a clone of DIE as a declaration. */
8091 clone_as_declaration (dw_die_ref die
)
8098 /* If the DIE is already a declaration, just clone it. */
8099 if (is_declaration_die (die
))
8100 return clone_die (die
);
8102 /* If the DIE is a specification, just clone its declaration DIE. */
8103 decl
= get_AT_ref (die
, DW_AT_specification
);
8106 clone
= clone_die (decl
);
8107 if (die
->comdat_type_p
)
8108 add_AT_die_ref (clone
, DW_AT_signature
, die
);
8112 clone
= new_die_raw (die
->die_tag
);
8114 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8116 /* We don't want to copy over all attributes.
8117 For example we don't want DW_AT_byte_size because otherwise we will no
8118 longer have a declaration and GDB will treat it as a definition. */
8122 case DW_AT_abstract_origin
:
8123 case DW_AT_artificial
:
8124 case DW_AT_containing_type
:
8125 case DW_AT_external
:
8128 case DW_AT_virtuality
:
8129 case DW_AT_linkage_name
:
8130 case DW_AT_MIPS_linkage_name
:
8131 add_dwarf_attr (clone
, a
);
8133 case DW_AT_byte_size
:
8134 case DW_AT_alignment
:
8140 if (die
->comdat_type_p
)
8141 add_AT_die_ref (clone
, DW_AT_signature
, die
);
8143 add_AT_flag (clone
, DW_AT_declaration
, 1);
8148 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
8150 struct decl_table_entry
8156 /* Helpers to manipulate hash table of copied declarations. */
8158 /* Hashtable helpers. */
8160 struct decl_table_entry_hasher
: free_ptr_hash
<decl_table_entry
>
8162 typedef die_struct
*compare_type
;
8163 static inline hashval_t
hash (const decl_table_entry
*);
8164 static inline bool equal (const decl_table_entry
*, const die_struct
*);
8168 decl_table_entry_hasher::hash (const decl_table_entry
*entry
)
8170 return htab_hash_pointer (entry
->orig
);
8174 decl_table_entry_hasher::equal (const decl_table_entry
*entry1
,
8175 const die_struct
*entry2
)
8177 return entry1
->orig
== entry2
;
8180 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
8182 /* Copy DIE and its ancestors, up to, but not including, the compile unit
8183 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
8184 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
8185 to check if the ancestor has already been copied into UNIT. */
8188 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
,
8189 decl_hash_type
*decl_table
)
8191 dw_die_ref parent
= die
->die_parent
;
8192 dw_die_ref new_parent
= unit
;
8194 decl_table_entry
**slot
= NULL
;
8195 struct decl_table_entry
*entry
= NULL
;
8199 /* Check if the entry has already been copied to UNIT. */
8200 slot
= decl_table
->find_slot_with_hash (die
, htab_hash_pointer (die
),
8202 if (*slot
!= HTAB_EMPTY_ENTRY
)
8208 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
8209 entry
= XCNEW (struct decl_table_entry
);
8217 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
8220 if (!is_unit_die (parent
))
8221 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
8224 copy
= clone_as_declaration (die
);
8225 add_child_die (new_parent
, copy
);
8229 /* Record the pointer to the copy. */
8235 /* Copy the declaration context to the new type unit DIE. This includes
8236 any surrounding namespace or type declarations. If the DIE has an
8237 AT_specification attribute, it also includes attributes and children
8238 attached to the specification, and returns a pointer to the original
8239 parent of the declaration DIE. Returns NULL otherwise. */
8242 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
8245 dw_die_ref new_decl
;
8246 dw_die_ref orig_parent
= NULL
;
8248 decl
= get_AT_ref (die
, DW_AT_specification
);
8257 /* The original DIE will be changed to a declaration, and must
8258 be moved to be a child of the original declaration DIE. */
8259 orig_parent
= decl
->die_parent
;
8261 /* Copy the type node pointer from the new DIE to the original
8262 declaration DIE so we can forward references later. */
8263 decl
->comdat_type_p
= true;
8264 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
8266 remove_AT (die
, DW_AT_specification
);
8268 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
8270 if (a
->dw_attr
!= DW_AT_name
8271 && a
->dw_attr
!= DW_AT_declaration
8272 && a
->dw_attr
!= DW_AT_external
)
8273 add_dwarf_attr (die
, a
);
8276 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
8279 if (decl
->die_parent
!= NULL
8280 && !is_unit_die (decl
->die_parent
))
8282 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
8283 if (new_decl
!= NULL
)
8285 remove_AT (new_decl
, DW_AT_signature
);
8286 add_AT_specification (die
, new_decl
);
8293 /* Generate the skeleton ancestor tree for the given NODE, then clone
8294 the DIE and add the clone into the tree. */
8297 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
8299 if (node
->new_die
!= NULL
)
8302 node
->new_die
= clone_as_declaration (node
->old_die
);
8304 if (node
->parent
!= NULL
)
8306 generate_skeleton_ancestor_tree (node
->parent
);
8307 add_child_die (node
->parent
->new_die
, node
->new_die
);
8311 /* Generate a skeleton tree of DIEs containing any declarations that are
8312 found in the original tree. We traverse the tree looking for declaration
8313 DIEs, and construct the skeleton from the bottom up whenever we find one. */
8316 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
8318 skeleton_chain_node node
;
8321 dw_die_ref prev
= NULL
;
8322 dw_die_ref next
= NULL
;
8324 node
.parent
= parent
;
8326 first
= c
= parent
->old_die
->die_child
;
8330 if (prev
== NULL
|| prev
->die_sib
== c
)
8333 next
= (c
== first
? NULL
: c
->die_sib
);
8335 node
.new_die
= NULL
;
8336 if (is_declaration_die (c
))
8338 if (is_template_instantiation (c
))
8340 /* Instantiated templates do not need to be cloned into the
8341 type unit. Just move the DIE and its children back to
8342 the skeleton tree (in the main CU). */
8343 remove_child_with_prev (c
, prev
);
8344 add_child_die (parent
->new_die
, c
);
8347 else if (c
->comdat_type_p
)
8349 /* This is the skeleton of earlier break_out_comdat_types
8350 type. Clone the existing DIE, but keep the children
8351 under the original (which is in the main CU). */
8352 dw_die_ref clone
= clone_die (c
);
8354 replace_child (c
, clone
, prev
);
8355 generate_skeleton_ancestor_tree (parent
);
8356 add_child_die (parent
->new_die
, c
);
8362 /* Clone the existing DIE, move the original to the skeleton
8363 tree (which is in the main CU), and put the clone, with
8364 all the original's children, where the original came from
8365 (which is about to be moved to the type unit). */
8366 dw_die_ref clone
= clone_die (c
);
8367 move_all_children (c
, clone
);
8369 /* If the original has a DW_AT_object_pointer attribute,
8370 it would now point to a child DIE just moved to the
8371 cloned tree, so we need to remove that attribute from
8373 remove_AT (c
, DW_AT_object_pointer
);
8375 replace_child (c
, clone
, prev
);
8376 generate_skeleton_ancestor_tree (parent
);
8377 add_child_die (parent
->new_die
, c
);
8378 node
.old_die
= clone
;
8383 generate_skeleton_bottom_up (&node
);
8384 } while (next
!= NULL
);
8387 /* Wrapper function for generate_skeleton_bottom_up. */
8390 generate_skeleton (dw_die_ref die
)
8392 skeleton_chain_node node
;
8395 node
.new_die
= NULL
;
8398 /* If this type definition is nested inside another type,
8399 and is not an instantiation of a template, always leave
8400 at least a declaration in its place. */
8401 if (die
->die_parent
!= NULL
8402 && is_type_die (die
->die_parent
)
8403 && !is_template_instantiation (die
))
8404 node
.new_die
= clone_as_declaration (die
);
8406 generate_skeleton_bottom_up (&node
);
8407 return node
.new_die
;
8410 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
8411 declaration. The original DIE is moved to a new compile unit so that
8412 existing references to it follow it to the new location. If any of the
8413 original DIE's descendants is a declaration, we need to replace the
8414 original DIE with a skeleton tree and move the declarations back into the
8418 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
8421 dw_die_ref skeleton
, orig_parent
;
8423 /* Copy the declaration context to the type unit DIE. If the returned
8424 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
8426 orig_parent
= copy_declaration_context (unit
, child
);
8428 skeleton
= generate_skeleton (child
);
8429 if (skeleton
== NULL
)
8430 remove_child_with_prev (child
, prev
);
8433 skeleton
->comdat_type_p
= true;
8434 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
8436 /* If the original DIE was a specification, we need to put
8437 the skeleton under the parent DIE of the declaration.
8438 This leaves the original declaration in the tree, but
8439 it will be pruned later since there are no longer any
8440 references to it. */
8441 if (orig_parent
!= NULL
)
8443 remove_child_with_prev (child
, prev
);
8444 add_child_die (orig_parent
, skeleton
);
8447 replace_child (child
, skeleton
, prev
);
8454 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8455 comdat_type_node
*type_node
,
8456 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
);
8458 /* Helper for copy_dwarf_procs_ref_in_dies. Make a copy of the DIE DWARF
8459 procedure, put it under TYPE_NODE and return the copy. Continue looking for
8460 DWARF procedure references in the DW_AT_location attribute. */
8463 copy_dwarf_procedure (dw_die_ref die
,
8464 comdat_type_node
*type_node
,
8465 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8467 gcc_assert (die
->die_tag
== DW_TAG_dwarf_procedure
);
8469 /* DWARF procedures are not supposed to have children... */
8470 gcc_assert (die
->die_child
== NULL
);
8472 /* ... and they are supposed to have only one attribute: DW_AT_location. */
8473 gcc_assert (vec_safe_length (die
->die_attr
) == 1
8474 && ((*die
->die_attr
)[0].dw_attr
== DW_AT_location
));
8476 /* Do not copy more than once DWARF procedures. */
8478 dw_die_ref
&die_copy
= copied_dwarf_procs
.get_or_insert (die
, &existed
);
8482 die_copy
= clone_die (die
);
8483 add_child_die (type_node
->root_die
, die_copy
);
8484 copy_dwarf_procs_ref_in_attrs (die_copy
, type_node
, copied_dwarf_procs
);
8488 /* Helper for copy_dwarf_procs_ref_in_dies. Look for references to DWARF
8489 procedures in DIE's attributes. */
8492 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8493 comdat_type_node
*type_node
,
8494 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8499 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, i
, a
)
8501 dw_loc_descr_ref loc
;
8503 if (a
->dw_attr_val
.val_class
!= dw_val_class_loc
)
8506 for (loc
= a
->dw_attr_val
.v
.val_loc
; loc
!= NULL
; loc
= loc
->dw_loc_next
)
8508 switch (loc
->dw_loc_opc
)
8512 case DW_OP_call_ref
:
8513 gcc_assert (loc
->dw_loc_oprnd1
.val_class
8514 == dw_val_class_die_ref
);
8515 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
8516 = copy_dwarf_procedure (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
,
8518 copied_dwarf_procs
);
8527 /* Copy DWARF procedures that are referenced by the DIE tree to TREE_NODE and
8528 rewrite references to point to the copies.
8530 References are looked for in DIE's attributes and recursively in all its
8531 children attributes that are location descriptions. COPIED_DWARF_PROCS is a
8532 mapping from old DWARF procedures to their copy. It is used not to copy
8533 twice the same DWARF procedure under TYPE_NODE. */
8536 copy_dwarf_procs_ref_in_dies (dw_die_ref die
,
8537 comdat_type_node
*type_node
,
8538 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8542 copy_dwarf_procs_ref_in_attrs (die
, type_node
, copied_dwarf_procs
);
8543 FOR_EACH_CHILD (die
, c
, copy_dwarf_procs_ref_in_dies (c
,
8545 copied_dwarf_procs
));
8548 /* Traverse the DIE and set up additional .debug_types or .debug_info
8549 DW_UT_*type sections for each type worthy of being placed in a COMDAT
8553 break_out_comdat_types (dw_die_ref die
)
8557 dw_die_ref prev
= NULL
;
8558 dw_die_ref next
= NULL
;
8559 dw_die_ref unit
= NULL
;
8561 first
= c
= die
->die_child
;
8565 if (prev
== NULL
|| prev
->die_sib
== c
)
8568 next
= (c
== first
? NULL
: c
->die_sib
);
8569 if (should_move_die_to_comdat (c
))
8571 dw_die_ref replacement
;
8572 comdat_type_node
*type_node
;
8574 /* Break out nested types into their own type units. */
8575 break_out_comdat_types (c
);
8577 /* Create a new type unit DIE as the root for the new tree, and
8578 add it to the list of comdat types. */
8579 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
8580 add_AT_unsigned (unit
, DW_AT_language
,
8581 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
8582 type_node
= ggc_cleared_alloc
<comdat_type_node
> ();
8583 type_node
->root_die
= unit
;
8584 type_node
->next
= comdat_type_list
;
8585 comdat_type_list
= type_node
;
8587 /* Generate the type signature. */
8588 generate_type_signature (c
, type_node
);
8590 /* Copy the declaration context, attributes, and children of the
8591 declaration into the new type unit DIE, then remove this DIE
8592 from the main CU (or replace it with a skeleton if necessary). */
8593 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
8594 type_node
->skeleton_die
= replacement
;
8596 /* Add the DIE to the new compunit. */
8597 add_child_die (unit
, c
);
8599 /* Types can reference DWARF procedures for type size or data location
8600 expressions. Calls in DWARF expressions cannot target procedures
8601 that are not in the same section. So we must copy DWARF procedures
8602 along with this type and then rewrite references to them. */
8603 hash_map
<dw_die_ref
, dw_die_ref
> copied_dwarf_procs
;
8604 copy_dwarf_procs_ref_in_dies (c
, type_node
, copied_dwarf_procs
);
8606 if (replacement
!= NULL
)
8609 else if (c
->die_tag
== DW_TAG_namespace
8610 || c
->die_tag
== DW_TAG_class_type
8611 || c
->die_tag
== DW_TAG_structure_type
8612 || c
->die_tag
== DW_TAG_union_type
)
8614 /* Look for nested types that can be broken out. */
8615 break_out_comdat_types (c
);
8617 } while (next
!= NULL
);
8620 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
8621 Enter all the cloned children into the hash table decl_table. */
8624 clone_tree_partial (dw_die_ref die
, decl_hash_type
*decl_table
)
8628 struct decl_table_entry
*entry
;
8629 decl_table_entry
**slot
;
8631 if (die
->die_tag
== DW_TAG_subprogram
)
8632 clone
= clone_as_declaration (die
);
8634 clone
= clone_die (die
);
8636 slot
= decl_table
->find_slot_with_hash (die
,
8637 htab_hash_pointer (die
), INSERT
);
8639 /* Assert that DIE isn't in the hash table yet. If it would be there
8640 before, the ancestors would be necessarily there as well, therefore
8641 clone_tree_partial wouldn't be called. */
8642 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
8644 entry
= XCNEW (struct decl_table_entry
);
8646 entry
->copy
= clone
;
8649 if (die
->die_tag
!= DW_TAG_subprogram
)
8650 FOR_EACH_CHILD (die
, c
,
8651 add_child_die (clone
, clone_tree_partial (c
, decl_table
)));
8656 /* Walk the DIE and its children, looking for references to incomplete
8657 or trivial types that are unmarked (i.e., that are not in the current
8661 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type
*decl_table
)
8667 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8669 if (AT_class (a
) == dw_val_class_die_ref
)
8671 dw_die_ref targ
= AT_ref (a
);
8672 decl_table_entry
**slot
;
8673 struct decl_table_entry
*entry
;
8675 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
8678 slot
= decl_table
->find_slot_with_hash (targ
,
8679 htab_hash_pointer (targ
),
8682 if (*slot
!= HTAB_EMPTY_ENTRY
)
8684 /* TARG has already been copied, so we just need to
8685 modify the reference to point to the copy. */
8687 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
8691 dw_die_ref parent
= unit
;
8692 dw_die_ref copy
= clone_die (targ
);
8694 /* Record in DECL_TABLE that TARG has been copied.
8695 Need to do this now, before the recursive call,
8696 because DECL_TABLE may be expanded and SLOT
8697 would no longer be a valid pointer. */
8698 entry
= XCNEW (struct decl_table_entry
);
8703 /* If TARG is not a declaration DIE, we need to copy its
8705 if (!is_declaration_die (targ
))
8709 add_child_die (copy
,
8710 clone_tree_partial (c
, decl_table
)));
8713 /* Make sure the cloned tree is marked as part of the
8717 /* If TARG has surrounding context, copy its ancestor tree
8718 into the new type unit. */
8719 if (targ
->die_parent
!= NULL
8720 && !is_unit_die (targ
->die_parent
))
8721 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
8724 add_child_die (parent
, copy
);
8725 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
8727 /* Make sure the newly-copied DIE is walked. If it was
8728 installed in a previously-added context, it won't
8729 get visited otherwise. */
8732 /* Find the highest point of the newly-added tree,
8733 mark each node along the way, and walk from there. */
8734 parent
->die_mark
= 1;
8735 while (parent
->die_parent
8736 && parent
->die_parent
->die_mark
== 0)
8738 parent
= parent
->die_parent
;
8739 parent
->die_mark
= 1;
8741 copy_decls_walk (unit
, parent
, decl_table
);
8747 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
8750 /* Copy declarations for "unworthy" types into the new comdat section.
8751 Incomplete types, modified types, and certain other types aren't broken
8752 out into comdat sections of their own, so they don't have a signature,
8753 and we need to copy the declaration into the same section so that we
8754 don't have an external reference. */
8757 copy_decls_for_unworthy_types (dw_die_ref unit
)
8760 decl_hash_type
decl_table (10);
8761 copy_decls_walk (unit
, unit
, &decl_table
);
8765 /* Traverse the DIE and add a sibling attribute if it may have the
8766 effect of speeding up access to siblings. To save some space,
8767 avoid generating sibling attributes for DIE's without children. */
8770 add_sibling_attributes (dw_die_ref die
)
8774 if (! die
->die_child
)
8777 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
8778 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
8780 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
8783 /* Output all location lists for the DIE and its children. */
8786 output_location_lists (dw_die_ref die
)
8792 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8793 if (AT_class (a
) == dw_val_class_loc_list
)
8794 output_loc_list (AT_loc_list (a
));
8796 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
8799 /* During assign_location_list_indexes and output_loclists_offset the
8800 current index, after it the number of assigned indexes (i.e. how
8801 large the .debug_loclists* offset table should be). */
8802 static unsigned int loc_list_idx
;
8804 /* Output all location list offsets for the DIE and its children. */
8807 output_loclists_offsets (dw_die_ref die
)
8813 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8814 if (AT_class (a
) == dw_val_class_loc_list
)
8816 dw_loc_list_ref l
= AT_loc_list (a
);
8817 if (l
->offset_emitted
)
8819 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l
->ll_symbol
,
8820 loc_section_label
, NULL
);
8821 gcc_assert (l
->hash
== loc_list_idx
);
8823 l
->offset_emitted
= true;
8826 FOR_EACH_CHILD (die
, c
, output_loclists_offsets (c
));
8829 /* Recursively set indexes of location lists. */
8832 assign_location_list_indexes (dw_die_ref die
)
8838 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8839 if (AT_class (a
) == dw_val_class_loc_list
)
8841 dw_loc_list_ref list
= AT_loc_list (a
);
8842 if (!list
->num_assigned
)
8844 list
->num_assigned
= true;
8845 list
->hash
= loc_list_idx
++;
8849 FOR_EACH_CHILD (die
, c
, assign_location_list_indexes (c
));
8852 /* We want to limit the number of external references, because they are
8853 larger than local references: a relocation takes multiple words, and
8854 even a sig8 reference is always eight bytes, whereas a local reference
8855 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
8856 So if we encounter multiple external references to the same type DIE, we
8857 make a local typedef stub for it and redirect all references there.
8859 This is the element of the hash table for keeping track of these
8869 /* Hashtable helpers. */
8871 struct external_ref_hasher
: free_ptr_hash
<external_ref
>
8873 static inline hashval_t
hash (const external_ref
*);
8874 static inline bool equal (const external_ref
*, const external_ref
*);
8878 external_ref_hasher::hash (const external_ref
*r
)
8880 dw_die_ref die
= r
->type
;
8883 /* We can't use the address of the DIE for hashing, because
8884 that will make the order of the stub DIEs non-deterministic. */
8885 if (! die
->comdat_type_p
)
8886 /* We have a symbol; use it to compute a hash. */
8887 h
= htab_hash_string (die
->die_id
.die_symbol
);
8890 /* We have a type signature; use a subset of the bits as the hash.
8891 The 8-byte signature is at least as large as hashval_t. */
8892 comdat_type_node
*type_node
= die
->die_id
.die_type_node
;
8893 memcpy (&h
, type_node
->signature
, sizeof (h
));
8899 external_ref_hasher::equal (const external_ref
*r1
, const external_ref
*r2
)
8901 return r1
->type
== r2
->type
;
8904 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
8906 /* Return a pointer to the external_ref for references to DIE. */
8908 static struct external_ref
*
8909 lookup_external_ref (external_ref_hash_type
*map
, dw_die_ref die
)
8911 struct external_ref ref
, *ref_p
;
8912 external_ref
**slot
;
8915 slot
= map
->find_slot (&ref
, INSERT
);
8916 if (*slot
!= HTAB_EMPTY_ENTRY
)
8919 ref_p
= XCNEW (struct external_ref
);
8925 /* Subroutine of optimize_external_refs, below.
8927 If we see a type skeleton, record it as our stub. If we see external
8928 references, remember how many we've seen. */
8931 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type
*map
)
8936 struct external_ref
*ref_p
;
8938 if (is_type_die (die
)
8939 && (c
= get_AT_ref (die
, DW_AT_signature
)))
8941 /* This is a local skeleton; use it for local references. */
8942 ref_p
= lookup_external_ref (map
, c
);
8946 /* Scan the DIE references, and remember any that refer to DIEs from
8947 other CUs (i.e. those which are not marked). */
8948 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8949 if (AT_class (a
) == dw_val_class_die_ref
8950 && (c
= AT_ref (a
))->die_mark
== 0
8953 ref_p
= lookup_external_ref (map
, c
);
8957 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
8960 /* htab_traverse callback function for optimize_external_refs, below. SLOT
8961 points to an external_ref, DATA is the CU we're processing. If we don't
8962 already have a local stub, and we have multiple refs, build a stub. */
8965 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
8967 struct external_ref
*ref_p
= *slot
;
8969 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
8971 /* We have multiple references to this type, so build a small stub.
8972 Both of these forms are a bit dodgy from the perspective of the
8973 DWARF standard, since technically they should have names. */
8974 dw_die_ref cu
= data
;
8975 dw_die_ref type
= ref_p
->type
;
8976 dw_die_ref stub
= NULL
;
8978 if (type
->comdat_type_p
)
8980 /* If we refer to this type via sig8, use AT_signature. */
8981 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
8982 add_AT_die_ref (stub
, DW_AT_signature
, type
);
8986 /* Otherwise, use a typedef with no name. */
8987 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
8988 add_AT_die_ref (stub
, DW_AT_type
, type
);
8997 /* DIE is a unit; look through all the DIE references to see if there are
8998 any external references to types, and if so, create local stubs for
8999 them which will be applied in build_abbrev_table. This is useful because
9000 references to local DIEs are smaller. */
9002 static external_ref_hash_type
*
9003 optimize_external_refs (dw_die_ref die
)
9005 external_ref_hash_type
*map
= new external_ref_hash_type (10);
9006 optimize_external_refs_1 (die
, map
);
9007 map
->traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
9011 /* The following 3 variables are temporaries that are computed only during the
9012 build_abbrev_table call and used and released during the following
9013 optimize_abbrev_table call. */
9015 /* First abbrev_id that can be optimized based on usage. */
9016 static unsigned int abbrev_opt_start
;
9018 /* Maximum abbrev_id of a base type plus one (we can't optimize DIEs with
9019 abbrev_id smaller than this, because they must be already sized
9020 during build_abbrev_table). */
9021 static unsigned int abbrev_opt_base_type_end
;
9023 /* Vector of usage counts during build_abbrev_table. Indexed by
9024 abbrev_id - abbrev_opt_start. */
9025 static vec
<unsigned int> abbrev_usage_count
;
9027 /* Vector of all DIEs added with die_abbrev >= abbrev_opt_start. */
9028 static vec
<dw_die_ref
> sorted_abbrev_dies
;
9030 /* The format of each DIE (and its attribute value pairs) is encoded in an
9031 abbreviation table. This routine builds the abbreviation table and assigns
9032 a unique abbreviation id for each abbreviation entry. The children of each
9033 die are visited recursively. */
9036 build_abbrev_table (dw_die_ref die
, external_ref_hash_type
*extern_map
)
9038 unsigned int abbrev_id
= 0;
9044 /* Scan the DIE references, and replace any that refer to
9045 DIEs from other CUs (i.e. those which are not marked) with
9046 the local stubs we built in optimize_external_refs. */
9047 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9048 if (AT_class (a
) == dw_val_class_die_ref
9049 && (c
= AT_ref (a
))->die_mark
== 0)
9051 struct external_ref
*ref_p
;
9052 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
9054 ref_p
= lookup_external_ref (extern_map
, c
);
9055 if (ref_p
->stub
&& ref_p
->stub
!= die
)
9056 change_AT_die_ref (a
, ref_p
->stub
);
9058 /* We aren't changing this reference, so mark it external. */
9059 set_AT_ref_external (a
, 1);
9062 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
9064 dw_attr_node
*die_a
, *abbrev_a
;
9070 if (abbrev
->die_tag
!= die
->die_tag
)
9072 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
9075 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
9078 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
9080 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
9081 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
9082 || (value_format (abbrev_a
) != value_format (die_a
)))
9092 if (abbrev_id
>= vec_safe_length (abbrev_die_table
))
9094 vec_safe_push (abbrev_die_table
, die
);
9095 if (abbrev_opt_start
)
9096 abbrev_usage_count
.safe_push (0);
9098 if (abbrev_opt_start
&& abbrev_id
>= abbrev_opt_start
)
9100 abbrev_usage_count
[abbrev_id
- abbrev_opt_start
]++;
9101 sorted_abbrev_dies
.safe_push (die
);
9104 die
->die_abbrev
= abbrev_id
;
9105 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
9108 /* Callback function for sorted_abbrev_dies vector sorting. We sort
9109 by die_abbrev's usage count, from the most commonly used
9110 abbreviation to the least. */
9113 die_abbrev_cmp (const void *p1
, const void *p2
)
9115 dw_die_ref die1
= *(const dw_die_ref
*) p1
;
9116 dw_die_ref die2
= *(const dw_die_ref
*) p2
;
9118 gcc_checking_assert (die1
->die_abbrev
>= abbrev_opt_start
);
9119 gcc_checking_assert (die2
->die_abbrev
>= abbrev_opt_start
);
9121 if (die1
->die_abbrev
>= abbrev_opt_base_type_end
9122 && die2
->die_abbrev
>= abbrev_opt_base_type_end
)
9124 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
9125 > abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
9127 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
9128 < abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
9132 /* Stabilize the sort. */
9133 if (die1
->die_abbrev
< die2
->die_abbrev
)
9135 if (die1
->die_abbrev
> die2
->die_abbrev
)
9141 /* Convert dw_val_class_const and dw_val_class_unsigned_const class attributes
9142 of DIEs in between sorted_abbrev_dies[first_id] and abbrev_dies[end_id - 1]
9143 into dw_val_class_const_implicit or
9144 dw_val_class_unsigned_const_implicit. */
9147 optimize_implicit_const (unsigned int first_id
, unsigned int end
,
9148 vec
<bool> &implicit_consts
)
9150 /* It never makes sense if there is just one DIE using the abbreviation. */
9151 if (end
< first_id
+ 2)
9156 dw_die_ref die
= sorted_abbrev_dies
[first_id
];
9157 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9158 if (implicit_consts
[ix
])
9160 enum dw_val_class new_class
= dw_val_class_none
;
9161 switch (AT_class (a
))
9163 case dw_val_class_unsigned_const
:
9164 if ((HOST_WIDE_INT
) AT_unsigned (a
) < 0)
9167 /* The .debug_abbrev section will grow by
9168 size_of_sleb128 (AT_unsigned (a)) and we avoid the constants
9169 in all the DIEs using that abbreviation. */
9170 if (constant_size (AT_unsigned (a
)) * (end
- first_id
)
9171 <= (unsigned) size_of_sleb128 (AT_unsigned (a
)))
9174 new_class
= dw_val_class_unsigned_const_implicit
;
9177 case dw_val_class_const
:
9178 new_class
= dw_val_class_const_implicit
;
9181 case dw_val_class_file
:
9182 new_class
= dw_val_class_file_implicit
;
9188 for (i
= first_id
; i
< end
; i
++)
9189 (*sorted_abbrev_dies
[i
]->die_attr
)[ix
].dw_attr_val
.val_class
9194 /* Attempt to optimize abbreviation table from abbrev_opt_start
9195 abbreviation above. */
9198 optimize_abbrev_table (void)
9200 if (abbrev_opt_start
9201 && vec_safe_length (abbrev_die_table
) > abbrev_opt_start
9202 && (dwarf_version
>= 5 || vec_safe_length (abbrev_die_table
) > 127))
9204 auto_vec
<bool, 32> implicit_consts
;
9205 sorted_abbrev_dies
.qsort (die_abbrev_cmp
);
9207 unsigned int abbrev_id
= abbrev_opt_start
- 1;
9208 unsigned int first_id
= ~0U;
9209 unsigned int last_abbrev_id
= 0;
9212 if (abbrev_opt_base_type_end
> abbrev_opt_start
)
9213 abbrev_id
= abbrev_opt_base_type_end
- 1;
9214 /* Reassign abbreviation ids from abbrev_opt_start above, so that
9215 most commonly used abbreviations come first. */
9216 FOR_EACH_VEC_ELT (sorted_abbrev_dies
, i
, die
)
9221 /* If calc_base_type_die_sizes has been called, the CU and
9222 base types after it can't be optimized, because we've already
9223 calculated their DIE offsets. We've sorted them first. */
9224 if (die
->die_abbrev
< abbrev_opt_base_type_end
)
9226 if (die
->die_abbrev
!= last_abbrev_id
)
9228 last_abbrev_id
= die
->die_abbrev
;
9229 if (dwarf_version
>= 5 && first_id
!= ~0U)
9230 optimize_implicit_const (first_id
, i
, implicit_consts
);
9232 (*abbrev_die_table
)[abbrev_id
] = die
;
9233 if (dwarf_version
>= 5)
9236 implicit_consts
.truncate (0);
9238 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9239 switch (AT_class (a
))
9241 case dw_val_class_const
:
9242 case dw_val_class_unsigned_const
:
9243 case dw_val_class_file
:
9244 implicit_consts
.safe_push (true);
9247 implicit_consts
.safe_push (false);
9252 else if (dwarf_version
>= 5)
9254 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9255 if (!implicit_consts
[ix
])
9259 dw_attr_node
*other_a
9260 = &(*(*abbrev_die_table
)[abbrev_id
]->die_attr
)[ix
];
9261 if (!dw_val_equal_p (&a
->dw_attr_val
,
9262 &other_a
->dw_attr_val
))
9263 implicit_consts
[ix
] = false;
9266 die
->die_abbrev
= abbrev_id
;
9268 gcc_assert (abbrev_id
== vec_safe_length (abbrev_die_table
) - 1);
9269 if (dwarf_version
>= 5 && first_id
!= ~0U)
9270 optimize_implicit_const (first_id
, i
, implicit_consts
);
9273 abbrev_opt_start
= 0;
9274 abbrev_opt_base_type_end
= 0;
9275 abbrev_usage_count
.release ();
9276 sorted_abbrev_dies
.release ();
9279 /* Return the power-of-two number of bytes necessary to represent VALUE. */
9282 constant_size (unsigned HOST_WIDE_INT value
)
9289 log
= floor_log2 (value
);
9292 log
= 1 << (floor_log2 (log
) + 1);
9297 /* Return the size of a DIE as it is represented in the
9298 .debug_info section. */
9300 static unsigned long
9301 size_of_die (dw_die_ref die
)
9303 unsigned long size
= 0;
9306 enum dwarf_form form
;
9308 size
+= size_of_uleb128 (die
->die_abbrev
);
9309 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9311 switch (AT_class (a
))
9313 case dw_val_class_addr
:
9314 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9316 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9317 size
+= size_of_uleb128 (AT_index (a
));
9320 size
+= DWARF2_ADDR_SIZE
;
9322 case dw_val_class_offset
:
9323 size
+= DWARF_OFFSET_SIZE
;
9325 case dw_val_class_loc
:
9327 unsigned long lsize
= size_of_locs (AT_loc (a
));
9330 if (dwarf_version
>= 4)
9331 size
+= size_of_uleb128 (lsize
);
9333 size
+= constant_size (lsize
);
9337 case dw_val_class_loc_list
:
9338 case dw_val_class_view_list
:
9339 if (dwarf_split_debug_info
&& dwarf_version
>= 5)
9341 gcc_assert (AT_loc_list (a
)->num_assigned
);
9342 size
+= size_of_uleb128 (AT_loc_list (a
)->hash
);
9345 size
+= DWARF_OFFSET_SIZE
;
9347 case dw_val_class_range_list
:
9348 if (value_format (a
) == DW_FORM_rnglistx
)
9350 gcc_assert (rnglist_idx
);
9351 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
9352 size
+= size_of_uleb128 (r
->idx
);
9355 size
+= DWARF_OFFSET_SIZE
;
9357 case dw_val_class_const
:
9358 size
+= size_of_sleb128 (AT_int (a
));
9360 case dw_val_class_unsigned_const
:
9362 int csize
= constant_size (AT_unsigned (a
));
9363 if (dwarf_version
== 3
9364 && a
->dw_attr
== DW_AT_data_member_location
9366 size
+= size_of_uleb128 (AT_unsigned (a
));
9371 case dw_val_class_symview
:
9372 if (symview_upper_bound
<= 0xff)
9374 else if (symview_upper_bound
<= 0xffff)
9376 else if (symview_upper_bound
<= 0xffffffff)
9381 case dw_val_class_const_implicit
:
9382 case dw_val_class_unsigned_const_implicit
:
9383 case dw_val_class_file_implicit
:
9384 /* These occupy no size in the DIE, just an extra sleb128 in
9387 case dw_val_class_const_double
:
9388 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
9389 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
9392 case dw_val_class_wide_int
:
9393 size
+= (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9394 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
9395 if (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9396 * HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
9399 case dw_val_class_vec
:
9400 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
9401 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
9402 + a
->dw_attr_val
.v
.val_vec
.length
9403 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
9405 case dw_val_class_flag
:
9406 if (dwarf_version
>= 4)
9407 /* Currently all add_AT_flag calls pass in 1 as last argument,
9408 so DW_FORM_flag_present can be used. If that ever changes,
9409 we'll need to use DW_FORM_flag and have some optimization
9410 in build_abbrev_table that will change those to
9411 DW_FORM_flag_present if it is set to 1 in all DIEs using
9412 the same abbrev entry. */
9413 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9417 case dw_val_class_die_ref
:
9418 if (AT_ref_external (a
))
9420 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
9421 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
9422 is sized by target address length, whereas in DWARF3
9423 it's always sized as an offset. */
9424 if (use_debug_types
)
9425 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
9426 else if (dwarf_version
== 2)
9427 size
+= DWARF2_ADDR_SIZE
;
9429 size
+= DWARF_OFFSET_SIZE
;
9432 size
+= DWARF_OFFSET_SIZE
;
9434 case dw_val_class_fde_ref
:
9435 size
+= DWARF_OFFSET_SIZE
;
9437 case dw_val_class_lbl_id
:
9438 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9440 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9441 size
+= size_of_uleb128 (AT_index (a
));
9444 size
+= DWARF2_ADDR_SIZE
;
9446 case dw_val_class_lineptr
:
9447 case dw_val_class_macptr
:
9448 case dw_val_class_loclistsptr
:
9449 size
+= DWARF_OFFSET_SIZE
;
9451 case dw_val_class_str
:
9452 form
= AT_string_form (a
);
9453 if (form
== DW_FORM_strp
|| form
== DW_FORM_line_strp
)
9454 size
+= DWARF_OFFSET_SIZE
;
9455 else if (form
== dwarf_FORM (DW_FORM_strx
))
9456 size
+= size_of_uleb128 (AT_index (a
));
9458 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
9460 case dw_val_class_file
:
9461 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
9463 case dw_val_class_data8
:
9466 case dw_val_class_vms_delta
:
9467 size
+= DWARF_OFFSET_SIZE
;
9469 case dw_val_class_high_pc
:
9470 size
+= DWARF2_ADDR_SIZE
;
9472 case dw_val_class_discr_value
:
9473 size
+= size_of_discr_value (&a
->dw_attr_val
.v
.val_discr_value
);
9475 case dw_val_class_discr_list
:
9477 unsigned block_size
= size_of_discr_list (AT_discr_list (a
));
9479 /* This is a block, so we have the block length and then its
9481 size
+= constant_size (block_size
) + block_size
;
9492 /* Size the debugging information associated with a given DIE. Visits the
9493 DIE's children recursively. Updates the global variable next_die_offset, on
9494 each time through. Uses the current value of next_die_offset to update the
9495 die_offset field in each DIE. */
9498 calc_die_sizes (dw_die_ref die
)
9502 gcc_assert (die
->die_offset
== 0
9503 || (unsigned long int) die
->die_offset
== next_die_offset
);
9504 die
->die_offset
= next_die_offset
;
9505 next_die_offset
+= size_of_die (die
);
9507 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
9509 if (die
->die_child
!= NULL
)
9510 /* Count the null byte used to terminate sibling lists. */
9511 next_die_offset
+= 1;
9514 /* Size just the base type children at the start of the CU.
9515 This is needed because build_abbrev needs to size locs
9516 and sizing of type based stack ops needs to know die_offset
9517 values for the base types. */
9520 calc_base_type_die_sizes (void)
9522 unsigned long die_offset
= (dwarf_split_debug_info
9523 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
9524 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
9526 dw_die_ref base_type
;
9527 #if ENABLE_ASSERT_CHECKING
9528 dw_die_ref prev
= comp_unit_die ()->die_child
;
9531 die_offset
+= size_of_die (comp_unit_die ());
9532 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
9534 #if ENABLE_ASSERT_CHECKING
9535 gcc_assert (base_type
->die_offset
== 0
9536 && prev
->die_sib
== base_type
9537 && base_type
->die_child
== NULL
9538 && base_type
->die_abbrev
);
9541 if (abbrev_opt_start
9542 && base_type
->die_abbrev
>= abbrev_opt_base_type_end
)
9543 abbrev_opt_base_type_end
= base_type
->die_abbrev
+ 1;
9544 base_type
->die_offset
= die_offset
;
9545 die_offset
+= size_of_die (base_type
);
9549 /* Set the marks for a die and its children. We do this so
9550 that we know whether or not a reference needs to use FORM_ref_addr; only
9551 DIEs in the same CU will be marked. We used to clear out the offset
9552 and use that as the flag, but ran into ordering problems. */
9555 mark_dies (dw_die_ref die
)
9559 gcc_assert (!die
->die_mark
);
9562 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
9565 /* Clear the marks for a die and its children. */
9568 unmark_dies (dw_die_ref die
)
9572 if (! use_debug_types
)
9573 gcc_assert (die
->die_mark
);
9576 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
9579 /* Clear the marks for a die, its children and referred dies. */
9582 unmark_all_dies (dw_die_ref die
)
9592 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
9594 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9595 if (AT_class (a
) == dw_val_class_die_ref
)
9596 unmark_all_dies (AT_ref (a
));
9599 /* Calculate if the entry should appear in the final output file. It may be
9600 from a pruned a type. */
9603 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
9605 /* By limiting gnu pubnames to definitions only, gold can generate a
9606 gdb index without entries for declarations, which don't include
9607 enough information to be useful. */
9608 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
9611 if (table
== pubname_table
)
9613 /* Enumerator names are part of the pubname table, but the
9614 parent DW_TAG_enumeration_type die may have been pruned.
9615 Don't output them if that is the case. */
9616 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
9617 (p
->die
->die_parent
== NULL
9618 || !p
->die
->die_parent
->die_perennial_p
))
9621 /* Everything else in the pubname table is included. */
9625 /* The pubtypes table shouldn't include types that have been
9627 return (p
->die
->die_offset
!= 0
9628 || !flag_eliminate_unused_debug_types
);
9631 /* Return the size of the .debug_pubnames or .debug_pubtypes table
9632 generated for the compilation unit. */
9634 static unsigned long
9635 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9640 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
9642 size
= DWARF_PUBNAMES_HEADER_SIZE
;
9643 FOR_EACH_VEC_ELT (*names
, i
, p
)
9644 if (include_pubname_in_output (names
, p
))
9645 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1 + space_for_flags
;
9647 size
+= DWARF_OFFSET_SIZE
;
9651 /* Return the size of the information in the .debug_aranges section. */
9653 static unsigned long
9654 size_of_aranges (void)
9658 size
= DWARF_ARANGES_HEADER_SIZE
;
9660 /* Count the address/length pair for this compilation unit. */
9661 if (text_section_used
)
9662 size
+= 2 * DWARF2_ADDR_SIZE
;
9663 if (cold_text_section_used
)
9664 size
+= 2 * DWARF2_ADDR_SIZE
;
9665 if (have_multiple_function_sections
)
9670 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
9672 if (DECL_IGNORED_P (fde
->decl
))
9674 if (!fde
->in_std_section
)
9675 size
+= 2 * DWARF2_ADDR_SIZE
;
9676 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
9677 size
+= 2 * DWARF2_ADDR_SIZE
;
9681 /* Count the two zero words used to terminated the address range table. */
9682 size
+= 2 * DWARF2_ADDR_SIZE
;
9686 /* Select the encoding of an attribute value. */
9688 static enum dwarf_form
9689 value_format (dw_attr_node
*a
)
9691 switch (AT_class (a
))
9693 case dw_val_class_addr
:
9694 /* Only very few attributes allow DW_FORM_addr. */
9699 case DW_AT_entry_pc
:
9700 case DW_AT_trampoline
:
9701 return (AT_index (a
) == NOT_INDEXED
9702 ? DW_FORM_addr
: dwarf_FORM (DW_FORM_addrx
));
9706 switch (DWARF2_ADDR_SIZE
)
9709 return DW_FORM_data1
;
9711 return DW_FORM_data2
;
9713 return DW_FORM_data4
;
9715 return DW_FORM_data8
;
9719 case dw_val_class_loc_list
:
9720 case dw_val_class_view_list
:
9721 if (dwarf_split_debug_info
9722 && dwarf_version
>= 5
9723 && AT_loc_list (a
)->num_assigned
)
9724 return DW_FORM_loclistx
;
9726 case dw_val_class_range_list
:
9727 /* For range lists in DWARF 5, use DW_FORM_rnglistx from .debug_info.dwo
9728 but in .debug_info use DW_FORM_sec_offset, which is shorter if we
9729 care about sizes of .debug* sections in shared libraries and
9730 executables and don't take into account relocations that affect just
9731 relocatable objects - for DW_FORM_rnglistx we'd have to emit offset
9732 table in the .debug_rnglists section. */
9733 if (dwarf_split_debug_info
9734 && dwarf_version
>= 5
9735 && AT_class (a
) == dw_val_class_range_list
9737 && a
->dw_attr_val
.val_entry
!= RELOCATED_OFFSET
)
9738 return DW_FORM_rnglistx
;
9739 if (dwarf_version
>= 4)
9740 return DW_FORM_sec_offset
;
9742 case dw_val_class_vms_delta
:
9743 case dw_val_class_offset
:
9744 switch (DWARF_OFFSET_SIZE
)
9747 return DW_FORM_data4
;
9749 return DW_FORM_data8
;
9753 case dw_val_class_loc
:
9754 if (dwarf_version
>= 4)
9755 return DW_FORM_exprloc
;
9756 switch (constant_size (size_of_locs (AT_loc (a
))))
9759 return DW_FORM_block1
;
9761 return DW_FORM_block2
;
9763 return DW_FORM_block4
;
9767 case dw_val_class_const
:
9768 return DW_FORM_sdata
;
9769 case dw_val_class_unsigned_const
:
9770 switch (constant_size (AT_unsigned (a
)))
9773 return DW_FORM_data1
;
9775 return DW_FORM_data2
;
9777 /* In DWARF3 DW_AT_data_member_location with
9778 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
9779 constant, so we need to use DW_FORM_udata if we need
9780 a large constant. */
9781 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9782 return DW_FORM_udata
;
9783 return DW_FORM_data4
;
9785 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9786 return DW_FORM_udata
;
9787 return DW_FORM_data8
;
9791 case dw_val_class_const_implicit
:
9792 case dw_val_class_unsigned_const_implicit
:
9793 case dw_val_class_file_implicit
:
9794 return DW_FORM_implicit_const
;
9795 case dw_val_class_const_double
:
9796 switch (HOST_BITS_PER_WIDE_INT
)
9799 return DW_FORM_data2
;
9801 return DW_FORM_data4
;
9803 return DW_FORM_data8
;
9805 if (dwarf_version
>= 5)
9806 return DW_FORM_data16
;
9809 return DW_FORM_block1
;
9811 case dw_val_class_wide_int
:
9812 switch (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
)
9815 return DW_FORM_data1
;
9817 return DW_FORM_data2
;
9819 return DW_FORM_data4
;
9821 return DW_FORM_data8
;
9823 if (dwarf_version
>= 5)
9824 return DW_FORM_data16
;
9827 return DW_FORM_block1
;
9829 case dw_val_class_symview
:
9830 /* ??? We might use uleb128, but then we'd have to compute
9831 .debug_info offsets in the assembler. */
9832 if (symview_upper_bound
<= 0xff)
9833 return DW_FORM_data1
;
9834 else if (symview_upper_bound
<= 0xffff)
9835 return DW_FORM_data2
;
9836 else if (symview_upper_bound
<= 0xffffffff)
9837 return DW_FORM_data4
;
9839 return DW_FORM_data8
;
9840 case dw_val_class_vec
:
9841 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
9842 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
9845 return DW_FORM_block1
;
9847 return DW_FORM_block2
;
9849 return DW_FORM_block4
;
9853 case dw_val_class_flag
:
9854 if (dwarf_version
>= 4)
9856 /* Currently all add_AT_flag calls pass in 1 as last argument,
9857 so DW_FORM_flag_present can be used. If that ever changes,
9858 we'll need to use DW_FORM_flag and have some optimization
9859 in build_abbrev_table that will change those to
9860 DW_FORM_flag_present if it is set to 1 in all DIEs using
9861 the same abbrev entry. */
9862 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9863 return DW_FORM_flag_present
;
9865 return DW_FORM_flag
;
9866 case dw_val_class_die_ref
:
9867 if (AT_ref_external (a
))
9868 return use_debug_types
? DW_FORM_ref_sig8
: DW_FORM_ref_addr
;
9871 case dw_val_class_fde_ref
:
9872 return DW_FORM_data
;
9873 case dw_val_class_lbl_id
:
9874 return (AT_index (a
) == NOT_INDEXED
9875 ? DW_FORM_addr
: dwarf_FORM (DW_FORM_addrx
));
9876 case dw_val_class_lineptr
:
9877 case dw_val_class_macptr
:
9878 case dw_val_class_loclistsptr
:
9879 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
9880 case dw_val_class_str
:
9881 return AT_string_form (a
);
9882 case dw_val_class_file
:
9883 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
9886 return DW_FORM_data1
;
9888 return DW_FORM_data2
;
9890 return DW_FORM_data4
;
9895 case dw_val_class_data8
:
9896 return DW_FORM_data8
;
9898 case dw_val_class_high_pc
:
9899 switch (DWARF2_ADDR_SIZE
)
9902 return DW_FORM_data1
;
9904 return DW_FORM_data2
;
9906 return DW_FORM_data4
;
9908 return DW_FORM_data8
;
9913 case dw_val_class_discr_value
:
9914 return (a
->dw_attr_val
.v
.val_discr_value
.pos
9917 case dw_val_class_discr_list
:
9918 switch (constant_size (size_of_discr_list (AT_discr_list (a
))))
9921 return DW_FORM_block1
;
9923 return DW_FORM_block2
;
9925 return DW_FORM_block4
;
9935 /* Output the encoding of an attribute value. */
9938 output_value_format (dw_attr_node
*a
)
9940 enum dwarf_form form
= value_format (a
);
9942 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
9945 /* Given a die and id, produce the appropriate abbreviations. */
9948 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
9951 dw_attr_node
*a_attr
;
9953 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
9954 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
9955 dwarf_tag_name (abbrev
->die_tag
));
9957 if (abbrev
->die_child
!= NULL
)
9958 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
9960 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
9962 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
9964 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
9965 dwarf_attr_name (a_attr
->dw_attr
));
9966 output_value_format (a_attr
);
9967 if (value_format (a_attr
) == DW_FORM_implicit_const
)
9969 if (AT_class (a_attr
) == dw_val_class_file_implicit
)
9971 int f
= maybe_emit_file (a_attr
->dw_attr_val
.v
.val_file
);
9972 const char *filename
= a_attr
->dw_attr_val
.v
.val_file
->filename
;
9973 dw2_asm_output_data_sleb128 (f
, "(%s)", filename
);
9976 dw2_asm_output_data_sleb128 (a_attr
->dw_attr_val
.v
.val_int
, NULL
);
9980 dw2_asm_output_data (1, 0, NULL
);
9981 dw2_asm_output_data (1, 0, NULL
);
9985 /* Output the .debug_abbrev section which defines the DIE abbreviation
9989 output_abbrev_section (void)
9991 unsigned int abbrev_id
;
9994 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
9996 output_die_abbrevs (abbrev_id
, abbrev
);
9998 /* Terminate the table. */
9999 dw2_asm_output_data (1, 0, NULL
);
10002 /* Return a new location list, given the begin and end range, and the
10005 static inline dw_loc_list_ref
10006 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, var_loc_view vbegin
,
10007 const char *end
, var_loc_view vend
,
10008 const char *section
)
10010 dw_loc_list_ref retlist
= ggc_cleared_alloc
<dw_loc_list_node
> ();
10012 retlist
->begin
= begin
;
10013 retlist
->begin_entry
= NULL
;
10014 retlist
->end
= end
;
10015 retlist
->expr
= expr
;
10016 retlist
->section
= section
;
10017 retlist
->vbegin
= vbegin
;
10018 retlist
->vend
= vend
;
10023 /* Return true iff there's any nonzero view number in the loc list.
10025 ??? When views are not enabled, we'll often extend a single range
10026 to the entire function, so that we emit a single location
10027 expression rather than a location list. With views, even with a
10028 single range, we'll output a list if start or end have a nonzero
10029 view. If we change this, we may want to stop splitting a single
10030 range in dw_loc_list just because of a nonzero view, even if it
10031 straddles across hot/cold partitions. */
10034 loc_list_has_views (dw_loc_list_ref list
)
10036 if (!debug_variable_location_views
)
10039 for (dw_loc_list_ref loc
= list
;
10040 loc
!= NULL
; loc
= loc
->dw_loc_next
)
10041 if (!ZERO_VIEW_P (loc
->vbegin
) || !ZERO_VIEW_P (loc
->vend
))
10047 /* Generate a new internal symbol for this location list node, if it
10048 hasn't got one yet. */
10051 gen_llsym (dw_loc_list_ref list
)
10053 gcc_assert (!list
->ll_symbol
);
10054 list
->ll_symbol
= gen_internal_sym ("LLST");
10056 if (!loc_list_has_views (list
))
10059 if (dwarf2out_locviews_in_attribute ())
10061 /* Use the same label_num for the view list. */
10063 list
->vl_symbol
= gen_internal_sym ("LVUS");
10066 list
->vl_symbol
= list
->ll_symbol
;
10069 /* Generate a symbol for the list, but only if we really want to emit
10073 maybe_gen_llsym (dw_loc_list_ref list
)
10075 if (!list
|| (!list
->dw_loc_next
&& !loc_list_has_views (list
)))
10081 /* Determine whether or not to skip loc_list entry CURR. If SIZEP is
10082 NULL, don't consider size of the location expression. If we're not
10083 to skip it, and SIZEP is non-null, store the size of CURR->expr's
10084 representation in *SIZEP. */
10087 skip_loc_list_entry (dw_loc_list_ref curr
, unsigned long *sizep
= NULL
)
10089 /* Don't output an entry that starts and ends at the same address. */
10090 if (strcmp (curr
->begin
, curr
->end
) == 0
10091 && curr
->vbegin
== curr
->vend
&& !curr
->force
)
10097 unsigned long size
= size_of_locs (curr
->expr
);
10099 /* If the expression is too large, drop it on the floor. We could
10100 perhaps put it into DW_TAG_dwarf_procedure and refer to that
10101 in the expression, but >= 64KB expressions for a single value
10102 in a single range are unlikely very useful. */
10103 if (dwarf_version
< 5 && size
> 0xffff)
10111 /* Output a view pair loclist entry for CURR, if it requires one. */
10114 dwarf2out_maybe_output_loclist_view_pair (dw_loc_list_ref curr
)
10116 if (!dwarf2out_locviews_in_loclist ())
10119 if (ZERO_VIEW_P (curr
->vbegin
) && ZERO_VIEW_P (curr
->vend
))
10122 #ifdef DW_LLE_view_pair
10123 dw2_asm_output_data (1, DW_LLE_view_pair
, "DW_LLE_view_pair");
10125 if (dwarf2out_as_locview_support
)
10127 if (ZERO_VIEW_P (curr
->vbegin
))
10128 dw2_asm_output_data_uleb128 (0, "Location view begin");
10131 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10132 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vbegin
);
10133 dw2_asm_output_symname_uleb128 (label
, "Location view begin");
10136 if (ZERO_VIEW_P (curr
->vend
))
10137 dw2_asm_output_data_uleb128 (0, "Location view end");
10140 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10141 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vend
);
10142 dw2_asm_output_symname_uleb128 (label
, "Location view end");
10147 dw2_asm_output_data_uleb128 (curr
->vbegin
, "Location view begin");
10148 dw2_asm_output_data_uleb128 (curr
->vend
, "Location view end");
10150 #endif /* DW_LLE_view_pair */
10155 /* Output the location list given to us. */
10158 output_loc_list (dw_loc_list_ref list_head
)
10160 int vcount
= 0, lcount
= 0;
10162 if (list_head
->emitted
)
10164 list_head
->emitted
= true;
10166 if (list_head
->vl_symbol
&& dwarf2out_locviews_in_attribute ())
10168 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->vl_symbol
);
10170 for (dw_loc_list_ref curr
= list_head
; curr
!= NULL
;
10171 curr
= curr
->dw_loc_next
)
10173 unsigned long size
;
10175 if (skip_loc_list_entry (curr
, &size
))
10180 /* ?? dwarf_split_debug_info? */
10181 if (dwarf2out_as_locview_support
)
10183 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10185 if (!ZERO_VIEW_P (curr
->vbegin
))
10187 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vbegin
);
10188 dw2_asm_output_symname_uleb128 (label
,
10189 "View list begin (%s)",
10190 list_head
->vl_symbol
);
10193 dw2_asm_output_data_uleb128 (0,
10194 "View list begin (%s)",
10195 list_head
->vl_symbol
);
10197 if (!ZERO_VIEW_P (curr
->vend
))
10199 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vend
);
10200 dw2_asm_output_symname_uleb128 (label
,
10201 "View list end (%s)",
10202 list_head
->vl_symbol
);
10205 dw2_asm_output_data_uleb128 (0,
10206 "View list end (%s)",
10207 list_head
->vl_symbol
);
10211 dw2_asm_output_data_uleb128 (curr
->vbegin
,
10212 "View list begin (%s)",
10213 list_head
->vl_symbol
);
10214 dw2_asm_output_data_uleb128 (curr
->vend
,
10215 "View list end (%s)",
10216 list_head
->vl_symbol
);
10221 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
10223 const char *last_section
= NULL
;
10224 const char *base_label
= NULL
;
10226 /* Walk the location list, and output each range + expression. */
10227 for (dw_loc_list_ref curr
= list_head
; curr
!= NULL
;
10228 curr
= curr
->dw_loc_next
)
10230 unsigned long size
;
10232 /* Skip this entry? If we skip it here, we must skip it in the
10233 view list above as well. */
10234 if (skip_loc_list_entry (curr
, &size
))
10239 if (dwarf_version
>= 5)
10241 if (dwarf_split_debug_info
)
10243 dwarf2out_maybe_output_loclist_view_pair (curr
);
10244 /* For -gsplit-dwarf, emit DW_LLE_starx_length, which has
10245 uleb128 index into .debug_addr and uleb128 length. */
10246 dw2_asm_output_data (1, DW_LLE_startx_length
,
10247 "DW_LLE_startx_length (%s)",
10248 list_head
->ll_symbol
);
10249 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10250 "Location list range start index "
10251 "(%s)", curr
->begin
);
10252 /* FIXME: This will ICE ifndef HAVE_AS_LEB128.
10253 For that case we probably need to emit DW_LLE_startx_endx,
10254 but we'd need 2 .debug_addr entries rather than just one. */
10255 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
10256 "Location list length (%s)",
10257 list_head
->ll_symbol
);
10259 else if (!have_multiple_function_sections
&& HAVE_AS_LEB128
)
10261 dwarf2out_maybe_output_loclist_view_pair (curr
);
10262 /* If all code is in .text section, the base address is
10263 already provided by the CU attributes. Use
10264 DW_LLE_offset_pair where both addresses are uleb128 encoded
10265 offsets against that base. */
10266 dw2_asm_output_data (1, DW_LLE_offset_pair
,
10267 "DW_LLE_offset_pair (%s)",
10268 list_head
->ll_symbol
);
10269 dw2_asm_output_delta_uleb128 (curr
->begin
, curr
->section
,
10270 "Location list begin address (%s)",
10271 list_head
->ll_symbol
);
10272 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->section
,
10273 "Location list end address (%s)",
10274 list_head
->ll_symbol
);
10276 else if (HAVE_AS_LEB128
)
10278 /* Otherwise, find out how many consecutive entries could share
10279 the same base entry. If just one, emit DW_LLE_start_length,
10280 otherwise emit DW_LLE_base_address for the base address
10281 followed by a series of DW_LLE_offset_pair. */
10282 if (last_section
== NULL
|| curr
->section
!= last_section
)
10284 dw_loc_list_ref curr2
;
10285 for (curr2
= curr
->dw_loc_next
; curr2
!= NULL
;
10286 curr2
= curr2
->dw_loc_next
)
10288 if (strcmp (curr2
->begin
, curr2
->end
) == 0
10293 if (curr2
== NULL
|| curr
->section
!= curr2
->section
)
10294 last_section
= NULL
;
10297 last_section
= curr
->section
;
10298 base_label
= curr
->begin
;
10299 dw2_asm_output_data (1, DW_LLE_base_address
,
10300 "DW_LLE_base_address (%s)",
10301 list_head
->ll_symbol
);
10302 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, base_label
,
10303 "Base address (%s)",
10304 list_head
->ll_symbol
);
10307 /* Only one entry with the same base address. Use
10308 DW_LLE_start_length with absolute address and uleb128
10310 if (last_section
== NULL
)
10312 dwarf2out_maybe_output_loclist_view_pair (curr
);
10313 dw2_asm_output_data (1, DW_LLE_start_length
,
10314 "DW_LLE_start_length (%s)",
10315 list_head
->ll_symbol
);
10316 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10317 "Location list begin address (%s)",
10318 list_head
->ll_symbol
);
10319 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
10320 "Location list length "
10321 "(%s)", list_head
->ll_symbol
);
10323 /* Otherwise emit DW_LLE_offset_pair, relative to above emitted
10324 DW_LLE_base_address. */
10327 dwarf2out_maybe_output_loclist_view_pair (curr
);
10328 dw2_asm_output_data (1, DW_LLE_offset_pair
,
10329 "DW_LLE_offset_pair (%s)",
10330 list_head
->ll_symbol
);
10331 dw2_asm_output_delta_uleb128 (curr
->begin
, base_label
,
10332 "Location list begin address "
10333 "(%s)", list_head
->ll_symbol
);
10334 dw2_asm_output_delta_uleb128 (curr
->end
, base_label
,
10335 "Location list end address "
10336 "(%s)", list_head
->ll_symbol
);
10339 /* The assembler does not support .uleb128 directive. Emit
10340 DW_LLE_start_end with a pair of absolute addresses. */
10343 dwarf2out_maybe_output_loclist_view_pair (curr
);
10344 dw2_asm_output_data (1, DW_LLE_start_end
,
10345 "DW_LLE_start_end (%s)",
10346 list_head
->ll_symbol
);
10347 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10348 "Location list begin address (%s)",
10349 list_head
->ll_symbol
);
10350 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10351 "Location list end address (%s)",
10352 list_head
->ll_symbol
);
10355 else if (dwarf_split_debug_info
)
10357 /* For -gsplit-dwarf -gdwarf-{2,3,4} emit index into .debug_addr
10358 and 4 byte length. */
10359 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
10360 "Location list start/length entry (%s)",
10361 list_head
->ll_symbol
);
10362 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10363 "Location list range start index (%s)",
10365 /* The length field is 4 bytes. If we ever need to support
10366 an 8-byte length, we can add a new DW_LLE code or fall back
10367 to DW_LLE_GNU_start_end_entry. */
10368 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
10369 "Location list range length (%s)",
10370 list_head
->ll_symbol
);
10372 else if (!have_multiple_function_sections
)
10374 /* Pair of relative addresses against start of text section. */
10375 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
10376 "Location list begin address (%s)",
10377 list_head
->ll_symbol
);
10378 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
10379 "Location list end address (%s)",
10380 list_head
->ll_symbol
);
10384 /* Pair of absolute addresses. */
10385 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10386 "Location list begin address (%s)",
10387 list_head
->ll_symbol
);
10388 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10389 "Location list end address (%s)",
10390 list_head
->ll_symbol
);
10393 /* Output the block length for this list of location operations. */
10394 if (dwarf_version
>= 5)
10395 dw2_asm_output_data_uleb128 (size
, "Location expression size");
10398 gcc_assert (size
<= 0xffff);
10399 dw2_asm_output_data (2, size
, "Location expression size");
10402 output_loc_sequence (curr
->expr
, -1);
10405 /* And finally list termination. */
10406 if (dwarf_version
>= 5)
10407 dw2_asm_output_data (1, DW_LLE_end_of_list
,
10408 "DW_LLE_end_of_list (%s)", list_head
->ll_symbol
);
10409 else if (dwarf_split_debug_info
)
10410 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
10411 "Location list terminator (%s)",
10412 list_head
->ll_symbol
);
10415 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10416 "Location list terminator begin (%s)",
10417 list_head
->ll_symbol
);
10418 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10419 "Location list terminator end (%s)",
10420 list_head
->ll_symbol
);
10423 gcc_assert (!list_head
->vl_symbol
10424 || vcount
== lcount
* (dwarf2out_locviews_in_attribute () ? 1 : 0));
10427 /* Output a range_list offset into the .debug_ranges or .debug_rnglists
10428 section. Emit a relocated reference if val_entry is NULL, otherwise,
10429 emit an indirect reference. */
10432 output_range_list_offset (dw_attr_node
*a
)
10434 const char *name
= dwarf_attr_name (a
->dw_attr
);
10436 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
10438 if (dwarf_version
>= 5)
10440 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
10441 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, r
->label
,
10442 debug_ranges_section
, "%s", name
);
10446 char *p
= strchr (ranges_section_label
, '\0');
10447 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
10448 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
);
10449 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
10450 debug_ranges_section
, "%s", name
);
10454 else if (dwarf_version
>= 5)
10456 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
10457 gcc_assert (rnglist_idx
);
10458 dw2_asm_output_data_uleb128 (r
->idx
, "%s", name
);
10461 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
10462 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
,
10463 "%s (offset from %s)", name
, ranges_section_label
);
10466 /* Output the offset into the debug_loc section. */
10469 output_loc_list_offset (dw_attr_node
*a
)
10471 char *sym
= AT_loc_list (a
)->ll_symbol
;
10474 if (!dwarf_split_debug_info
)
10475 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
10476 "%s", dwarf_attr_name (a
->dw_attr
));
10477 else if (dwarf_version
>= 5)
10479 gcc_assert (AT_loc_list (a
)->num_assigned
);
10480 dw2_asm_output_data_uleb128 (AT_loc_list (a
)->hash
, "%s (%s)",
10481 dwarf_attr_name (a
->dw_attr
),
10485 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
10486 "%s", dwarf_attr_name (a
->dw_attr
));
10489 /* Output the offset into the debug_loc section. */
10492 output_view_list_offset (dw_attr_node
*a
)
10494 char *sym
= (*AT_loc_list_ptr (a
))->vl_symbol
;
10497 if (dwarf_split_debug_info
)
10498 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
10499 "%s", dwarf_attr_name (a
->dw_attr
));
10501 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
10502 "%s", dwarf_attr_name (a
->dw_attr
));
10505 /* Output an attribute's index or value appropriately. */
10508 output_attr_index_or_value (dw_attr_node
*a
)
10510 const char *name
= dwarf_attr_name (a
->dw_attr
);
10512 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
10514 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
10517 switch (AT_class (a
))
10519 case dw_val_class_addr
:
10520 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
10522 case dw_val_class_high_pc
:
10523 case dw_val_class_lbl_id
:
10524 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
10527 gcc_unreachable ();
10531 /* Output a type signature. */
10534 output_signature (const char *sig
, const char *name
)
10538 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
10539 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
10542 /* Output a discriminant value. */
10545 output_discr_value (dw_discr_value
*discr_value
, const char *name
)
10547 if (discr_value
->pos
)
10548 dw2_asm_output_data_uleb128 (discr_value
->v
.uval
, "%s", name
);
10550 dw2_asm_output_data_sleb128 (discr_value
->v
.sval
, "%s", name
);
10553 /* Output the DIE and its attributes. Called recursively to generate
10554 the definitions of each child DIE. */
10557 output_die (dw_die_ref die
)
10561 unsigned long size
;
10564 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
10565 (unsigned long)die
->die_offset
,
10566 dwarf_tag_name (die
->die_tag
));
10568 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
10570 const char *name
= dwarf_attr_name (a
->dw_attr
);
10572 switch (AT_class (a
))
10574 case dw_val_class_addr
:
10575 output_attr_index_or_value (a
);
10578 case dw_val_class_offset
:
10579 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
10583 case dw_val_class_range_list
:
10584 output_range_list_offset (a
);
10587 case dw_val_class_loc
:
10588 size
= size_of_locs (AT_loc (a
));
10590 /* Output the block length for this list of location operations. */
10591 if (dwarf_version
>= 4)
10592 dw2_asm_output_data_uleb128 (size
, "%s", name
);
10594 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
10596 output_loc_sequence (AT_loc (a
), -1);
10599 case dw_val_class_const
:
10600 /* ??? It would be slightly more efficient to use a scheme like is
10601 used for unsigned constants below, but gdb 4.x does not sign
10602 extend. Gdb 5.x does sign extend. */
10603 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
10606 case dw_val_class_unsigned_const
:
10608 int csize
= constant_size (AT_unsigned (a
));
10609 if (dwarf_version
== 3
10610 && a
->dw_attr
== DW_AT_data_member_location
10612 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
10614 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
10618 case dw_val_class_symview
:
10621 if (symview_upper_bound
<= 0xff)
10623 else if (symview_upper_bound
<= 0xffff)
10625 else if (symview_upper_bound
<= 0xffffffff)
10629 dw2_asm_output_addr (vsize
, a
->dw_attr_val
.v
.val_symbolic_view
,
10634 case dw_val_class_const_implicit
:
10635 if (flag_debug_asm
)
10636 fprintf (asm_out_file
, "\t\t\t%s %s ("
10637 HOST_WIDE_INT_PRINT_DEC
")\n",
10638 ASM_COMMENT_START
, name
, AT_int (a
));
10641 case dw_val_class_unsigned_const_implicit
:
10642 if (flag_debug_asm
)
10643 fprintf (asm_out_file
, "\t\t\t%s %s ("
10644 HOST_WIDE_INT_PRINT_HEX
")\n",
10645 ASM_COMMENT_START
, name
, AT_unsigned (a
));
10648 case dw_val_class_const_double
:
10650 unsigned HOST_WIDE_INT first
, second
;
10652 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
10653 dw2_asm_output_data (1,
10654 HOST_BITS_PER_DOUBLE_INT
10655 / HOST_BITS_PER_CHAR
,
10658 if (WORDS_BIG_ENDIAN
)
10660 first
= a
->dw_attr_val
.v
.val_double
.high
;
10661 second
= a
->dw_attr_val
.v
.val_double
.low
;
10665 first
= a
->dw_attr_val
.v
.val_double
.low
;
10666 second
= a
->dw_attr_val
.v
.val_double
.high
;
10669 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10670 first
, "%s", name
);
10671 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10676 case dw_val_class_wide_int
:
10679 int len
= get_full_len (*a
->dw_attr_val
.v
.val_wide
);
10680 int l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
10681 if (len
* HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
10682 dw2_asm_output_data (1, get_full_len (*a
->dw_attr_val
.v
.val_wide
)
10685 if (WORDS_BIG_ENDIAN
)
10686 for (i
= len
- 1; i
>= 0; --i
)
10688 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10693 for (i
= 0; i
< len
; ++i
)
10695 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10702 case dw_val_class_vec
:
10704 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
10705 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
10709 dw2_asm_output_data (constant_size (len
* elt_size
),
10710 len
* elt_size
, "%s", name
);
10711 if (elt_size
> sizeof (HOST_WIDE_INT
))
10716 for (i
= 0, p
= (unsigned char *) a
->dw_attr_val
.v
.val_vec
.array
;
10718 i
++, p
+= elt_size
)
10719 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
10720 "fp or vector constant word %u", i
);
10724 case dw_val_class_flag
:
10725 if (dwarf_version
>= 4)
10727 /* Currently all add_AT_flag calls pass in 1 as last argument,
10728 so DW_FORM_flag_present can be used. If that ever changes,
10729 we'll need to use DW_FORM_flag and have some optimization
10730 in build_abbrev_table that will change those to
10731 DW_FORM_flag_present if it is set to 1 in all DIEs using
10732 the same abbrev entry. */
10733 gcc_assert (AT_flag (a
) == 1);
10734 if (flag_debug_asm
)
10735 fprintf (asm_out_file
, "\t\t\t%s %s\n",
10736 ASM_COMMENT_START
, name
);
10739 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
10742 case dw_val_class_loc_list
:
10743 output_loc_list_offset (a
);
10746 case dw_val_class_view_list
:
10747 output_view_list_offset (a
);
10750 case dw_val_class_die_ref
:
10751 if (AT_ref_external (a
))
10753 if (AT_ref (a
)->comdat_type_p
)
10755 comdat_type_node
*type_node
10756 = AT_ref (a
)->die_id
.die_type_node
;
10758 gcc_assert (type_node
);
10759 output_signature (type_node
->signature
, name
);
10763 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
10767 /* In DWARF2, DW_FORM_ref_addr is sized by target address
10768 length, whereas in DWARF3 it's always sized as an
10770 if (dwarf_version
== 2)
10771 size
= DWARF2_ADDR_SIZE
;
10773 size
= DWARF_OFFSET_SIZE
;
10774 /* ??? We cannot unconditionally output die_offset if
10775 non-zero - others might create references to those
10777 And we do not clear its DIE offset after outputting it
10778 (and the label refers to the actual DIEs, not the
10779 DWARF CU unit header which is when using label + offset
10780 would be the correct thing to do).
10781 ??? This is the reason for the with_offset flag. */
10782 if (AT_ref (a
)->with_offset
)
10783 dw2_asm_output_offset (size
, sym
, AT_ref (a
)->die_offset
,
10784 debug_info_section
, "%s", name
);
10786 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
10792 gcc_assert (AT_ref (a
)->die_offset
);
10793 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
10798 case dw_val_class_fde_ref
:
10800 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
10802 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
10803 a
->dw_attr_val
.v
.val_fde_index
* 2);
10804 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
10809 case dw_val_class_vms_delta
:
10810 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
10811 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
10812 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
10815 dw2_asm_output_delta (DWARF_OFFSET_SIZE
,
10816 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
10821 case dw_val_class_lbl_id
:
10822 output_attr_index_or_value (a
);
10825 case dw_val_class_lineptr
:
10826 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10827 debug_line_section
, "%s", name
);
10830 case dw_val_class_macptr
:
10831 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10832 debug_macinfo_section
, "%s", name
);
10835 case dw_val_class_loclistsptr
:
10836 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10837 debug_loc_section
, "%s", name
);
10840 case dw_val_class_str
:
10841 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
10842 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
10843 a
->dw_attr_val
.v
.val_str
->label
,
10845 "%s: \"%s\"", name
, AT_string (a
));
10846 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_line_strp
)
10847 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
10848 a
->dw_attr_val
.v
.val_str
->label
,
10849 debug_line_str_section
,
10850 "%s: \"%s\"", name
, AT_string (a
));
10851 else if (a
->dw_attr_val
.v
.val_str
->form
== dwarf_FORM (DW_FORM_strx
))
10852 dw2_asm_output_data_uleb128 (AT_index (a
),
10853 "%s: \"%s\"", name
, AT_string (a
));
10855 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
10858 case dw_val_class_file
:
10860 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
10862 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
10863 a
->dw_attr_val
.v
.val_file
->filename
);
10867 case dw_val_class_file_implicit
:
10868 if (flag_debug_asm
)
10869 fprintf (asm_out_file
, "\t\t\t%s %s (%d, %s)\n",
10870 ASM_COMMENT_START
, name
,
10871 maybe_emit_file (a
->dw_attr_val
.v
.val_file
),
10872 a
->dw_attr_val
.v
.val_file
->filename
);
10875 case dw_val_class_data8
:
10879 for (i
= 0; i
< 8; i
++)
10880 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
10881 i
== 0 ? "%s" : NULL
, name
);
10885 case dw_val_class_high_pc
:
10886 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
10887 get_AT_low_pc (die
), "DW_AT_high_pc");
10890 case dw_val_class_discr_value
:
10891 output_discr_value (&a
->dw_attr_val
.v
.val_discr_value
, name
);
10894 case dw_val_class_discr_list
:
10896 dw_discr_list_ref list
= AT_discr_list (a
);
10897 const int size
= size_of_discr_list (list
);
10899 /* This is a block, so output its length first. */
10900 dw2_asm_output_data (constant_size (size
), size
,
10901 "%s: block size", name
);
10903 for (; list
!= NULL
; list
= list
->dw_discr_next
)
10905 /* One byte for the discriminant value descriptor, and then as
10906 many LEB128 numbers as required. */
10907 if (list
->dw_discr_range
)
10908 dw2_asm_output_data (1, DW_DSC_range
,
10909 "%s: DW_DSC_range", name
);
10911 dw2_asm_output_data (1, DW_DSC_label
,
10912 "%s: DW_DSC_label", name
);
10914 output_discr_value (&list
->dw_discr_lower_bound
, name
);
10915 if (list
->dw_discr_range
)
10916 output_discr_value (&list
->dw_discr_upper_bound
, name
);
10922 gcc_unreachable ();
10926 FOR_EACH_CHILD (die
, c
, output_die (c
));
10928 /* Add null byte to terminate sibling list. */
10929 if (die
->die_child
!= NULL
)
10930 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
10931 (unsigned long) die
->die_offset
);
10934 /* Output the dwarf version number. */
10937 output_dwarf_version ()
10939 /* ??? For now, if -gdwarf-6 is specified, we output version 5 with
10940 views in loclist. That will change eventually. */
10941 if (dwarf_version
== 6)
10947 "-gdwarf-6 is output as version 5 with incompatibilities");
10950 dw2_asm_output_data (2, 5, "DWARF version number");
10953 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
10956 /* Output the compilation unit that appears at the beginning of the
10957 .debug_info section, and precedes the DIE descriptions. */
10960 output_compilation_unit_header (enum dwarf_unit_type ut
)
10962 if (!XCOFF_DEBUGGING_INFO
)
10964 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10965 dw2_asm_output_data (4, 0xffffffff,
10966 "Initial length escape value indicating 64-bit DWARF extension");
10967 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
10968 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
10969 "Length of Compilation Unit Info");
10972 output_dwarf_version ();
10973 if (dwarf_version
>= 5)
10978 case DW_UT_compile
: name
= "DW_UT_compile"; break;
10979 case DW_UT_type
: name
= "DW_UT_type"; break;
10980 case DW_UT_split_compile
: name
= "DW_UT_split_compile"; break;
10981 case DW_UT_split_type
: name
= "DW_UT_split_type"; break;
10982 default: gcc_unreachable ();
10984 dw2_asm_output_data (1, ut
, "%s", name
);
10985 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
10987 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
10988 debug_abbrev_section
,
10989 "Offset Into Abbrev. Section");
10990 if (dwarf_version
< 5)
10991 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
10994 /* Output the compilation unit DIE and its children. */
10997 output_comp_unit (dw_die_ref die
, int output_if_empty
,
10998 const unsigned char *dwo_id
)
11000 const char *secname
, *oldsym
;
11003 /* Unless we are outputting main CU, we may throw away empty ones. */
11004 if (!output_if_empty
&& die
->die_child
== NULL
)
11007 /* Even if there are no children of this DIE, we must output the information
11008 about the compilation unit. Otherwise, on an empty translation unit, we
11009 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
11010 will then complain when examining the file. First mark all the DIEs in
11011 this CU so we know which get local refs. */
11014 external_ref_hash_type
*extern_map
= optimize_external_refs (die
);
11016 /* For now, optimize only the main CU, in order to optimize the rest
11017 we'd need to see all of them earlier. Leave the rest for post-linking
11019 if (die
== comp_unit_die ())
11020 abbrev_opt_start
= vec_safe_length (abbrev_die_table
);
11022 build_abbrev_table (die
, extern_map
);
11024 optimize_abbrev_table ();
11028 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11029 next_die_offset
= (dwo_id
11030 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11031 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
11032 calc_die_sizes (die
);
11034 oldsym
= die
->die_id
.die_symbol
;
11035 if (oldsym
&& die
->comdat_type_p
)
11037 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
11039 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
11041 die
->die_id
.die_symbol
= NULL
;
11042 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11046 switch_to_section (debug_info_section
);
11047 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
11048 info_section_emitted
= true;
11051 /* For LTO cross unit DIE refs we want a symbol on the start of the
11052 debuginfo section, not on the CU DIE. */
11053 if ((flag_generate_lto
|| flag_generate_offload
) && oldsym
)
11055 /* ??? No way to get visibility assembled without a decl. */
11056 tree decl
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
11057 get_identifier (oldsym
), char_type_node
);
11058 TREE_PUBLIC (decl
) = true;
11059 TREE_STATIC (decl
) = true;
11060 DECL_ARTIFICIAL (decl
) = true;
11061 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
11062 DECL_VISIBILITY_SPECIFIED (decl
) = true;
11063 targetm
.asm_out
.assemble_visibility (decl
, VISIBILITY_HIDDEN
);
11064 #ifdef ASM_WEAKEN_LABEL
11065 /* We prefer a .weak because that handles duplicates from duplicate
11066 archive members in a graceful way. */
11067 ASM_WEAKEN_LABEL (asm_out_file
, oldsym
);
11069 targetm
.asm_out
.globalize_label (asm_out_file
, oldsym
);
11071 ASM_OUTPUT_LABEL (asm_out_file
, oldsym
);
11074 /* Output debugging information. */
11075 output_compilation_unit_header (dwo_id
11076 ? DW_UT_split_compile
: DW_UT_compile
);
11077 if (dwarf_version
>= 5)
11079 if (dwo_id
!= NULL
)
11080 for (int i
= 0; i
< 8; i
++)
11081 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
11085 /* Leave the marks on the main CU, so we can check them in
11086 output_pubnames. */
11090 die
->die_id
.die_symbol
= oldsym
;
11094 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
11095 and .debug_pubtypes. This is configured per-target, but can be
11096 overridden by the -gpubnames or -gno-pubnames options. */
11099 want_pubnames (void)
11101 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
11103 if (debug_generate_pub_sections
!= -1)
11104 return debug_generate_pub_sections
;
11105 return targetm
.want_debug_pub_sections
;
11108 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
11111 add_AT_pubnames (dw_die_ref die
)
11113 if (want_pubnames ())
11114 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
11117 /* Add a string attribute value to a skeleton DIE. */
11120 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
11124 struct indirect_string_node
*node
;
11126 if (! skeleton_debug_str_hash
)
11127 skeleton_debug_str_hash
11128 = hash_table
<indirect_string_hasher
>::create_ggc (10);
11130 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
11131 find_string_form (node
);
11132 if (node
->form
== dwarf_FORM (DW_FORM_strx
))
11133 node
->form
= DW_FORM_strp
;
11135 attr
.dw_attr
= attr_kind
;
11136 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
11137 attr
.dw_attr_val
.val_entry
= NULL
;
11138 attr
.dw_attr_val
.v
.val_str
= node
;
11139 add_dwarf_attr (die
, &attr
);
11142 /* Helper function to generate top-level dies for skeleton debug_info and
11146 add_top_level_skeleton_die_attrs (dw_die_ref die
)
11148 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
11149 const char *comp_dir
= comp_dir_string ();
11151 add_skeleton_AT_string (die
, dwarf_AT (DW_AT_dwo_name
), dwo_file_name
);
11152 if (comp_dir
!= NULL
)
11153 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
11154 add_AT_pubnames (die
);
11155 add_AT_lineptr (die
, dwarf_AT (DW_AT_addr_base
), debug_addr_section_label
);
11158 /* Output skeleton debug sections that point to the dwo file. */
11161 output_skeleton_debug_sections (dw_die_ref comp_unit
,
11162 const unsigned char *dwo_id
)
11164 /* These attributes will be found in the full debug_info section. */
11165 remove_AT (comp_unit
, DW_AT_producer
);
11166 remove_AT (comp_unit
, DW_AT_language
);
11168 switch_to_section (debug_skeleton_info_section
);
11169 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
11171 /* Produce the skeleton compilation-unit header. This one differs enough from
11172 a normal CU header that it's better not to call output_compilation_unit
11174 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11175 dw2_asm_output_data (4, 0xffffffff,
11176 "Initial length escape value indicating 64-bit "
11177 "DWARF extension");
11179 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
11180 DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11181 - DWARF_INITIAL_LENGTH_SIZE
11182 + size_of_die (comp_unit
),
11183 "Length of Compilation Unit Info");
11184 output_dwarf_version ();
11185 if (dwarf_version
>= 5)
11187 dw2_asm_output_data (1, DW_UT_skeleton
, "DW_UT_skeleton");
11188 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11190 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_abbrev_section_label
,
11191 debug_skeleton_abbrev_section
,
11192 "Offset Into Abbrev. Section");
11193 if (dwarf_version
< 5)
11194 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11196 for (int i
= 0; i
< 8; i
++)
11197 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
11199 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
11200 output_die (comp_unit
);
11202 /* Build the skeleton debug_abbrev section. */
11203 switch_to_section (debug_skeleton_abbrev_section
);
11204 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
11206 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
11208 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
11211 /* Output a comdat type unit DIE and its children. */
11214 output_comdat_type_unit (comdat_type_node
*node
)
11216 const char *secname
;
11219 #if defined (OBJECT_FORMAT_ELF)
11223 /* First mark all the DIEs in this CU so we know which get local refs. */
11224 mark_dies (node
->root_die
);
11226 external_ref_hash_type
*extern_map
= optimize_external_refs (node
->root_die
);
11228 build_abbrev_table (node
->root_die
, extern_map
);
11233 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11234 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
11235 calc_die_sizes (node
->root_die
);
11237 #if defined (OBJECT_FORMAT_ELF)
11238 if (dwarf_version
>= 5)
11240 if (!dwarf_split_debug_info
)
11241 secname
= ".debug_info";
11243 secname
= ".debug_info.dwo";
11245 else if (!dwarf_split_debug_info
)
11246 secname
= ".debug_types";
11248 secname
= ".debug_types.dwo";
11250 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11251 sprintf (tmp
, dwarf_version
>= 5 ? "wi." : "wt.");
11252 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11253 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11254 comdat_key
= get_identifier (tmp
);
11255 targetm
.asm_out
.named_section (secname
,
11256 SECTION_DEBUG
| SECTION_LINKONCE
,
11259 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11260 sprintf (tmp
, (dwarf_version
>= 5
11261 ? ".gnu.linkonce.wi." : ".gnu.linkonce.wt."));
11262 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11263 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11265 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11268 /* Output debugging information. */
11269 output_compilation_unit_header (dwarf_split_debug_info
11270 ? DW_UT_split_type
: DW_UT_type
);
11271 output_signature (node
->signature
, "Type Signature");
11272 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
11273 "Offset to Type DIE");
11274 output_die (node
->root_die
);
11276 unmark_dies (node
->root_die
);
11279 /* Return the DWARF2/3 pubname associated with a decl. */
11281 static const char *
11282 dwarf2_name (tree decl
, int scope
)
11284 if (DECL_NAMELESS (decl
))
11286 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
11289 /* Add a new entry to .debug_pubnames if appropriate. */
11292 add_pubname_string (const char *str
, dw_die_ref die
)
11297 e
.name
= xstrdup (str
);
11298 vec_safe_push (pubname_table
, e
);
11302 add_pubname (tree decl
, dw_die_ref die
)
11304 if (!want_pubnames ())
11307 /* Don't add items to the table when we expect that the consumer will have
11308 just read the enclosing die. For example, if the consumer is looking at a
11309 class_member, it will either be inside the class already, or will have just
11310 looked up the class to find the member. Either way, searching the class is
11311 faster than searching the index. */
11312 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
11313 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
11315 const char *name
= dwarf2_name (decl
, 1);
11318 add_pubname_string (name
, die
);
11322 /* Add an enumerator to the pubnames section. */
11325 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
11329 gcc_assert (scope_name
);
11330 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
11332 vec_safe_push (pubname_table
, e
);
11335 /* Add a new entry to .debug_pubtypes if appropriate. */
11338 add_pubtype (tree decl
, dw_die_ref die
)
11342 if (!want_pubnames ())
11345 if ((TREE_PUBLIC (decl
)
11346 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
11347 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
11350 const char *scope_name
= "";
11351 const char *sep
= is_cxx () ? "::" : ".";
11354 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
11355 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
11357 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
11358 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
11359 scope_name
= concat (scope_name
, sep
, NULL
);
11365 name
= type_tag (decl
);
11367 name
= lang_hooks
.dwarf_name (decl
, 1);
11369 /* If we don't have a name for the type, there's no point in adding
11370 it to the table. */
11371 if (name
!= NULL
&& name
[0] != '\0')
11374 e
.name
= concat (scope_name
, name
, NULL
);
11375 vec_safe_push (pubtype_table
, e
);
11378 /* Although it might be more consistent to add the pubinfo for the
11379 enumerators as their dies are created, they should only be added if the
11380 enum type meets the criteria above. So rather than re-check the parent
11381 enum type whenever an enumerator die is created, just output them all
11382 here. This isn't protected by the name conditional because anonymous
11383 enums don't have names. */
11384 if (die
->die_tag
== DW_TAG_enumeration_type
)
11388 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
11393 /* Output a single entry in the pubnames table. */
11396 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
11398 dw_die_ref die
= entry
->die
;
11399 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
11401 dw2_asm_output_data (DWARF_OFFSET_SIZE
, die_offset
, "DIE offset");
11403 if (debug_generate_pub_sections
== 2)
11405 /* This logic follows gdb's method for determining the value of the flag
11407 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
11408 switch (die
->die_tag
)
11410 case DW_TAG_typedef
:
11411 case DW_TAG_base_type
:
11412 case DW_TAG_subrange_type
:
11413 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11414 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11416 case DW_TAG_enumerator
:
11417 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11418 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11420 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11422 case DW_TAG_subprogram
:
11423 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11424 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
11426 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11428 case DW_TAG_constant
:
11429 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11430 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11431 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11433 case DW_TAG_variable
:
11434 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11435 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11436 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11438 case DW_TAG_namespace
:
11439 case DW_TAG_imported_declaration
:
11440 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11442 case DW_TAG_class_type
:
11443 case DW_TAG_interface_type
:
11444 case DW_TAG_structure_type
:
11445 case DW_TAG_union_type
:
11446 case DW_TAG_enumeration_type
:
11447 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11449 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11452 /* An unusual tag. Leave the flag-byte empty. */
11455 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
11456 "GDB-index flags");
11459 dw2_asm_output_nstring (entry
->name
, -1, "external name");
11463 /* Output the public names table used to speed up access to externally
11464 visible names; or the public types table used to find type definitions. */
11467 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
11470 unsigned long pubnames_length
= size_of_pubnames (names
);
11471 pubname_entry
*pub
;
11473 if (!XCOFF_DEBUGGING_INFO
)
11475 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11476 dw2_asm_output_data (4, 0xffffffff,
11477 "Initial length escape value indicating 64-bit DWARF extension");
11478 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
11479 "Pub Info Length");
11482 /* Version number for pubnames/pubtypes is independent of dwarf version. */
11483 dw2_asm_output_data (2, 2, "DWARF pubnames/pubtypes version");
11485 if (dwarf_split_debug_info
)
11486 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
11487 debug_skeleton_info_section
,
11488 "Offset of Compilation Unit Info");
11490 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
11491 debug_info_section
,
11492 "Offset of Compilation Unit Info");
11493 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
11494 "Compilation Unit Length");
11496 FOR_EACH_VEC_ELT (*names
, i
, pub
)
11498 if (include_pubname_in_output (names
, pub
))
11500 dw_offset die_offset
= pub
->die
->die_offset
;
11502 /* We shouldn't see pubnames for DIEs outside of the main CU. */
11503 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
11504 gcc_assert (pub
->die
->die_mark
);
11506 /* If we're putting types in their own .debug_types sections,
11507 the .debug_pubtypes table will still point to the compile
11508 unit (not the type unit), so we want to use the offset of
11509 the skeleton DIE (if there is one). */
11510 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
11512 comdat_type_node
*type_node
= pub
->die
->die_id
.die_type_node
;
11514 if (type_node
!= NULL
)
11515 die_offset
= (type_node
->skeleton_die
!= NULL
11516 ? type_node
->skeleton_die
->die_offset
11517 : comp_unit_die ()->die_offset
);
11520 output_pubname (die_offset
, pub
);
11524 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
11527 /* Output public names and types tables if necessary. */
11530 output_pubtables (void)
11532 if (!want_pubnames () || !info_section_emitted
)
11535 switch_to_section (debug_pubnames_section
);
11536 output_pubnames (pubname_table
);
11537 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
11538 It shouldn't hurt to emit it always, since pure DWARF2 consumers
11539 simply won't look for the section. */
11540 switch_to_section (debug_pubtypes_section
);
11541 output_pubnames (pubtype_table
);
11545 /* Output the information that goes into the .debug_aranges table.
11546 Namely, define the beginning and ending address range of the
11547 text section generated for this compilation unit. */
11550 output_aranges (void)
11553 unsigned long aranges_length
= size_of_aranges ();
11555 if (!XCOFF_DEBUGGING_INFO
)
11557 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11558 dw2_asm_output_data (4, 0xffffffff,
11559 "Initial length escape value indicating 64-bit DWARF extension");
11560 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
11561 "Length of Address Ranges Info");
11564 /* Version number for aranges is still 2, even up to DWARF5. */
11565 dw2_asm_output_data (2, 2, "DWARF aranges version");
11566 if (dwarf_split_debug_info
)
11567 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
11568 debug_skeleton_info_section
,
11569 "Offset of Compilation Unit Info");
11571 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
11572 debug_info_section
,
11573 "Offset of Compilation Unit Info");
11574 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
11575 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
11577 /* We need to align to twice the pointer size here. */
11578 if (DWARF_ARANGES_PAD_SIZE
)
11580 /* Pad using a 2 byte words so that padding is correct for any
11582 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
11583 2 * DWARF2_ADDR_SIZE
);
11584 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
11585 dw2_asm_output_data (2, 0, NULL
);
11588 /* It is necessary not to output these entries if the sections were
11589 not used; if the sections were not used, the length will be 0 and
11590 the address may end up as 0 if the section is discarded by ld
11591 --gc-sections, leaving an invalid (0, 0) entry that can be
11592 confused with the terminator. */
11593 if (text_section_used
)
11595 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
11596 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
11597 text_section_label
, "Length");
11599 if (cold_text_section_used
)
11601 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
11603 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
11604 cold_text_section_label
, "Length");
11607 if (have_multiple_function_sections
)
11612 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
11614 if (DECL_IGNORED_P (fde
->decl
))
11616 if (!fde
->in_std_section
)
11618 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
11620 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
11621 fde
->dw_fde_begin
, "Length");
11623 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
11625 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
11627 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
11628 fde
->dw_fde_second_begin
, "Length");
11633 /* Output the terminator words. */
11634 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11635 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11638 /* Add a new entry to .debug_ranges. Return its index into
11639 ranges_table vector. */
11641 static unsigned int
11642 add_ranges_num (int num
, bool maybe_new_sec
)
11644 dw_ranges r
= { NULL
, num
, 0, maybe_new_sec
};
11645 vec_safe_push (ranges_table
, r
);
11646 return vec_safe_length (ranges_table
) - 1;
11649 /* Add a new entry to .debug_ranges corresponding to a block, or a
11650 range terminator if BLOCK is NULL. MAYBE_NEW_SEC is true if
11651 this entry might be in a different section from previous range. */
11653 static unsigned int
11654 add_ranges (const_tree block
, bool maybe_new_sec
)
11656 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0, maybe_new_sec
);
11659 /* Note that (*rnglist_table)[offset] is either a head of a rnglist
11660 chain, or middle entry of a chain that will be directly referred to. */
11663 note_rnglist_head (unsigned int offset
)
11665 if (dwarf_version
< 5 || (*ranges_table
)[offset
].label
)
11667 (*ranges_table
)[offset
].label
= gen_internal_sym ("LLRL");
11670 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
11671 When using dwarf_split_debug_info, address attributes in dies destined
11672 for the final executable should be direct references--setting the
11673 parameter force_direct ensures this behavior. */
11676 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
11677 bool *added
, bool force_direct
)
11679 unsigned int in_use
= vec_safe_length (ranges_by_label
);
11680 unsigned int offset
;
11681 dw_ranges_by_label rbl
= { begin
, end
};
11682 vec_safe_push (ranges_by_label
, rbl
);
11683 offset
= add_ranges_num (-(int)in_use
- 1, true);
11686 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
11688 note_rnglist_head (offset
);
11692 /* Emit .debug_ranges section. */
11695 output_ranges (void)
11698 static const char *const start_fmt
= "Offset %#x";
11699 const char *fmt
= start_fmt
;
11702 switch_to_section (debug_ranges_section
);
11703 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11704 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11706 int block_num
= r
->num
;
11710 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11711 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11713 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11714 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11716 /* If all code is in the text section, then the compilation
11717 unit base address defaults to DW_AT_low_pc, which is the
11718 base of the text section. */
11719 if (!have_multiple_function_sections
)
11721 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
11722 text_section_label
,
11723 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11724 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
11725 text_section_label
, NULL
);
11728 /* Otherwise, the compilation unit base address is zero,
11729 which allows us to use absolute addresses, and not worry
11730 about whether the target supports cross-section
11734 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11735 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11736 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
11742 /* Negative block_num stands for an index into ranges_by_label. */
11743 else if (block_num
< 0)
11745 int lab_idx
= - block_num
- 1;
11747 if (!have_multiple_function_sections
)
11749 gcc_unreachable ();
11751 /* If we ever use add_ranges_by_labels () for a single
11752 function section, all we have to do is to take out
11753 the #if 0 above. */
11754 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11755 (*ranges_by_label
)[lab_idx
].begin
,
11756 text_section_label
,
11757 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11758 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11759 (*ranges_by_label
)[lab_idx
].end
,
11760 text_section_label
, NULL
);
11765 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11766 (*ranges_by_label
)[lab_idx
].begin
,
11767 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11768 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11769 (*ranges_by_label
)[lab_idx
].end
,
11775 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11776 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11782 /* Non-zero if .debug_line_str should be used for .debug_line section
11783 strings or strings that are likely shareable with those. */
11784 #define DWARF5_USE_DEBUG_LINE_STR \
11785 (!DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET \
11786 && (DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) != 0 \
11787 /* FIXME: there is no .debug_line_str.dwo section, \
11788 for -gsplit-dwarf we should use DW_FORM_strx instead. */ \
11789 && !dwarf_split_debug_info)
11791 /* Assign .debug_rnglists indexes. */
11794 index_rnglists (void)
11799 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11801 r
->idx
= rnglist_idx
++;
11804 /* Emit .debug_rnglists section. */
11807 output_rnglists (unsigned generation
)
11811 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
11812 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
11813 char basebuf
[MAX_ARTIFICIAL_LABEL_BYTES
];
11815 switch_to_section (debug_ranges_section
);
11816 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11817 /* There are up to 4 unique ranges labels per generation.
11818 See also init_sections_and_labels. */
11819 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_RANGES_SECTION_LABEL
,
11820 2 + generation
* 4);
11821 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_RANGES_SECTION_LABEL
,
11822 3 + generation
* 4);
11823 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11824 dw2_asm_output_data (4, 0xffffffff,
11825 "Initial length escape value indicating "
11826 "64-bit DWARF extension");
11827 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
11828 "Length of Range Lists");
11829 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
11830 output_dwarf_version ();
11831 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
11832 dw2_asm_output_data (1, 0, "Segment Size");
11833 /* Emit the offset table only for -gsplit-dwarf. If we don't care
11834 about relocation sizes and primarily care about the size of .debug*
11835 sections in linked shared libraries and executables, then
11836 the offset table plus corresponding DW_FORM_rnglistx uleb128 indexes
11837 into it are usually larger than just DW_FORM_sec_offset offsets
11838 into the .debug_rnglists section. */
11839 dw2_asm_output_data (4, dwarf_split_debug_info
? rnglist_idx
: 0,
11840 "Offset Entry Count");
11841 if (dwarf_split_debug_info
)
11843 ASM_OUTPUT_LABEL (asm_out_file
, ranges_base_label
);
11844 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11846 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, r
->label
,
11847 ranges_base_label
, NULL
);
11850 const char *lab
= "";
11851 unsigned int len
= vec_safe_length (ranges_table
);
11852 const char *base
= NULL
;
11853 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11855 int block_num
= r
->num
;
11859 ASM_OUTPUT_LABEL (asm_out_file
, r
->label
);
11862 if (HAVE_AS_LEB128
&& (r
->label
|| r
->maybe_new_sec
))
11866 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11867 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11869 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11870 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11872 if (HAVE_AS_LEB128
)
11874 /* If all code is in the text section, then the compilation
11875 unit base address defaults to DW_AT_low_pc, which is the
11876 base of the text section. */
11877 if (!have_multiple_function_sections
)
11879 dw2_asm_output_data (1, DW_RLE_offset_pair
,
11880 "DW_RLE_offset_pair (%s)", lab
);
11881 dw2_asm_output_delta_uleb128 (blabel
, text_section_label
,
11882 "Range begin address (%s)", lab
);
11883 dw2_asm_output_delta_uleb128 (elabel
, text_section_label
,
11884 "Range end address (%s)", lab
);
11889 dw_ranges
*r2
= NULL
;
11891 r2
= &(*ranges_table
)[i
+ 1];
11894 && r2
->label
== NULL
11895 && !r2
->maybe_new_sec
)
11897 dw2_asm_output_data (1, DW_RLE_base_address
,
11898 "DW_RLE_base_address (%s)", lab
);
11899 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11900 "Base address (%s)", lab
);
11901 strcpy (basebuf
, blabel
);
11907 dw2_asm_output_data (1, DW_RLE_offset_pair
,
11908 "DW_RLE_offset_pair (%s)", lab
);
11909 dw2_asm_output_delta_uleb128 (blabel
, base
,
11910 "Range begin address (%s)", lab
);
11911 dw2_asm_output_delta_uleb128 (elabel
, base
,
11912 "Range end address (%s)", lab
);
11915 dw2_asm_output_data (1, DW_RLE_start_length
,
11916 "DW_RLE_start_length (%s)", lab
);
11917 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11918 "Range begin address (%s)", lab
);
11919 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
11920 "Range length (%s)", lab
);
11924 dw2_asm_output_data (1, DW_RLE_start_end
,
11925 "DW_RLE_start_end (%s)", lab
);
11926 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11927 "Range begin address (%s)", lab
);
11928 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
11929 "Range end address (%s)", lab
);
11933 /* Negative block_num stands for an index into ranges_by_label. */
11934 else if (block_num
< 0)
11936 int lab_idx
= - block_num
- 1;
11937 const char *blabel
= (*ranges_by_label
)[lab_idx
].begin
;
11938 const char *elabel
= (*ranges_by_label
)[lab_idx
].end
;
11940 if (!have_multiple_function_sections
)
11941 gcc_unreachable ();
11942 if (HAVE_AS_LEB128
)
11944 dw2_asm_output_data (1, DW_RLE_start_length
,
11945 "DW_RLE_start_length (%s)", lab
);
11946 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11947 "Range begin address (%s)", lab
);
11948 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
11949 "Range length (%s)", lab
);
11953 dw2_asm_output_data (1, DW_RLE_start_end
,
11954 "DW_RLE_start_end (%s)", lab
);
11955 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11956 "Range begin address (%s)", lab
);
11957 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
11958 "Range end address (%s)", lab
);
11962 dw2_asm_output_data (1, DW_RLE_end_of_list
,
11963 "DW_RLE_end_of_list (%s)", lab
);
11965 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
11968 /* Data structure containing information about input files. */
11971 const char *path
; /* Complete file name. */
11972 const char *fname
; /* File name part. */
11973 int length
; /* Length of entire string. */
11974 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
11975 int dir_idx
; /* Index in directory table. */
11978 /* Data structure containing information about directories with source
11982 const char *path
; /* Path including directory name. */
11983 int length
; /* Path length. */
11984 int prefix
; /* Index of directory entry which is a prefix. */
11985 int count
; /* Number of files in this directory. */
11986 int dir_idx
; /* Index of directory used as base. */
11989 /* Callback function for file_info comparison. We sort by looking at
11990 the directories in the path. */
11993 file_info_cmp (const void *p1
, const void *p2
)
11995 const struct file_info
*const s1
= (const struct file_info
*) p1
;
11996 const struct file_info
*const s2
= (const struct file_info
*) p2
;
11997 const unsigned char *cp1
;
11998 const unsigned char *cp2
;
12000 /* Take care of file names without directories. We need to make sure that
12001 we return consistent values to qsort since some will get confused if
12002 we return the same value when identical operands are passed in opposite
12003 orders. So if neither has a directory, return 0 and otherwise return
12004 1 or -1 depending on which one has the directory. We want the one with
12005 the directory to sort after the one without, so all no directory files
12006 are at the start (normally only the compilation unit file). */
12007 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
12008 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
12010 cp1
= (const unsigned char *) s1
->path
;
12011 cp2
= (const unsigned char *) s2
->path
;
12017 /* Reached the end of the first path? If so, handle like above,
12018 but now we want longer directory prefixes before shorter ones. */
12019 if ((cp1
== (const unsigned char *) s1
->fname
)
12020 || (cp2
== (const unsigned char *) s2
->fname
))
12021 return ((cp1
== (const unsigned char *) s1
->fname
)
12022 - (cp2
== (const unsigned char *) s2
->fname
));
12024 /* Character of current path component the same? */
12025 else if (*cp1
!= *cp2
)
12026 return *cp1
- *cp2
;
12030 struct file_name_acquire_data
12032 struct file_info
*files
;
12037 /* Traversal function for the hash table. */
12040 file_name_acquire (dwarf_file_data
**slot
, file_name_acquire_data
*fnad
)
12042 struct dwarf_file_data
*d
= *slot
;
12043 struct file_info
*fi
;
12046 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
12048 if (! d
->emitted_number
)
12051 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
12053 fi
= fnad
->files
+ fnad
->used_files
++;
12055 /* Skip all leading "./". */
12057 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
12060 /* Create a new array entry. */
12062 fi
->length
= strlen (f
);
12065 /* Search for the file name part. */
12066 f
= strrchr (f
, DIR_SEPARATOR
);
12067 #if defined (DIR_SEPARATOR_2)
12069 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
12073 if (f
== NULL
|| f
< g
)
12079 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
12083 /* Helper function for output_file_names. Emit a FORM encoded
12084 string STR, with assembly comment start ENTRY_KIND and
12088 output_line_string (enum dwarf_form form
, const char *str
,
12089 const char *entry_kind
, unsigned int idx
)
12093 case DW_FORM_string
:
12094 dw2_asm_output_nstring (str
, -1, "%s: %#x", entry_kind
, idx
);
12096 case DW_FORM_line_strp
:
12097 if (!debug_line_str_hash
)
12098 debug_line_str_hash
12099 = hash_table
<indirect_string_hasher
>::create_ggc (10);
12101 struct indirect_string_node
*node
;
12102 node
= find_AT_string_in_table (str
, debug_line_str_hash
);
12103 set_indirect_string (node
);
12105 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
12106 debug_line_str_section
, "%s: %#x: \"%s\"",
12107 entry_kind
, 0, node
->str
);
12110 gcc_unreachable ();
12114 /* Output the directory table and the file name table. We try to minimize
12115 the total amount of memory needed. A heuristic is used to avoid large
12116 slowdowns with many input files. */
12119 output_file_names (void)
12121 struct file_name_acquire_data fnad
;
12123 struct file_info
*files
;
12124 struct dir_info
*dirs
;
12132 if (!last_emitted_file
)
12134 if (dwarf_version
>= 5)
12136 dw2_asm_output_data (1, 0, "Directory entry format count");
12137 dw2_asm_output_data_uleb128 (0, "Directories count");
12138 dw2_asm_output_data (1, 0, "File name entry format count");
12139 dw2_asm_output_data_uleb128 (0, "File names count");
12143 dw2_asm_output_data (1, 0, "End directory table");
12144 dw2_asm_output_data (1, 0, "End file name table");
12149 numfiles
= last_emitted_file
->emitted_number
;
12151 /* Allocate the various arrays we need. */
12152 files
= XALLOCAVEC (struct file_info
, numfiles
);
12153 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
12155 fnad
.files
= files
;
12156 fnad
.used_files
= 0;
12157 fnad
.max_files
= numfiles
;
12158 file_table
->traverse
<file_name_acquire_data
*, file_name_acquire
> (&fnad
);
12159 gcc_assert (fnad
.used_files
== fnad
.max_files
);
12161 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
12163 /* Find all the different directories used. */
12164 dirs
[0].path
= files
[0].path
;
12165 dirs
[0].length
= files
[0].fname
- files
[0].path
;
12166 dirs
[0].prefix
= -1;
12168 dirs
[0].dir_idx
= 0;
12169 files
[0].dir_idx
= 0;
12172 for (i
= 1; i
< numfiles
; i
++)
12173 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
12174 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
12175 dirs
[ndirs
- 1].length
) == 0)
12177 /* Same directory as last entry. */
12178 files
[i
].dir_idx
= ndirs
- 1;
12179 ++dirs
[ndirs
- 1].count
;
12185 /* This is a new directory. */
12186 dirs
[ndirs
].path
= files
[i
].path
;
12187 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
12188 dirs
[ndirs
].count
= 1;
12189 dirs
[ndirs
].dir_idx
= ndirs
;
12190 files
[i
].dir_idx
= ndirs
;
12192 /* Search for a prefix. */
12193 dirs
[ndirs
].prefix
= -1;
12194 for (j
= 0; j
< ndirs
; j
++)
12195 if (dirs
[j
].length
< dirs
[ndirs
].length
12196 && dirs
[j
].length
> 1
12197 && (dirs
[ndirs
].prefix
== -1
12198 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
12199 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
12200 dirs
[ndirs
].prefix
= j
;
12205 /* Now to the actual work. We have to find a subset of the directories which
12206 allow expressing the file name using references to the directory table
12207 with the least amount of characters. We do not do an exhaustive search
12208 where we would have to check out every combination of every single
12209 possible prefix. Instead we use a heuristic which provides nearly optimal
12210 results in most cases and never is much off. */
12211 saved
= XALLOCAVEC (int, ndirs
);
12212 savehere
= XALLOCAVEC (int, ndirs
);
12214 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
12215 for (i
= 0; i
< ndirs
; i
++)
12220 /* We can always save some space for the current directory. But this
12221 does not mean it will be enough to justify adding the directory. */
12222 savehere
[i
] = dirs
[i
].length
;
12223 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
12225 for (j
= i
+ 1; j
< ndirs
; j
++)
12228 if (saved
[j
] < dirs
[i
].length
)
12230 /* Determine whether the dirs[i] path is a prefix of the
12234 k
= dirs
[j
].prefix
;
12235 while (k
!= -1 && k
!= (int) i
)
12236 k
= dirs
[k
].prefix
;
12240 /* Yes it is. We can possibly save some memory by
12241 writing the filenames in dirs[j] relative to
12243 savehere
[j
] = dirs
[i
].length
;
12244 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
12249 /* Check whether we can save enough to justify adding the dirs[i]
12251 if (total
> dirs
[i
].length
+ 1)
12253 /* It's worthwhile adding. */
12254 for (j
= i
; j
< ndirs
; j
++)
12255 if (savehere
[j
] > 0)
12257 /* Remember how much we saved for this directory so far. */
12258 saved
[j
] = savehere
[j
];
12260 /* Remember the prefix directory. */
12261 dirs
[j
].dir_idx
= i
;
12266 /* Emit the directory name table. */
12267 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
12268 enum dwarf_form str_form
= DW_FORM_string
;
12269 enum dwarf_form idx_form
= DW_FORM_udata
;
12270 if (dwarf_version
>= 5)
12272 const char *comp_dir
= comp_dir_string ();
12273 if (comp_dir
== NULL
)
12275 dw2_asm_output_data (1, 1, "Directory entry format count");
12276 if (DWARF5_USE_DEBUG_LINE_STR
)
12277 str_form
= DW_FORM_line_strp
;
12278 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12279 dw2_asm_output_data_uleb128 (str_form
, "%s",
12280 get_DW_FORM_name (str_form
));
12281 dw2_asm_output_data_uleb128 (ndirs
+ idx_offset
, "Directories count");
12282 if (str_form
== DW_FORM_string
)
12284 dw2_asm_output_nstring (comp_dir
, -1, "Directory Entry: %#x", 0);
12285 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12286 dw2_asm_output_nstring (dirs
[i
].path
,
12288 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
12289 "Directory Entry: %#x", i
+ idx_offset
);
12293 output_line_string (str_form
, comp_dir
, "Directory Entry", 0);
12294 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12297 = ggc_alloc_string (dirs
[i
].path
,
12299 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
);
12300 output_line_string (str_form
, str
, "Directory Entry",
12301 (unsigned) i
+ idx_offset
);
12307 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12308 dw2_asm_output_nstring (dirs
[i
].path
,
12310 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
12311 "Directory Entry: %#x", i
+ idx_offset
);
12313 dw2_asm_output_data (1, 0, "End directory table");
12316 /* We have to emit them in the order of emitted_number since that's
12317 used in the debug info generation. To do this efficiently we
12318 generate a back-mapping of the indices first. */
12319 backmap
= XALLOCAVEC (int, numfiles
);
12320 for (i
= 0; i
< numfiles
; i
++)
12321 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
12323 if (dwarf_version
>= 5)
12325 const char *filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
12326 if (filename0
== NULL
)
12328 /* DW_LNCT_directory_index can use DW_FORM_udata, DW_FORM_data1 and
12329 DW_FORM_data2. Choose one based on the number of directories
12330 and how much space would they occupy in each encoding.
12331 If we have at most 256 directories, all indexes fit into
12332 a single byte, so DW_FORM_data1 is most compact (if there
12333 are at most 128 directories, DW_FORM_udata would be as
12334 compact as that, but not shorter and slower to decode). */
12335 if (ndirs
+ idx_offset
<= 256)
12336 idx_form
= DW_FORM_data1
;
12337 /* If there are more than 65536 directories, we have to use
12338 DW_FORM_udata, DW_FORM_data2 can't refer to them.
12339 Otherwise, compute what space would occupy if all the indexes
12340 used DW_FORM_udata - sum - and compare that to how large would
12341 be DW_FORM_data2 encoding, and pick the more efficient one. */
12342 else if (ndirs
+ idx_offset
<= 65536)
12344 unsigned HOST_WIDE_INT sum
= 1;
12345 for (i
= 0; i
< numfiles
; i
++)
12347 int file_idx
= backmap
[i
];
12348 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
12349 sum
+= size_of_uleb128 (dir_idx
);
12351 if (sum
>= HOST_WIDE_INT_UC (2) * (numfiles
+ 1))
12352 idx_form
= DW_FORM_data2
;
12354 #ifdef VMS_DEBUGGING_INFO
12355 dw2_asm_output_data (1, 4, "File name entry format count");
12357 dw2_asm_output_data (1, 2, "File name entry format count");
12359 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12360 dw2_asm_output_data_uleb128 (str_form
, "%s",
12361 get_DW_FORM_name (str_form
));
12362 dw2_asm_output_data_uleb128 (DW_LNCT_directory_index
,
12363 "DW_LNCT_directory_index");
12364 dw2_asm_output_data_uleb128 (idx_form
, "%s",
12365 get_DW_FORM_name (idx_form
));
12366 #ifdef VMS_DEBUGGING_INFO
12367 dw2_asm_output_data_uleb128 (DW_LNCT_timestamp
, "DW_LNCT_timestamp");
12368 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12369 dw2_asm_output_data_uleb128 (DW_LNCT_size
, "DW_LNCT_size");
12370 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12372 dw2_asm_output_data_uleb128 (numfiles
+ 1, "File names count");
12374 output_line_string (str_form
, filename0
, "File Entry", 0);
12376 /* Include directory index. */
12377 if (idx_form
!= DW_FORM_udata
)
12378 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12381 dw2_asm_output_data_uleb128 (0, NULL
);
12383 #ifdef VMS_DEBUGGING_INFO
12384 dw2_asm_output_data_uleb128 (0, NULL
);
12385 dw2_asm_output_data_uleb128 (0, NULL
);
12389 /* Now write all the file names. */
12390 for (i
= 0; i
< numfiles
; i
++)
12392 int file_idx
= backmap
[i
];
12393 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
12395 #ifdef VMS_DEBUGGING_INFO
12396 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
12398 /* Setting these fields can lead to debugger miscomparisons,
12399 but VMS Debug requires them to be set correctly. */
12404 int maxfilelen
= (strlen (files
[file_idx
].path
)
12405 + dirs
[dir_idx
].length
12406 + MAX_VMS_VERSION_LEN
+ 1);
12407 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
12409 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
12410 snprintf (filebuf
, maxfilelen
, "%s;%d",
12411 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
12413 output_line_string (str_form
, filebuf
, "File Entry", (unsigned) i
+ 1);
12415 /* Include directory index. */
12416 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
12417 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12418 dir_idx
+ idx_offset
, NULL
);
12420 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
12422 /* Modification time. */
12423 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
12424 &cdt
, 0, 0, 0) == 0)
12427 /* File length in bytes. */
12428 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
12429 0, &siz
, 0, 0) == 0)
12432 output_line_string (str_form
,
12433 files
[file_idx
].path
+ dirs
[dir_idx
].length
,
12434 "File Entry", (unsigned) i
+ 1);
12436 /* Include directory index. */
12437 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
12438 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12439 dir_idx
+ idx_offset
, NULL
);
12441 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
12443 if (dwarf_version
>= 5)
12446 /* Modification time. */
12447 dw2_asm_output_data_uleb128 (0, NULL
);
12449 /* File length in bytes. */
12450 dw2_asm_output_data_uleb128 (0, NULL
);
12451 #endif /* VMS_DEBUGGING_INFO */
12454 if (dwarf_version
< 5)
12455 dw2_asm_output_data (1, 0, "End file name table");
12459 /* Output one line number table into the .debug_line section. */
12462 output_one_line_info_table (dw_line_info_table
*table
)
12464 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12465 unsigned int current_line
= 1;
12466 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
12467 dw_line_info_entry
*ent
, *prev_addr
;
12473 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
12475 switch (ent
->opcode
)
12477 case LI_set_address
:
12478 /* ??? Unfortunately, we have little choice here currently, and
12479 must always use the most general form. GCC does not know the
12480 address delta itself, so we can't use DW_LNS_advance_pc. Many
12481 ports do have length attributes which will give an upper bound
12482 on the address range. We could perhaps use length attributes
12483 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
12484 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
12488 /* This can handle any delta. This takes
12489 4+DWARF2_ADDR_SIZE bytes. */
12490 dw2_asm_output_data (1, 0, "set address %s%s", line_label
,
12491 debug_variable_location_views
12492 ? ", reset view to 0" : "");
12493 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12494 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12495 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
12500 case LI_adv_address
:
12502 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
12503 char prev_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12504 ASM_GENERATE_INTERNAL_LABEL (prev_label
, LINE_CODE_LABEL
, prev_addr
->val
);
12508 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
, "fixed advance PC, increment view to %i", view
);
12509 dw2_asm_output_delta (2, line_label
, prev_label
,
12510 "from %s to %s", prev_label
, line_label
);
12517 if (ent
->val
== current_line
)
12519 /* We still need to start a new row, so output a copy insn. */
12520 dw2_asm_output_data (1, DW_LNS_copy
,
12521 "copy line %u", current_line
);
12525 int line_offset
= ent
->val
- current_line
;
12526 int line_delta
= line_offset
- DWARF_LINE_BASE
;
12528 current_line
= ent
->val
;
12529 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
12531 /* This can handle deltas from -10 to 234, using the current
12532 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
12533 This takes 1 byte. */
12534 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
12535 "line %u", current_line
);
12539 /* This can handle any delta. This takes at least 4 bytes,
12540 depending on the value being encoded. */
12541 dw2_asm_output_data (1, DW_LNS_advance_line
,
12542 "advance to line %u", current_line
);
12543 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
12544 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
12550 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
12551 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
12554 case LI_set_column
:
12555 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
12556 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
12559 case LI_negate_stmt
:
12560 current_is_stmt
= !current_is_stmt
;
12561 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
12562 "is_stmt %d", current_is_stmt
);
12565 case LI_set_prologue_end
:
12566 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
12567 "set prologue end");
12570 case LI_set_epilogue_begin
:
12571 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
12572 "set epilogue begin");
12575 case LI_set_discriminator
:
12576 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
12577 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
12578 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
12579 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
12584 /* Emit debug info for the address of the end of the table. */
12585 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
12586 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12587 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12588 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
12590 dw2_asm_output_data (1, 0, "end sequence");
12591 dw2_asm_output_data_uleb128 (1, NULL
);
12592 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
12595 /* Output the source line number correspondence information. This
12596 information goes into the .debug_line section. */
12599 output_line_info (bool prologue_only
)
12601 static unsigned int generation
;
12602 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
12603 char p1
[MAX_ARTIFICIAL_LABEL_BYTES
], p2
[MAX_ARTIFICIAL_LABEL_BYTES
];
12604 bool saw_one
= false;
12607 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, generation
);
12608 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, generation
);
12609 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, generation
);
12610 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, generation
++);
12612 if (!XCOFF_DEBUGGING_INFO
)
12614 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
12615 dw2_asm_output_data (4, 0xffffffff,
12616 "Initial length escape value indicating 64-bit DWARF extension");
12617 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
12618 "Length of Source Line Info");
12621 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
12623 output_dwarf_version ();
12624 if (dwarf_version
>= 5)
12626 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
12627 dw2_asm_output_data (1, 0, "Segment Size");
12629 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
12630 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
12632 /* Define the architecture-dependent minimum instruction length (in bytes).
12633 In this implementation of DWARF, this field is used for information
12634 purposes only. Since GCC generates assembly language, we have no
12635 a priori knowledge of how many instruction bytes are generated for each
12636 source line, and therefore can use only the DW_LNE_set_address and
12637 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
12638 this as '1', which is "correct enough" for all architectures,
12639 and don't let the target override. */
12640 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
12642 if (dwarf_version
>= 4)
12643 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
12644 "Maximum Operations Per Instruction");
12645 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
12646 "Default is_stmt_start flag");
12647 dw2_asm_output_data (1, DWARF_LINE_BASE
,
12648 "Line Base Value (Special Opcodes)");
12649 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
12650 "Line Range Value (Special Opcodes)");
12651 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
12652 "Special Opcode Base");
12654 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
12659 case DW_LNS_advance_pc
:
12660 case DW_LNS_advance_line
:
12661 case DW_LNS_set_file
:
12662 case DW_LNS_set_column
:
12663 case DW_LNS_fixed_advance_pc
:
12664 case DW_LNS_set_isa
:
12672 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
12676 /* Write out the information about the files we use. */
12677 output_file_names ();
12678 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
12681 /* Output the marker for the end of the line number info. */
12682 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12686 if (separate_line_info
)
12688 dw_line_info_table
*table
;
12691 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
12694 output_one_line_info_table (table
);
12698 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
12700 output_one_line_info_table (cold_text_section_line_info
);
12704 /* ??? Some Darwin linkers crash on a .debug_line section with no
12705 sequences. Further, merely a DW_LNE_end_sequence entry is not
12706 sufficient -- the address column must also be initialized.
12707 Make sure to output at least one set_address/end_sequence pair,
12708 choosing .text since that section is always present. */
12709 if (text_section_line_info
->in_use
|| !saw_one
)
12710 output_one_line_info_table (text_section_line_info
);
12712 /* Output the marker for the end of the line number info. */
12713 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12716 /* Return true if DW_AT_endianity should be emitted according to REVERSE. */
12719 need_endianity_attribute_p (bool reverse
)
12721 return reverse
&& (dwarf_version
>= 3 || !dwarf_strict
);
12724 /* Given a pointer to a tree node for some base type, return a pointer to
12725 a DIE that describes the given type. REVERSE is true if the type is
12726 to be interpreted in the reverse storage order wrt the target order.
12728 This routine must only be called for GCC type nodes that correspond to
12729 Dwarf base (fundamental) types. */
12732 base_type_die (tree type
, bool reverse
)
12734 dw_die_ref base_type_result
;
12735 enum dwarf_type encoding
;
12736 bool fpt_used
= false;
12737 struct fixed_point_type_info fpt_info
;
12738 tree type_bias
= NULL_TREE
;
12740 /* If this is a subtype that should not be emitted as a subrange type,
12741 use the base type. See subrange_type_for_debug_p. */
12742 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
12743 type
= TREE_TYPE (type
);
12745 switch (TREE_CODE (type
))
12748 if ((dwarf_version
>= 4 || !dwarf_strict
)
12749 && TYPE_NAME (type
)
12750 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
12751 && DECL_IS_BUILTIN (TYPE_NAME (type
))
12752 && DECL_NAME (TYPE_NAME (type
)))
12754 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
12755 if (strcmp (name
, "char16_t") == 0
12756 || strcmp (name
, "char32_t") == 0)
12758 encoding
= DW_ATE_UTF
;
12762 if ((dwarf_version
>= 3 || !dwarf_strict
)
12763 && lang_hooks
.types
.get_fixed_point_type_info
)
12765 memset (&fpt_info
, 0, sizeof (fpt_info
));
12766 if (lang_hooks
.types
.get_fixed_point_type_info (type
, &fpt_info
))
12769 encoding
= ((TYPE_UNSIGNED (type
))
12770 ? DW_ATE_unsigned_fixed
12771 : DW_ATE_signed_fixed
);
12775 if (TYPE_STRING_FLAG (type
))
12777 if (TYPE_UNSIGNED (type
))
12778 encoding
= DW_ATE_unsigned_char
;
12780 encoding
= DW_ATE_signed_char
;
12782 else if (TYPE_UNSIGNED (type
))
12783 encoding
= DW_ATE_unsigned
;
12785 encoding
= DW_ATE_signed
;
12788 && lang_hooks
.types
.get_type_bias
)
12789 type_bias
= lang_hooks
.types
.get_type_bias (type
);
12793 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
12795 if (dwarf_version
>= 3 || !dwarf_strict
)
12796 encoding
= DW_ATE_decimal_float
;
12798 encoding
= DW_ATE_lo_user
;
12801 encoding
= DW_ATE_float
;
12804 case FIXED_POINT_TYPE
:
12805 if (!(dwarf_version
>= 3 || !dwarf_strict
))
12806 encoding
= DW_ATE_lo_user
;
12807 else if (TYPE_UNSIGNED (type
))
12808 encoding
= DW_ATE_unsigned_fixed
;
12810 encoding
= DW_ATE_signed_fixed
;
12813 /* Dwarf2 doesn't know anything about complex ints, so use
12814 a user defined type for it. */
12816 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
12817 encoding
= DW_ATE_complex_float
;
12819 encoding
= DW_ATE_lo_user
;
12823 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
12824 encoding
= DW_ATE_boolean
;
12828 /* No other TREE_CODEs are Dwarf fundamental types. */
12829 gcc_unreachable ();
12832 base_type_result
= new_die_raw (DW_TAG_base_type
);
12834 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
12835 int_size_in_bytes (type
));
12836 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
12838 if (need_endianity_attribute_p (reverse
))
12839 add_AT_unsigned (base_type_result
, DW_AT_endianity
,
12840 BYTES_BIG_ENDIAN
? DW_END_little
: DW_END_big
);
12842 add_alignment_attribute (base_type_result
, type
);
12846 switch (fpt_info
.scale_factor_kind
)
12848 case fixed_point_scale_factor_binary
:
12849 add_AT_int (base_type_result
, DW_AT_binary_scale
,
12850 fpt_info
.scale_factor
.binary
);
12853 case fixed_point_scale_factor_decimal
:
12854 add_AT_int (base_type_result
, DW_AT_decimal_scale
,
12855 fpt_info
.scale_factor
.decimal
);
12858 case fixed_point_scale_factor_arbitrary
:
12859 /* Arbitrary scale factors cannot be described in standard DWARF,
12863 /* Describe the scale factor as a rational constant. */
12864 const dw_die_ref scale_factor
12865 = new_die (DW_TAG_constant
, comp_unit_die (), type
);
12867 add_AT_unsigned (scale_factor
, DW_AT_GNU_numerator
,
12868 fpt_info
.scale_factor
.arbitrary
.numerator
);
12869 add_AT_int (scale_factor
, DW_AT_GNU_denominator
,
12870 fpt_info
.scale_factor
.arbitrary
.denominator
);
12872 add_AT_die_ref (base_type_result
, DW_AT_small
, scale_factor
);
12877 gcc_unreachable ();
12882 add_scalar_info (base_type_result
, DW_AT_GNU_bias
, type_bias
,
12883 dw_scalar_form_constant
12884 | dw_scalar_form_exprloc
12885 | dw_scalar_form_reference
,
12888 return base_type_result
;
12891 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
12892 named 'auto' in its type: return true for it, false otherwise. */
12895 is_cxx_auto (tree type
)
12899 tree name
= TYPE_IDENTIFIER (type
);
12900 if (name
== get_identifier ("auto")
12901 || name
== get_identifier ("decltype(auto)"))
12907 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
12908 given input type is a Dwarf "fundamental" type. Otherwise return null. */
12911 is_base_type (tree type
)
12913 switch (TREE_CODE (type
))
12917 case FIXED_POINT_TYPE
:
12926 case QUAL_UNION_TYPE
:
12927 case ENUMERAL_TYPE
:
12928 case FUNCTION_TYPE
:
12931 case REFERENCE_TYPE
:
12939 if (is_cxx_auto (type
))
12941 gcc_unreachable ();
12947 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
12948 node, return the size in bits for the type if it is a constant, or else
12949 return the alignment for the type if the type's size is not constant, or
12950 else return BITS_PER_WORD if the type actually turns out to be an
12951 ERROR_MARK node. */
12953 static inline unsigned HOST_WIDE_INT
12954 simple_type_size_in_bits (const_tree type
)
12956 if (TREE_CODE (type
) == ERROR_MARK
)
12957 return BITS_PER_WORD
;
12958 else if (TYPE_SIZE (type
) == NULL_TREE
)
12960 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
12961 return tree_to_uhwi (TYPE_SIZE (type
));
12963 return TYPE_ALIGN (type
);
12966 /* Similarly, but return an offset_int instead of UHWI. */
12968 static inline offset_int
12969 offset_int_type_size_in_bits (const_tree type
)
12971 if (TREE_CODE (type
) == ERROR_MARK
)
12972 return BITS_PER_WORD
;
12973 else if (TYPE_SIZE (type
) == NULL_TREE
)
12975 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
12976 return wi::to_offset (TYPE_SIZE (type
));
12978 return TYPE_ALIGN (type
);
12981 /* Given a pointer to a tree node for a subrange type, return a pointer
12982 to a DIE that describes the given type. */
12985 subrange_type_die (tree type
, tree low
, tree high
, tree bias
,
12986 dw_die_ref context_die
)
12988 dw_die_ref subrange_die
;
12989 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
12991 if (context_die
== NULL
)
12992 context_die
= comp_unit_die ();
12994 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
12996 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
12998 /* The size of the subrange type and its base type do not match,
12999 so we need to generate a size attribute for the subrange type. */
13000 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
13003 add_alignment_attribute (subrange_die
, type
);
13006 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
, NULL
);
13008 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
, NULL
);
13009 if (bias
&& !dwarf_strict
)
13010 add_scalar_info (subrange_die
, DW_AT_GNU_bias
, bias
,
13011 dw_scalar_form_constant
13012 | dw_scalar_form_exprloc
13013 | dw_scalar_form_reference
,
13016 return subrange_die
;
13019 /* Returns the (const and/or volatile) cv_qualifiers associated with
13020 the decl node. This will normally be augmented with the
13021 cv_qualifiers of the underlying type in add_type_attribute. */
13024 decl_quals (const_tree decl
)
13026 return ((TREE_READONLY (decl
)
13027 /* The C++ front-end correctly marks reference-typed
13028 variables as readonly, but from a language (and debug
13029 info) standpoint they are not const-qualified. */
13030 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
13031 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
)
13032 | (TREE_THIS_VOLATILE (decl
)
13033 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
));
13036 /* Determine the TYPE whose qualifiers match the largest strict subset
13037 of the given TYPE_QUALS, and return its qualifiers. Ignore all
13038 qualifiers outside QUAL_MASK. */
13041 get_nearest_type_subqualifiers (tree type
, int type_quals
, int qual_mask
)
13044 int best_rank
= 0, best_qual
= 0, max_rank
;
13046 type_quals
&= qual_mask
;
13047 max_rank
= popcount_hwi (type_quals
) - 1;
13049 for (t
= TYPE_MAIN_VARIANT (type
); t
&& best_rank
< max_rank
;
13050 t
= TYPE_NEXT_VARIANT (t
))
13052 int q
= TYPE_QUALS (t
) & qual_mask
;
13054 if ((q
& type_quals
) == q
&& q
!= type_quals
13055 && check_base_type (t
, type
))
13057 int rank
= popcount_hwi (q
);
13059 if (rank
> best_rank
)
13070 struct dwarf_qual_info_t
{ int q
; enum dwarf_tag t
; };
13071 static const dwarf_qual_info_t dwarf_qual_info
[] =
13073 { TYPE_QUAL_CONST
, DW_TAG_const_type
},
13074 { TYPE_QUAL_VOLATILE
, DW_TAG_volatile_type
},
13075 { TYPE_QUAL_RESTRICT
, DW_TAG_restrict_type
},
13076 { TYPE_QUAL_ATOMIC
, DW_TAG_atomic_type
}
13078 static const unsigned int dwarf_qual_info_size
13079 = sizeof (dwarf_qual_info
) / sizeof (dwarf_qual_info
[0]);
13081 /* If DIE is a qualified DIE of some base DIE with the same parent,
13082 return the base DIE, otherwise return NULL. Set MASK to the
13083 qualifiers added compared to the returned DIE. */
13086 qualified_die_p (dw_die_ref die
, int *mask
, unsigned int depth
)
13089 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13090 if (die
->die_tag
== dwarf_qual_info
[i
].t
)
13092 if (i
== dwarf_qual_info_size
)
13094 if (vec_safe_length (die
->die_attr
) != 1)
13096 dw_die_ref type
= get_AT_ref (die
, DW_AT_type
);
13097 if (type
== NULL
|| type
->die_parent
!= die
->die_parent
)
13099 *mask
|= dwarf_qual_info
[i
].q
;
13102 dw_die_ref ret
= qualified_die_p (type
, mask
, depth
- 1);
13109 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
13110 entry that chains the modifiers specified by CV_QUALS in front of the
13111 given type. REVERSE is true if the type is to be interpreted in the
13112 reverse storage order wrt the target order. */
13115 modified_type_die (tree type
, int cv_quals
, bool reverse
,
13116 dw_die_ref context_die
)
13118 enum tree_code code
= TREE_CODE (type
);
13119 dw_die_ref mod_type_die
;
13120 dw_die_ref sub_die
= NULL
;
13121 tree item_type
= NULL
;
13122 tree qualified_type
;
13123 tree name
, low
, high
;
13124 dw_die_ref mod_scope
;
13125 /* Only these cv-qualifiers are currently handled. */
13126 const int cv_qual_mask
= (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
13127 | TYPE_QUAL_RESTRICT
| TYPE_QUAL_ATOMIC
|
13128 ENCODE_QUAL_ADDR_SPACE(~0U));
13129 const bool reverse_base_type
13130 = need_endianity_attribute_p (reverse
) && is_base_type (type
);
13132 if (code
== ERROR_MARK
)
13135 if (lang_hooks
.types
.get_debug_type
)
13137 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
13139 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
13140 return modified_type_die (debug_type
, cv_quals
, reverse
, context_die
);
13143 cv_quals
&= cv_qual_mask
;
13145 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
13146 tag modifier (and not an attribute) old consumers won't be able
13148 if (dwarf_version
< 3)
13149 cv_quals
&= ~TYPE_QUAL_RESTRICT
;
13151 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
13152 if (dwarf_version
< 5)
13153 cv_quals
&= ~TYPE_QUAL_ATOMIC
;
13155 /* See if we already have the appropriately qualified variant of
13157 qualified_type
= get_qualified_type (type
, cv_quals
);
13159 if (qualified_type
== sizetype
)
13161 /* Try not to expose the internal sizetype type's name. */
13162 if (TYPE_NAME (qualified_type
)
13163 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
13165 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
13167 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
13168 && (TYPE_PRECISION (t
)
13169 == TYPE_PRECISION (qualified_type
))
13170 && (TYPE_UNSIGNED (t
)
13171 == TYPE_UNSIGNED (qualified_type
)));
13172 qualified_type
= t
;
13174 else if (qualified_type
== sizetype
13175 && TREE_CODE (sizetype
) == TREE_CODE (size_type_node
)
13176 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (size_type_node
)
13177 && TYPE_UNSIGNED (sizetype
) == TYPE_UNSIGNED (size_type_node
))
13178 qualified_type
= size_type_node
;
13181 /* If we do, then we can just use its DIE, if it exists. */
13182 if (qualified_type
)
13184 mod_type_die
= lookup_type_die (qualified_type
);
13186 /* DW_AT_endianity doesn't come from a qualifier on the type, so it is
13187 dealt with specially: the DIE with the attribute, if it exists, is
13188 placed immediately after the regular DIE for the same base type. */
13190 && (!reverse_base_type
13191 || ((mod_type_die
= mod_type_die
->die_sib
) != NULL
13192 && get_AT_unsigned (mod_type_die
, DW_AT_endianity
))))
13193 return mod_type_die
;
13196 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
13198 /* Handle C typedef types. */
13200 && TREE_CODE (name
) == TYPE_DECL
13201 && DECL_ORIGINAL_TYPE (name
)
13202 && !DECL_ARTIFICIAL (name
))
13204 tree dtype
= TREE_TYPE (name
);
13206 /* Skip the typedef for base types with DW_AT_endianity, no big deal. */
13207 if (qualified_type
== dtype
&& !reverse_base_type
)
13209 tree origin
= decl_ultimate_origin (name
);
13211 /* Typedef variants that have an abstract origin don't get their own
13212 type DIE (see gen_typedef_die), so fall back on the ultimate
13213 abstract origin instead. */
13214 if (origin
!= NULL
&& origin
!= name
)
13215 return modified_type_die (TREE_TYPE (origin
), cv_quals
, reverse
,
13218 /* For a named type, use the typedef. */
13219 gen_type_die (qualified_type
, context_die
);
13220 return lookup_type_die (qualified_type
);
13224 int dquals
= TYPE_QUALS_NO_ADDR_SPACE (dtype
);
13225 dquals
&= cv_qual_mask
;
13226 if ((dquals
& ~cv_quals
) != TYPE_UNQUALIFIED
13227 || (cv_quals
== dquals
&& DECL_ORIGINAL_TYPE (name
) != type
))
13228 /* cv-unqualified version of named type. Just use
13229 the unnamed type to which it refers. */
13230 return modified_type_die (DECL_ORIGINAL_TYPE (name
), cv_quals
,
13231 reverse
, context_die
);
13232 /* Else cv-qualified version of named type; fall through. */
13236 mod_scope
= scope_die_for (type
, context_die
);
13240 int sub_quals
= 0, first_quals
= 0;
13242 dw_die_ref first
= NULL
, last
= NULL
;
13244 /* Determine a lesser qualified type that most closely matches
13245 this one. Then generate DW_TAG_* entries for the remaining
13247 sub_quals
= get_nearest_type_subqualifiers (type
, cv_quals
,
13249 if (sub_quals
&& use_debug_types
)
13251 bool needed
= false;
13252 /* If emitting type units, make sure the order of qualifiers
13253 is canonical. Thus, start from unqualified type if
13254 an earlier qualifier is missing in sub_quals, but some later
13255 one is present there. */
13256 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13257 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
13259 else if (needed
&& (dwarf_qual_info
[i
].q
& cv_quals
))
13265 mod_type_die
= modified_type_die (type
, sub_quals
, reverse
, context_die
);
13266 if (mod_scope
&& mod_type_die
&& mod_type_die
->die_parent
== mod_scope
)
13268 /* As not all intermediate qualified DIEs have corresponding
13269 tree types, ensure that qualified DIEs in the same scope
13270 as their DW_AT_type are emitted after their DW_AT_type,
13271 only with other qualified DIEs for the same type possibly
13272 in between them. Determine the range of such qualified
13273 DIEs now (first being the base type, last being corresponding
13274 last qualified DIE for it). */
13275 unsigned int count
= 0;
13276 first
= qualified_die_p (mod_type_die
, &first_quals
,
13277 dwarf_qual_info_size
);
13279 first
= mod_type_die
;
13280 gcc_assert ((first_quals
& ~sub_quals
) == 0);
13281 for (count
= 0, last
= first
;
13282 count
< (1U << dwarf_qual_info_size
);
13283 count
++, last
= last
->die_sib
)
13286 if (last
== mod_scope
->die_child
)
13288 if (qualified_die_p (last
->die_sib
, &quals
, dwarf_qual_info_size
)
13294 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13295 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
13298 if (first
&& first
!= last
)
13300 for (d
= first
->die_sib
; ; d
= d
->die_sib
)
13303 qualified_die_p (d
, &quals
, dwarf_qual_info_size
);
13304 if (quals
== (first_quals
| dwarf_qual_info
[i
].q
))
13320 d
= new_die_raw (dwarf_qual_info
[i
].t
);
13321 add_child_die_after (mod_scope
, d
, last
);
13325 d
= new_die (dwarf_qual_info
[i
].t
, mod_scope
, type
);
13327 add_AT_die_ref (d
, DW_AT_type
, mod_type_die
);
13329 first_quals
|= dwarf_qual_info
[i
].q
;
13332 else if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
)
13334 dwarf_tag tag
= DW_TAG_pointer_type
;
13335 if (code
== REFERENCE_TYPE
)
13337 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
13338 tag
= DW_TAG_rvalue_reference_type
;
13340 tag
= DW_TAG_reference_type
;
13342 mod_type_die
= new_die (tag
, mod_scope
, type
);
13344 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
13345 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
13346 add_alignment_attribute (mod_type_die
, type
);
13347 item_type
= TREE_TYPE (type
);
13349 addr_space_t as
= TYPE_ADDR_SPACE (item_type
);
13350 if (!ADDR_SPACE_GENERIC_P (as
))
13352 int action
= targetm
.addr_space
.debug (as
);
13355 /* Positive values indicate an address_class. */
13356 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, action
);
13360 /* Negative values indicate an (inverted) segment base reg. */
13362 = one_reg_loc_descriptor (~action
, VAR_INIT_STATUS_INITIALIZED
);
13363 add_AT_loc (mod_type_die
, DW_AT_segment
, d
);
13367 else if (code
== INTEGER_TYPE
13368 && TREE_TYPE (type
) != NULL_TREE
13369 && subrange_type_for_debug_p (type
, &low
, &high
))
13371 tree bias
= NULL_TREE
;
13372 if (lang_hooks
.types
.get_type_bias
)
13373 bias
= lang_hooks
.types
.get_type_bias (type
);
13374 mod_type_die
= subrange_type_die (type
, low
, high
, bias
, context_die
);
13375 item_type
= TREE_TYPE (type
);
13377 else if (is_base_type (type
))
13379 mod_type_die
= base_type_die (type
, reverse
);
13381 /* The DIE with DW_AT_endianity is placed right after the naked DIE. */
13382 if (reverse_base_type
)
13384 dw_die_ref after_die
13385 = modified_type_die (type
, cv_quals
, false, context_die
);
13386 add_child_die_after (comp_unit_die (), mod_type_die
, after_die
);
13389 add_child_die (comp_unit_die (), mod_type_die
);
13391 add_pubtype (type
, mod_type_die
);
13395 gen_type_die (type
, context_die
);
13397 /* We have to get the type_main_variant here (and pass that to the
13398 `lookup_type_die' routine) because the ..._TYPE node we have
13399 might simply be a *copy* of some original type node (where the
13400 copy was created to help us keep track of typedef names) and
13401 that copy might have a different TYPE_UID from the original
13403 if (TREE_CODE (type
) == FUNCTION_TYPE
13404 || TREE_CODE (type
) == METHOD_TYPE
)
13406 /* For function/method types, can't just use type_main_variant here,
13407 because that can have different ref-qualifiers for C++,
13408 but try to canonicalize. */
13409 tree main
= TYPE_MAIN_VARIANT (type
);
13410 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
13411 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
13412 && check_base_type (t
, main
)
13413 && check_lang_type (t
, type
))
13414 return lookup_type_die (t
);
13415 return lookup_type_die (type
);
13417 else if (TREE_CODE (type
) != VECTOR_TYPE
13418 && TREE_CODE (type
) != ARRAY_TYPE
)
13419 return lookup_type_die (type_main_variant (type
));
13421 /* Vectors have the debugging information in the type,
13422 not the main variant. */
13423 return lookup_type_die (type
);
13426 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
13427 don't output a DW_TAG_typedef, since there isn't one in the
13428 user's program; just attach a DW_AT_name to the type.
13429 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
13430 if the base type already has the same name. */
13432 && ((TREE_CODE (name
) != TYPE_DECL
13433 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
13434 || (cv_quals
== TYPE_UNQUALIFIED
)))
13435 || (TREE_CODE (name
) == TYPE_DECL
13436 && TREE_TYPE (name
) == qualified_type
13437 && DECL_NAME (name
))))
13439 if (TREE_CODE (name
) == TYPE_DECL
)
13440 /* Could just call add_name_and_src_coords_attributes here,
13441 but since this is a builtin type it doesn't have any
13442 useful source coordinates anyway. */
13443 name
= DECL_NAME (name
);
13444 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
13446 /* This probably indicates a bug. */
13447 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
13449 name
= TYPE_IDENTIFIER (type
);
13450 add_name_attribute (mod_type_die
,
13451 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
13454 if (qualified_type
&& !reverse_base_type
)
13455 equate_type_number_to_die (qualified_type
, mod_type_die
);
13458 /* We must do this after the equate_type_number_to_die call, in case
13459 this is a recursive type. This ensures that the modified_type_die
13460 recursion will terminate even if the type is recursive. Recursive
13461 types are possible in Ada. */
13462 sub_die
= modified_type_die (item_type
,
13463 TYPE_QUALS_NO_ADDR_SPACE (item_type
),
13467 if (sub_die
!= NULL
)
13468 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
13470 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
13471 if (TYPE_ARTIFICIAL (type
))
13472 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
13474 return mod_type_die
;
13477 /* Generate DIEs for the generic parameters of T.
13478 T must be either a generic type or a generic function.
13479 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
13482 gen_generic_params_dies (tree t
)
13486 dw_die_ref die
= NULL
;
13489 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
13493 die
= lookup_type_die (t
);
13494 else if (DECL_P (t
))
13495 die
= lookup_decl_die (t
);
13499 parms
= lang_hooks
.get_innermost_generic_parms (t
);
13501 /* T has no generic parameter. It means T is neither a generic type
13502 or function. End of story. */
13505 parms_num
= TREE_VEC_LENGTH (parms
);
13506 args
= lang_hooks
.get_innermost_generic_args (t
);
13507 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
13508 non_default
= int_cst_value (TREE_CHAIN (args
));
13510 non_default
= TREE_VEC_LENGTH (args
);
13511 for (i
= 0; i
< parms_num
; i
++)
13513 tree parm
, arg
, arg_pack_elems
;
13514 dw_die_ref parm_die
;
13516 parm
= TREE_VEC_ELT (parms
, i
);
13517 arg
= TREE_VEC_ELT (args
, i
);
13518 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
13519 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
13521 if (parm
&& TREE_VALUE (parm
) && arg
)
13523 /* If PARM represents a template parameter pack,
13524 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
13525 by DW_TAG_template_*_parameter DIEs for the argument
13526 pack elements of ARG. Note that ARG would then be
13527 an argument pack. */
13528 if (arg_pack_elems
)
13529 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
13533 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
13534 true /* emit name */, die
);
13535 if (i
>= non_default
)
13536 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
13541 /* Create and return a DIE for PARM which should be
13542 the representation of a generic type parameter.
13543 For instance, in the C++ front end, PARM would be a template parameter.
13544 ARG is the argument to PARM.
13545 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
13547 PARENT_DIE is the parent DIE which the new created DIE should be added to,
13548 as a child node. */
13551 generic_parameter_die (tree parm
, tree arg
,
13553 dw_die_ref parent_die
)
13555 dw_die_ref tmpl_die
= NULL
;
13556 const char *name
= NULL
;
13558 if (!parm
|| !DECL_NAME (parm
) || !arg
)
13561 /* We support non-type generic parameters and arguments,
13562 type generic parameters and arguments, as well as
13563 generic generic parameters (a.k.a. template template parameters in C++)
13565 if (TREE_CODE (parm
) == PARM_DECL
)
13566 /* PARM is a nontype generic parameter */
13567 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
13568 else if (TREE_CODE (parm
) == TYPE_DECL
)
13569 /* PARM is a type generic parameter. */
13570 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
13571 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
13572 /* PARM is a generic generic parameter.
13573 Its DIE is a GNU extension. It shall have a
13574 DW_AT_name attribute to represent the name of the template template
13575 parameter, and a DW_AT_GNU_template_name attribute to represent the
13576 name of the template template argument. */
13577 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
13580 gcc_unreachable ();
13586 /* If PARM is a generic parameter pack, it means we are
13587 emitting debug info for a template argument pack element.
13588 In other terms, ARG is a template argument pack element.
13589 In that case, we don't emit any DW_AT_name attribute for
13593 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
13595 add_AT_string (tmpl_die
, DW_AT_name
, name
);
13598 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
13600 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
13601 TMPL_DIE should have a child DW_AT_type attribute that is set
13602 to the type of the argument to PARM, which is ARG.
13603 If PARM is a type generic parameter, TMPL_DIE should have a
13604 child DW_AT_type that is set to ARG. */
13605 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
13606 add_type_attribute (tmpl_die
, tmpl_type
,
13607 (TREE_THIS_VOLATILE (tmpl_type
)
13608 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
),
13609 false, parent_die
);
13613 /* So TMPL_DIE is a DIE representing a
13614 a generic generic template parameter, a.k.a template template
13615 parameter in C++ and arg is a template. */
13617 /* The DW_AT_GNU_template_name attribute of the DIE must be set
13618 to the name of the argument. */
13619 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
13621 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
13624 if (TREE_CODE (parm
) == PARM_DECL
)
13625 /* So PARM is a non-type generic parameter.
13626 DWARF3 5.6.8 says we must set a DW_AT_const_value child
13627 attribute of TMPL_DIE which value represents the value
13629 We must be careful here:
13630 The value of ARG might reference some function decls.
13631 We might currently be emitting debug info for a generic
13632 type and types are emitted before function decls, we don't
13633 know if the function decls referenced by ARG will actually be
13634 emitted after cgraph computations.
13635 So must defer the generation of the DW_AT_const_value to
13636 after cgraph is ready. */
13637 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
13643 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
13644 PARM_PACK must be a template parameter pack. The returned DIE
13645 will be child DIE of PARENT_DIE. */
13648 template_parameter_pack_die (tree parm_pack
,
13649 tree parm_pack_args
,
13650 dw_die_ref parent_die
)
13655 gcc_assert (parent_die
&& parm_pack
);
13657 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
13658 add_name_and_src_coords_attributes (die
, parm_pack
);
13659 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
13660 generic_parameter_die (parm_pack
,
13661 TREE_VEC_ELT (parm_pack_args
, j
),
13662 false /* Don't emit DW_AT_name */,
13667 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
13668 an enumerated type. */
13671 type_is_enum (const_tree type
)
13673 return TREE_CODE (type
) == ENUMERAL_TYPE
;
13676 /* Return the DBX register number described by a given RTL node. */
13678 static unsigned int
13679 dbx_reg_number (const_rtx rtl
)
13681 unsigned regno
= REGNO (rtl
);
13683 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
13685 #ifdef LEAF_REG_REMAP
13686 if (crtl
->uses_only_leaf_regs
)
13688 int leaf_reg
= LEAF_REG_REMAP (regno
);
13689 if (leaf_reg
!= -1)
13690 regno
= (unsigned) leaf_reg
;
13694 regno
= DBX_REGISTER_NUMBER (regno
);
13695 gcc_assert (regno
!= INVALID_REGNUM
);
13699 /* Optionally add a DW_OP_piece term to a location description expression.
13700 DW_OP_piece is only added if the location description expression already
13701 doesn't end with DW_OP_piece. */
13704 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
13706 dw_loc_descr_ref loc
;
13708 if (*list_head
!= NULL
)
13710 /* Find the end of the chain. */
13711 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
13714 if (loc
->dw_loc_opc
!= DW_OP_piece
)
13715 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
13719 /* Return a location descriptor that designates a machine register or
13720 zero if there is none. */
13722 static dw_loc_descr_ref
13723 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
13727 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
13730 /* We only use "frame base" when we're sure we're talking about the
13731 post-prologue local stack frame. We do this by *not* running
13732 register elimination until this point, and recognizing the special
13733 argument pointer and soft frame pointer rtx's.
13734 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
13735 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
13736 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
13738 dw_loc_descr_ref result
= NULL
;
13740 if (dwarf_version
>= 4 || !dwarf_strict
)
13742 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
13745 add_loc_descr (&result
,
13746 new_loc_descr (DW_OP_stack_value
, 0, 0));
13751 regs
= targetm
.dwarf_register_span (rtl
);
13753 if (REG_NREGS (rtl
) > 1 || regs
)
13754 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
13757 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
13758 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
13760 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
13764 /* Return a location descriptor that designates a machine register for
13765 a given hard register number. */
13767 static dw_loc_descr_ref
13768 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
13770 dw_loc_descr_ref reg_loc_descr
;
13774 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
13776 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
13778 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13779 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13781 return reg_loc_descr
;
13784 /* Given an RTL of a register, return a location descriptor that
13785 designates a value that spans more than one register. */
13787 static dw_loc_descr_ref
13788 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
13789 enum var_init_status initialized
)
13792 dw_loc_descr_ref loc_result
= NULL
;
13794 /* Simple, contiguous registers. */
13795 if (regs
== NULL_RTX
)
13797 unsigned reg
= REGNO (rtl
);
13800 #ifdef LEAF_REG_REMAP
13801 if (crtl
->uses_only_leaf_regs
)
13803 int leaf_reg
= LEAF_REG_REMAP (reg
);
13804 if (leaf_reg
!= -1)
13805 reg
= (unsigned) leaf_reg
;
13809 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
13810 nregs
= REG_NREGS (rtl
);
13812 /* At present we only track constant-sized pieces. */
13813 if (!GET_MODE_SIZE (GET_MODE (rtl
)).is_constant (&size
))
13820 dw_loc_descr_ref t
;
13822 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
13823 VAR_INIT_STATUS_INITIALIZED
);
13824 add_loc_descr (&loc_result
, t
);
13825 add_loc_descr_op_piece (&loc_result
, size
);
13831 /* Now onto stupid register sets in non contiguous locations. */
13833 gcc_assert (GET_CODE (regs
) == PARALLEL
);
13835 /* At present we only track constant-sized pieces. */
13836 if (!GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0))).is_constant (&size
))
13840 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
13842 dw_loc_descr_ref t
;
13844 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
13845 VAR_INIT_STATUS_INITIALIZED
);
13846 add_loc_descr (&loc_result
, t
);
13847 add_loc_descr_op_piece (&loc_result
, size
);
13850 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13851 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13855 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
13857 /* Return a location descriptor that designates a constant i,
13858 as a compound operation from constant (i >> shift), constant shift
13861 static dw_loc_descr_ref
13862 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
13864 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
13865 add_loc_descr (&ret
, int_loc_descriptor (shift
));
13866 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
13870 /* Return a location descriptor that designates constant POLY_I. */
13872 static dw_loc_descr_ref
13873 int_loc_descriptor (poly_int64 poly_i
)
13875 enum dwarf_location_atom op
;
13878 if (!poly_i
.is_constant (&i
))
13880 /* Create location descriptions for the non-constant part and
13881 add any constant offset at the end. */
13882 dw_loc_descr_ref ret
= NULL
;
13883 HOST_WIDE_INT constant
= poly_i
.coeffs
[0];
13884 for (unsigned int j
= 1; j
< NUM_POLY_INT_COEFFS
; ++j
)
13886 HOST_WIDE_INT coeff
= poly_i
.coeffs
[j
];
13889 dw_loc_descr_ref start
= ret
;
13890 unsigned int factor
;
13892 unsigned int regno
= targetm
.dwarf_poly_indeterminate_value
13893 (j
, &factor
, &bias
);
13895 /* Add COEFF * ((REGNO / FACTOR) - BIAS) to the value:
13896 add COEFF * (REGNO / FACTOR) now and subtract
13897 COEFF * BIAS from the final constant part. */
13898 constant
-= coeff
* bias
;
13899 add_loc_descr (&ret
, new_reg_loc_descr (regno
, 0));
13900 if (coeff
% factor
== 0)
13904 int amount
= exact_log2 (factor
);
13905 gcc_assert (amount
>= 0);
13906 add_loc_descr (&ret
, int_loc_descriptor (amount
));
13907 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
13911 add_loc_descr (&ret
, int_loc_descriptor (coeff
));
13912 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
13915 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
13918 loc_descr_plus_const (&ret
, constant
);
13922 /* Pick the smallest representation of a constant, rather than just
13923 defaulting to the LEB encoding. */
13926 int clz
= clz_hwi (i
);
13927 int ctz
= ctz_hwi (i
);
13929 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
13930 else if (i
<= 0xff)
13931 op
= DW_OP_const1u
;
13932 else if (i
<= 0xffff)
13933 op
= DW_OP_const2u
;
13934 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
13935 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
13936 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
13937 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
13938 while DW_OP_const4u is 5 bytes. */
13939 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
13940 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13941 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
13942 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
13943 while DW_OP_const4u is 5 bytes. */
13944 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
13946 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
13947 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
13950 /* As i >= 2**31, the double cast above will yield a negative number.
13951 Since wrapping is defined in DWARF expressions we can output big
13952 positive integers as small negative ones, regardless of the size
13955 Here, since the evaluator will handle 32-bit values and since i >=
13956 2**31, we know it's going to be interpreted as a negative literal:
13957 store it this way if we can do better than 5 bytes this way. */
13958 return int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
13960 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
13961 op
= DW_OP_const4u
;
13963 /* Past this point, i >= 0x100000000 and thus DW_OP_constu will take at
13964 least 6 bytes: see if we can do better before falling back to it. */
13965 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13966 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
13967 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes. */
13968 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
13969 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
13970 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
13971 >= HOST_BITS_PER_WIDE_INT
)
13972 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
13973 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes. */
13974 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
13975 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
13976 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
13977 && size_of_uleb128 (i
) > 6)
13978 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
13979 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
13986 op
= DW_OP_const1s
;
13987 else if (i
>= -0x8000)
13988 op
= DW_OP_const2s
;
13989 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
13991 if (size_of_int_loc_descriptor (i
) < 5)
13993 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
13994 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
13997 op
= DW_OP_const4s
;
14001 if (size_of_int_loc_descriptor (i
)
14002 < (unsigned long) 1 + size_of_sleb128 (i
))
14004 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
14005 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14012 return new_loc_descr (op
, i
, 0);
14015 /* Likewise, for unsigned constants. */
14017 static dw_loc_descr_ref
14018 uint_loc_descriptor (unsigned HOST_WIDE_INT i
)
14020 const unsigned HOST_WIDE_INT max_int
= INTTYPE_MAXIMUM (HOST_WIDE_INT
);
14021 const unsigned HOST_WIDE_INT max_uint
14022 = INTTYPE_MAXIMUM (unsigned HOST_WIDE_INT
);
14024 /* If possible, use the clever signed constants handling. */
14026 return int_loc_descriptor ((HOST_WIDE_INT
) i
);
14028 /* Here, we are left with positive numbers that cannot be represented as
14029 HOST_WIDE_INT, i.e.:
14030 max (HOST_WIDE_INT) < i <= max (unsigned HOST_WIDE_INT)
14032 Using DW_OP_const4/8/./u operation to encode them consumes a lot of bytes
14033 whereas may be better to output a negative integer: thanks to integer
14034 wrapping, we know that:
14035 x = x - 2 ** DWARF2_ADDR_SIZE
14036 = x - 2 * (max (HOST_WIDE_INT) + 1)
14037 So numbers close to max (unsigned HOST_WIDE_INT) could be represented as
14038 small negative integers. Let's try that in cases it will clearly improve
14039 the encoding: there is no gain turning DW_OP_const4u into
14041 if (DWARF2_ADDR_SIZE
* 8 == HOST_BITS_PER_WIDE_INT
14042 && ((DWARF2_ADDR_SIZE
== 4 && i
> max_uint
- 0x8000)
14043 || (DWARF2_ADDR_SIZE
== 8 && i
> max_uint
- 0x80000000)))
14045 const unsigned HOST_WIDE_INT first_shift
= i
- max_int
- 1;
14047 /* Now, -1 < first_shift <= max (HOST_WIDE_INT)
14048 i.e. 0 <= first_shift <= max (HOST_WIDE_INT). */
14049 const HOST_WIDE_INT second_shift
14050 = (HOST_WIDE_INT
) first_shift
- (HOST_WIDE_INT
) max_int
- 1;
14052 /* So we finally have:
14053 -max (HOST_WIDE_INT) - 1 <= second_shift <= -1.
14054 i.e. min (HOST_WIDE_INT) <= second_shift < 0. */
14055 return int_loc_descriptor (second_shift
);
14058 /* Last chance: fallback to a simple constant operation. */
14059 return new_loc_descr
14060 ((HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14066 /* Generate and return a location description that computes the unsigned
14067 comparison of the two stack top entries (a OP b where b is the top-most
14068 entry and a is the second one). The KIND of comparison can be LT_EXPR,
14069 LE_EXPR, GT_EXPR or GE_EXPR. */
14071 static dw_loc_descr_ref
14072 uint_comparison_loc_list (enum tree_code kind
)
14074 enum dwarf_location_atom op
, flip_op
;
14075 dw_loc_descr_ref ret
, bra_node
, jmp_node
, tmp
;
14092 gcc_unreachable ();
14095 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14096 jmp_node
= new_loc_descr (DW_OP_skip
, 0, 0);
14098 /* Until DWARFv4, operations all work on signed integers. It is nevertheless
14099 possible to perform unsigned comparisons: we just have to distinguish
14102 1. when a and b have the same sign (as signed integers); then we should
14103 return: a OP(signed) b;
14105 2. when a is a negative signed integer while b is a positive one, then a
14106 is a greater unsigned integer than b; likewise when a and b's roles
14109 So first, compare the sign of the two operands. */
14110 ret
= new_loc_descr (DW_OP_over
, 0, 0);
14111 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
14112 add_loc_descr (&ret
, new_loc_descr (DW_OP_xor
, 0, 0));
14113 /* If they have different signs (i.e. they have different sign bits), then
14114 the stack top value has now the sign bit set and thus it's smaller than
14116 add_loc_descr (&ret
, new_loc_descr (DW_OP_lit0
, 0, 0));
14117 add_loc_descr (&ret
, new_loc_descr (DW_OP_lt
, 0, 0));
14118 add_loc_descr (&ret
, bra_node
);
14120 /* We are in case 1. At this point, we know both operands have the same
14121 sign, to it's safe to use the built-in signed comparison. */
14122 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14123 add_loc_descr (&ret
, jmp_node
);
14125 /* We are in case 2. Here, we know both operands do not have the same sign,
14126 so we have to flip the signed comparison. */
14127 flip_op
= (kind
== LT_EXPR
|| kind
== LE_EXPR
) ? DW_OP_gt
: DW_OP_lt
;
14128 tmp
= new_loc_descr (flip_op
, 0, 0);
14129 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14130 bra_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14131 add_loc_descr (&ret
, tmp
);
14133 /* This dummy operation is necessary to make the two branches join. */
14134 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
14135 jmp_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14136 jmp_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14137 add_loc_descr (&ret
, tmp
);
14142 /* Likewise, but takes the location description lists (might be destructive on
14143 them). Return NULL if either is NULL or if concatenation fails. */
14145 static dw_loc_list_ref
14146 loc_list_from_uint_comparison (dw_loc_list_ref left
, dw_loc_list_ref right
,
14147 enum tree_code kind
)
14149 if (left
== NULL
|| right
== NULL
)
14152 add_loc_list (&left
, right
);
14156 add_loc_descr_to_each (left
, uint_comparison_loc_list (kind
));
14160 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
14161 without actually allocating it. */
14163 static unsigned long
14164 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
14166 return size_of_int_loc_descriptor (i
>> shift
)
14167 + size_of_int_loc_descriptor (shift
)
14171 /* Return size_of_locs (int_loc_descriptor (i)) without
14172 actually allocating it. */
14174 static unsigned long
14175 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
14184 else if (i
<= 0xff)
14186 else if (i
<= 0xffff)
14190 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
14191 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
14192 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14194 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14195 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
14196 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14198 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
14199 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
14201 return size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
14202 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14204 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
14205 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14206 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
14207 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14209 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
14210 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
14211 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14213 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
14214 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
14216 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14225 else if (i
>= -0x8000)
14227 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
14229 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
14231 s
= size_of_int_loc_descriptor (-i
) + 1;
14239 unsigned long r
= 1 + size_of_sleb128 (i
);
14240 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
14242 s
= size_of_int_loc_descriptor (-i
) + 1;
14251 /* Return loc description representing "address" of integer value.
14252 This can appear only as toplevel expression. */
14254 static dw_loc_descr_ref
14255 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
14258 dw_loc_descr_ref loc_result
= NULL
;
14260 if (!(dwarf_version
>= 4 || !dwarf_strict
))
14263 litsize
= size_of_int_loc_descriptor (i
);
14264 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
14265 is more compact. For DW_OP_stack_value we need:
14266 litsize + 1 (DW_OP_stack_value)
14267 and for DW_OP_implicit_value:
14268 1 (DW_OP_implicit_value) + 1 (length) + size. */
14269 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
14271 loc_result
= int_loc_descriptor (i
);
14272 add_loc_descr (&loc_result
,
14273 new_loc_descr (DW_OP_stack_value
, 0, 0));
14277 loc_result
= new_loc_descr (DW_OP_implicit_value
,
14279 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
14280 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
14284 /* Return a location descriptor that designates a base+offset location. */
14286 static dw_loc_descr_ref
14287 based_loc_descr (rtx reg
, poly_int64 offset
,
14288 enum var_init_status initialized
)
14290 unsigned int regno
;
14291 dw_loc_descr_ref result
;
14292 dw_fde_ref fde
= cfun
->fde
;
14294 /* We only use "frame base" when we're sure we're talking about the
14295 post-prologue local stack frame. We do this by *not* running
14296 register elimination until this point, and recognizing the special
14297 argument pointer and soft frame pointer rtx's. */
14298 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
14300 rtx elim
= (ira_use_lra_p
14301 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
14302 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
14306 elim
= strip_offset_and_add (elim
, &offset
);
14307 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
14308 && (elim
== hard_frame_pointer_rtx
14309 || elim
== stack_pointer_rtx
))
14310 || elim
== (frame_pointer_needed
14311 ? hard_frame_pointer_rtx
14312 : stack_pointer_rtx
));
14314 /* If drap register is used to align stack, use frame
14315 pointer + offset to access stack variables. If stack
14316 is aligned without drap, use stack pointer + offset to
14317 access stack variables. */
14318 if (crtl
->stack_realign_tried
14319 && reg
== frame_pointer_rtx
)
14322 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
14323 ? HARD_FRAME_POINTER_REGNUM
14325 return new_reg_loc_descr (base_reg
, offset
);
14328 gcc_assert (frame_pointer_fb_offset_valid
);
14329 offset
+= frame_pointer_fb_offset
;
14330 HOST_WIDE_INT const_offset
;
14331 if (offset
.is_constant (&const_offset
))
14332 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
14335 dw_loc_descr_ref ret
= new_loc_descr (DW_OP_fbreg
, 0, 0);
14336 loc_descr_plus_const (&ret
, offset
);
14342 regno
= REGNO (reg
);
14343 #ifdef LEAF_REG_REMAP
14344 if (crtl
->uses_only_leaf_regs
)
14346 int leaf_reg
= LEAF_REG_REMAP (regno
);
14347 if (leaf_reg
!= -1)
14348 regno
= (unsigned) leaf_reg
;
14351 regno
= DWARF_FRAME_REGNUM (regno
);
14353 HOST_WIDE_INT const_offset
;
14354 if (!optimize
&& fde
14355 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
)
14356 && offset
.is_constant (&const_offset
))
14358 /* Use cfa+offset to represent the location of arguments passed
14359 on the stack when drap is used to align stack.
14360 Only do this when not optimizing, for optimized code var-tracking
14361 is supposed to track where the arguments live and the register
14362 used as vdrap or drap in some spot might be used for something
14363 else in other part of the routine. */
14364 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
14367 result
= new_reg_loc_descr (regno
, offset
);
14369 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14370 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14375 /* Return true if this RTL expression describes a base+offset calculation. */
14378 is_based_loc (const_rtx rtl
)
14380 return (GET_CODE (rtl
) == PLUS
14381 && ((REG_P (XEXP (rtl
, 0))
14382 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
14383 && CONST_INT_P (XEXP (rtl
, 1)))));
14386 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
14389 static dw_loc_descr_ref
14390 tls_mem_loc_descriptor (rtx mem
)
14393 dw_loc_descr_ref loc_result
;
14395 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
14398 base
= get_base_address (MEM_EXPR (mem
));
14401 || !DECL_THREAD_LOCAL_P (base
))
14404 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1, NULL
);
14405 if (loc_result
== NULL
)
14408 if (maybe_ne (MEM_OFFSET (mem
), 0))
14409 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
14414 /* Output debug info about reason why we failed to expand expression as dwarf
14418 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
14420 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
14422 fprintf (dump_file
, "Failed to expand as dwarf: ");
14424 print_generic_expr (dump_file
, expr
, dump_flags
);
14427 fprintf (dump_file
, "\n");
14428 print_rtl (dump_file
, rtl
);
14430 fprintf (dump_file
, "\nReason: %s\n", reason
);
14434 /* Helper function for const_ok_for_output. */
14437 const_ok_for_output_1 (rtx rtl
)
14439 if (targetm
.const_not_ok_for_debug_p (rtl
))
14441 if (GET_CODE (rtl
) != UNSPEC
)
14443 expansion_failed (NULL_TREE
, rtl
,
14444 "Expression rejected for debug by the backend.\n");
14448 /* If delegitimize_address couldn't do anything with the UNSPEC, and
14449 the target hook doesn't explicitly allow it in debug info, assume
14450 we can't express it in the debug info. */
14451 /* Don't complain about TLS UNSPECs, those are just too hard to
14452 delegitimize. Note this could be a non-decl SYMBOL_REF such as
14453 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
14454 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
14456 && (XVECLEN (rtl
, 0) == 0
14457 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
14458 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
))
14459 inform (current_function_decl
14460 ? DECL_SOURCE_LOCATION (current_function_decl
)
14461 : UNKNOWN_LOCATION
,
14462 #if NUM_UNSPEC_VALUES > 0
14463 "non-delegitimized UNSPEC %s (%d) found in variable location",
14464 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
14465 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
14468 "non-delegitimized UNSPEC %d found in variable location",
14471 expansion_failed (NULL_TREE
, rtl
,
14472 "UNSPEC hasn't been delegitimized.\n");
14476 if (CONST_POLY_INT_P (rtl
))
14479 if (targetm
.const_not_ok_for_debug_p (rtl
))
14481 expansion_failed (NULL_TREE
, rtl
,
14482 "Expression rejected for debug by the backend.\n");
14486 /* FIXME: Refer to PR60655. It is possible for simplification
14487 of rtl expressions in var tracking to produce such expressions.
14488 We should really identify / validate expressions
14489 enclosed in CONST that can be handled by assemblers on various
14490 targets and only handle legitimate cases here. */
14491 switch (GET_CODE (rtl
))
14502 if (CONSTANT_POOL_ADDRESS_P (rtl
))
14505 get_pool_constant_mark (rtl
, &marked
);
14506 /* If all references to this pool constant were optimized away,
14507 it was not output and thus we can't represent it. */
14510 expansion_failed (NULL_TREE
, rtl
,
14511 "Constant was removed from constant pool.\n");
14516 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
14519 /* Avoid references to external symbols in debug info, on several targets
14520 the linker might even refuse to link when linking a shared library,
14521 and in many other cases the relocations for .debug_info/.debug_loc are
14522 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
14523 to be defined within the same shared library or executable are fine. */
14524 if (SYMBOL_REF_EXTERNAL_P (rtl
))
14526 tree decl
= SYMBOL_REF_DECL (rtl
);
14528 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
14530 expansion_failed (NULL_TREE
, rtl
,
14531 "Symbol not defined in current TU.\n");
14539 /* Return true if constant RTL can be emitted in DW_OP_addr or
14540 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
14541 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
14544 const_ok_for_output (rtx rtl
)
14546 if (GET_CODE (rtl
) == SYMBOL_REF
)
14547 return const_ok_for_output_1 (rtl
);
14549 if (GET_CODE (rtl
) == CONST
)
14551 subrtx_var_iterator::array_type array
;
14552 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
14553 if (!const_ok_for_output_1 (*iter
))
14561 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
14562 if possible, NULL otherwise. */
14565 base_type_for_mode (machine_mode mode
, bool unsignedp
)
14567 dw_die_ref type_die
;
14568 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
14572 switch (TREE_CODE (type
))
14580 type_die
= lookup_type_die (type
);
14582 type_die
= modified_type_die (type
, TYPE_UNQUALIFIED
, false,
14584 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
14589 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
14590 type matching MODE, or, if MODE is narrower than or as wide as
14591 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
14594 static dw_loc_descr_ref
14595 convert_descriptor_to_mode (scalar_int_mode mode
, dw_loc_descr_ref op
)
14597 machine_mode outer_mode
= mode
;
14598 dw_die_ref type_die
;
14599 dw_loc_descr_ref cvt
;
14601 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
14603 add_loc_descr (&op
, new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0));
14606 type_die
= base_type_for_mode (outer_mode
, 1);
14607 if (type_die
== NULL
)
14609 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14610 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14611 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14612 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14613 add_loc_descr (&op
, cvt
);
14617 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
14619 static dw_loc_descr_ref
14620 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
14621 dw_loc_descr_ref op1
)
14623 dw_loc_descr_ref ret
= op0
;
14624 add_loc_descr (&ret
, op1
);
14625 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14626 if (STORE_FLAG_VALUE
!= 1)
14628 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
14629 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
14634 /* Subroutine of scompare_loc_descriptor for the case in which we're
14635 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
14636 and in which OP_MODE is bigger than DWARF2_ADDR_SIZE. */
14638 static dw_loc_descr_ref
14639 scompare_loc_descriptor_wide (enum dwarf_location_atom op
,
14640 scalar_int_mode op_mode
,
14641 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
14643 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
14644 dw_loc_descr_ref cvt
;
14646 if (type_die
== NULL
)
14648 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14649 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14650 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14651 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14652 add_loc_descr (&op0
, cvt
);
14653 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14654 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14655 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14656 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14657 add_loc_descr (&op1
, cvt
);
14658 return compare_loc_descriptor (op
, op0
, op1
);
14661 /* Subroutine of scompare_loc_descriptor for the case in which we're
14662 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
14663 and in which OP_MODE is smaller than DWARF2_ADDR_SIZE. */
14665 static dw_loc_descr_ref
14666 scompare_loc_descriptor_narrow (enum dwarf_location_atom op
, rtx rtl
,
14667 scalar_int_mode op_mode
,
14668 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
14670 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
14671 /* For eq/ne, if the operands are known to be zero-extended,
14672 there is no need to do the fancy shifting up. */
14673 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
14675 dw_loc_descr_ref last0
, last1
;
14676 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
14678 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
14680 /* deref_size zero extends, and for constants we can check
14681 whether they are zero extended or not. */
14682 if (((last0
->dw_loc_opc
== DW_OP_deref_size
14683 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
14684 || (CONST_INT_P (XEXP (rtl
, 0))
14685 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
14686 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
14687 && ((last1
->dw_loc_opc
== DW_OP_deref_size
14688 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
14689 || (CONST_INT_P (XEXP (rtl
, 1))
14690 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
14691 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
14692 return compare_loc_descriptor (op
, op0
, op1
);
14694 /* EQ/NE comparison against constant in narrower type than
14695 DWARF2_ADDR_SIZE can be performed either as
14696 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
14699 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
14700 DW_OP_{eq,ne}. Pick whatever is shorter. */
14701 if (CONST_INT_P (XEXP (rtl
, 1))
14702 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
14703 && (size_of_int_loc_descriptor (shift
) + 1
14704 + size_of_int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
)
14705 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
14706 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
14707 & GET_MODE_MASK (op_mode
))))
14709 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
14710 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14711 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
14712 & GET_MODE_MASK (op_mode
));
14713 return compare_loc_descriptor (op
, op0
, op1
);
14716 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14717 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14718 if (CONST_INT_P (XEXP (rtl
, 1)))
14719 op1
= int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
);
14722 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14723 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14725 return compare_loc_descriptor (op
, op0
, op1
);
14728 /* Return location descriptor for unsigned comparison OP RTL. */
14730 static dw_loc_descr_ref
14731 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
14732 machine_mode mem_mode
)
14734 machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
14735 dw_loc_descr_ref op0
, op1
;
14737 if (op_mode
== VOIDmode
)
14738 op_mode
= GET_MODE (XEXP (rtl
, 1));
14739 if (op_mode
== VOIDmode
)
14742 scalar_int_mode int_op_mode
;
14744 && dwarf_version
< 5
14745 && (!is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
)
14746 || GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
))
14749 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
14750 VAR_INIT_STATUS_INITIALIZED
);
14751 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
14752 VAR_INIT_STATUS_INITIALIZED
);
14754 if (op0
== NULL
|| op1
== NULL
)
14757 if (is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
))
14759 if (GET_MODE_SIZE (int_op_mode
) < DWARF2_ADDR_SIZE
)
14760 return scompare_loc_descriptor_narrow (op
, rtl
, int_op_mode
, op0
, op1
);
14762 if (GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
)
14763 return scompare_loc_descriptor_wide (op
, int_op_mode
, op0
, op1
);
14765 return compare_loc_descriptor (op
, op0
, op1
);
14768 /* Return location descriptor for unsigned comparison OP RTL. */
14770 static dw_loc_descr_ref
14771 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
14772 machine_mode mem_mode
)
14774 dw_loc_descr_ref op0
, op1
;
14776 machine_mode test_op_mode
= GET_MODE (XEXP (rtl
, 0));
14777 if (test_op_mode
== VOIDmode
)
14778 test_op_mode
= GET_MODE (XEXP (rtl
, 1));
14780 scalar_int_mode op_mode
;
14781 if (!is_a
<scalar_int_mode
> (test_op_mode
, &op_mode
))
14785 && dwarf_version
< 5
14786 && GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
14789 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
14790 VAR_INIT_STATUS_INITIALIZED
);
14791 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
14792 VAR_INIT_STATUS_INITIALIZED
);
14794 if (op0
== NULL
|| op1
== NULL
)
14797 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
14799 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
14800 dw_loc_descr_ref last0
, last1
;
14801 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
14803 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
14805 if (CONST_INT_P (XEXP (rtl
, 0)))
14806 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
14807 /* deref_size zero extends, so no need to mask it again. */
14808 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
14809 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
14811 add_loc_descr (&op0
, int_loc_descriptor (mask
));
14812 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14814 if (CONST_INT_P (XEXP (rtl
, 1)))
14815 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
14816 /* deref_size zero extends, so no need to mask it again. */
14817 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
14818 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
14820 add_loc_descr (&op1
, int_loc_descriptor (mask
));
14821 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
14824 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
14826 HOST_WIDE_INT bias
= 1;
14827 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
14828 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14829 if (CONST_INT_P (XEXP (rtl
, 1)))
14830 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
14831 + INTVAL (XEXP (rtl
, 1)));
14833 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
14836 return compare_loc_descriptor (op
, op0
, op1
);
14839 /* Return location descriptor for {U,S}{MIN,MAX}. */
14841 static dw_loc_descr_ref
14842 minmax_loc_descriptor (rtx rtl
, machine_mode mode
,
14843 machine_mode mem_mode
)
14845 enum dwarf_location_atom op
;
14846 dw_loc_descr_ref op0
, op1
, ret
;
14847 dw_loc_descr_ref bra_node
, drop_node
;
14849 scalar_int_mode int_mode
;
14851 && dwarf_version
< 5
14852 && (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
14853 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
))
14856 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14857 VAR_INIT_STATUS_INITIALIZED
);
14858 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
14859 VAR_INIT_STATUS_INITIALIZED
);
14861 if (op0
== NULL
|| op1
== NULL
)
14864 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
14865 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
14866 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
14867 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
14869 /* Checked by the caller. */
14870 int_mode
= as_a
<scalar_int_mode
> (mode
);
14871 if (GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
14873 HOST_WIDE_INT mask
= GET_MODE_MASK (int_mode
);
14874 add_loc_descr (&op0
, int_loc_descriptor (mask
));
14875 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14876 add_loc_descr (&op1
, int_loc_descriptor (mask
));
14877 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
14879 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
14881 HOST_WIDE_INT bias
= 1;
14882 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
14883 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14884 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14887 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14888 && GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
14890 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (int_mode
)) * BITS_PER_UNIT
;
14891 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14892 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14893 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14894 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14896 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14897 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
14899 dw_die_ref type_die
= base_type_for_mode (int_mode
, 0);
14900 dw_loc_descr_ref cvt
;
14901 if (type_die
== NULL
)
14903 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14904 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14905 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14906 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14907 add_loc_descr (&op0
, cvt
);
14908 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14909 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14910 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14911 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14912 add_loc_descr (&op1
, cvt
);
14915 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
14920 add_loc_descr (&ret
, op1
);
14921 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14922 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14923 add_loc_descr (&ret
, bra_node
);
14924 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14925 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
14926 add_loc_descr (&ret
, drop_node
);
14927 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14928 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
14929 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
14930 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
14931 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
14932 ret
= convert_descriptor_to_mode (int_mode
, ret
);
14936 /* Helper function for mem_loc_descriptor. Perform OP binary op,
14937 but after converting arguments to type_die, afterwards
14938 convert back to unsigned. */
14940 static dw_loc_descr_ref
14941 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
14942 scalar_int_mode mode
, machine_mode mem_mode
)
14944 dw_loc_descr_ref cvt
, op0
, op1
;
14946 if (type_die
== NULL
)
14948 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14949 VAR_INIT_STATUS_INITIALIZED
);
14950 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
14951 VAR_INIT_STATUS_INITIALIZED
);
14952 if (op0
== NULL
|| op1
== NULL
)
14954 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14955 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14956 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14957 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14958 add_loc_descr (&op0
, cvt
);
14959 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14960 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14961 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14962 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14963 add_loc_descr (&op1
, cvt
);
14964 add_loc_descr (&op0
, op1
);
14965 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
14966 return convert_descriptor_to_mode (mode
, op0
);
14969 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
14970 const0 is DW_OP_lit0 or corresponding typed constant,
14971 const1 is DW_OP_lit1 or corresponding typed constant
14972 and constMSB is constant with just the MSB bit set
14974 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
14975 L1: const0 DW_OP_swap
14976 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
14977 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
14982 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
14983 L1: const0 DW_OP_swap
14984 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
14985 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
14990 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
14991 L1: const1 DW_OP_swap
14992 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
14993 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
14997 static dw_loc_descr_ref
14998 clz_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
14999 machine_mode mem_mode
)
15001 dw_loc_descr_ref op0
, ret
, tmp
;
15002 HOST_WIDE_INT valv
;
15003 dw_loc_descr_ref l1jump
, l1label
;
15004 dw_loc_descr_ref l2jump
, l2label
;
15005 dw_loc_descr_ref l3jump
, l3label
;
15006 dw_loc_descr_ref l4jump
, l4label
;
15009 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
15012 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15013 VAR_INIT_STATUS_INITIALIZED
);
15017 if (GET_CODE (rtl
) == CLZ
)
15019 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
15020 valv
= GET_MODE_BITSIZE (mode
);
15022 else if (GET_CODE (rtl
) == FFS
)
15024 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
15025 valv
= GET_MODE_BITSIZE (mode
);
15026 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15027 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15028 add_loc_descr (&ret
, l1jump
);
15029 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
15030 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
15031 VAR_INIT_STATUS_INITIALIZED
);
15034 add_loc_descr (&ret
, tmp
);
15035 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15036 add_loc_descr (&ret
, l4jump
);
15037 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
15038 ? const1_rtx
: const0_rtx
,
15040 VAR_INIT_STATUS_INITIALIZED
);
15041 if (l1label
== NULL
)
15043 add_loc_descr (&ret
, l1label
);
15044 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15045 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
15046 add_loc_descr (&ret
, l2label
);
15047 if (GET_CODE (rtl
) != CLZ
)
15049 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
15050 msb
= GEN_INT (HOST_WIDE_INT_1U
15051 << (GET_MODE_BITSIZE (mode
) - 1));
15053 msb
= immed_wide_int_const
15054 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode
) - 1,
15055 GET_MODE_PRECISION (mode
)), mode
);
15056 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
15057 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
15058 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
15059 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
15061 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
15062 VAR_INIT_STATUS_INITIALIZED
);
15065 add_loc_descr (&ret
, tmp
);
15066 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15067 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15068 add_loc_descr (&ret
, l3jump
);
15069 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15070 VAR_INIT_STATUS_INITIALIZED
);
15073 add_loc_descr (&ret
, tmp
);
15074 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
15075 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
15076 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15077 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
15078 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15079 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15080 add_loc_descr (&ret
, l2jump
);
15081 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
15082 add_loc_descr (&ret
, l3label
);
15083 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
15084 add_loc_descr (&ret
, l4label
);
15085 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15086 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15087 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15088 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15089 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15090 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
15091 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15092 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
15096 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
15097 const1 is DW_OP_lit1 or corresponding typed constant):
15099 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15100 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15104 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15105 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15108 static dw_loc_descr_ref
15109 popcount_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15110 machine_mode mem_mode
)
15112 dw_loc_descr_ref op0
, ret
, tmp
;
15113 dw_loc_descr_ref l1jump
, l1label
;
15114 dw_loc_descr_ref l2jump
, l2label
;
15116 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
15119 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15120 VAR_INIT_STATUS_INITIALIZED
);
15124 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15125 VAR_INIT_STATUS_INITIALIZED
);
15128 add_loc_descr (&ret
, tmp
);
15129 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15130 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
15131 add_loc_descr (&ret
, l1label
);
15132 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15133 add_loc_descr (&ret
, l2jump
);
15134 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15135 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
15136 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15137 VAR_INIT_STATUS_INITIALIZED
);
15140 add_loc_descr (&ret
, tmp
);
15141 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15142 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
15143 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
15144 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15145 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15146 VAR_INIT_STATUS_INITIALIZED
);
15147 add_loc_descr (&ret
, tmp
);
15148 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15149 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15150 add_loc_descr (&ret
, l1jump
);
15151 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
15152 add_loc_descr (&ret
, l2label
);
15153 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15154 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15155 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15156 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15160 /* BSWAP (constS is initial shift count, either 56 or 24):
15162 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
15163 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
15164 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
15165 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
15166 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
15168 static dw_loc_descr_ref
15169 bswap_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15170 machine_mode mem_mode
)
15172 dw_loc_descr_ref op0
, ret
, tmp
;
15173 dw_loc_descr_ref l1jump
, l1label
;
15174 dw_loc_descr_ref l2jump
, l2label
;
15176 if (BITS_PER_UNIT
!= 8
15177 || (GET_MODE_BITSIZE (mode
) != 32
15178 && GET_MODE_BITSIZE (mode
) != 64))
15181 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15182 VAR_INIT_STATUS_INITIALIZED
);
15187 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
15189 VAR_INIT_STATUS_INITIALIZED
);
15192 add_loc_descr (&ret
, tmp
);
15193 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15194 VAR_INIT_STATUS_INITIALIZED
);
15197 add_loc_descr (&ret
, tmp
);
15198 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
15199 add_loc_descr (&ret
, l1label
);
15200 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
15202 VAR_INIT_STATUS_INITIALIZED
);
15203 add_loc_descr (&ret
, tmp
);
15204 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
15205 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15206 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15207 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
15208 VAR_INIT_STATUS_INITIALIZED
);
15211 add_loc_descr (&ret
, tmp
);
15212 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15213 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
15214 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
15215 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
15216 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15217 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15218 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15219 VAR_INIT_STATUS_INITIALIZED
);
15220 add_loc_descr (&ret
, tmp
);
15221 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
15222 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15223 add_loc_descr (&ret
, l2jump
);
15224 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
15225 VAR_INIT_STATUS_INITIALIZED
);
15226 add_loc_descr (&ret
, tmp
);
15227 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15228 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15229 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15230 add_loc_descr (&ret
, l1jump
);
15231 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
15232 add_loc_descr (&ret
, l2label
);
15233 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15234 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
15235 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15236 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15237 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15238 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15242 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
15243 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15244 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
15245 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
15247 ROTATERT is similar:
15248 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
15249 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15250 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
15252 static dw_loc_descr_ref
15253 rotate_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15254 machine_mode mem_mode
)
15256 rtx rtlop1
= XEXP (rtl
, 1);
15257 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
15260 if (is_narrower_int_mode (GET_MODE (rtlop1
), mode
))
15261 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
15262 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15263 VAR_INIT_STATUS_INITIALIZED
);
15264 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
15265 VAR_INIT_STATUS_INITIALIZED
);
15266 if (op0
== NULL
|| op1
== NULL
)
15268 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
15269 for (i
= 0; i
< 2; i
++)
15271 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
15272 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
15274 VAR_INIT_STATUS_INITIALIZED
);
15275 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
15276 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
15278 : HOST_BITS_PER_WIDE_INT
== 64
15279 ? DW_OP_const8u
: DW_OP_constu
,
15280 GET_MODE_MASK (mode
), 0);
15283 if (mask
[i
] == NULL
)
15285 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
15288 add_loc_descr (&ret
, op1
);
15289 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
15290 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
15291 if (GET_CODE (rtl
) == ROTATERT
)
15293 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
15294 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
15295 GET_MODE_BITSIZE (mode
), 0));
15297 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
15298 if (mask
[0] != NULL
)
15299 add_loc_descr (&ret
, mask
[0]);
15300 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
15301 if (mask
[1] != NULL
)
15303 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15304 add_loc_descr (&ret
, mask
[1]);
15305 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15307 if (GET_CODE (rtl
) == ROTATE
)
15309 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
15310 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
15311 GET_MODE_BITSIZE (mode
), 0));
15313 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15314 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
15318 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
15319 for DEBUG_PARAMETER_REF RTL. */
15321 static dw_loc_descr_ref
15322 parameter_ref_descriptor (rtx rtl
)
15324 dw_loc_descr_ref ret
;
15329 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
15330 /* With LTO during LTRANS we get the late DIE that refers to the early
15331 DIE, thus we add another indirection here. This seems to confuse
15332 gdb enough to make gcc.dg/guality/pr68860-1.c FAIL with LTO. */
15333 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
15334 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
15337 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15338 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
15339 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15343 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
15344 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
15349 /* The following routine converts the RTL for a variable or parameter
15350 (resident in memory) into an equivalent Dwarf representation of a
15351 mechanism for getting the address of that same variable onto the top of a
15352 hypothetical "address evaluation" stack.
15354 When creating memory location descriptors, we are effectively transforming
15355 the RTL for a memory-resident object into its Dwarf postfix expression
15356 equivalent. This routine recursively descends an RTL tree, turning
15357 it into Dwarf postfix code as it goes.
15359 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
15361 MEM_MODE is the mode of the memory reference, needed to handle some
15362 autoincrement addressing modes.
15364 Return 0 if we can't represent the location. */
15367 mem_loc_descriptor (rtx rtl
, machine_mode mode
,
15368 machine_mode mem_mode
,
15369 enum var_init_status initialized
)
15371 dw_loc_descr_ref mem_loc_result
= NULL
;
15372 enum dwarf_location_atom op
;
15373 dw_loc_descr_ref op0
, op1
;
15374 rtx inner
= NULL_RTX
;
15377 if (mode
== VOIDmode
)
15378 mode
= GET_MODE (rtl
);
15380 /* Note that for a dynamically sized array, the location we will generate a
15381 description of here will be the lowest numbered location which is
15382 actually within the array. That's *not* necessarily the same as the
15383 zeroth element of the array. */
15385 rtl
= targetm
.delegitimize_address (rtl
);
15387 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
15390 scalar_int_mode int_mode
, inner_mode
, op1_mode
;
15391 switch (GET_CODE (rtl
))
15396 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
15399 /* The case of a subreg may arise when we have a local (register)
15400 variable or a formal (register) parameter which doesn't quite fill
15401 up an entire register. For now, just assume that it is
15402 legitimate to make the Dwarf info refer to the whole register which
15403 contains the given subreg. */
15404 if (!subreg_lowpart_p (rtl
))
15406 inner
= SUBREG_REG (rtl
);
15409 if (inner
== NULL_RTX
)
15410 inner
= XEXP (rtl
, 0);
15411 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15412 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
15413 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15414 #ifdef POINTERS_EXTEND_UNSIGNED
15415 || (int_mode
== Pmode
&& mem_mode
!= VOIDmode
)
15418 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
)
15420 mem_loc_result
= mem_loc_descriptor (inner
,
15422 mem_mode
, initialized
);
15425 if (dwarf_strict
&& dwarf_version
< 5)
15427 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15428 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
15429 ? GET_MODE_SIZE (int_mode
) <= GET_MODE_SIZE (inner_mode
)
15430 : known_eq (GET_MODE_SIZE (mode
), GET_MODE_SIZE (GET_MODE (inner
))))
15432 dw_die_ref type_die
;
15433 dw_loc_descr_ref cvt
;
15435 mem_loc_result
= mem_loc_descriptor (inner
,
15437 mem_mode
, initialized
);
15438 if (mem_loc_result
== NULL
)
15440 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15441 if (type_die
== NULL
)
15443 mem_loc_result
= NULL
;
15446 if (maybe_ne (GET_MODE_SIZE (mode
), GET_MODE_SIZE (GET_MODE (inner
))))
15447 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15449 cvt
= new_loc_descr (dwarf_OP (DW_OP_reinterpret
), 0, 0);
15450 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15451 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15452 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15453 add_loc_descr (&mem_loc_result
, cvt
);
15454 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15455 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
15457 /* Convert it to untyped afterwards. */
15458 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15459 add_loc_descr (&mem_loc_result
, cvt
);
15465 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15466 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
15467 && rtl
!= arg_pointer_rtx
15468 && rtl
!= frame_pointer_rtx
15469 #ifdef POINTERS_EXTEND_UNSIGNED
15470 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
15474 dw_die_ref type_die
;
15475 unsigned int dbx_regnum
;
15477 if (dwarf_strict
&& dwarf_version
< 5)
15479 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
15481 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15482 if (type_die
== NULL
)
15485 dbx_regnum
= dbx_reg_number (rtl
);
15486 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
15488 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_regval_type
),
15490 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
15491 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
15492 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
15495 /* Whenever a register number forms a part of the description of the
15496 method for calculating the (dynamic) address of a memory resident
15497 object, DWARF rules require the register number be referred to as
15498 a "base register". This distinction is not based in any way upon
15499 what category of register the hardware believes the given register
15500 belongs to. This is strictly DWARF terminology we're dealing with
15501 here. Note that in cases where the location of a memory-resident
15502 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
15503 OP_CONST (0)) the actual DWARF location descriptor that we generate
15504 may just be OP_BASEREG (basereg). This may look deceptively like
15505 the object in question was allocated to a register (rather than in
15506 memory) so DWARF consumers need to be aware of the subtle
15507 distinction between OP_REG and OP_BASEREG. */
15508 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
15509 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
15510 else if (stack_realign_drap
15512 && crtl
->args
.internal_arg_pointer
== rtl
15513 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
15515 /* If RTL is internal_arg_pointer, which has been optimized
15516 out, use DRAP instead. */
15517 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
15518 VAR_INIT_STATUS_INITIALIZED
);
15524 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15525 || !is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
))
15527 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
15528 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
15531 else if (GET_CODE (rtl
) == ZERO_EXTEND
15532 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15533 && GET_MODE_BITSIZE (inner_mode
) < HOST_BITS_PER_WIDE_INT
15534 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
15535 to expand zero extend as two shifts instead of
15537 && GET_MODE_SIZE (inner_mode
) <= 4)
15539 mem_loc_result
= op0
;
15540 add_loc_descr (&mem_loc_result
,
15541 int_loc_descriptor (GET_MODE_MASK (inner_mode
)));
15542 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
15544 else if (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
15546 int shift
= DWARF2_ADDR_SIZE
- GET_MODE_SIZE (inner_mode
);
15547 shift
*= BITS_PER_UNIT
;
15548 if (GET_CODE (rtl
) == SIGN_EXTEND
)
15552 mem_loc_result
= op0
;
15553 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
15554 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
15555 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
15556 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15558 else if (!dwarf_strict
|| dwarf_version
>= 5)
15560 dw_die_ref type_die1
, type_die2
;
15561 dw_loc_descr_ref cvt
;
15563 type_die1
= base_type_for_mode (inner_mode
,
15564 GET_CODE (rtl
) == ZERO_EXTEND
);
15565 if (type_die1
== NULL
)
15567 type_die2
= base_type_for_mode (int_mode
, 1);
15568 if (type_die2
== NULL
)
15570 mem_loc_result
= op0
;
15571 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15572 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15573 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
15574 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15575 add_loc_descr (&mem_loc_result
, cvt
);
15576 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15577 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15578 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
15579 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15580 add_loc_descr (&mem_loc_result
, cvt
);
15586 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
15587 if (new_rtl
!= rtl
)
15589 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
15591 if (mem_loc_result
!= NULL
)
15592 return mem_loc_result
;
15595 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
15596 get_address_mode (rtl
), mode
,
15597 VAR_INIT_STATUS_INITIALIZED
);
15598 if (mem_loc_result
== NULL
)
15599 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
15600 if (mem_loc_result
!= NULL
)
15602 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15603 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15605 dw_die_ref type_die
;
15606 dw_loc_descr_ref deref
;
15607 HOST_WIDE_INT size
;
15609 if (dwarf_strict
&& dwarf_version
< 5)
15611 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
15614 = base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15615 if (type_die
== NULL
)
15617 deref
= new_loc_descr (dwarf_OP (DW_OP_deref_type
), size
, 0);
15618 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
15619 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
15620 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
15621 add_loc_descr (&mem_loc_result
, deref
);
15623 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
15624 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
15626 add_loc_descr (&mem_loc_result
,
15627 new_loc_descr (DW_OP_deref_size
,
15628 GET_MODE_SIZE (int_mode
), 0));
15633 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
15636 /* Some ports can transform a symbol ref into a label ref, because
15637 the symbol ref is too far away and has to be dumped into a constant
15641 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15642 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
15643 #ifdef POINTERS_EXTEND_UNSIGNED
15644 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
15648 if (GET_CODE (rtl
) == SYMBOL_REF
15649 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
15651 dw_loc_descr_ref temp
;
15653 /* If this is not defined, we have no way to emit the data. */
15654 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
15657 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
15659 /* We check for DWARF 5 here because gdb did not implement
15660 DW_OP_form_tls_address until after 7.12. */
15661 mem_loc_result
= new_loc_descr ((dwarf_version
>= 5
15662 ? DW_OP_form_tls_address
15663 : DW_OP_GNU_push_tls_address
),
15665 add_loc_descr (&mem_loc_result
, temp
);
15670 if (!const_ok_for_output (rtl
))
15672 if (GET_CODE (rtl
) == CONST
)
15673 switch (GET_CODE (XEXP (rtl
, 0)))
15677 goto try_const_unop
;
15680 goto try_const_unop
;
15683 arg
= XEXP (XEXP (rtl
, 0), 0);
15684 if (!CONSTANT_P (arg
))
15685 arg
= gen_rtx_CONST (int_mode
, arg
);
15686 op0
= mem_loc_descriptor (arg
, int_mode
, mem_mode
,
15690 mem_loc_result
= op0
;
15691 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15695 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
,
15696 mem_mode
, initialized
);
15703 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
15704 vec_safe_push (used_rtx_array
, rtl
);
15710 case DEBUG_IMPLICIT_PTR
:
15711 expansion_failed (NULL_TREE
, rtl
,
15712 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
15716 if (dwarf_strict
&& dwarf_version
< 5)
15718 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
15720 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15721 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15722 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
15723 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15726 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
15727 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
15729 op0
= one_reg_loc_descriptor (dbx_regnum
,
15730 VAR_INIT_STATUS_INITIALIZED
);
15733 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
15734 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
15736 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
15737 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15738 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
15742 gcc_unreachable ();
15745 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_entry_value
), 0, 0);
15746 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15747 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
15750 case DEBUG_PARAMETER_REF
:
15751 mem_loc_result
= parameter_ref_descriptor (rtl
);
15755 /* Extract the PLUS expression nested inside and fall into
15756 PLUS code below. */
15757 rtl
= XEXP (rtl
, 1);
15762 /* Turn these into a PLUS expression and fall into the PLUS code
15764 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
15765 gen_int_mode (GET_CODE (rtl
) == PRE_INC
15766 ? GET_MODE_UNIT_SIZE (mem_mode
)
15767 : -GET_MODE_UNIT_SIZE (mem_mode
),
15774 if (is_based_loc (rtl
)
15775 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15776 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15777 || XEXP (rtl
, 0) == arg_pointer_rtx
15778 || XEXP (rtl
, 0) == frame_pointer_rtx
))
15779 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
15780 INTVAL (XEXP (rtl
, 1)),
15781 VAR_INIT_STATUS_INITIALIZED
);
15784 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15785 VAR_INIT_STATUS_INITIALIZED
);
15786 if (mem_loc_result
== 0)
15789 if (CONST_INT_P (XEXP (rtl
, 1))
15790 && (GET_MODE_SIZE (as_a
<scalar_int_mode
> (mode
))
15791 <= DWARF2_ADDR_SIZE
))
15792 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
15795 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15796 VAR_INIT_STATUS_INITIALIZED
);
15799 add_loc_descr (&mem_loc_result
, op1
);
15800 add_loc_descr (&mem_loc_result
,
15801 new_loc_descr (DW_OP_plus
, 0, 0));
15806 /* If a pseudo-reg is optimized away, it is possible for it to
15807 be replaced with a MEM containing a multiply or shift. */
15817 if ((!dwarf_strict
|| dwarf_version
>= 5)
15818 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15819 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15821 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
15822 base_type_for_mode (mode
, 0),
15823 int_mode
, mem_mode
);
15846 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
))
15848 op0
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
, mem_mode
,
15849 VAR_INIT_STATUS_INITIALIZED
);
15851 rtx rtlop1
= XEXP (rtl
, 1);
15852 if (is_a
<scalar_int_mode
> (GET_MODE (rtlop1
), &op1_mode
)
15853 && GET_MODE_BITSIZE (op1_mode
) < GET_MODE_BITSIZE (int_mode
))
15854 rtlop1
= gen_rtx_ZERO_EXTEND (int_mode
, rtlop1
);
15855 op1
= mem_loc_descriptor (rtlop1
, int_mode
, mem_mode
,
15856 VAR_INIT_STATUS_INITIALIZED
);
15859 if (op0
== 0 || op1
== 0)
15862 mem_loc_result
= op0
;
15863 add_loc_descr (&mem_loc_result
, op1
);
15864 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15880 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15881 VAR_INIT_STATUS_INITIALIZED
);
15882 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15883 VAR_INIT_STATUS_INITIALIZED
);
15885 if (op0
== 0 || op1
== 0)
15888 mem_loc_result
= op0
;
15889 add_loc_descr (&mem_loc_result
, op1
);
15890 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15894 if ((!dwarf_strict
|| dwarf_version
>= 5)
15895 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15896 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15898 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
15899 base_type_for_mode (mode
, 0),
15900 int_mode
, mem_mode
);
15904 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15905 VAR_INIT_STATUS_INITIALIZED
);
15906 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15907 VAR_INIT_STATUS_INITIALIZED
);
15909 if (op0
== 0 || op1
== 0)
15912 mem_loc_result
= op0
;
15913 add_loc_descr (&mem_loc_result
, op1
);
15914 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
15915 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
15916 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
15917 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
15918 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
15922 if ((!dwarf_strict
|| dwarf_version
>= 5)
15923 && is_a
<scalar_int_mode
> (mode
, &int_mode
))
15925 if (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15930 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
15931 base_type_for_mode (int_mode
, 1),
15932 int_mode
, mem_mode
);
15949 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15950 VAR_INIT_STATUS_INITIALIZED
);
15955 mem_loc_result
= op0
;
15956 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15960 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15961 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15962 #ifdef POINTERS_EXTEND_UNSIGNED
15963 || (int_mode
== Pmode
15964 && mem_mode
!= VOIDmode
15965 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
15969 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
15972 if ((!dwarf_strict
|| dwarf_version
>= 5)
15973 && (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
15974 || GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_DOUBLE_INT
))
15976 dw_die_ref type_die
= base_type_for_mode (int_mode
, 1);
15977 scalar_int_mode amode
;
15978 if (type_die
== NULL
)
15980 if (INTVAL (rtl
) >= 0
15981 && (int_mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
, 0)
15983 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
15984 /* const DW_OP_convert <XXX> vs.
15985 DW_OP_const_type <XXX, 1, const>. */
15986 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
15987 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (int_mode
))
15989 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
15990 op0
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15991 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15992 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15993 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15994 add_loc_descr (&mem_loc_result
, op0
);
15995 return mem_loc_result
;
15997 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0,
15999 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16000 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16001 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16002 if (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
)
16003 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
16006 mem_loc_result
->dw_loc_oprnd2
.val_class
16007 = dw_val_class_const_double
;
16008 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
16009 = double_int::from_shwi (INTVAL (rtl
));
16015 if (!dwarf_strict
|| dwarf_version
>= 5)
16017 dw_die_ref type_die
;
16019 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
16020 CONST_DOUBLE rtx could represent either a large integer
16021 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
16022 the value is always a floating point constant.
16024 When it is an integer, a CONST_DOUBLE is used whenever
16025 the constant requires 2 HWIs to be adequately represented.
16026 We output CONST_DOUBLEs as blocks. */
16027 if (mode
== VOIDmode
16028 || (GET_MODE (rtl
) == VOIDmode
16029 && maybe_ne (GET_MODE_BITSIZE (mode
),
16030 HOST_BITS_PER_DOUBLE_INT
)))
16032 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16033 if (type_die
== NULL
)
16035 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
16036 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16037 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16038 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16039 #if TARGET_SUPPORTS_WIDE_INT == 0
16040 if (!SCALAR_FLOAT_MODE_P (mode
))
16042 mem_loc_result
->dw_loc_oprnd2
.val_class
16043 = dw_val_class_const_double
;
16044 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
16045 = rtx_to_double_int (rtl
);
16050 scalar_float_mode float_mode
= as_a
<scalar_float_mode
> (mode
);
16051 unsigned int length
= GET_MODE_SIZE (float_mode
);
16052 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
16054 insert_float (rtl
, array
);
16055 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16056 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
16057 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
16058 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16063 case CONST_WIDE_INT
:
16064 if (!dwarf_strict
|| dwarf_version
>= 5)
16066 dw_die_ref type_die
;
16068 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16069 if (type_die
== NULL
)
16071 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
16072 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16073 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16074 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16075 mem_loc_result
->dw_loc_oprnd2
.val_class
16076 = dw_val_class_wide_int
;
16077 mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
16078 *mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, mode
);
16082 case CONST_POLY_INT
:
16083 mem_loc_result
= int_loc_descriptor (rtx_to_poly_int64 (rtl
));
16087 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
16091 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
16095 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
16099 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
16103 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
16107 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
16111 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
16115 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
16119 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
16123 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
16128 if (!SCALAR_INT_MODE_P (mode
))
16133 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
16138 if (CONST_INT_P (XEXP (rtl
, 1))
16139 && CONST_INT_P (XEXP (rtl
, 2))
16140 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16141 && is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
)
16142 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16143 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
16144 && ((unsigned) INTVAL (XEXP (rtl
, 1))
16145 + (unsigned) INTVAL (XEXP (rtl
, 2))
16146 <= GET_MODE_BITSIZE (int_mode
)))
16149 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
16150 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16153 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
16157 mem_loc_result
= op0
;
16158 size
= INTVAL (XEXP (rtl
, 1));
16159 shift
= INTVAL (XEXP (rtl
, 2));
16160 if (BITS_BIG_ENDIAN
)
16161 shift
= GET_MODE_BITSIZE (inner_mode
) - shift
- size
;
16162 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
16164 add_loc_descr (&mem_loc_result
,
16165 int_loc_descriptor (DWARF2_ADDR_SIZE
16167 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
16169 if (size
!= (int) DWARF2_ADDR_SIZE
)
16171 add_loc_descr (&mem_loc_result
,
16172 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
16173 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16180 dw_loc_descr_ref op2
, bra_node
, drop_node
;
16181 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
16182 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
16183 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
16184 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16185 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16186 VAR_INIT_STATUS_INITIALIZED
);
16187 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
16188 VAR_INIT_STATUS_INITIALIZED
);
16189 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
16192 mem_loc_result
= op1
;
16193 add_loc_descr (&mem_loc_result
, op2
);
16194 add_loc_descr (&mem_loc_result
, op0
);
16195 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
16196 add_loc_descr (&mem_loc_result
, bra_node
);
16197 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
16198 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
16199 add_loc_descr (&mem_loc_result
, drop_node
);
16200 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
16201 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
16206 case FLOAT_TRUNCATE
:
16208 case UNSIGNED_FLOAT
:
16211 if (!dwarf_strict
|| dwarf_version
>= 5)
16213 dw_die_ref type_die
;
16214 dw_loc_descr_ref cvt
;
16216 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
16217 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16220 if (is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &int_mode
)
16221 && (GET_CODE (rtl
) == FLOAT
16222 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
))
16224 type_die
= base_type_for_mode (int_mode
,
16225 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
16226 if (type_die
== NULL
)
16228 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16229 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16230 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16231 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16232 add_loc_descr (&op0
, cvt
);
16234 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
16235 if (type_die
== NULL
)
16237 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16238 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16239 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16240 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16241 add_loc_descr (&op0
, cvt
);
16242 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16243 && (GET_CODE (rtl
) == FIX
16244 || GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
))
16246 op0
= convert_descriptor_to_mode (int_mode
, op0
);
16250 mem_loc_result
= op0
;
16257 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16258 mem_loc_result
= clz_loc_descriptor (rtl
, int_mode
, mem_mode
);
16263 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16264 mem_loc_result
= popcount_loc_descriptor (rtl
, int_mode
, mem_mode
);
16268 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16269 mem_loc_result
= bswap_loc_descriptor (rtl
, int_mode
, mem_mode
);
16274 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16275 mem_loc_result
= rotate_loc_descriptor (rtl
, int_mode
, mem_mode
);
16279 /* In theory, we could implement the above. */
16280 /* DWARF cannot represent the unsigned compare operations
16305 case FRACT_CONVERT
:
16306 case UNSIGNED_FRACT_CONVERT
:
16308 case UNSIGNED_SAT_FRACT
:
16314 case VEC_DUPLICATE
:
16319 case STRICT_LOW_PART
:
16325 /* If delegitimize_address couldn't do anything with the UNSPEC, we
16326 can't express it in the debug info. This can happen e.g. with some
16331 resolve_one_addr (&rtl
);
16334 /* RTL sequences inside PARALLEL record a series of DWARF operations for
16335 the expression. An UNSPEC rtx represents a raw DWARF operation,
16336 new_loc_descr is called for it to build the operation directly.
16337 Otherwise mem_loc_descriptor is called recursively. */
16341 dw_loc_descr_ref exp_result
= NULL
;
16343 for (; index
< XVECLEN (rtl
, 0); index
++)
16345 rtx elem
= XVECEXP (rtl
, 0, index
);
16346 if (GET_CODE (elem
) == UNSPEC
)
16348 /* Each DWARF operation UNSPEC contain two operands, if
16349 one operand is not used for the operation, const0_rtx is
16351 gcc_assert (XVECLEN (elem
, 0) == 2);
16353 HOST_WIDE_INT dw_op
= XINT (elem
, 1);
16354 HOST_WIDE_INT oprnd1
= INTVAL (XVECEXP (elem
, 0, 0));
16355 HOST_WIDE_INT oprnd2
= INTVAL (XVECEXP (elem
, 0, 1));
16357 = new_loc_descr ((enum dwarf_location_atom
) dw_op
, oprnd1
,
16362 = mem_loc_descriptor (elem
, mode
, mem_mode
,
16363 VAR_INIT_STATUS_INITIALIZED
);
16365 if (!mem_loc_result
)
16366 mem_loc_result
= exp_result
;
16368 add_loc_descr (&mem_loc_result
, exp_result
);
16377 print_rtl (stderr
, rtl
);
16378 gcc_unreachable ();
16383 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
16384 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
16386 return mem_loc_result
;
16389 /* Return a descriptor that describes the concatenation of two locations.
16390 This is typically a complex variable. */
16392 static dw_loc_descr_ref
16393 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
16395 /* At present we only track constant-sized pieces. */
16396 unsigned int size0
, size1
;
16397 if (!GET_MODE_SIZE (GET_MODE (x0
)).is_constant (&size0
)
16398 || !GET_MODE_SIZE (GET_MODE (x1
)).is_constant (&size1
))
16401 dw_loc_descr_ref cc_loc_result
= NULL
;
16402 dw_loc_descr_ref x0_ref
16403 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16404 dw_loc_descr_ref x1_ref
16405 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16407 if (x0_ref
== 0 || x1_ref
== 0)
16410 cc_loc_result
= x0_ref
;
16411 add_loc_descr_op_piece (&cc_loc_result
, size0
);
16413 add_loc_descr (&cc_loc_result
, x1_ref
);
16414 add_loc_descr_op_piece (&cc_loc_result
, size1
);
16416 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
16417 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
16419 return cc_loc_result
;
16422 /* Return a descriptor that describes the concatenation of N
16425 static dw_loc_descr_ref
16426 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
16429 dw_loc_descr_ref cc_loc_result
= NULL
;
16430 unsigned int n
= XVECLEN (concatn
, 0);
16433 for (i
= 0; i
< n
; ++i
)
16435 dw_loc_descr_ref ref
;
16436 rtx x
= XVECEXP (concatn
, 0, i
);
16438 /* At present we only track constant-sized pieces. */
16439 if (!GET_MODE_SIZE (GET_MODE (x
)).is_constant (&size
))
16442 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16446 add_loc_descr (&cc_loc_result
, ref
);
16447 add_loc_descr_op_piece (&cc_loc_result
, size
);
16450 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
16451 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
16453 return cc_loc_result
;
16456 /* Helper function for loc_descriptor. Return DW_OP_implicit_pointer
16457 for DEBUG_IMPLICIT_PTR RTL. */
16459 static dw_loc_descr_ref
16460 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
16462 dw_loc_descr_ref ret
;
16465 if (dwarf_strict
&& dwarf_version
< 5)
16467 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
16468 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
16469 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
16470 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
16471 ret
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
16472 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
16475 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16476 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
16477 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16481 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
16482 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
16487 /* Output a proper Dwarf location descriptor for a variable or parameter
16488 which is either allocated in a register or in a memory location. For a
16489 register, we just generate an OP_REG and the register number. For a
16490 memory location we provide a Dwarf postfix expression describing how to
16491 generate the (dynamic) address of the object onto the address stack.
16493 MODE is mode of the decl if this loc_descriptor is going to be used in
16494 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
16495 allowed, VOIDmode otherwise.
16497 If we don't know how to describe it, return 0. */
16499 static dw_loc_descr_ref
16500 loc_descriptor (rtx rtl
, machine_mode mode
,
16501 enum var_init_status initialized
)
16503 dw_loc_descr_ref loc_result
= NULL
;
16504 scalar_int_mode int_mode
;
16506 switch (GET_CODE (rtl
))
16509 /* The case of a subreg may arise when we have a local (register)
16510 variable or a formal (register) parameter which doesn't quite fill
16511 up an entire register. For now, just assume that it is
16512 legitimate to make the Dwarf info refer to the whole register which
16513 contains the given subreg. */
16514 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
16515 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
16516 GET_MODE (SUBREG_REG (rtl
)), initialized
);
16522 loc_result
= reg_loc_descriptor (rtl
, initialized
);
16526 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
16527 GET_MODE (rtl
), initialized
);
16528 if (loc_result
== NULL
)
16529 loc_result
= tls_mem_loc_descriptor (rtl
);
16530 if (loc_result
== NULL
)
16532 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
16533 if (new_rtl
!= rtl
)
16534 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
16539 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
16544 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
16549 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
16551 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
16552 if (GET_CODE (loc
) == EXPR_LIST
)
16553 loc
= XEXP (loc
, 0);
16554 loc_result
= loc_descriptor (loc
, mode
, initialized
);
16558 rtl
= XEXP (rtl
, 1);
16563 rtvec par_elems
= XVEC (rtl
, 0);
16564 int num_elem
= GET_NUM_ELEM (par_elems
);
16568 /* Create the first one, so we have something to add to. */
16569 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
16570 VOIDmode
, initialized
);
16571 if (loc_result
== NULL
)
16573 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
16574 /* At present we only track constant-sized pieces. */
16575 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
16577 add_loc_descr_op_piece (&loc_result
, size
);
16578 for (i
= 1; i
< num_elem
; i
++)
16580 dw_loc_descr_ref temp
;
16582 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
16583 VOIDmode
, initialized
);
16586 add_loc_descr (&loc_result
, temp
);
16587 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
16588 /* At present we only track constant-sized pieces. */
16589 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
16591 add_loc_descr_op_piece (&loc_result
, size
);
16597 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
16599 int_mode
= as_a
<scalar_int_mode
> (mode
);
16600 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (int_mode
),
16606 if (mode
== VOIDmode
)
16607 mode
= GET_MODE (rtl
);
16609 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16611 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
16613 /* Note that a CONST_DOUBLE rtx could represent either an integer
16614 or a floating-point constant. A CONST_DOUBLE is used whenever
16615 the constant requires more than one word in order to be
16616 adequately represented. We output CONST_DOUBLEs as blocks. */
16617 scalar_mode smode
= as_a
<scalar_mode
> (mode
);
16618 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16619 GET_MODE_SIZE (smode
), 0);
16620 #if TARGET_SUPPORTS_WIDE_INT == 0
16621 if (!SCALAR_FLOAT_MODE_P (smode
))
16623 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
16624 loc_result
->dw_loc_oprnd2
.v
.val_double
16625 = rtx_to_double_int (rtl
);
16630 unsigned int length
= GET_MODE_SIZE (smode
);
16631 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
16633 insert_float (rtl
, array
);
16634 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16635 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
16636 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
16637 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16642 case CONST_WIDE_INT
:
16643 if (mode
== VOIDmode
)
16644 mode
= GET_MODE (rtl
);
16646 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16648 int_mode
= as_a
<scalar_int_mode
> (mode
);
16649 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16650 GET_MODE_SIZE (int_mode
), 0);
16651 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_wide_int
;
16652 loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
16653 *loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, int_mode
);
16658 if (mode
== VOIDmode
)
16659 mode
= GET_MODE (rtl
);
16661 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16663 unsigned int length
;
16664 if (!CONST_VECTOR_NUNITS (rtl
).is_constant (&length
))
16667 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
16668 unsigned char *array
16669 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
16672 machine_mode imode
= GET_MODE_INNER (mode
);
16674 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
16675 switch (GET_MODE_CLASS (mode
))
16677 case MODE_VECTOR_INT
:
16678 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
16680 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
16681 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
16685 case MODE_VECTOR_FLOAT
:
16686 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
16688 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
16689 insert_float (elt
, p
);
16694 gcc_unreachable ();
16697 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16698 length
* elt_size
, 0);
16699 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16700 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
16701 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
16702 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16707 if (mode
== VOIDmode
16708 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
16709 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
16710 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
16712 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
16717 if (!const_ok_for_output (rtl
))
16721 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16722 && GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
16723 && (dwarf_version
>= 4 || !dwarf_strict
))
16725 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
16726 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16727 vec_safe_push (used_rtx_array
, rtl
);
16731 case DEBUG_IMPLICIT_PTR
:
16732 loc_result
= implicit_ptr_descriptor (rtl
, 0);
16736 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
16737 && CONST_INT_P (XEXP (rtl
, 1)))
16740 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
16746 if ((is_a
<scalar_int_mode
> (mode
, &int_mode
)
16747 && GET_MODE (rtl
) == int_mode
16748 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16749 && dwarf_version
>= 4)
16750 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
16752 /* Value expression. */
16753 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
16755 add_loc_descr (&loc_result
,
16756 new_loc_descr (DW_OP_stack_value
, 0, 0));
16764 /* We need to figure out what section we should use as the base for the
16765 address ranges where a given location is valid.
16766 1. If this particular DECL has a section associated with it, use that.
16767 2. If this function has a section associated with it, use that.
16768 3. Otherwise, use the text section.
16769 XXX: If you split a variable across multiple sections, we won't notice. */
16771 static const char *
16772 secname_for_decl (const_tree decl
)
16774 const char *secname
;
16776 if (VAR_OR_FUNCTION_DECL_P (decl
)
16777 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
) || TREE_STATIC (decl
))
16778 && DECL_SECTION_NAME (decl
))
16779 secname
= DECL_SECTION_NAME (decl
);
16780 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
16781 secname
= DECL_SECTION_NAME (current_function_decl
);
16782 else if (cfun
&& in_cold_section_p
)
16783 secname
= crtl
->subsections
.cold_section_label
;
16785 secname
= text_section_label
;
16790 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
16793 decl_by_reference_p (tree decl
)
16795 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
16797 && DECL_BY_REFERENCE (decl
));
16800 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
16803 static dw_loc_descr_ref
16804 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
16805 enum var_init_status initialized
)
16807 int have_address
= 0;
16808 dw_loc_descr_ref descr
;
16811 if (want_address
!= 2)
16813 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
16815 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
16817 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
16818 if (GET_CODE (varloc
) == EXPR_LIST
)
16819 varloc
= XEXP (varloc
, 0);
16820 mode
= GET_MODE (varloc
);
16821 if (MEM_P (varloc
))
16823 rtx addr
= XEXP (varloc
, 0);
16824 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
16825 mode
, initialized
);
16830 rtx x
= avoid_constant_pool_reference (varloc
);
16832 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
16837 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
16844 if (GET_CODE (varloc
) == VAR_LOCATION
)
16845 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
16847 mode
= DECL_MODE (loc
);
16848 descr
= loc_descriptor (varloc
, mode
, initialized
);
16855 if (want_address
== 2 && !have_address
16856 && (dwarf_version
>= 4 || !dwarf_strict
))
16858 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
16860 expansion_failed (loc
, NULL_RTX
,
16861 "DWARF address size mismatch");
16864 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16867 /* Show if we can't fill the request for an address. */
16868 if (want_address
&& !have_address
)
16870 expansion_failed (loc
, NULL_RTX
,
16871 "Want address and only have value");
16875 /* If we've got an address and don't want one, dereference. */
16876 if (!want_address
&& have_address
)
16878 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
16879 enum dwarf_location_atom op
;
16881 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
16883 expansion_failed (loc
, NULL_RTX
,
16884 "DWARF address size mismatch");
16887 else if (size
== DWARF2_ADDR_SIZE
)
16890 op
= DW_OP_deref_size
;
16892 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
16898 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
16899 if it is not possible. */
16901 static dw_loc_descr_ref
16902 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
16904 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
16905 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
16906 else if (dwarf_version
>= 3 || !dwarf_strict
)
16907 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
16912 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
16913 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
16915 static dw_loc_descr_ref
16916 dw_sra_loc_expr (tree decl
, rtx loc
)
16919 unsigned HOST_WIDE_INT padsize
= 0;
16920 dw_loc_descr_ref descr
, *descr_tail
;
16921 unsigned HOST_WIDE_INT decl_size
;
16923 enum var_init_status initialized
;
16925 if (DECL_SIZE (decl
) == NULL
16926 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
16929 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
16931 descr_tail
= &descr
;
16933 for (p
= loc
; p
; p
= XEXP (p
, 1))
16935 unsigned HOST_WIDE_INT bitsize
= decl_piece_bitsize (p
);
16936 rtx loc_note
= *decl_piece_varloc_ptr (p
);
16937 dw_loc_descr_ref cur_descr
;
16938 dw_loc_descr_ref
*tail
, last
= NULL
;
16939 unsigned HOST_WIDE_INT opsize
= 0;
16941 if (loc_note
== NULL_RTX
16942 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
16944 padsize
+= bitsize
;
16947 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
16948 varloc
= NOTE_VAR_LOCATION (loc_note
);
16949 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
16950 if (cur_descr
== NULL
)
16952 padsize
+= bitsize
;
16956 /* Check that cur_descr either doesn't use
16957 DW_OP_*piece operations, or their sum is equal
16958 to bitsize. Otherwise we can't embed it. */
16959 for (tail
= &cur_descr
; *tail
!= NULL
;
16960 tail
= &(*tail
)->dw_loc_next
)
16961 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
16963 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
16967 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
16969 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
16973 if (last
!= NULL
&& opsize
!= bitsize
)
16975 padsize
+= bitsize
;
16976 /* Discard the current piece of the descriptor and release any
16977 addr_table entries it uses. */
16978 remove_loc_list_addr_table_entries (cur_descr
);
16982 /* If there is a hole, add DW_OP_*piece after empty DWARF
16983 expression, which means that those bits are optimized out. */
16986 if (padsize
> decl_size
)
16988 remove_loc_list_addr_table_entries (cur_descr
);
16989 goto discard_descr
;
16991 decl_size
-= padsize
;
16992 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
16993 if (*descr_tail
== NULL
)
16995 remove_loc_list_addr_table_entries (cur_descr
);
16996 goto discard_descr
;
16998 descr_tail
= &(*descr_tail
)->dw_loc_next
;
17001 *descr_tail
= cur_descr
;
17003 if (bitsize
> decl_size
)
17004 goto discard_descr
;
17005 decl_size
-= bitsize
;
17008 HOST_WIDE_INT offset
= 0;
17009 if (GET_CODE (varloc
) == VAR_LOCATION
17010 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
17012 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
17013 if (GET_CODE (varloc
) == EXPR_LIST
)
17014 varloc
= XEXP (varloc
, 0);
17018 if (GET_CODE (varloc
) == CONST
17019 || GET_CODE (varloc
) == SIGN_EXTEND
17020 || GET_CODE (varloc
) == ZERO_EXTEND
)
17021 varloc
= XEXP (varloc
, 0);
17022 else if (GET_CODE (varloc
) == SUBREG
)
17023 varloc
= SUBREG_REG (varloc
);
17028 /* DW_OP_bit_size offset should be zero for register
17029 or implicit location descriptions and empty location
17030 descriptions, but for memory addresses needs big endian
17032 if (MEM_P (varloc
))
17034 unsigned HOST_WIDE_INT memsize
;
17035 if (!poly_uint64 (MEM_SIZE (varloc
)).is_constant (&memsize
))
17036 goto discard_descr
;
17037 memsize
*= BITS_PER_UNIT
;
17038 if (memsize
!= bitsize
)
17040 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
17041 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
17042 goto discard_descr
;
17043 if (memsize
< bitsize
)
17044 goto discard_descr
;
17045 if (BITS_BIG_ENDIAN
)
17046 offset
= memsize
- bitsize
;
17050 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
17051 if (*descr_tail
== NULL
)
17052 goto discard_descr
;
17053 descr_tail
= &(*descr_tail
)->dw_loc_next
;
17057 /* If there were any non-empty expressions, add padding till the end of
17059 if (descr
!= NULL
&& decl_size
!= 0)
17061 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
17062 if (*descr_tail
== NULL
)
17063 goto discard_descr
;
17068 /* Discard the descriptor and release any addr_table entries it uses. */
17069 remove_loc_list_addr_table_entries (descr
);
17073 /* Return the dwarf representation of the location list LOC_LIST of
17074 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
17077 static dw_loc_list_ref
17078 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
17080 const char *endname
, *secname
;
17081 var_loc_view endview
;
17083 enum var_init_status initialized
;
17084 struct var_loc_node
*node
;
17085 dw_loc_descr_ref descr
;
17086 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
17087 dw_loc_list_ref list
= NULL
;
17088 dw_loc_list_ref
*listp
= &list
;
17090 /* Now that we know what section we are using for a base,
17091 actually construct the list of locations.
17092 The first location information is what is passed to the
17093 function that creates the location list, and the remaining
17094 locations just get added on to that list.
17095 Note that we only know the start address for a location
17096 (IE location changes), so to build the range, we use
17097 the range [current location start, next location start].
17098 This means we have to special case the last node, and generate
17099 a range of [last location start, end of function label]. */
17101 if (cfun
&& crtl
->has_bb_partition
)
17103 bool save_in_cold_section_p
= in_cold_section_p
;
17104 in_cold_section_p
= first_function_block_is_cold
;
17105 if (loc_list
->last_before_switch
== NULL
)
17106 in_cold_section_p
= !in_cold_section_p
;
17107 secname
= secname_for_decl (decl
);
17108 in_cold_section_p
= save_in_cold_section_p
;
17111 secname
= secname_for_decl (decl
);
17113 for (node
= loc_list
->first
; node
; node
= node
->next
)
17115 bool range_across_switch
= false;
17116 if (GET_CODE (node
->loc
) == EXPR_LIST
17117 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
17119 if (GET_CODE (node
->loc
) == EXPR_LIST
)
17122 /* This requires DW_OP_{,bit_}piece, which is not usable
17123 inside DWARF expressions. */
17124 if (want_address
== 2)
17125 descr
= dw_sra_loc_expr (decl
, node
->loc
);
17129 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
17130 varloc
= NOTE_VAR_LOCATION (node
->loc
);
17131 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
17135 /* If section switch happens in between node->label
17136 and node->next->label (or end of function) and
17137 we can't emit it as a single entry list,
17138 emit two ranges, first one ending at the end
17139 of first partition and second one starting at the
17140 beginning of second partition. */
17141 if (node
== loc_list
->last_before_switch
17142 && (node
!= loc_list
->first
|| loc_list
->first
->next
17143 /* If we are to emit a view number, we will emit
17144 a loclist rather than a single location
17145 expression for the entire function (see
17146 loc_list_has_views), so we have to split the
17147 range that straddles across partitions. */
17148 || !ZERO_VIEW_P (node
->view
))
17149 && current_function_decl
)
17151 endname
= cfun
->fde
->dw_fde_end
;
17153 range_across_switch
= true;
17155 /* The variable has a location between NODE->LABEL and
17156 NODE->NEXT->LABEL. */
17157 else if (node
->next
)
17158 endname
= node
->next
->label
, endview
= node
->next
->view
;
17159 /* If the variable has a location at the last label
17160 it keeps its location until the end of function. */
17161 else if (!current_function_decl
)
17162 endname
= text_end_label
, endview
= 0;
17165 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
17166 current_function_funcdef_no
);
17167 endname
= ggc_strdup (label_id
);
17171 *listp
= new_loc_list (descr
, node
->label
, node
->view
,
17172 endname
, endview
, secname
);
17173 if (TREE_CODE (decl
) == PARM_DECL
17174 && node
== loc_list
->first
17175 && NOTE_P (node
->loc
)
17176 && strcmp (node
->label
, endname
) == 0)
17177 (*listp
)->force
= true;
17178 listp
= &(*listp
)->dw_loc_next
;
17183 && crtl
->has_bb_partition
17184 && node
== loc_list
->last_before_switch
)
17186 bool save_in_cold_section_p
= in_cold_section_p
;
17187 in_cold_section_p
= !first_function_block_is_cold
;
17188 secname
= secname_for_decl (decl
);
17189 in_cold_section_p
= save_in_cold_section_p
;
17192 if (range_across_switch
)
17194 if (GET_CODE (node
->loc
) == EXPR_LIST
)
17195 descr
= dw_sra_loc_expr (decl
, node
->loc
);
17198 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
17199 varloc
= NOTE_VAR_LOCATION (node
->loc
);
17200 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
17203 gcc_assert (descr
);
17204 /* The variable has a location between NODE->LABEL and
17205 NODE->NEXT->LABEL. */
17207 endname
= node
->next
->label
, endview
= node
->next
->view
;
17209 endname
= cfun
->fde
->dw_fde_second_end
, endview
= 0;
17210 *listp
= new_loc_list (descr
, cfun
->fde
->dw_fde_second_begin
, 0,
17211 endname
, endview
, secname
);
17212 listp
= &(*listp
)->dw_loc_next
;
17216 /* Try to avoid the overhead of a location list emitting a location
17217 expression instead, but only if we didn't have more than one
17218 location entry in the first place. If some entries were not
17219 representable, we don't want to pretend a single entry that was
17220 applies to the entire scope in which the variable is
17222 if (list
&& loc_list
->first
->next
)
17225 maybe_gen_llsym (list
);
17230 /* Return if the loc_list has only single element and thus can be represented
17231 as location description. */
17234 single_element_loc_list_p (dw_loc_list_ref list
)
17236 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
17237 return !list
->ll_symbol
;
17240 /* Duplicate a single element of location list. */
17242 static inline dw_loc_descr_ref
17243 copy_loc_descr (dw_loc_descr_ref ref
)
17245 dw_loc_descr_ref copy
= ggc_alloc
<dw_loc_descr_node
> ();
17246 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
17250 /* To each location in list LIST append loc descr REF. */
17253 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
17255 dw_loc_descr_ref copy
;
17256 add_loc_descr (&list
->expr
, ref
);
17257 list
= list
->dw_loc_next
;
17260 copy
= copy_loc_descr (ref
);
17261 add_loc_descr (&list
->expr
, copy
);
17262 while (copy
->dw_loc_next
)
17263 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
17264 list
= list
->dw_loc_next
;
17268 /* To each location in list LIST prepend loc descr REF. */
17271 prepend_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
17273 dw_loc_descr_ref copy
;
17274 dw_loc_descr_ref ref_end
= list
->expr
;
17275 add_loc_descr (&ref
, list
->expr
);
17277 list
= list
->dw_loc_next
;
17280 dw_loc_descr_ref end
= list
->expr
;
17281 list
->expr
= copy
= copy_loc_descr (ref
);
17282 while (copy
->dw_loc_next
!= ref_end
)
17283 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
17284 copy
->dw_loc_next
= end
;
17285 list
= list
->dw_loc_next
;
17289 /* Given two lists RET and LIST
17290 produce location list that is result of adding expression in LIST
17291 to expression in RET on each position in program.
17292 Might be destructive on both RET and LIST.
17294 TODO: We handle only simple cases of RET or LIST having at most one
17295 element. General case would involve sorting the lists in program order
17296 and merging them that will need some additional work.
17297 Adding that will improve quality of debug info especially for SRA-ed
17301 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
17310 if (!list
->dw_loc_next
)
17312 add_loc_descr_to_each (*ret
, list
->expr
);
17315 if (!(*ret
)->dw_loc_next
)
17317 prepend_loc_descr_to_each (list
, (*ret
)->expr
);
17321 expansion_failed (NULL_TREE
, NULL_RTX
,
17322 "Don't know how to merge two non-trivial"
17323 " location lists.\n");
17328 /* LOC is constant expression. Try a luck, look it up in constant
17329 pool and return its loc_descr of its address. */
17331 static dw_loc_descr_ref
17332 cst_pool_loc_descr (tree loc
)
17334 /* Get an RTL for this, if something has been emitted. */
17335 rtx rtl
= lookup_constant_def (loc
);
17337 if (!rtl
|| !MEM_P (rtl
))
17342 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
17344 /* TODO: We might get more coverage if we was actually delaying expansion
17345 of all expressions till end of compilation when constant pools are fully
17347 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
17349 expansion_failed (loc
, NULL_RTX
,
17350 "CST value in contant pool but not marked.");
17353 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
17354 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
17357 /* Return dw_loc_list representing address of addr_expr LOC
17358 by looking for inner INDIRECT_REF expression and turning
17359 it into simple arithmetics.
17361 See loc_list_from_tree for the meaning of CONTEXT. */
17363 static dw_loc_list_ref
17364 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
,
17365 loc_descr_context
*context
)
17368 poly_int64 bitsize
, bitpos
, bytepos
;
17370 int unsignedp
, reversep
, volatilep
= 0;
17371 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
17373 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
17374 &bitsize
, &bitpos
, &offset
, &mode
,
17375 &unsignedp
, &reversep
, &volatilep
);
17377 if (!multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
))
17379 expansion_failed (loc
, NULL_RTX
, "bitfield access");
17382 if (!INDIRECT_REF_P (obj
))
17384 expansion_failed (obj
,
17385 NULL_RTX
, "no indirect ref in inner refrence");
17388 if (!offset
&& known_eq (bitpos
, 0))
17389 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1,
17392 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
17393 && (dwarf_version
>= 4 || !dwarf_strict
))
17395 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0, context
);
17400 /* Variable offset. */
17401 list_ret1
= loc_list_from_tree (offset
, 0, context
);
17402 if (list_ret1
== 0)
17404 add_loc_list (&list_ret
, list_ret1
);
17407 add_loc_descr_to_each (list_ret
,
17408 new_loc_descr (DW_OP_plus
, 0, 0));
17410 HOST_WIDE_INT value
;
17411 if (bytepos
.is_constant (&value
) && value
> 0)
17412 add_loc_descr_to_each (list_ret
,
17413 new_loc_descr (DW_OP_plus_uconst
, value
, 0));
17414 else if (maybe_ne (bytepos
, 0))
17415 loc_list_plus_const (list_ret
, bytepos
);
17416 add_loc_descr_to_each (list_ret
,
17417 new_loc_descr (DW_OP_stack_value
, 0, 0));
17422 /* Set LOC to the next operation that is not a DW_OP_nop operation. In the case
17423 all operations from LOC are nops, move to the last one. Insert in NOPS all
17424 operations that are skipped. */
17427 loc_descr_to_next_no_nop (dw_loc_descr_ref
&loc
,
17428 hash_set
<dw_loc_descr_ref
> &nops
)
17430 while (loc
->dw_loc_next
!= NULL
&& loc
->dw_loc_opc
== DW_OP_nop
)
17433 loc
= loc
->dw_loc_next
;
17437 /* Helper for loc_descr_without_nops: free the location description operation
17441 free_loc_descr (const dw_loc_descr_ref
&loc
, void *data ATTRIBUTE_UNUSED
)
17447 /* Remove all DW_OP_nop operations from LOC except, if it exists, the one that
17451 loc_descr_without_nops (dw_loc_descr_ref
&loc
)
17453 if (loc
->dw_loc_opc
== DW_OP_nop
&& loc
->dw_loc_next
== NULL
)
17456 /* Set of all DW_OP_nop operations we remove. */
17457 hash_set
<dw_loc_descr_ref
> nops
;
17459 /* First, strip all prefix NOP operations in order to keep the head of the
17460 operations list. */
17461 loc_descr_to_next_no_nop (loc
, nops
);
17463 for (dw_loc_descr_ref cur
= loc
; cur
!= NULL
;)
17465 /* For control flow operations: strip "prefix" nops in destination
17467 if (cur
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
)
17468 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd1
.v
.val_loc
, nops
);
17469 if (cur
->dw_loc_oprnd2
.val_class
== dw_val_class_loc
)
17470 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd2
.v
.val_loc
, nops
);
17472 /* Do the same for the operations that follow, then move to the next
17474 if (cur
->dw_loc_next
!= NULL
)
17475 loc_descr_to_next_no_nop (cur
->dw_loc_next
, nops
);
17476 cur
= cur
->dw_loc_next
;
17479 nops
.traverse
<void *, free_loc_descr
> (NULL
);
17483 struct dwarf_procedure_info
;
17485 /* Helper structure for location descriptions generation. */
17486 struct loc_descr_context
17488 /* The type that is implicitly referenced by DW_OP_push_object_address, or
17489 NULL_TREE if DW_OP_push_object_address in invalid for this location
17490 description. This is used when processing PLACEHOLDER_EXPR nodes. */
17492 /* The ..._DECL node that should be translated as a
17493 DW_OP_push_object_address operation. */
17495 /* Information about the DWARF procedure we are currently generating. NULL if
17496 we are not generating a DWARF procedure. */
17497 struct dwarf_procedure_info
*dpi
;
17498 /* True if integral PLACEHOLDER_EXPR stands for the first argument passed
17499 by consumer. Used for DW_TAG_generic_subrange attributes. */
17500 bool placeholder_arg
;
17501 /* True if PLACEHOLDER_EXPR has been seen. */
17502 bool placeholder_seen
;
17505 /* DWARF procedures generation
17507 DWARF expressions (aka. location descriptions) are used to encode variable
17508 things such as sizes or offsets. Such computations can have redundant parts
17509 that can be factorized in order to reduce the size of the output debug
17510 information. This is the whole point of DWARF procedures.
17512 Thanks to stor-layout.c, size and offset expressions in GENERIC trees are
17513 already factorized into functions ("size functions") in order to handle very
17514 big and complex types. Such functions are quite simple: they have integral
17515 arguments, they return an integral result and their body contains only a
17516 return statement with arithmetic expressions. This is the only kind of
17517 function we are interested in translating into DWARF procedures, here.
17519 DWARF expressions and DWARF procedure are executed using a stack, so we have
17520 to define some calling convention for them to interact. Let's say that:
17522 - Before calling a DWARF procedure, DWARF expressions must push on the stack
17523 all arguments in reverse order (right-to-left) so that when the DWARF
17524 procedure execution starts, the first argument is the top of the stack.
17526 - Then, when returning, the DWARF procedure must have consumed all arguments
17527 on the stack, must have pushed the result and touched nothing else.
17529 - Each integral argument and the result are integral types can be hold in a
17532 - We call "frame offset" the number of stack slots that are "under DWARF
17533 procedure control": it includes the arguments slots, the temporaries and
17534 the result slot. Thus, it is equal to the number of arguments when the
17535 procedure execution starts and must be equal to one (the result) when it
17538 /* Helper structure used when generating operations for a DWARF procedure. */
17539 struct dwarf_procedure_info
17541 /* The FUNCTION_DECL node corresponding to the DWARF procedure that is
17542 currently translated. */
17544 /* The number of arguments FNDECL takes. */
17545 unsigned args_count
;
17548 /* Return a pointer to a newly created DIE node for a DWARF procedure. Add
17549 LOCATION as its DW_AT_location attribute. If FNDECL is not NULL_TREE,
17550 equate it to this DIE. */
17553 new_dwarf_proc_die (dw_loc_descr_ref location
, tree fndecl
,
17554 dw_die_ref parent_die
)
17556 dw_die_ref dwarf_proc_die
;
17558 if ((dwarf_version
< 3 && dwarf_strict
)
17559 || location
== NULL
)
17562 dwarf_proc_die
= new_die (DW_TAG_dwarf_procedure
, parent_die
, fndecl
);
17564 equate_decl_number_to_die (fndecl
, dwarf_proc_die
);
17565 add_AT_loc (dwarf_proc_die
, DW_AT_location
, location
);
17566 return dwarf_proc_die
;
17569 /* Return whether TYPE is a supported type as a DWARF procedure argument
17570 type or return type (we handle only scalar types and pointer types that
17571 aren't wider than the DWARF expression evaluation stack. */
17574 is_handled_procedure_type (tree type
)
17576 return ((INTEGRAL_TYPE_P (type
)
17577 || TREE_CODE (type
) == OFFSET_TYPE
17578 || TREE_CODE (type
) == POINTER_TYPE
)
17579 && int_size_in_bytes (type
) <= DWARF2_ADDR_SIZE
);
17582 /* Helper for resolve_args_picking: do the same but stop when coming across
17583 visited nodes. For each node we visit, register in FRAME_OFFSETS the frame
17584 offset *before* evaluating the corresponding operation. */
17587 resolve_args_picking_1 (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
17588 struct dwarf_procedure_info
*dpi
,
17589 hash_map
<dw_loc_descr_ref
, unsigned> &frame_offsets
)
17591 /* The "frame_offset" identifier is already used to name a macro... */
17592 unsigned frame_offset_
= initial_frame_offset
;
17593 dw_loc_descr_ref l
;
17595 for (l
= loc
; l
!= NULL
;)
17598 unsigned &l_frame_offset
= frame_offsets
.get_or_insert (l
, &existed
);
17600 /* If we already met this node, there is nothing to compute anymore. */
17603 /* Make sure that the stack size is consistent wherever the execution
17604 flow comes from. */
17605 gcc_assert ((unsigned) l_frame_offset
== frame_offset_
);
17608 l_frame_offset
= frame_offset_
;
17610 /* If needed, relocate the picking offset with respect to the frame
17612 if (l
->frame_offset_rel
)
17614 unsigned HOST_WIDE_INT off
;
17615 switch (l
->dw_loc_opc
)
17618 off
= l
->dw_loc_oprnd1
.v
.val_unsigned
;
17627 gcc_unreachable ();
17629 /* frame_offset_ is the size of the current stack frame, including
17630 incoming arguments. Besides, the arguments are pushed
17631 right-to-left. Thus, in order to access the Nth argument from
17632 this operation node, the picking has to skip temporaries *plus*
17633 one stack slot per argument (0 for the first one, 1 for the second
17636 The targetted argument number (N) is already set as the operand,
17637 and the number of temporaries can be computed with:
17638 frame_offsets_ - dpi->args_count */
17639 off
+= frame_offset_
- dpi
->args_count
;
17641 /* DW_OP_pick handles only offsets from 0 to 255 (inclusive)... */
17647 l
->dw_loc_opc
= DW_OP_dup
;
17648 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
17652 l
->dw_loc_opc
= DW_OP_over
;
17653 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
17657 l
->dw_loc_opc
= DW_OP_pick
;
17658 l
->dw_loc_oprnd1
.v
.val_unsigned
= off
;
17662 /* Update frame_offset according to the effect the current operation has
17664 switch (l
->dw_loc_opc
)
17672 case DW_OP_plus_uconst
:
17708 case DW_OP_deref_size
:
17710 case DW_OP_bit_piece
:
17711 case DW_OP_implicit_value
:
17712 case DW_OP_stack_value
:
17716 case DW_OP_const1u
:
17717 case DW_OP_const1s
:
17718 case DW_OP_const2u
:
17719 case DW_OP_const2s
:
17720 case DW_OP_const4u
:
17721 case DW_OP_const4s
:
17722 case DW_OP_const8u
:
17723 case DW_OP_const8s
:
17794 case DW_OP_push_object_address
:
17795 case DW_OP_call_frame_cfa
:
17796 case DW_OP_GNU_variable_value
:
17821 case DW_OP_xderef_size
:
17827 case DW_OP_call_ref
:
17829 dw_die_ref dwarf_proc
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
17830 int *stack_usage
= dwarf_proc_stack_usage_map
->get (dwarf_proc
);
17832 if (stack_usage
== NULL
)
17834 frame_offset_
+= *stack_usage
;
17838 case DW_OP_implicit_pointer
:
17839 case DW_OP_entry_value
:
17840 case DW_OP_const_type
:
17841 case DW_OP_regval_type
:
17842 case DW_OP_deref_type
:
17843 case DW_OP_convert
:
17844 case DW_OP_reinterpret
:
17845 case DW_OP_form_tls_address
:
17846 case DW_OP_GNU_push_tls_address
:
17847 case DW_OP_GNU_uninit
:
17848 case DW_OP_GNU_encoded_addr
:
17849 case DW_OP_GNU_implicit_pointer
:
17850 case DW_OP_GNU_entry_value
:
17851 case DW_OP_GNU_const_type
:
17852 case DW_OP_GNU_regval_type
:
17853 case DW_OP_GNU_deref_type
:
17854 case DW_OP_GNU_convert
:
17855 case DW_OP_GNU_reinterpret
:
17856 case DW_OP_GNU_parameter_ref
:
17857 /* loc_list_from_tree will probably not output these operations for
17858 size functions, so assume they will not appear here. */
17859 /* Fall through... */
17862 gcc_unreachable ();
17865 /* Now, follow the control flow (except subroutine calls). */
17866 switch (l
->dw_loc_opc
)
17869 if (!resolve_args_picking_1 (l
->dw_loc_next
, frame_offset_
, dpi
,
17872 /* Fall through. */
17875 l
= l
->dw_loc_oprnd1
.v
.val_loc
;
17878 case DW_OP_stack_value
:
17882 l
= l
->dw_loc_next
;
17890 /* Make a DFS over operations reachable through LOC (i.e. follow branch
17891 operations) in order to resolve the operand of DW_OP_pick operations that
17892 target DWARF procedure arguments (DPI). INITIAL_FRAME_OFFSET is the frame
17893 offset *before* LOC is executed. Return if all relocations were
17897 resolve_args_picking (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
17898 struct dwarf_procedure_info
*dpi
)
17900 /* Associate to all visited operations the frame offset *before* evaluating
17902 hash_map
<dw_loc_descr_ref
, unsigned> frame_offsets
;
17904 return resolve_args_picking_1 (loc
, initial_frame_offset
, dpi
,
17908 /* Try to generate a DWARF procedure that computes the same result as FNDECL.
17909 Return NULL if it is not possible. */
17912 function_to_dwarf_procedure (tree fndecl
)
17914 struct loc_descr_context ctx
;
17915 struct dwarf_procedure_info dpi
;
17916 dw_die_ref dwarf_proc_die
;
17917 tree tree_body
= DECL_SAVED_TREE (fndecl
);
17918 dw_loc_descr_ref loc_body
, epilogue
;
17923 /* Do not generate multiple DWARF procedures for the same function
17925 dwarf_proc_die
= lookup_decl_die (fndecl
);
17926 if (dwarf_proc_die
!= NULL
)
17927 return dwarf_proc_die
;
17929 /* DWARF procedures are available starting with the DWARFv3 standard. */
17930 if (dwarf_version
< 3 && dwarf_strict
)
17933 /* We handle only functions for which we still have a body, that return a
17934 supported type and that takes arguments with supported types. Note that
17935 there is no point translating functions that return nothing. */
17936 if (tree_body
== NULL_TREE
17937 || DECL_RESULT (fndecl
) == NULL_TREE
17938 || !is_handled_procedure_type (TREE_TYPE (DECL_RESULT (fndecl
))))
17941 for (cursor
= DECL_ARGUMENTS (fndecl
);
17942 cursor
!= NULL_TREE
;
17943 cursor
= TREE_CHAIN (cursor
))
17944 if (!is_handled_procedure_type (TREE_TYPE (cursor
)))
17947 /* Match only "expr" in: RETURN_EXPR (MODIFY_EXPR (RESULT_DECL, expr)). */
17948 if (TREE_CODE (tree_body
) != RETURN_EXPR
)
17950 tree_body
= TREE_OPERAND (tree_body
, 0);
17951 if (TREE_CODE (tree_body
) != MODIFY_EXPR
17952 || TREE_OPERAND (tree_body
, 0) != DECL_RESULT (fndecl
))
17954 tree_body
= TREE_OPERAND (tree_body
, 1);
17956 /* Try to translate the body expression itself. Note that this will probably
17957 cause an infinite recursion if its call graph has a cycle. This is very
17958 unlikely for size functions, however, so don't bother with such things at
17960 ctx
.context_type
= NULL_TREE
;
17961 ctx
.base_decl
= NULL_TREE
;
17963 ctx
.placeholder_arg
= false;
17964 ctx
.placeholder_seen
= false;
17965 dpi
.fndecl
= fndecl
;
17966 dpi
.args_count
= list_length (DECL_ARGUMENTS (fndecl
));
17967 loc_body
= loc_descriptor_from_tree (tree_body
, 0, &ctx
);
17971 /* After evaluating all operands in "loc_body", we should still have on the
17972 stack all arguments plus the desired function result (top of the stack).
17973 Generate code in order to keep only the result in our stack frame. */
17975 for (i
= 0; i
< dpi
.args_count
; ++i
)
17977 dw_loc_descr_ref op_couple
= new_loc_descr (DW_OP_swap
, 0, 0);
17978 op_couple
->dw_loc_next
= new_loc_descr (DW_OP_drop
, 0, 0);
17979 op_couple
->dw_loc_next
->dw_loc_next
= epilogue
;
17980 epilogue
= op_couple
;
17982 add_loc_descr (&loc_body
, epilogue
);
17983 if (!resolve_args_picking (loc_body
, dpi
.args_count
, &dpi
))
17986 /* Trailing nops from loc_descriptor_from_tree (if any) cannot be removed
17987 because they are considered useful. Now there is an epilogue, they are
17988 not anymore, so give it another try. */
17989 loc_descr_without_nops (loc_body
);
17991 /* fndecl may be used both as a regular DW_TAG_subprogram DIE and as
17992 a DW_TAG_dwarf_procedure, so we may have a conflict, here. It's unlikely,
17993 though, given that size functions do not come from source, so they should
17994 not have a dedicated DW_TAG_subprogram DIE. */
17996 = new_dwarf_proc_die (loc_body
, fndecl
,
17997 get_context_die (DECL_CONTEXT (fndecl
)));
17999 /* The called DWARF procedure consumes one stack slot per argument and
18000 returns one stack slot. */
18001 dwarf_proc_stack_usage_map
->put (dwarf_proc_die
, 1 - dpi
.args_count
);
18003 return dwarf_proc_die
;
18007 /* Generate Dwarf location list representing LOC.
18008 If WANT_ADDRESS is false, expression computing LOC will be computed
18009 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
18010 if WANT_ADDRESS is 2, expression computing address useable in location
18011 will be returned (i.e. DW_OP_reg can be used
18012 to refer to register values).
18014 CONTEXT provides information to customize the location descriptions
18015 generation. Its context_type field specifies what type is implicitly
18016 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
18017 will not be generated.
18019 Its DPI field determines whether we are generating a DWARF expression for a
18020 DWARF procedure, so PARM_DECL references are processed specifically.
18022 If CONTEXT is NULL, the behavior is the same as if context_type, base_decl
18023 and dpi fields were null. */
18025 static dw_loc_list_ref
18026 loc_list_from_tree_1 (tree loc
, int want_address
,
18027 struct loc_descr_context
*context
)
18029 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
18030 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
18031 int have_address
= 0;
18032 enum dwarf_location_atom op
;
18034 /* ??? Most of the time we do not take proper care for sign/zero
18035 extending the values properly. Hopefully this won't be a real
18038 if (context
!= NULL
18039 && context
->base_decl
== loc
18040 && want_address
== 0)
18042 if (dwarf_version
>= 3 || !dwarf_strict
)
18043 return new_loc_list (new_loc_descr (DW_OP_push_object_address
, 0, 0),
18044 NULL
, 0, NULL
, 0, NULL
);
18049 switch (TREE_CODE (loc
))
18052 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
18055 case PLACEHOLDER_EXPR
:
18056 /* This case involves extracting fields from an object to determine the
18057 position of other fields. It is supposed to appear only as the first
18058 operand of COMPONENT_REF nodes and to reference precisely the type
18059 that the context allows. */
18060 if (context
!= NULL
18061 && TREE_TYPE (loc
) == context
->context_type
18062 && want_address
>= 1)
18064 if (dwarf_version
>= 3 || !dwarf_strict
)
18066 ret
= new_loc_descr (DW_OP_push_object_address
, 0, 0);
18073 /* For DW_TAG_generic_subrange attributes, PLACEHOLDER_EXPR stands for
18074 the single argument passed by consumer. */
18075 else if (context
!= NULL
18076 && context
->placeholder_arg
18077 && INTEGRAL_TYPE_P (TREE_TYPE (loc
))
18078 && want_address
== 0)
18080 ret
= new_loc_descr (DW_OP_pick
, 0, 0);
18081 ret
->frame_offset_rel
= 1;
18082 context
->placeholder_seen
= true;
18086 expansion_failed (loc
, NULL_RTX
,
18087 "PLACEHOLDER_EXPR for an unexpected type");
18092 const int nargs
= call_expr_nargs (loc
);
18093 tree callee
= get_callee_fndecl (loc
);
18095 dw_die_ref dwarf_proc
;
18097 if (callee
== NULL_TREE
)
18098 goto call_expansion_failed
;
18100 /* We handle only functions that return an integer. */
18101 if (!is_handled_procedure_type (TREE_TYPE (TREE_TYPE (callee
))))
18102 goto call_expansion_failed
;
18104 dwarf_proc
= function_to_dwarf_procedure (callee
);
18105 if (dwarf_proc
== NULL
)
18106 goto call_expansion_failed
;
18108 /* Evaluate arguments right-to-left so that the first argument will
18109 be the top-most one on the stack. */
18110 for (i
= nargs
- 1; i
>= 0; --i
)
18112 dw_loc_descr_ref loc_descr
18113 = loc_descriptor_from_tree (CALL_EXPR_ARG (loc
, i
), 0,
18116 if (loc_descr
== NULL
)
18117 goto call_expansion_failed
;
18119 add_loc_descr (&ret
, loc_descr
);
18122 ret1
= new_loc_descr (DW_OP_call4
, 0, 0);
18123 ret1
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18124 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.die
= dwarf_proc
;
18125 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18126 add_loc_descr (&ret
, ret1
);
18129 call_expansion_failed
:
18130 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
18131 /* There are no opcodes for these operations. */
18135 case PREINCREMENT_EXPR
:
18136 case PREDECREMENT_EXPR
:
18137 case POSTINCREMENT_EXPR
:
18138 case POSTDECREMENT_EXPR
:
18139 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
18140 /* There are no opcodes for these operations. */
18144 /* If we already want an address, see if there is INDIRECT_REF inside
18145 e.g. for &this->field. */
18148 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
18149 (loc
, want_address
== 2, context
);
18152 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
18153 && (ret
= cst_pool_loc_descr (loc
)))
18156 /* Otherwise, process the argument and look for the address. */
18157 if (!list_ret
&& !ret
)
18158 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 1, context
);
18162 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
18168 if (DECL_THREAD_LOCAL_P (loc
))
18171 enum dwarf_location_atom tls_op
;
18172 enum dtprel_bool dtprel
= dtprel_false
;
18174 if (targetm
.have_tls
)
18176 /* If this is not defined, we have no way to emit the
18178 if (!targetm
.asm_out
.output_dwarf_dtprel
)
18181 /* The way DW_OP_GNU_push_tls_address is specified, we
18182 can only look up addresses of objects in the current
18183 module. We used DW_OP_addr as first op, but that's
18184 wrong, because DW_OP_addr is relocated by the debug
18185 info consumer, while DW_OP_GNU_push_tls_address
18186 operand shouldn't be. */
18187 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
18189 dtprel
= dtprel_true
;
18190 /* We check for DWARF 5 here because gdb did not implement
18191 DW_OP_form_tls_address until after 7.12. */
18192 tls_op
= (dwarf_version
>= 5 ? DW_OP_form_tls_address
18193 : DW_OP_GNU_push_tls_address
);
18197 if (!targetm
.emutls
.debug_form_tls_address
18198 || !(dwarf_version
>= 3 || !dwarf_strict
))
18200 /* We stuffed the control variable into the DECL_VALUE_EXPR
18201 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
18202 no longer appear in gimple code. We used the control
18203 variable in specific so that we could pick it up here. */
18204 loc
= DECL_VALUE_EXPR (loc
);
18205 tls_op
= DW_OP_form_tls_address
;
18208 rtl
= rtl_for_decl_location (loc
);
18209 if (rtl
== NULL_RTX
)
18214 rtl
= XEXP (rtl
, 0);
18215 if (! CONSTANT_P (rtl
))
18218 ret
= new_addr_loc_descr (rtl
, dtprel
);
18219 ret1
= new_loc_descr (tls_op
, 0, 0);
18220 add_loc_descr (&ret
, ret1
);
18228 if (context
!= NULL
&& context
->dpi
!= NULL
18229 && DECL_CONTEXT (loc
) == context
->dpi
->fndecl
)
18231 /* We are generating code for a DWARF procedure and we want to access
18232 one of its arguments: find the appropriate argument offset and let
18233 the resolve_args_picking pass compute the offset that complies
18234 with the stack frame size. */
18238 for (cursor
= DECL_ARGUMENTS (context
->dpi
->fndecl
);
18239 cursor
!= NULL_TREE
&& cursor
!= loc
;
18240 cursor
= TREE_CHAIN (cursor
), ++i
)
18242 /* If we are translating a DWARF procedure, all referenced parameters
18243 must belong to the current function. */
18244 gcc_assert (cursor
!= NULL_TREE
);
18246 ret
= new_loc_descr (DW_OP_pick
, i
, 0);
18247 ret
->frame_offset_rel
= 1;
18253 if (DECL_HAS_VALUE_EXPR_P (loc
))
18254 return loc_list_from_tree_1 (DECL_VALUE_EXPR (loc
),
18255 want_address
, context
);
18258 case FUNCTION_DECL
:
18261 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
18263 if (loc_list
&& loc_list
->first
)
18265 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
18266 have_address
= want_address
!= 0;
18269 rtl
= rtl_for_decl_location (loc
);
18270 if (rtl
== NULL_RTX
)
18272 if (TREE_CODE (loc
) != FUNCTION_DECL
18274 && current_function_decl
18275 && want_address
!= 1
18276 && ! DECL_IGNORED_P (loc
)
18277 && (INTEGRAL_TYPE_P (TREE_TYPE (loc
))
18278 || POINTER_TYPE_P (TREE_TYPE (loc
)))
18279 && DECL_CONTEXT (loc
) == current_function_decl
18280 && (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (loc
)))
18281 <= DWARF2_ADDR_SIZE
))
18283 dw_die_ref ref
= lookup_decl_die (loc
);
18284 ret
= new_loc_descr (DW_OP_GNU_variable_value
, 0, 0);
18287 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18288 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
18289 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18293 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
18294 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= loc
;
18298 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
18301 else if (CONST_INT_P (rtl
))
18303 HOST_WIDE_INT val
= INTVAL (rtl
);
18304 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18305 val
&= GET_MODE_MASK (DECL_MODE (loc
));
18306 ret
= int_loc_descriptor (val
);
18308 else if (GET_CODE (rtl
) == CONST_STRING
)
18310 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
18313 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
18314 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
18317 machine_mode mode
, mem_mode
;
18319 /* Certain constructs can only be represented at top-level. */
18320 if (want_address
== 2)
18322 ret
= loc_descriptor (rtl
, VOIDmode
,
18323 VAR_INIT_STATUS_INITIALIZED
);
18328 mode
= GET_MODE (rtl
);
18329 mem_mode
= VOIDmode
;
18333 mode
= get_address_mode (rtl
);
18334 rtl
= XEXP (rtl
, 0);
18337 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
18338 VAR_INIT_STATUS_INITIALIZED
);
18341 expansion_failed (loc
, rtl
,
18342 "failed to produce loc descriptor for rtl");
18348 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
18355 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18359 case TARGET_MEM_REF
:
18361 case DEBUG_EXPR_DECL
:
18364 case COMPOUND_EXPR
:
18365 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), want_address
,
18369 case VIEW_CONVERT_EXPR
:
18372 case NON_LVALUE_EXPR
:
18373 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), want_address
,
18376 case COMPONENT_REF
:
18377 case BIT_FIELD_REF
:
18379 case ARRAY_RANGE_REF
:
18380 case REALPART_EXPR
:
18381 case IMAGPART_EXPR
:
18384 poly_int64 bitsize
, bitpos
, bytepos
;
18386 int unsignedp
, reversep
, volatilep
= 0;
18388 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
18389 &unsignedp
, &reversep
, &volatilep
);
18391 gcc_assert (obj
!= loc
);
18393 list_ret
= loc_list_from_tree_1 (obj
,
18395 && known_eq (bitpos
, 0)
18396 && !offset
? 2 : 1,
18398 /* TODO: We can extract value of the small expression via shifting even
18399 for nonzero bitpos. */
18402 if (!multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
18403 || !multiple_p (bitsize
, BITS_PER_UNIT
))
18405 expansion_failed (loc
, NULL_RTX
,
18406 "bitfield access");
18410 if (offset
!= NULL_TREE
)
18412 /* Variable offset. */
18413 list_ret1
= loc_list_from_tree_1 (offset
, 0, context
);
18414 if (list_ret1
== 0)
18416 add_loc_list (&list_ret
, list_ret1
);
18419 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
18422 HOST_WIDE_INT value
;
18423 if (bytepos
.is_constant (&value
) && value
> 0)
18424 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
,
18426 else if (maybe_ne (bytepos
, 0))
18427 loc_list_plus_const (list_ret
, bytepos
);
18434 if ((want_address
|| !tree_fits_shwi_p (loc
))
18435 && (ret
= cst_pool_loc_descr (loc
)))
18437 else if (want_address
== 2
18438 && tree_fits_shwi_p (loc
)
18439 && (ret
= address_of_int_loc_descriptor
18440 (int_size_in_bytes (TREE_TYPE (loc
)),
18441 tree_to_shwi (loc
))))
18443 else if (tree_fits_shwi_p (loc
))
18444 ret
= int_loc_descriptor (tree_to_shwi (loc
));
18445 else if (tree_fits_uhwi_p (loc
))
18446 ret
= uint_loc_descriptor (tree_to_uhwi (loc
));
18449 expansion_failed (loc
, NULL_RTX
,
18450 "Integer operand is not host integer");
18459 if ((ret
= cst_pool_loc_descr (loc
)))
18461 else if (TREE_CODE (loc
) == CONSTRUCTOR
)
18463 tree type
= TREE_TYPE (loc
);
18464 unsigned HOST_WIDE_INT size
= int_size_in_bytes (type
);
18465 unsigned HOST_WIDE_INT offset
= 0;
18466 unsigned HOST_WIDE_INT cnt
;
18467 constructor_elt
*ce
;
18469 if (TREE_CODE (type
) == RECORD_TYPE
)
18471 /* This is very limited, but it's enough to output
18472 pointers to member functions, as long as the
18473 referenced function is defined in the current
18474 translation unit. */
18475 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (loc
), cnt
, ce
)
18477 tree val
= ce
->value
;
18479 tree field
= ce
->index
;
18484 if (!field
|| DECL_BIT_FIELD (field
))
18486 expansion_failed (loc
, NULL_RTX
,
18487 "bitfield in record type constructor");
18488 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
18493 HOST_WIDE_INT fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
18494 unsigned HOST_WIDE_INT pos
= int_byte_position (field
);
18495 gcc_assert (pos
+ fieldsize
<= size
);
18498 expansion_failed (loc
, NULL_RTX
,
18499 "out-of-order fields in record constructor");
18500 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
18506 ret1
= new_loc_descr (DW_OP_piece
, pos
- offset
, 0);
18507 add_loc_descr (&ret
, ret1
);
18510 if (val
&& fieldsize
!= 0)
18512 ret1
= loc_descriptor_from_tree (val
, want_address
, context
);
18515 expansion_failed (loc
, NULL_RTX
,
18516 "unsupported expression in field");
18517 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
18521 add_loc_descr (&ret
, ret1
);
18525 ret1
= new_loc_descr (DW_OP_piece
, fieldsize
, 0);
18526 add_loc_descr (&ret
, ret1
);
18527 offset
= pos
+ fieldsize
;
18531 if (offset
!= size
)
18533 ret1
= new_loc_descr (DW_OP_piece
, size
- offset
, 0);
18534 add_loc_descr (&ret
, ret1
);
18538 have_address
= !!want_address
;
18541 expansion_failed (loc
, NULL_RTX
,
18542 "constructor of non-record type");
18545 /* We can construct small constants here using int_loc_descriptor. */
18546 expansion_failed (loc
, NULL_RTX
,
18547 "constructor or constant not in constant pool");
18550 case TRUTH_AND_EXPR
:
18551 case TRUTH_ANDIF_EXPR
:
18556 case TRUTH_XOR_EXPR
:
18561 case TRUTH_OR_EXPR
:
18562 case TRUTH_ORIF_EXPR
:
18567 case FLOOR_DIV_EXPR
:
18568 case CEIL_DIV_EXPR
:
18569 case ROUND_DIV_EXPR
:
18570 case TRUNC_DIV_EXPR
:
18571 case EXACT_DIV_EXPR
:
18572 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18581 case FLOOR_MOD_EXPR
:
18582 case CEIL_MOD_EXPR
:
18583 case ROUND_MOD_EXPR
:
18584 case TRUNC_MOD_EXPR
:
18585 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18590 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18591 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
18592 if (list_ret
== 0 || list_ret1
== 0)
18595 add_loc_list (&list_ret
, list_ret1
);
18598 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
18599 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
18600 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
18601 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
18602 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
18614 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
18617 case POINTER_PLUS_EXPR
:
18620 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
18622 /* Big unsigned numbers can fit in HOST_WIDE_INT but it may be
18623 smarter to encode their opposite. The DW_OP_plus_uconst operation
18624 takes 1 + X bytes, X being the size of the ULEB128 addend. On the
18625 other hand, a "<push literal>; DW_OP_minus" pattern takes 1 + Y
18626 bytes, Y being the size of the operation that pushes the opposite
18627 of the addend. So let's choose the smallest representation. */
18628 const tree tree_addend
= TREE_OPERAND (loc
, 1);
18629 offset_int wi_addend
;
18630 HOST_WIDE_INT shwi_addend
;
18631 dw_loc_descr_ref loc_naddend
;
18633 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18637 /* Try to get the literal to push. It is the opposite of the addend,
18638 so as we rely on wrapping during DWARF evaluation, first decode
18639 the literal as a "DWARF-sized" signed number. */
18640 wi_addend
= wi::to_offset (tree_addend
);
18641 wi_addend
= wi::sext (wi_addend
, DWARF2_ADDR_SIZE
* 8);
18642 shwi_addend
= wi_addend
.to_shwi ();
18643 loc_naddend
= (shwi_addend
!= INTTYPE_MINIMUM (HOST_WIDE_INT
))
18644 ? int_loc_descriptor (-shwi_addend
)
18647 if (loc_naddend
!= NULL
18648 && ((unsigned) size_of_uleb128 (shwi_addend
)
18649 > size_of_loc_descr (loc_naddend
)))
18651 add_loc_descr_to_each (list_ret
, loc_naddend
);
18652 add_loc_descr_to_each (list_ret
,
18653 new_loc_descr (DW_OP_minus
, 0, 0));
18657 for (dw_loc_descr_ref loc_cur
= loc_naddend
; loc_cur
!= NULL
; )
18659 loc_naddend
= loc_cur
;
18660 loc_cur
= loc_cur
->dw_loc_next
;
18661 ggc_free (loc_naddend
);
18663 loc_list_plus_const (list_ret
, wi_addend
.to_shwi ());
18673 goto do_comp_binop
;
18677 goto do_comp_binop
;
18681 goto do_comp_binop
;
18685 goto do_comp_binop
;
18688 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
18690 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0, context
);
18691 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
18692 list_ret
= loc_list_from_uint_comparison (list_ret
, list_ret1
,
18708 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18709 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
18710 if (list_ret
== 0 || list_ret1
== 0)
18713 add_loc_list (&list_ret
, list_ret1
);
18716 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
18719 case TRUTH_NOT_EXPR
:
18733 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18737 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
18743 const enum tree_code code
=
18744 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
18746 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
18747 build2 (code
, integer_type_node
,
18748 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
18749 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
18756 dw_loc_descr_ref lhs
18757 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
18758 dw_loc_list_ref rhs
18759 = loc_list_from_tree_1 (TREE_OPERAND (loc
, 2), 0, context
);
18760 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
18762 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18763 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
18766 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
18767 add_loc_descr_to_each (list_ret
, bra_node
);
18769 add_loc_list (&list_ret
, rhs
);
18770 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
18771 add_loc_descr_to_each (list_ret
, jump_node
);
18773 add_loc_descr_to_each (list_ret
, lhs
);
18774 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
18775 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
18777 /* ??? Need a node to point the skip at. Use a nop. */
18778 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
18779 add_loc_descr_to_each (list_ret
, tmp
);
18780 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
18781 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
18785 case FIX_TRUNC_EXPR
:
18789 /* Leave front-end specific codes as simply unknown. This comes
18790 up, for instance, with the C STMT_EXPR. */
18791 if ((unsigned int) TREE_CODE (loc
)
18792 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
18794 expansion_failed (loc
, NULL_RTX
,
18795 "language specific tree node");
18799 /* Otherwise this is a generic code; we should just lists all of
18800 these explicitly. We forgot one. */
18802 gcc_unreachable ();
18804 /* In a release build, we want to degrade gracefully: better to
18805 generate incomplete debugging information than to crash. */
18809 if (!ret
&& !list_ret
)
18812 if (want_address
== 2 && !have_address
18813 && (dwarf_version
>= 4 || !dwarf_strict
))
18815 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
18817 expansion_failed (loc
, NULL_RTX
,
18818 "DWARF address size mismatch");
18822 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
18824 add_loc_descr_to_each (list_ret
,
18825 new_loc_descr (DW_OP_stack_value
, 0, 0));
18828 /* Show if we can't fill the request for an address. */
18829 if (want_address
&& !have_address
)
18831 expansion_failed (loc
, NULL_RTX
,
18832 "Want address and only have value");
18836 gcc_assert (!ret
|| !list_ret
);
18838 /* If we've got an address and don't want one, dereference. */
18839 if (!want_address
&& have_address
)
18841 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
18843 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
18845 expansion_failed (loc
, NULL_RTX
,
18846 "DWARF address size mismatch");
18849 else if (size
== DWARF2_ADDR_SIZE
)
18852 op
= DW_OP_deref_size
;
18855 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
18857 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
18860 list_ret
= new_loc_list (ret
, NULL
, 0, NULL
, 0, NULL
);
18865 /* Likewise, but strip useless DW_OP_nop operations in the resulting
18868 static dw_loc_list_ref
18869 loc_list_from_tree (tree loc
, int want_address
,
18870 struct loc_descr_context
*context
)
18872 dw_loc_list_ref result
= loc_list_from_tree_1 (loc
, want_address
, context
);
18874 for (dw_loc_list_ref loc_cur
= result
;
18875 loc_cur
!= NULL
; loc_cur
= loc_cur
->dw_loc_next
)
18876 loc_descr_without_nops (loc_cur
->expr
);
18880 /* Same as above but return only single location expression. */
18881 static dw_loc_descr_ref
18882 loc_descriptor_from_tree (tree loc
, int want_address
,
18883 struct loc_descr_context
*context
)
18885 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
, context
);
18888 if (ret
->dw_loc_next
)
18890 expansion_failed (loc
, NULL_RTX
,
18891 "Location list where only loc descriptor needed");
18897 /* Given a value, round it up to the lowest multiple of `boundary'
18898 which is not less than the value itself. */
18900 static inline HOST_WIDE_INT
18901 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
18903 return (((value
+ boundary
- 1) / boundary
) * boundary
);
18906 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
18907 pointer to the declared type for the relevant field variable, or return
18908 `integer_type_node' if the given node turns out to be an
18909 ERROR_MARK node. */
18912 field_type (const_tree decl
)
18916 if (TREE_CODE (decl
) == ERROR_MARK
)
18917 return integer_type_node
;
18919 type
= DECL_BIT_FIELD_TYPE (decl
);
18920 if (type
== NULL_TREE
)
18921 type
= TREE_TYPE (decl
);
18926 /* Given a pointer to a tree node, return the alignment in bits for
18927 it, or else return BITS_PER_WORD if the node actually turns out to
18928 be an ERROR_MARK node. */
18930 static inline unsigned
18931 simple_type_align_in_bits (const_tree type
)
18933 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
18936 static inline unsigned
18937 simple_decl_align_in_bits (const_tree decl
)
18939 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
18942 /* Return the result of rounding T up to ALIGN. */
18944 static inline offset_int
18945 round_up_to_align (const offset_int
&t
, unsigned int align
)
18947 return wi::udiv_trunc (t
+ align
- 1, align
) * align
;
18950 /* Compute the size of TYPE in bytes. If possible, return NULL and store the
18951 size as an integer constant in CST_SIZE. Otherwise, if possible, return a
18952 DWARF expression that computes the size. Return NULL and set CST_SIZE to -1
18953 if we fail to return the size in one of these two forms. */
18955 static dw_loc_descr_ref
18956 type_byte_size (const_tree type
, HOST_WIDE_INT
*cst_size
)
18959 struct loc_descr_context ctx
;
18961 /* Return a constant integer in priority, if possible. */
18962 *cst_size
= int_size_in_bytes (type
);
18963 if (*cst_size
!= -1)
18966 ctx
.context_type
= const_cast<tree
> (type
);
18967 ctx
.base_decl
= NULL_TREE
;
18969 ctx
.placeholder_arg
= false;
18970 ctx
.placeholder_seen
= false;
18972 type
= TYPE_MAIN_VARIANT (type
);
18973 tree_size
= TYPE_SIZE_UNIT (type
);
18974 return ((tree_size
!= NULL_TREE
)
18975 ? loc_descriptor_from_tree (tree_size
, 0, &ctx
)
18979 /* Helper structure for RECORD_TYPE processing. */
18982 /* Root RECORD_TYPE. It is needed to generate data member location
18983 descriptions in variable-length records (VLR), but also to cope with
18984 variants, which are composed of nested structures multiplexed with
18985 QUAL_UNION_TYPE nodes. Each time such a structure is passed to a
18986 function processing a FIELD_DECL, it is required to be non null. */
18988 /* When generating a variant part in a RECORD_TYPE (i.e. a nested
18989 QUAL_UNION_TYPE), this holds an expression that computes the offset for
18990 this variant part as part of the root record (in storage units). For
18991 regular records, it must be NULL_TREE. */
18992 tree variant_part_offset
;
18995 /* Given a pointer to a FIELD_DECL, compute the byte offset of the lowest
18996 addressed byte of the "containing object" for the given FIELD_DECL. If
18997 possible, return a native constant through CST_OFFSET (in which case NULL is
18998 returned); otherwise return a DWARF expression that computes the offset.
19000 Set *CST_OFFSET to 0 and return NULL if we are unable to determine what
19001 that offset is, either because the argument turns out to be a pointer to an
19002 ERROR_MARK node, or because the offset expression is too complex for us.
19004 CTX is required: see the comment for VLR_CONTEXT. */
19006 static dw_loc_descr_ref
19007 field_byte_offset (const_tree decl
, struct vlr_context
*ctx
,
19008 HOST_WIDE_INT
*cst_offset
)
19011 dw_loc_list_ref loc_result
;
19015 if (TREE_CODE (decl
) == ERROR_MARK
)
19018 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
19020 /* We cannot handle variable bit offsets at the moment, so abort if it's the
19022 if (TREE_CODE (DECL_FIELD_BIT_OFFSET (decl
)) != INTEGER_CST
)
19025 #ifdef PCC_BITFIELD_TYPE_MATTERS
19026 /* We used to handle only constant offsets in all cases. Now, we handle
19027 properly dynamic byte offsets only when PCC bitfield type doesn't
19029 if (PCC_BITFIELD_TYPE_MATTERS
19030 && TREE_CODE (DECL_FIELD_OFFSET (decl
)) == INTEGER_CST
)
19032 offset_int object_offset_in_bits
;
19033 offset_int object_offset_in_bytes
;
19034 offset_int bitpos_int
;
19036 tree field_size_tree
;
19037 offset_int deepest_bitpos
;
19038 offset_int field_size_in_bits
;
19039 unsigned int type_align_in_bits
;
19040 unsigned int decl_align_in_bits
;
19041 offset_int type_size_in_bits
;
19043 bitpos_int
= wi::to_offset (bit_position (decl
));
19044 type
= field_type (decl
);
19045 type_size_in_bits
= offset_int_type_size_in_bits (type
);
19046 type_align_in_bits
= simple_type_align_in_bits (type
);
19048 field_size_tree
= DECL_SIZE (decl
);
19050 /* The size could be unspecified if there was an error, or for
19051 a flexible array member. */
19052 if (!field_size_tree
)
19053 field_size_tree
= bitsize_zero_node
;
19055 /* If the size of the field is not constant, use the type size. */
19056 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
19057 field_size_in_bits
= wi::to_offset (field_size_tree
);
19059 field_size_in_bits
= type_size_in_bits
;
19061 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
19063 /* The GCC front-end doesn't make any attempt to keep track of the
19064 starting bit offset (relative to the start of the containing
19065 structure type) of the hypothetical "containing object" for a
19066 bit-field. Thus, when computing the byte offset value for the
19067 start of the "containing object" of a bit-field, we must deduce
19068 this information on our own. This can be rather tricky to do in
19069 some cases. For example, handling the following structure type
19070 definition when compiling for an i386/i486 target (which only
19071 aligns long long's to 32-bit boundaries) can be very tricky:
19073 struct S { int field1; long long field2:31; };
19075 Fortunately, there is a simple rule-of-thumb which can be used
19076 in such cases. When compiling for an i386/i486, GCC will
19077 allocate 8 bytes for the structure shown above. It decides to
19078 do this based upon one simple rule for bit-field allocation.
19079 GCC allocates each "containing object" for each bit-field at
19080 the first (i.e. lowest addressed) legitimate alignment boundary
19081 (based upon the required minimum alignment for the declared
19082 type of the field) which it can possibly use, subject to the
19083 condition that there is still enough available space remaining
19084 in the containing object (when allocated at the selected point)
19085 to fully accommodate all of the bits of the bit-field itself.
19087 This simple rule makes it obvious why GCC allocates 8 bytes for
19088 each object of the structure type shown above. When looking
19089 for a place to allocate the "containing object" for `field2',
19090 the compiler simply tries to allocate a 64-bit "containing
19091 object" at each successive 32-bit boundary (starting at zero)
19092 until it finds a place to allocate that 64- bit field such that
19093 at least 31 contiguous (and previously unallocated) bits remain
19094 within that selected 64 bit field. (As it turns out, for the
19095 example above, the compiler finds it is OK to allocate the
19096 "containing object" 64-bit field at bit-offset zero within the
19099 Here we attempt to work backwards from the limited set of facts
19100 we're given, and we try to deduce from those facts, where GCC
19101 must have believed that the containing object started (within
19102 the structure type). The value we deduce is then used (by the
19103 callers of this routine) to generate DW_AT_location and
19104 DW_AT_bit_offset attributes for fields (both bit-fields and, in
19105 the case of DW_AT_location, regular fields as well). */
19107 /* Figure out the bit-distance from the start of the structure to
19108 the "deepest" bit of the bit-field. */
19109 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
19111 /* This is the tricky part. Use some fancy footwork to deduce
19112 where the lowest addressed bit of the containing object must
19114 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
19116 /* Round up to type_align by default. This works best for
19118 object_offset_in_bits
19119 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
19121 if (wi::gtu_p (object_offset_in_bits
, bitpos_int
))
19123 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
19125 /* Round up to decl_align instead. */
19126 object_offset_in_bits
19127 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
19130 object_offset_in_bytes
19131 = wi::lrshift (object_offset_in_bits
, LOG2_BITS_PER_UNIT
);
19132 if (ctx
->variant_part_offset
== NULL_TREE
)
19134 *cst_offset
= object_offset_in_bytes
.to_shwi ();
19137 tree_result
= wide_int_to_tree (sizetype
, object_offset_in_bytes
);
19140 #endif /* PCC_BITFIELD_TYPE_MATTERS */
19141 tree_result
= byte_position (decl
);
19143 if (ctx
->variant_part_offset
!= NULL_TREE
)
19144 tree_result
= fold_build2 (PLUS_EXPR
, TREE_TYPE (tree_result
),
19145 ctx
->variant_part_offset
, tree_result
);
19147 /* If the byte offset is a constant, it's simplier to handle a native
19148 constant rather than a DWARF expression. */
19149 if (TREE_CODE (tree_result
) == INTEGER_CST
)
19151 *cst_offset
= wi::to_offset (tree_result
).to_shwi ();
19154 struct loc_descr_context loc_ctx
= {
19155 ctx
->struct_type
, /* context_type */
19156 NULL_TREE
, /* base_decl */
19158 false, /* placeholder_arg */
19159 false /* placeholder_seen */
19161 loc_result
= loc_list_from_tree (tree_result
, 0, &loc_ctx
);
19163 /* We want a DWARF expression: abort if we only have a location list with
19164 multiple elements. */
19165 if (!loc_result
|| !single_element_loc_list_p (loc_result
))
19168 return loc_result
->expr
;
19171 /* The following routines define various Dwarf attributes and any data
19172 associated with them. */
19174 /* Add a location description attribute value to a DIE.
19176 This emits location attributes suitable for whole variables and
19177 whole parameters. Note that the location attributes for struct fields are
19178 generated by the routine `data_member_location_attribute' below. */
19181 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
19182 dw_loc_list_ref descr
)
19184 bool check_no_locviews
= true;
19187 if (single_element_loc_list_p (descr
))
19188 add_AT_loc (die
, attr_kind
, descr
->expr
);
19191 add_AT_loc_list (die
, attr_kind
, descr
);
19192 gcc_assert (descr
->ll_symbol
);
19193 if (attr_kind
== DW_AT_location
&& descr
->vl_symbol
19194 && dwarf2out_locviews_in_attribute ())
19196 add_AT_view_list (die
, DW_AT_GNU_locviews
);
19197 check_no_locviews
= false;
19201 if (check_no_locviews
)
19202 gcc_assert (!get_AT (die
, DW_AT_GNU_locviews
));
19205 /* Add DW_AT_accessibility attribute to DIE if needed. */
19208 add_accessibility_attribute (dw_die_ref die
, tree decl
)
19210 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19211 children, otherwise the default is DW_ACCESS_public. In DWARF2
19212 the default has always been DW_ACCESS_public. */
19213 if (TREE_PROTECTED (decl
))
19214 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
19215 else if (TREE_PRIVATE (decl
))
19217 if (dwarf_version
== 2
19218 || die
->die_parent
== NULL
19219 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
19220 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
19222 else if (dwarf_version
> 2
19224 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
19225 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
19228 /* Attach the specialized form of location attribute used for data members of
19229 struct and union types. In the special case of a FIELD_DECL node which
19230 represents a bit-field, the "offset" part of this special location
19231 descriptor must indicate the distance in bytes from the lowest-addressed
19232 byte of the containing struct or union type to the lowest-addressed byte of
19233 the "containing object" for the bit-field. (See the `field_byte_offset'
19236 For any given bit-field, the "containing object" is a hypothetical object
19237 (of some integral or enum type) within which the given bit-field lives. The
19238 type of this hypothetical "containing object" is always the same as the
19239 declared type of the individual bit-field itself (for GCC anyway... the
19240 DWARF spec doesn't actually mandate this). Note that it is the size (in
19241 bytes) of the hypothetical "containing object" which will be given in the
19242 DW_AT_byte_size attribute for this bit-field. (See the
19243 `byte_size_attribute' function below.) It is also used when calculating the
19244 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
19247 CTX is required: see the comment for VLR_CONTEXT. */
19250 add_data_member_location_attribute (dw_die_ref die
,
19252 struct vlr_context
*ctx
)
19254 HOST_WIDE_INT offset
;
19255 dw_loc_descr_ref loc_descr
= 0;
19257 if (TREE_CODE (decl
) == TREE_BINFO
)
19259 /* We're working on the TAG_inheritance for a base class. */
19260 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
19262 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
19263 aren't at a fixed offset from all (sub)objects of the same
19264 type. We need to extract the appropriate offset from our
19265 vtable. The following dwarf expression means
19267 BaseAddr = ObAddr + *((*ObAddr) - Offset)
19269 This is specific to the V3 ABI, of course. */
19271 dw_loc_descr_ref tmp
;
19273 /* Make a copy of the object address. */
19274 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
19275 add_loc_descr (&loc_descr
, tmp
);
19277 /* Extract the vtable address. */
19278 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
19279 add_loc_descr (&loc_descr
, tmp
);
19281 /* Calculate the address of the offset. */
19282 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
19283 gcc_assert (offset
< 0);
19285 tmp
= int_loc_descriptor (-offset
);
19286 add_loc_descr (&loc_descr
, tmp
);
19287 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
19288 add_loc_descr (&loc_descr
, tmp
);
19290 /* Extract the offset. */
19291 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
19292 add_loc_descr (&loc_descr
, tmp
);
19294 /* Add it to the object address. */
19295 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
19296 add_loc_descr (&loc_descr
, tmp
);
19299 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
19303 loc_descr
= field_byte_offset (decl
, ctx
, &offset
);
19305 /* If loc_descr is available then we know the field offset is dynamic.
19306 However, GDB does not handle dynamic field offsets very well at the
19308 if (loc_descr
!= NULL
&& gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
)
19314 /* Data member location evalutation starts with the base address on the
19315 stack. Compute the field offset and add it to this base address. */
19316 else if (loc_descr
!= NULL
)
19317 add_loc_descr (&loc_descr
, new_loc_descr (DW_OP_plus
, 0, 0));
19322 /* While DW_AT_data_bit_offset has been added already in DWARF4,
19323 e.g. GDB only added support to it in November 2016. For DWARF5
19324 we need newer debug info consumers anyway. We might change this
19325 to dwarf_version >= 4 once most consumers catched up. */
19326 if (dwarf_version
>= 5
19327 && TREE_CODE (decl
) == FIELD_DECL
19328 && DECL_BIT_FIELD_TYPE (decl
))
19330 tree off
= bit_position (decl
);
19331 if (tree_fits_uhwi_p (off
) && get_AT (die
, DW_AT_bit_size
))
19333 remove_AT (die
, DW_AT_byte_size
);
19334 remove_AT (die
, DW_AT_bit_offset
);
19335 add_AT_unsigned (die
, DW_AT_data_bit_offset
, tree_to_uhwi (off
));
19339 if (dwarf_version
> 2)
19341 /* Don't need to output a location expression, just the constant. */
19343 add_AT_int (die
, DW_AT_data_member_location
, offset
);
19345 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
19350 enum dwarf_location_atom op
;
19352 /* The DWARF2 standard says that we should assume that the structure
19353 address is already on the stack, so we can specify a structure
19354 field address by using DW_OP_plus_uconst. */
19355 op
= DW_OP_plus_uconst
;
19356 loc_descr
= new_loc_descr (op
, offset
, 0);
19360 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
19363 /* Writes integer values to dw_vec_const array. */
19366 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
19370 *dest
++ = val
& 0xff;
19376 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
19378 static HOST_WIDE_INT
19379 extract_int (const unsigned char *src
, unsigned int size
)
19381 HOST_WIDE_INT val
= 0;
19387 val
|= *--src
& 0xff;
19393 /* Writes wide_int values to dw_vec_const array. */
19396 insert_wide_int (const wide_int
&val
, unsigned char *dest
, int elt_size
)
19400 if (elt_size
<= HOST_BITS_PER_WIDE_INT
/BITS_PER_UNIT
)
19402 insert_int ((HOST_WIDE_INT
) val
.elt (0), elt_size
, dest
);
19406 /* We'd have to extend this code to support odd sizes. */
19407 gcc_assert (elt_size
% (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
) == 0);
19409 int n
= elt_size
/ (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
19411 if (WORDS_BIG_ENDIAN
)
19412 for (i
= n
- 1; i
>= 0; i
--)
19414 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
19415 dest
+= sizeof (HOST_WIDE_INT
);
19418 for (i
= 0; i
< n
; i
++)
19420 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
19421 dest
+= sizeof (HOST_WIDE_INT
);
19425 /* Writes floating point values to dw_vec_const array. */
19428 insert_float (const_rtx rtl
, unsigned char *array
)
19432 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
19434 real_to_target (val
, CONST_DOUBLE_REAL_VALUE (rtl
), mode
);
19436 /* real_to_target puts 32-bit pieces in each long. Pack them. */
19437 for (i
= 0; i
< GET_MODE_SIZE (mode
) / 4; i
++)
19439 insert_int (val
[i
], 4, array
);
19444 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
19445 does not have a "location" either in memory or in a register. These
19446 things can arise in GNU C when a constant is passed as an actual parameter
19447 to an inlined function. They can also arise in C++ where declared
19448 constants do not necessarily get memory "homes". */
19451 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
19453 switch (GET_CODE (rtl
))
19457 HOST_WIDE_INT val
= INTVAL (rtl
);
19460 add_AT_int (die
, DW_AT_const_value
, val
);
19462 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
19466 case CONST_WIDE_INT
:
19468 wide_int w1
= rtx_mode_t (rtl
, MAX_MODE_INT
);
19469 unsigned int prec
= MIN (wi::min_precision (w1
, UNSIGNED
),
19470 (unsigned int)CONST_WIDE_INT_NUNITS (rtl
) * HOST_BITS_PER_WIDE_INT
);
19471 wide_int w
= wi::zext (w1
, prec
);
19472 add_AT_wide (die
, DW_AT_const_value
, w
);
19477 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
19478 floating-point constant. A CONST_DOUBLE is used whenever the
19479 constant requires more than one word in order to be adequately
19481 if (TARGET_SUPPORTS_WIDE_INT
== 0
19482 && !SCALAR_FLOAT_MODE_P (GET_MODE (rtl
)))
19483 add_AT_double (die
, DW_AT_const_value
,
19484 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
19487 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
19488 unsigned int length
= GET_MODE_SIZE (mode
);
19489 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
19491 insert_float (rtl
, array
);
19492 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
19498 unsigned int length
;
19499 if (!CONST_VECTOR_NUNITS (rtl
).is_constant (&length
))
19502 machine_mode mode
= GET_MODE (rtl
);
19503 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
19504 unsigned char *array
19505 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
19508 machine_mode imode
= GET_MODE_INNER (mode
);
19510 switch (GET_MODE_CLASS (mode
))
19512 case MODE_VECTOR_INT
:
19513 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
19515 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
19516 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
19520 case MODE_VECTOR_FLOAT
:
19521 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
19523 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
19524 insert_float (elt
, p
);
19529 gcc_unreachable ();
19532 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
19537 if (dwarf_version
>= 4 || !dwarf_strict
)
19539 dw_loc_descr_ref loc_result
;
19540 resolve_one_addr (&rtl
);
19542 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
19543 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
19544 add_AT_loc (die
, DW_AT_location
, loc_result
);
19545 vec_safe_push (used_rtx_array
, rtl
);
19551 if (CONSTANT_P (XEXP (rtl
, 0)))
19552 return add_const_value_attribute (die
, XEXP (rtl
, 0));
19555 if (!const_ok_for_output (rtl
))
19559 if (dwarf_version
>= 4 || !dwarf_strict
)
19564 /* In cases where an inlined instance of an inline function is passed
19565 the address of an `auto' variable (which is local to the caller) we
19566 can get a situation where the DECL_RTL of the artificial local
19567 variable (for the inlining) which acts as a stand-in for the
19568 corresponding formal parameter (of the inline function) will look
19569 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
19570 exactly a compile-time constant expression, but it isn't the address
19571 of the (artificial) local variable either. Rather, it represents the
19572 *value* which the artificial local variable always has during its
19573 lifetime. We currently have no way to represent such quasi-constant
19574 values in Dwarf, so for now we just punt and generate nothing. */
19582 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
19583 && MEM_READONLY_P (rtl
)
19584 && GET_MODE (rtl
) == BLKmode
)
19586 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
19592 /* No other kinds of rtx should be possible here. */
19593 gcc_unreachable ();
19598 /* Determine whether the evaluation of EXPR references any variables
19599 or functions which aren't otherwise used (and therefore may not be
19602 reference_to_unused (tree
* tp
, int * walk_subtrees
,
19603 void * data ATTRIBUTE_UNUSED
)
19605 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
19606 *walk_subtrees
= 0;
19608 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
19609 && ! TREE_ASM_WRITTEN (*tp
))
19611 /* ??? The C++ FE emits debug information for using decls, so
19612 putting gcc_unreachable here falls over. See PR31899. For now
19613 be conservative. */
19614 else if (!symtab
->global_info_ready
&& VAR_OR_FUNCTION_DECL_P (*tp
))
19616 else if (VAR_P (*tp
))
19618 varpool_node
*node
= varpool_node::get (*tp
);
19619 if (!node
|| !node
->definition
)
19622 else if (TREE_CODE (*tp
) == FUNCTION_DECL
19623 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
19625 /* The call graph machinery must have finished analyzing,
19626 optimizing and gimplifying the CU by now.
19627 So if *TP has no call graph node associated
19628 to it, it means *TP will not be emitted. */
19629 if (!cgraph_node::get (*tp
))
19632 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
19638 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
19639 for use in a later add_const_value_attribute call. */
19642 rtl_for_decl_init (tree init
, tree type
)
19644 rtx rtl
= NULL_RTX
;
19648 /* If a variable is initialized with a string constant without embedded
19649 zeros, build CONST_STRING. */
19650 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
19652 tree enttype
= TREE_TYPE (type
);
19653 tree domain
= TYPE_DOMAIN (type
);
19654 scalar_int_mode mode
;
19656 if (is_int_mode (TYPE_MODE (enttype
), &mode
)
19657 && GET_MODE_SIZE (mode
) == 1
19659 && TYPE_MAX_VALUE (domain
)
19660 && TREE_CODE (TYPE_MAX_VALUE (domain
)) == INTEGER_CST
19661 && integer_zerop (TYPE_MIN_VALUE (domain
))
19662 && compare_tree_int (TYPE_MAX_VALUE (domain
),
19663 TREE_STRING_LENGTH (init
) - 1) == 0
19664 && ((size_t) TREE_STRING_LENGTH (init
)
19665 == strlen (TREE_STRING_POINTER (init
)) + 1))
19667 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
19668 ggc_strdup (TREE_STRING_POINTER (init
)));
19669 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
19670 MEM_READONLY_P (rtl
) = 1;
19673 /* Other aggregates, and complex values, could be represented using
19675 else if (AGGREGATE_TYPE_P (type
)
19676 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
19677 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
19678 || TREE_CODE (type
) == COMPLEX_TYPE
)
19680 /* Vectors only work if their mode is supported by the target.
19681 FIXME: generic vectors ought to work too. */
19682 else if (TREE_CODE (type
) == VECTOR_TYPE
19683 && !VECTOR_MODE_P (TYPE_MODE (type
)))
19685 /* If the initializer is something that we know will expand into an
19686 immediate RTL constant, expand it now. We must be careful not to
19687 reference variables which won't be output. */
19688 else if (initializer_constant_valid_p (init
, type
)
19689 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
19691 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
19693 if (TREE_CODE (type
) == VECTOR_TYPE
)
19694 switch (TREE_CODE (init
))
19699 if (TREE_CONSTANT (init
))
19701 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
19702 bool constant_p
= true;
19704 unsigned HOST_WIDE_INT ix
;
19706 /* Even when ctor is constant, it might contain non-*_CST
19707 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
19708 belong into VECTOR_CST nodes. */
19709 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
19710 if (!CONSTANT_CLASS_P (value
))
19712 constant_p
= false;
19718 init
= build_vector_from_ctor (type
, elts
);
19728 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
19730 /* If expand_expr returns a MEM, it wasn't immediate. */
19731 gcc_assert (!rtl
|| !MEM_P (rtl
));
19737 /* Generate RTL for the variable DECL to represent its location. */
19740 rtl_for_decl_location (tree decl
)
19744 /* Here we have to decide where we are going to say the parameter "lives"
19745 (as far as the debugger is concerned). We only have a couple of
19746 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
19748 DECL_RTL normally indicates where the parameter lives during most of the
19749 activation of the function. If optimization is enabled however, this
19750 could be either NULL or else a pseudo-reg. Both of those cases indicate
19751 that the parameter doesn't really live anywhere (as far as the code
19752 generation parts of GCC are concerned) during most of the function's
19753 activation. That will happen (for example) if the parameter is never
19754 referenced within the function.
19756 We could just generate a location descriptor here for all non-NULL
19757 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
19758 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
19759 where DECL_RTL is NULL or is a pseudo-reg.
19761 Note however that we can only get away with using DECL_INCOMING_RTL as
19762 a backup substitute for DECL_RTL in certain limited cases. In cases
19763 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
19764 we can be sure that the parameter was passed using the same type as it is
19765 declared to have within the function, and that its DECL_INCOMING_RTL
19766 points us to a place where a value of that type is passed.
19768 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
19769 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
19770 because in these cases DECL_INCOMING_RTL points us to a value of some
19771 type which is *different* from the type of the parameter itself. Thus,
19772 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
19773 such cases, the debugger would end up (for example) trying to fetch a
19774 `float' from a place which actually contains the first part of a
19775 `double'. That would lead to really incorrect and confusing
19776 output at debug-time.
19778 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
19779 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
19780 are a couple of exceptions however. On little-endian machines we can
19781 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
19782 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
19783 an integral type that is smaller than TREE_TYPE (decl). These cases arise
19784 when (on a little-endian machine) a non-prototyped function has a
19785 parameter declared to be of type `short' or `char'. In such cases,
19786 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
19787 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
19788 passed `int' value. If the debugger then uses that address to fetch
19789 a `short' or a `char' (on a little-endian machine) the result will be
19790 the correct data, so we allow for such exceptional cases below.
19792 Note that our goal here is to describe the place where the given formal
19793 parameter lives during most of the function's activation (i.e. between the
19794 end of the prologue and the start of the epilogue). We'll do that as best
19795 as we can. Note however that if the given formal parameter is modified
19796 sometime during the execution of the function, then a stack backtrace (at
19797 debug-time) will show the function as having been called with the *new*
19798 value rather than the value which was originally passed in. This happens
19799 rarely enough that it is not a major problem, but it *is* a problem, and
19800 I'd like to fix it.
19802 A future version of dwarf2out.c may generate two additional attributes for
19803 any given DW_TAG_formal_parameter DIE which will describe the "passed
19804 type" and the "passed location" for the given formal parameter in addition
19805 to the attributes we now generate to indicate the "declared type" and the
19806 "active location" for each parameter. This additional set of attributes
19807 could be used by debuggers for stack backtraces. Separately, note that
19808 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
19809 This happens (for example) for inlined-instances of inline function formal
19810 parameters which are never referenced. This really shouldn't be
19811 happening. All PARM_DECL nodes should get valid non-NULL
19812 DECL_INCOMING_RTL values. FIXME. */
19814 /* Use DECL_RTL as the "location" unless we find something better. */
19815 rtl
= DECL_RTL_IF_SET (decl
);
19817 /* When generating abstract instances, ignore everything except
19818 constants, symbols living in memory, and symbols living in
19819 fixed registers. */
19820 if (! reload_completed
)
19823 && (CONSTANT_P (rtl
)
19825 && CONSTANT_P (XEXP (rtl
, 0)))
19828 && TREE_STATIC (decl
))))
19830 rtl
= targetm
.delegitimize_address (rtl
);
19835 else if (TREE_CODE (decl
) == PARM_DECL
)
19837 if (rtl
== NULL_RTX
19838 || is_pseudo_reg (rtl
)
19840 && is_pseudo_reg (XEXP (rtl
, 0))
19841 && DECL_INCOMING_RTL (decl
)
19842 && MEM_P (DECL_INCOMING_RTL (decl
))
19843 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
19845 tree declared_type
= TREE_TYPE (decl
);
19846 tree passed_type
= DECL_ARG_TYPE (decl
);
19847 machine_mode dmode
= TYPE_MODE (declared_type
);
19848 machine_mode pmode
= TYPE_MODE (passed_type
);
19850 /* This decl represents a formal parameter which was optimized out.
19851 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
19852 all cases where (rtl == NULL_RTX) just below. */
19853 if (dmode
== pmode
)
19854 rtl
= DECL_INCOMING_RTL (decl
);
19855 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
19856 && SCALAR_INT_MODE_P (dmode
)
19857 && known_le (GET_MODE_SIZE (dmode
), GET_MODE_SIZE (pmode
))
19858 && DECL_INCOMING_RTL (decl
))
19860 rtx inc
= DECL_INCOMING_RTL (decl
);
19863 else if (MEM_P (inc
))
19865 if (BYTES_BIG_ENDIAN
)
19866 rtl
= adjust_address_nv (inc
, dmode
,
19867 GET_MODE_SIZE (pmode
)
19868 - GET_MODE_SIZE (dmode
));
19875 /* If the parm was passed in registers, but lives on the stack, then
19876 make a big endian correction if the mode of the type of the
19877 parameter is not the same as the mode of the rtl. */
19878 /* ??? This is the same series of checks that are made in dbxout.c before
19879 we reach the big endian correction code there. It isn't clear if all
19880 of these checks are necessary here, but keeping them all is the safe
19882 else if (MEM_P (rtl
)
19883 && XEXP (rtl
, 0) != const0_rtx
19884 && ! CONSTANT_P (XEXP (rtl
, 0))
19885 /* Not passed in memory. */
19886 && !MEM_P (DECL_INCOMING_RTL (decl
))
19887 /* Not passed by invisible reference. */
19888 && (!REG_P (XEXP (rtl
, 0))
19889 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
19890 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
19891 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
19892 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
19895 /* Big endian correction check. */
19896 && BYTES_BIG_ENDIAN
19897 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
19898 && known_lt (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))),
19901 machine_mode addr_mode
= get_address_mode (rtl
);
19902 poly_int64 offset
= (UNITS_PER_WORD
19903 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
19905 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
19906 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
19909 else if (VAR_P (decl
)
19912 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
)))
19914 machine_mode addr_mode
= get_address_mode (rtl
);
19915 poly_int64 offset
= byte_lowpart_offset (TYPE_MODE (TREE_TYPE (decl
)),
19918 /* If a variable is declared "register" yet is smaller than
19919 a register, then if we store the variable to memory, it
19920 looks like we're storing a register-sized value, when in
19921 fact we are not. We need to adjust the offset of the
19922 storage location to reflect the actual value's bytes,
19923 else gdb will not be able to display it. */
19924 if (maybe_ne (offset
, 0))
19925 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
19926 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
19929 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
19930 and will have been substituted directly into all expressions that use it.
19931 C does not have such a concept, but C++ and other languages do. */
19932 if (!rtl
&& VAR_P (decl
) && DECL_INITIAL (decl
))
19933 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
19936 rtl
= targetm
.delegitimize_address (rtl
);
19938 /* If we don't look past the constant pool, we risk emitting a
19939 reference to a constant pool entry that isn't referenced from
19940 code, and thus is not emitted. */
19942 rtl
= avoid_constant_pool_reference (rtl
);
19944 /* Try harder to get a rtl. If this symbol ends up not being emitted
19945 in the current CU, resolve_addr will remove the expression referencing
19947 if (rtl
== NULL_RTX
19948 && !(early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
19950 && !DECL_EXTERNAL (decl
)
19951 && TREE_STATIC (decl
)
19952 && DECL_NAME (decl
)
19953 && !DECL_HARD_REGISTER (decl
)
19954 && DECL_MODE (decl
) != VOIDmode
)
19956 rtl
= make_decl_rtl_for_debug (decl
);
19958 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
19959 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
19966 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
19967 returned. If so, the decl for the COMMON block is returned, and the
19968 value is the offset into the common block for the symbol. */
19971 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
19973 tree val_expr
, cvar
;
19975 poly_int64 bitsize
, bitpos
;
19977 HOST_WIDE_INT cbitpos
;
19978 int unsignedp
, reversep
, volatilep
= 0;
19980 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
19981 it does not have a value (the offset into the common area), or if it
19982 is thread local (as opposed to global) then it isn't common, and shouldn't
19983 be handled as such. */
19985 || !TREE_STATIC (decl
)
19986 || !DECL_HAS_VALUE_EXPR_P (decl
)
19990 val_expr
= DECL_VALUE_EXPR (decl
);
19991 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
19994 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
, &mode
,
19995 &unsignedp
, &reversep
, &volatilep
);
19997 if (cvar
== NULL_TREE
19999 || DECL_ARTIFICIAL (cvar
)
20000 || !TREE_PUBLIC (cvar
)
20001 /* We don't expect to have to cope with variable offsets,
20002 since at present all static data must have a constant size. */
20003 || !bitpos
.is_constant (&cbitpos
))
20007 if (offset
!= NULL
)
20009 if (!tree_fits_shwi_p (offset
))
20011 *value
= tree_to_shwi (offset
);
20014 *value
+= cbitpos
/ BITS_PER_UNIT
;
20019 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
20020 data attribute for a variable or a parameter. We generate the
20021 DW_AT_const_value attribute only in those cases where the given variable
20022 or parameter does not have a true "location" either in memory or in a
20023 register. This can happen (for example) when a constant is passed as an
20024 actual argument in a call to an inline function. (It's possible that
20025 these things can crop up in other ways also.) Note that one type of
20026 constant value which can be passed into an inlined function is a constant
20027 pointer. This can happen for example if an actual argument in an inlined
20028 function call evaluates to a compile-time constant address.
20030 CACHE_P is true if it is worth caching the location list for DECL,
20031 so that future calls can reuse it rather than regenerate it from scratch.
20032 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
20033 since we will need to refer to them each time the function is inlined. */
20036 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
)
20039 dw_loc_list_ref list
;
20040 var_loc_list
*loc_list
;
20041 cached_dw_loc_list
*cache
;
20046 if (TREE_CODE (decl
) == ERROR_MARK
)
20049 if (get_AT (die
, DW_AT_location
)
20050 || get_AT (die
, DW_AT_const_value
))
20053 gcc_assert (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
20054 || TREE_CODE (decl
) == RESULT_DECL
);
20056 /* Try to get some constant RTL for this decl, and use that as the value of
20059 rtl
= rtl_for_decl_location (decl
);
20060 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
20061 && add_const_value_attribute (die
, rtl
))
20064 /* See if we have single element location list that is equivalent to
20065 a constant value. That way we are better to use add_const_value_attribute
20066 rather than expanding constant value equivalent. */
20067 loc_list
= lookup_decl_loc (decl
);
20070 && loc_list
->first
->next
== NULL
20071 && NOTE_P (loc_list
->first
->loc
)
20072 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
20073 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
20075 struct var_loc_node
*node
;
20077 node
= loc_list
->first
;
20078 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
20079 if (GET_CODE (rtl
) == EXPR_LIST
)
20080 rtl
= XEXP (rtl
, 0);
20081 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
20082 && add_const_value_attribute (die
, rtl
))
20085 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
20086 list several times. See if we've already cached the contents. */
20088 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
20092 cache
= cached_dw_loc_list_table
->find_with_hash (decl
, DECL_UID (decl
));
20094 list
= cache
->loc_list
;
20098 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2,
20100 /* It is usually worth caching this result if the decl is from
20101 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
20102 if (cache_p
&& list
&& list
->dw_loc_next
)
20104 cached_dw_loc_list
**slot
20105 = cached_dw_loc_list_table
->find_slot_with_hash (decl
,
20108 cache
= ggc_cleared_alloc
<cached_dw_loc_list
> ();
20109 cache
->decl_id
= DECL_UID (decl
);
20110 cache
->loc_list
= list
;
20116 add_AT_location_description (die
, DW_AT_location
, list
);
20119 /* None of that worked, so it must not really have a location;
20120 try adding a constant value attribute from the DECL_INITIAL. */
20121 return tree_add_const_value_attribute_for_decl (die
, decl
);
20124 /* Helper function for tree_add_const_value_attribute. Natively encode
20125 initializer INIT into an array. Return true if successful. */
20128 native_encode_initializer (tree init
, unsigned char *array
, int size
)
20132 if (init
== NULL_TREE
)
20136 switch (TREE_CODE (init
))
20139 type
= TREE_TYPE (init
);
20140 if (TREE_CODE (type
) == ARRAY_TYPE
)
20142 tree enttype
= TREE_TYPE (type
);
20143 scalar_int_mode mode
;
20145 if (!is_int_mode (TYPE_MODE (enttype
), &mode
)
20146 || GET_MODE_SIZE (mode
) != 1)
20148 if (int_size_in_bytes (type
) != size
)
20150 if (size
> TREE_STRING_LENGTH (init
))
20152 memcpy (array
, TREE_STRING_POINTER (init
),
20153 TREE_STRING_LENGTH (init
));
20154 memset (array
+ TREE_STRING_LENGTH (init
),
20155 '\0', size
- TREE_STRING_LENGTH (init
));
20158 memcpy (array
, TREE_STRING_POINTER (init
), size
);
20163 type
= TREE_TYPE (init
);
20164 if (int_size_in_bytes (type
) != size
)
20166 if (TREE_CODE (type
) == ARRAY_TYPE
)
20168 HOST_WIDE_INT min_index
;
20169 unsigned HOST_WIDE_INT cnt
;
20170 int curpos
= 0, fieldsize
;
20171 constructor_elt
*ce
;
20173 if (TYPE_DOMAIN (type
) == NULL_TREE
20174 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
20177 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
20178 if (fieldsize
<= 0)
20181 min_index
= tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)));
20182 memset (array
, '\0', size
);
20183 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
20185 tree val
= ce
->value
;
20186 tree index
= ce
->index
;
20188 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
20189 pos
= (tree_to_shwi (TREE_OPERAND (index
, 0)) - min_index
)
20192 pos
= (tree_to_shwi (index
) - min_index
) * fieldsize
;
20197 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
20200 curpos
= pos
+ fieldsize
;
20201 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
20203 int count
= tree_to_shwi (TREE_OPERAND (index
, 1))
20204 - tree_to_shwi (TREE_OPERAND (index
, 0));
20205 while (count
-- > 0)
20208 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
20209 curpos
+= fieldsize
;
20212 gcc_assert (curpos
<= size
);
20216 else if (TREE_CODE (type
) == RECORD_TYPE
20217 || TREE_CODE (type
) == UNION_TYPE
)
20219 tree field
= NULL_TREE
;
20220 unsigned HOST_WIDE_INT cnt
;
20221 constructor_elt
*ce
;
20223 if (int_size_in_bytes (type
) != size
)
20226 if (TREE_CODE (type
) == RECORD_TYPE
)
20227 field
= TYPE_FIELDS (type
);
20229 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
20231 tree val
= ce
->value
;
20232 int pos
, fieldsize
;
20234 if (ce
->index
!= 0)
20240 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
20243 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
20244 && TYPE_DOMAIN (TREE_TYPE (field
))
20245 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
20247 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
20248 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field
)))
20250 fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
20251 pos
= int_byte_position (field
);
20252 gcc_assert (pos
+ fieldsize
<= size
);
20253 if (val
&& fieldsize
!= 0
20254 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
20260 case VIEW_CONVERT_EXPR
:
20261 case NON_LVALUE_EXPR
:
20262 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
20264 return native_encode_expr (init
, array
, size
) == size
;
20268 /* Attach a DW_AT_const_value attribute to DIE. The value of the
20269 attribute is the const value T. */
20272 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
20275 tree type
= TREE_TYPE (t
);
20278 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
20282 gcc_assert (!DECL_P (init
));
20284 if (TREE_CODE (init
) == INTEGER_CST
)
20286 if (tree_fits_uhwi_p (init
))
20288 add_AT_unsigned (die
, DW_AT_const_value
, tree_to_uhwi (init
));
20291 if (tree_fits_shwi_p (init
))
20293 add_AT_int (die
, DW_AT_const_value
, tree_to_shwi (init
));
20299 rtl
= rtl_for_decl_init (init
, type
);
20301 return add_const_value_attribute (die
, rtl
);
20303 /* If the host and target are sane, try harder. */
20304 if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
20305 && initializer_constant_valid_p (init
, type
))
20307 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
20308 if (size
> 0 && (int) size
== size
)
20310 unsigned char *array
= ggc_cleared_vec_alloc
<unsigned char> (size
);
20312 if (native_encode_initializer (init
, array
, size
))
20314 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
20323 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
20324 attribute is the const value of T, where T is an integral constant
20325 variable with static storage duration
20326 (so it can't be a PARM_DECL or a RESULT_DECL). */
20329 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
20333 || (!VAR_P (decl
) && TREE_CODE (decl
) != CONST_DECL
)
20334 || (VAR_P (decl
) && !TREE_STATIC (decl
)))
20337 if (TREE_READONLY (decl
)
20338 && ! TREE_THIS_VOLATILE (decl
)
20339 && DECL_INITIAL (decl
))
20344 /* Don't add DW_AT_const_value if abstract origin already has one. */
20345 if (get_AT (var_die
, DW_AT_const_value
))
20348 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
20351 /* Convert the CFI instructions for the current function into a
20352 location list. This is used for DW_AT_frame_base when we targeting
20353 a dwarf2 consumer that does not support the dwarf3
20354 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
20357 static dw_loc_list_ref
20358 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
20362 dw_loc_list_ref list
, *list_tail
;
20364 dw_cfa_location last_cfa
, next_cfa
;
20365 const char *start_label
, *last_label
, *section
;
20366 dw_cfa_location remember
;
20369 gcc_assert (fde
!= NULL
);
20371 section
= secname_for_decl (current_function_decl
);
20375 memset (&next_cfa
, 0, sizeof (next_cfa
));
20376 next_cfa
.reg
= INVALID_REGNUM
;
20377 remember
= next_cfa
;
20379 start_label
= fde
->dw_fde_begin
;
20381 /* ??? Bald assumption that the CIE opcode list does not contain
20382 advance opcodes. */
20383 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
20384 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
20386 last_cfa
= next_cfa
;
20387 last_label
= start_label
;
20389 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
20391 /* If the first partition contained no CFI adjustments, the
20392 CIE opcodes apply to the whole first partition. */
20393 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20394 fde
->dw_fde_begin
, 0, fde
->dw_fde_end
, 0, section
);
20395 list_tail
=&(*list_tail
)->dw_loc_next
;
20396 start_label
= last_label
= fde
->dw_fde_second_begin
;
20399 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
20401 switch (cfi
->dw_cfi_opc
)
20403 case DW_CFA_set_loc
:
20404 case DW_CFA_advance_loc1
:
20405 case DW_CFA_advance_loc2
:
20406 case DW_CFA_advance_loc4
:
20407 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
20409 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20410 start_label
, 0, last_label
, 0, section
);
20412 list_tail
= &(*list_tail
)->dw_loc_next
;
20413 last_cfa
= next_cfa
;
20414 start_label
= last_label
;
20416 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
20419 case DW_CFA_advance_loc
:
20420 /* The encoding is complex enough that we should never emit this. */
20421 gcc_unreachable ();
20424 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
20427 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
20429 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
20431 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20432 start_label
, 0, last_label
, 0, section
);
20434 list_tail
= &(*list_tail
)->dw_loc_next
;
20435 last_cfa
= next_cfa
;
20436 start_label
= last_label
;
20438 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20439 start_label
, 0, fde
->dw_fde_end
, 0, section
);
20440 list_tail
= &(*list_tail
)->dw_loc_next
;
20441 start_label
= last_label
= fde
->dw_fde_second_begin
;
20445 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
20447 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20448 start_label
, 0, last_label
, 0, section
);
20449 list_tail
= &(*list_tail
)->dw_loc_next
;
20450 start_label
= last_label
;
20453 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
20455 fde
->dw_fde_second_begin
20456 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
, 0,
20459 maybe_gen_llsym (list
);
20464 /* Compute a displacement from the "steady-state frame pointer" to the
20465 frame base (often the same as the CFA), and store it in
20466 frame_pointer_fb_offset. OFFSET is added to the displacement
20467 before the latter is negated. */
20470 compute_frame_pointer_to_fb_displacement (poly_int64 offset
)
20474 #ifdef FRAME_POINTER_CFA_OFFSET
20475 reg
= frame_pointer_rtx
;
20476 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
20478 reg
= arg_pointer_rtx
;
20479 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
20482 elim
= (ira_use_lra_p
20483 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
20484 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
20485 elim
= strip_offset_and_add (elim
, &offset
);
20487 frame_pointer_fb_offset
= -offset
;
20489 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
20490 in which to eliminate. This is because it's stack pointer isn't
20491 directly accessible as a register within the ISA. To work around
20492 this, assume that while we cannot provide a proper value for
20493 frame_pointer_fb_offset, we won't need one either. */
20494 frame_pointer_fb_offset_valid
20495 = ((SUPPORTS_STACK_ALIGNMENT
20496 && (elim
== hard_frame_pointer_rtx
20497 || elim
== stack_pointer_rtx
))
20498 || elim
== (frame_pointer_needed
20499 ? hard_frame_pointer_rtx
20500 : stack_pointer_rtx
));
20503 /* Generate a DW_AT_name attribute given some string value to be included as
20504 the value of the attribute. */
20507 add_name_attribute (dw_die_ref die
, const char *name_string
)
20509 if (name_string
!= NULL
&& *name_string
!= 0)
20511 if (demangle_name_func
)
20512 name_string
= (*demangle_name_func
) (name_string
);
20514 add_AT_string (die
, DW_AT_name
, name_string
);
20518 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
20519 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
20520 of TYPE accordingly.
20522 ??? This is a temporary measure until after we're able to generate
20523 regular DWARF for the complex Ada type system. */
20526 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
20527 dw_die_ref context_die
)
20530 dw_die_ref dtype_die
;
20532 if (!lang_hooks
.types
.descriptive_type
)
20535 dtype
= lang_hooks
.types
.descriptive_type (type
);
20539 dtype_die
= lookup_type_die (dtype
);
20542 gen_type_die (dtype
, context_die
);
20543 dtype_die
= lookup_type_die (dtype
);
20544 gcc_assert (dtype_die
);
20547 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
20550 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
20552 static const char *
20553 comp_dir_string (void)
20557 static const char *cached_wd
= NULL
;
20559 if (cached_wd
!= NULL
)
20562 wd
= get_src_pwd ();
20566 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
20570 wdlen
= strlen (wd
);
20571 wd1
= ggc_vec_alloc
<char> (wdlen
+ 2);
20573 wd1
[wdlen
] = DIR_SEPARATOR
;
20574 wd1
[wdlen
+ 1] = 0;
20578 cached_wd
= remap_debug_filename (wd
);
20582 /* Generate a DW_AT_comp_dir attribute for DIE. */
20585 add_comp_dir_attribute (dw_die_ref die
)
20587 const char * wd
= comp_dir_string ();
20589 add_AT_string (die
, DW_AT_comp_dir
, wd
);
20592 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
20593 pointer computation, ...), output a representation for that bound according
20594 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
20595 loc_list_from_tree for the meaning of CONTEXT. */
20598 add_scalar_info (dw_die_ref die
, enum dwarf_attribute attr
, tree value
,
20599 int forms
, struct loc_descr_context
*context
)
20601 dw_die_ref context_die
, decl_die
;
20602 dw_loc_list_ref list
;
20603 bool strip_conversions
= true;
20604 bool placeholder_seen
= false;
20606 while (strip_conversions
)
20607 switch (TREE_CODE (value
))
20614 case VIEW_CONVERT_EXPR
:
20615 value
= TREE_OPERAND (value
, 0);
20619 strip_conversions
= false;
20623 /* If possible and permitted, output the attribute as a constant. */
20624 if ((forms
& dw_scalar_form_constant
) != 0
20625 && TREE_CODE (value
) == INTEGER_CST
)
20627 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (value
));
20629 /* If HOST_WIDE_INT is big enough then represent the bound as
20630 a constant value. We need to choose a form based on
20631 whether the type is signed or unsigned. We cannot just
20632 call add_AT_unsigned if the value itself is positive
20633 (add_AT_unsigned might add the unsigned value encoded as
20634 DW_FORM_data[1248]). Some DWARF consumers will lookup the
20635 bounds type and then sign extend any unsigned values found
20636 for signed types. This is needed only for
20637 DW_AT_{lower,upper}_bound, since for most other attributes,
20638 consumers will treat DW_FORM_data[1248] as unsigned values,
20639 regardless of the underlying type. */
20640 if (prec
<= HOST_BITS_PER_WIDE_INT
20641 || tree_fits_uhwi_p (value
))
20643 if (TYPE_UNSIGNED (TREE_TYPE (value
)))
20644 add_AT_unsigned (die
, attr
, TREE_INT_CST_LOW (value
));
20646 add_AT_int (die
, attr
, TREE_INT_CST_LOW (value
));
20649 /* Otherwise represent the bound as an unsigned value with
20650 the precision of its type. The precision and signedness
20651 of the type will be necessary to re-interpret it
20653 add_AT_wide (die
, attr
, wi::to_wide (value
));
20657 /* Otherwise, if it's possible and permitted too, output a reference to
20659 if ((forms
& dw_scalar_form_reference
) != 0)
20661 tree decl
= NULL_TREE
;
20663 /* Some type attributes reference an outer type. For instance, the upper
20664 bound of an array may reference an embedding record (this happens in
20666 if (TREE_CODE (value
) == COMPONENT_REF
20667 && TREE_CODE (TREE_OPERAND (value
, 0)) == PLACEHOLDER_EXPR
20668 && TREE_CODE (TREE_OPERAND (value
, 1)) == FIELD_DECL
)
20669 decl
= TREE_OPERAND (value
, 1);
20671 else if (VAR_P (value
)
20672 || TREE_CODE (value
) == PARM_DECL
20673 || TREE_CODE (value
) == RESULT_DECL
)
20676 if (decl
!= NULL_TREE
)
20678 dw_die_ref decl_die
= lookup_decl_die (decl
);
20680 /* ??? Can this happen, or should the variable have been bound
20681 first? Probably it can, since I imagine that we try to create
20682 the types of parameters in the order in which they exist in
20683 the list, and won't have created a forward reference to a
20684 later parameter. */
20685 if (decl_die
!= NULL
)
20687 add_AT_die_ref (die
, attr
, decl_die
);
20693 /* Last chance: try to create a stack operation procedure to evaluate the
20694 value. Do nothing if even that is not possible or permitted. */
20695 if ((forms
& dw_scalar_form_exprloc
) == 0)
20698 list
= loc_list_from_tree (value
, 2, context
);
20699 if (context
&& context
->placeholder_arg
)
20701 placeholder_seen
= context
->placeholder_seen
;
20702 context
->placeholder_seen
= false;
20704 if (list
== NULL
|| single_element_loc_list_p (list
))
20706 /* If this attribute is not a reference nor constant, it is
20707 a DWARF expression rather than location description. For that
20708 loc_list_from_tree (value, 0, &context) is needed. */
20709 dw_loc_list_ref list2
= loc_list_from_tree (value
, 0, context
);
20710 if (list2
&& single_element_loc_list_p (list2
))
20712 if (placeholder_seen
)
20714 struct dwarf_procedure_info dpi
;
20715 dpi
.fndecl
= NULL_TREE
;
20716 dpi
.args_count
= 1;
20717 if (!resolve_args_picking (list2
->expr
, 1, &dpi
))
20720 add_AT_loc (die
, attr
, list2
->expr
);
20725 /* If that failed to give a single element location list, fall back to
20726 outputting this as a reference... still if permitted. */
20728 || (forms
& dw_scalar_form_reference
) == 0
20729 || placeholder_seen
)
20732 if (current_function_decl
== 0)
20733 context_die
= comp_unit_die ();
20735 context_die
= lookup_decl_die (current_function_decl
);
20737 decl_die
= new_die (DW_TAG_variable
, context_die
, value
);
20738 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
20739 add_type_attribute (decl_die
, TREE_TYPE (value
), TYPE_QUAL_CONST
, false,
20741 add_AT_location_description (decl_die
, DW_AT_location
, list
);
20742 add_AT_die_ref (die
, attr
, decl_die
);
20745 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
20749 lower_bound_default (void)
20751 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
20757 case DW_LANG_C_plus_plus
:
20758 case DW_LANG_C_plus_plus_11
:
20759 case DW_LANG_C_plus_plus_14
:
20761 case DW_LANG_ObjC_plus_plus
:
20763 case DW_LANG_Fortran77
:
20764 case DW_LANG_Fortran90
:
20765 case DW_LANG_Fortran95
:
20766 case DW_LANG_Fortran03
:
20767 case DW_LANG_Fortran08
:
20771 case DW_LANG_Python
:
20772 return dwarf_version
>= 4 ? 0 : -1;
20773 case DW_LANG_Ada95
:
20774 case DW_LANG_Ada83
:
20775 case DW_LANG_Cobol74
:
20776 case DW_LANG_Cobol85
:
20777 case DW_LANG_Modula2
:
20779 return dwarf_version
>= 4 ? 1 : -1;
20785 /* Given a tree node describing an array bound (either lower or upper) output
20786 a representation for that bound. */
20789 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
,
20790 tree bound
, struct loc_descr_context
*context
)
20795 switch (TREE_CODE (bound
))
20797 /* Strip all conversions. */
20799 case VIEW_CONVERT_EXPR
:
20800 bound
= TREE_OPERAND (bound
, 0);
20803 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
20804 are even omitted when they are the default. */
20806 /* If the value for this bound is the default one, we can even omit the
20808 if (bound_attr
== DW_AT_lower_bound
20809 && tree_fits_shwi_p (bound
)
20810 && (dflt
= lower_bound_default ()) != -1
20811 && tree_to_shwi (bound
) == dflt
)
20817 /* Because of the complex interaction there can be with other GNAT
20818 encodings, GDB isn't ready yet to handle proper DWARF description
20819 for self-referencial subrange bounds: let GNAT encodings do the
20820 magic in such a case. */
20822 && gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
20823 && contains_placeholder_p (bound
))
20826 add_scalar_info (subrange_die
, bound_attr
, bound
,
20827 dw_scalar_form_constant
20828 | dw_scalar_form_exprloc
20829 | dw_scalar_form_reference
,
20835 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
20836 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
20837 Note that the block of subscript information for an array type also
20838 includes information about the element type of the given array type.
20840 This function reuses previously set type and bound information if
20844 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
20846 unsigned dimension_number
;
20848 dw_die_ref child
= type_die
->die_child
;
20850 for (dimension_number
= 0;
20851 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
20852 type
= TREE_TYPE (type
), dimension_number
++)
20854 tree domain
= TYPE_DOMAIN (type
);
20856 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
20859 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
20860 and (in GNU C only) variable bounds. Handle all three forms
20863 /* Find and reuse a previously generated DW_TAG_subrange_type if
20866 For multi-dimensional arrays, as we iterate through the
20867 various dimensions in the enclosing for loop above, we also
20868 iterate through the DIE children and pick at each
20869 DW_TAG_subrange_type previously generated (if available).
20870 Each child DW_TAG_subrange_type DIE describes the range of
20871 the current dimension. At this point we should have as many
20872 DW_TAG_subrange_type's as we have dimensions in the
20874 dw_die_ref subrange_die
= NULL
;
20878 child
= child
->die_sib
;
20879 if (child
->die_tag
== DW_TAG_subrange_type
)
20880 subrange_die
= child
;
20881 if (child
== type_die
->die_child
)
20883 /* If we wrapped around, stop looking next time. */
20887 if (child
->die_tag
== DW_TAG_subrange_type
)
20891 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
20895 /* We have an array type with specified bounds. */
20896 lower
= TYPE_MIN_VALUE (domain
);
20897 upper
= TYPE_MAX_VALUE (domain
);
20899 /* Define the index type. */
20900 if (TREE_TYPE (domain
)
20901 && !get_AT (subrange_die
, DW_AT_type
))
20903 /* ??? This is probably an Ada unnamed subrange type. Ignore the
20904 TREE_TYPE field. We can't emit debug info for this
20905 because it is an unnamed integral type. */
20906 if (TREE_CODE (domain
) == INTEGER_TYPE
20907 && TYPE_NAME (domain
) == NULL_TREE
20908 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
20909 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
20912 add_type_attribute (subrange_die
, TREE_TYPE (domain
),
20913 TYPE_UNQUALIFIED
, false, type_die
);
20916 /* ??? If upper is NULL, the array has unspecified length,
20917 but it does have a lower bound. This happens with Fortran
20919 Since the debugger is definitely going to need to know N
20920 to produce useful results, go ahead and output the lower
20921 bound solo, and hope the debugger can cope. */
20923 if (!get_AT (subrange_die
, DW_AT_lower_bound
))
20924 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
, NULL
);
20925 if (upper
&& !get_AT (subrange_die
, DW_AT_upper_bound
))
20926 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
, NULL
);
20929 /* Otherwise we have an array type with an unspecified length. The
20930 DWARF-2 spec does not say how to handle this; let's just leave out the
20935 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
20938 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
20940 dw_die_ref decl_die
;
20941 HOST_WIDE_INT size
;
20942 dw_loc_descr_ref size_expr
= NULL
;
20944 switch (TREE_CODE (tree_node
))
20949 case ENUMERAL_TYPE
:
20952 case QUAL_UNION_TYPE
:
20953 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
20954 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
20956 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
20959 size_expr
= type_byte_size (tree_node
, &size
);
20962 /* For a data member of a struct or union, the DW_AT_byte_size is
20963 generally given as the number of bytes normally allocated for an
20964 object of the *declared* type of the member itself. This is true
20965 even for bit-fields. */
20966 size
= int_size_in_bytes (field_type (tree_node
));
20969 gcc_unreachable ();
20972 /* Support for dynamically-sized objects was introduced by DWARFv3.
20973 At the moment, GDB does not handle variable byte sizes very well,
20975 if ((dwarf_version
>= 3 || !dwarf_strict
)
20976 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
20977 && size_expr
!= NULL
)
20978 add_AT_loc (die
, DW_AT_byte_size
, size_expr
);
20980 /* Note that `size' might be -1 when we get to this point. If it is, that
20981 indicates that the byte size of the entity in question is variable and
20982 that we could not generate a DWARF expression that computes it. */
20984 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
20987 /* Add a DW_AT_alignment attribute to DIE with TREE_NODE's non-default
20991 add_alignment_attribute (dw_die_ref die
, tree tree_node
)
20993 if (dwarf_version
< 5 && dwarf_strict
)
20998 if (DECL_P (tree_node
))
21000 if (!DECL_USER_ALIGN (tree_node
))
21003 align
= DECL_ALIGN_UNIT (tree_node
);
21005 else if (TYPE_P (tree_node
))
21007 if (!TYPE_USER_ALIGN (tree_node
))
21010 align
= TYPE_ALIGN_UNIT (tree_node
);
21013 gcc_unreachable ();
21015 add_AT_unsigned (die
, DW_AT_alignment
, align
);
21018 /* For a FIELD_DECL node which represents a bit-field, output an attribute
21019 which specifies the distance in bits from the highest order bit of the
21020 "containing object" for the bit-field to the highest order bit of the
21023 For any given bit-field, the "containing object" is a hypothetical object
21024 (of some integral or enum type) within which the given bit-field lives. The
21025 type of this hypothetical "containing object" is always the same as the
21026 declared type of the individual bit-field itself. The determination of the
21027 exact location of the "containing object" for a bit-field is rather
21028 complicated. It's handled by the `field_byte_offset' function (above).
21030 CTX is required: see the comment for VLR_CONTEXT.
21032 Note that it is the size (in bytes) of the hypothetical "containing object"
21033 which will be given in the DW_AT_byte_size attribute for this bit-field.
21034 (See `byte_size_attribute' above). */
21037 add_bit_offset_attribute (dw_die_ref die
, tree decl
, struct vlr_context
*ctx
)
21039 HOST_WIDE_INT object_offset_in_bytes
;
21040 tree original_type
= DECL_BIT_FIELD_TYPE (decl
);
21041 HOST_WIDE_INT bitpos_int
;
21042 HOST_WIDE_INT highest_order_object_bit_offset
;
21043 HOST_WIDE_INT highest_order_field_bit_offset
;
21044 HOST_WIDE_INT bit_offset
;
21046 field_byte_offset (decl
, ctx
, &object_offset_in_bytes
);
21048 /* Must be a field and a bit field. */
21049 gcc_assert (original_type
&& TREE_CODE (decl
) == FIELD_DECL
);
21051 /* We can't yet handle bit-fields whose offsets are variable, so if we
21052 encounter such things, just return without generating any attribute
21053 whatsoever. Likewise for variable or too large size. */
21054 if (! tree_fits_shwi_p (bit_position (decl
))
21055 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
21058 bitpos_int
= int_bit_position (decl
);
21060 /* Note that the bit offset is always the distance (in bits) from the
21061 highest-order bit of the "containing object" to the highest-order bit of
21062 the bit-field itself. Since the "high-order end" of any object or field
21063 is different on big-endian and little-endian machines, the computation
21064 below must take account of these differences. */
21065 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
21066 highest_order_field_bit_offset
= bitpos_int
;
21068 if (! BYTES_BIG_ENDIAN
)
21070 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
21071 highest_order_object_bit_offset
+=
21072 simple_type_size_in_bits (original_type
);
21076 = (! BYTES_BIG_ENDIAN
21077 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
21078 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
21080 if (bit_offset
< 0)
21081 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
21083 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
21086 /* For a FIELD_DECL node which represents a bit field, output an attribute
21087 which specifies the length in bits of the given field. */
21090 add_bit_size_attribute (dw_die_ref die
, tree decl
)
21092 /* Must be a field and a bit field. */
21093 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
21094 && DECL_BIT_FIELD_TYPE (decl
));
21096 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
21097 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
21100 /* If the compiled language is ANSI C, then add a 'prototyped'
21101 attribute, if arg types are given for the parameters of a function. */
21104 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
21106 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
21113 if (prototype_p (func_type
))
21114 add_AT_flag (die
, DW_AT_prototyped
, 1);
21121 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
21122 by looking in the type declaration, the object declaration equate table or
21123 the block mapping. */
21125 static inline dw_die_ref
21126 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
21128 dw_die_ref origin_die
= NULL
;
21130 if (DECL_P (origin
))
21133 origin_die
= lookup_decl_die (origin
);
21134 /* "Unwrap" the decls DIE which we put in the imported unit context.
21135 We are looking for the abstract copy here. */
21138 && (c
= get_AT_ref (origin_die
, DW_AT_abstract_origin
))
21139 /* ??? Identify this better. */
21143 else if (TYPE_P (origin
))
21144 origin_die
= lookup_type_die (origin
);
21145 else if (TREE_CODE (origin
) == BLOCK
)
21146 origin_die
= BLOCK_DIE (origin
);
21148 /* XXX: Functions that are never lowered don't always have correct block
21149 trees (in the case of java, they simply have no block tree, in some other
21150 languages). For these functions, there is nothing we can really do to
21151 output correct debug info for inlined functions in all cases. Rather
21152 than die, we'll just produce deficient debug info now, in that we will
21153 have variables without a proper abstract origin. In the future, when all
21154 functions are lowered, we should re-add a gcc_assert (origin_die)
21158 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
21162 /* We do not currently support the pure_virtual attribute. */
21165 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
21167 if (DECL_VINDEX (func_decl
))
21169 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
21171 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
21172 add_AT_loc (die
, DW_AT_vtable_elem_location
,
21173 new_loc_descr (DW_OP_constu
,
21174 tree_to_shwi (DECL_VINDEX (func_decl
)),
21177 /* GNU extension: Record what type this method came from originally. */
21178 if (debug_info_level
> DINFO_LEVEL_TERSE
21179 && DECL_CONTEXT (func_decl
))
21180 add_AT_die_ref (die
, DW_AT_containing_type
,
21181 lookup_type_die (DECL_CONTEXT (func_decl
)));
21185 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
21186 given decl. This used to be a vendor extension until after DWARF 4
21187 standardized it. */
21190 add_linkage_attr (dw_die_ref die
, tree decl
)
21192 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
21194 /* Mimic what assemble_name_raw does with a leading '*'. */
21195 if (name
[0] == '*')
21198 if (dwarf_version
>= 4)
21199 add_AT_string (die
, DW_AT_linkage_name
, name
);
21201 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
21204 /* Add source coordinate attributes for the given decl. */
21207 add_src_coords_attributes (dw_die_ref die
, tree decl
)
21209 expanded_location s
;
21211 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
21213 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
21214 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
21215 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
21216 if (debug_column_info
&& s
.column
)
21217 add_AT_unsigned (die
, DW_AT_decl_column
, s
.column
);
21220 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
21223 add_linkage_name_raw (dw_die_ref die
, tree decl
)
21225 /* Defer until we have an assembler name set. */
21226 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
21228 limbo_die_node
*asm_name
;
21230 asm_name
= ggc_cleared_alloc
<limbo_die_node
> ();
21231 asm_name
->die
= die
;
21232 asm_name
->created_for
= decl
;
21233 asm_name
->next
= deferred_asm_name
;
21234 deferred_asm_name
= asm_name
;
21236 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
21237 add_linkage_attr (die
, decl
);
21240 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl if desired. */
21243 add_linkage_name (dw_die_ref die
, tree decl
)
21245 if (debug_info_level
> DINFO_LEVEL_NONE
21246 && VAR_OR_FUNCTION_DECL_P (decl
)
21247 && TREE_PUBLIC (decl
)
21248 && !(VAR_P (decl
) && DECL_REGISTER (decl
))
21249 && die
->die_tag
!= DW_TAG_member
)
21250 add_linkage_name_raw (die
, decl
);
21253 /* Add a DW_AT_name attribute and source coordinate attribute for the
21254 given decl, but only if it actually has a name. */
21257 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
,
21258 bool no_linkage_name
)
21262 decl_name
= DECL_NAME (decl
);
21263 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
21265 const char *name
= dwarf2_name (decl
, 0);
21267 add_name_attribute (die
, name
);
21268 if (! DECL_ARTIFICIAL (decl
))
21269 add_src_coords_attributes (die
, decl
);
21271 if (!no_linkage_name
)
21272 add_linkage_name (die
, decl
);
21275 #ifdef VMS_DEBUGGING_INFO
21276 /* Get the function's name, as described by its RTL. This may be different
21277 from the DECL_NAME name used in the source file. */
21278 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
21280 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
21281 XEXP (DECL_RTL (decl
), 0), false);
21282 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
21284 #endif /* VMS_DEBUGGING_INFO */
21287 /* Add VALUE as a DW_AT_discr_value attribute to DIE. */
21290 add_discr_value (dw_die_ref die
, dw_discr_value
*value
)
21294 attr
.dw_attr
= DW_AT_discr_value
;
21295 attr
.dw_attr_val
.val_class
= dw_val_class_discr_value
;
21296 attr
.dw_attr_val
.val_entry
= NULL
;
21297 attr
.dw_attr_val
.v
.val_discr_value
.pos
= value
->pos
;
21299 attr
.dw_attr_val
.v
.val_discr_value
.v
.uval
= value
->v
.uval
;
21301 attr
.dw_attr_val
.v
.val_discr_value
.v
.sval
= value
->v
.sval
;
21302 add_dwarf_attr (die
, &attr
);
21305 /* Add DISCR_LIST as a DW_AT_discr_list to DIE. */
21308 add_discr_list (dw_die_ref die
, dw_discr_list_ref discr_list
)
21312 attr
.dw_attr
= DW_AT_discr_list
;
21313 attr
.dw_attr_val
.val_class
= dw_val_class_discr_list
;
21314 attr
.dw_attr_val
.val_entry
= NULL
;
21315 attr
.dw_attr_val
.v
.val_discr_list
= discr_list
;
21316 add_dwarf_attr (die
, &attr
);
21319 static inline dw_discr_list_ref
21320 AT_discr_list (dw_attr_node
*attr
)
21322 return attr
->dw_attr_val
.v
.val_discr_list
;
21325 #ifdef VMS_DEBUGGING_INFO
21326 /* Output the debug main pointer die for VMS */
21329 dwarf2out_vms_debug_main_pointer (void)
21331 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21334 /* Allocate the VMS debug main subprogram die. */
21335 die
= new_die_raw (DW_TAG_subprogram
);
21336 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
21337 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
21338 current_function_funcdef_no
);
21339 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
21341 /* Make it the first child of comp_unit_die (). */
21342 die
->die_parent
= comp_unit_die ();
21343 if (comp_unit_die ()->die_child
)
21345 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
21346 comp_unit_die ()->die_child
->die_sib
= die
;
21350 die
->die_sib
= die
;
21351 comp_unit_die ()->die_child
= die
;
21354 #endif /* VMS_DEBUGGING_INFO */
21356 /* walk_tree helper function for uses_local_type, below. */
21359 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
21362 *walk_subtrees
= 0;
21365 tree name
= TYPE_NAME (*tp
);
21366 if (name
&& DECL_P (name
) && decl_function_context (name
))
21372 /* If TYPE involves a function-local type (including a local typedef to a
21373 non-local type), returns that type; otherwise returns NULL_TREE. */
21376 uses_local_type (tree type
)
21378 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
21382 /* Return the DIE for the scope that immediately contains this type.
21383 Non-named types that do not involve a function-local type get global
21384 scope. Named types nested in namespaces or other types get their
21385 containing scope. All other types (i.e. function-local named types) get
21386 the current active scope. */
21389 scope_die_for (tree t
, dw_die_ref context_die
)
21391 dw_die_ref scope_die
= NULL
;
21392 tree containing_scope
;
21394 /* Non-types always go in the current scope. */
21395 gcc_assert (TYPE_P (t
));
21397 /* Use the scope of the typedef, rather than the scope of the type
21399 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
21400 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
21402 containing_scope
= TYPE_CONTEXT (t
);
21404 /* Use the containing namespace if there is one. */
21405 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
21407 if (context_die
== lookup_decl_die (containing_scope
))
21409 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
21410 context_die
= get_context_die (containing_scope
);
21412 containing_scope
= NULL_TREE
;
21415 /* Ignore function type "scopes" from the C frontend. They mean that
21416 a tagged type is local to a parmlist of a function declarator, but
21417 that isn't useful to DWARF. */
21418 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
21419 containing_scope
= NULL_TREE
;
21421 if (SCOPE_FILE_SCOPE_P (containing_scope
))
21423 /* If T uses a local type keep it local as well, to avoid references
21424 to function-local DIEs from outside the function. */
21425 if (current_function_decl
&& uses_local_type (t
))
21426 scope_die
= context_die
;
21428 scope_die
= comp_unit_die ();
21430 else if (TYPE_P (containing_scope
))
21432 /* For types, we can just look up the appropriate DIE. */
21433 if (debug_info_level
> DINFO_LEVEL_TERSE
)
21434 scope_die
= get_context_die (containing_scope
);
21437 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
21438 if (scope_die
== NULL
)
21439 scope_die
= comp_unit_die ();
21443 scope_die
= context_die
;
21448 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
21451 local_scope_p (dw_die_ref context_die
)
21453 for (; context_die
; context_die
= context_die
->die_parent
)
21454 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
21455 || context_die
->die_tag
== DW_TAG_subprogram
)
21461 /* Returns nonzero if CONTEXT_DIE is a class. */
21464 class_scope_p (dw_die_ref context_die
)
21466 return (context_die
21467 && (context_die
->die_tag
== DW_TAG_structure_type
21468 || context_die
->die_tag
== DW_TAG_class_type
21469 || context_die
->die_tag
== DW_TAG_interface_type
21470 || context_die
->die_tag
== DW_TAG_union_type
));
21473 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
21474 whether or not to treat a DIE in this context as a declaration. */
21477 class_or_namespace_scope_p (dw_die_ref context_die
)
21479 return (class_scope_p (context_die
)
21480 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
21483 /* Many forms of DIEs require a "type description" attribute. This
21484 routine locates the proper "type descriptor" die for the type given
21485 by 'type' plus any additional qualifiers given by 'cv_quals', and
21486 adds a DW_AT_type attribute below the given die. */
21489 add_type_attribute (dw_die_ref object_die
, tree type
, int cv_quals
,
21490 bool reverse
, dw_die_ref context_die
)
21492 enum tree_code code
= TREE_CODE (type
);
21493 dw_die_ref type_die
= NULL
;
21495 /* ??? If this type is an unnamed subrange type of an integral, floating-point
21496 or fixed-point type, use the inner type. This is because we have no
21497 support for unnamed types in base_type_die. This can happen if this is
21498 an Ada subrange type. Correct solution is emit a subrange type die. */
21499 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
21500 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
21501 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
21503 if (code
== ERROR_MARK
21504 /* Handle a special case. For functions whose return type is void, we
21505 generate *no* type attribute. (Note that no object may have type
21506 `void', so this only applies to function return types). */
21507 || code
== VOID_TYPE
)
21510 type_die
= modified_type_die (type
,
21511 cv_quals
| TYPE_QUALS (type
),
21515 if (type_die
!= NULL
)
21516 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
21519 /* Given an object die, add the calling convention attribute for the
21520 function call type. */
21522 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
21524 enum dwarf_calling_convention value
= DW_CC_normal
;
21526 value
= ((enum dwarf_calling_convention
)
21527 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
21530 && id_equal (DECL_ASSEMBLER_NAME (decl
), "MAIN__"))
21532 /* DWARF 2 doesn't provide a way to identify a program's source-level
21533 entry point. DW_AT_calling_convention attributes are only meant
21534 to describe functions' calling conventions. However, lacking a
21535 better way to signal the Fortran main program, we used this for
21536 a long time, following existing custom. Now, DWARF 4 has
21537 DW_AT_main_subprogram, which we add below, but some tools still
21538 rely on the old way, which we thus keep. */
21539 value
= DW_CC_program
;
21541 if (dwarf_version
>= 4 || !dwarf_strict
)
21542 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
21545 /* Only add the attribute if the backend requests it, and
21546 is not DW_CC_normal. */
21547 if (value
&& (value
!= DW_CC_normal
))
21548 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
21551 /* Given a tree pointer to a struct, class, union, or enum type node, return
21552 a pointer to the (string) tag name for the given type, or zero if the type
21553 was declared without a tag. */
21555 static const char *
21556 type_tag (const_tree type
)
21558 const char *name
= 0;
21560 if (TYPE_NAME (type
) != 0)
21564 /* Find the IDENTIFIER_NODE for the type name. */
21565 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
21566 && !TYPE_NAMELESS (type
))
21567 t
= TYPE_NAME (type
);
21569 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
21570 a TYPE_DECL node, regardless of whether or not a `typedef' was
21572 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
21573 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
21575 /* We want to be extra verbose. Don't call dwarf_name if
21576 DECL_NAME isn't set. The default hook for decl_printable_name
21577 doesn't like that, and in this context it's correct to return
21578 0, instead of "<anonymous>" or the like. */
21579 if (DECL_NAME (TYPE_NAME (type
))
21580 && !DECL_NAMELESS (TYPE_NAME (type
)))
21581 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
21584 /* Now get the name as a string, or invent one. */
21585 if (!name
&& t
!= 0)
21586 name
= IDENTIFIER_POINTER (t
);
21589 return (name
== 0 || *name
== '\0') ? 0 : name
;
21592 /* Return the type associated with a data member, make a special check
21593 for bit field types. */
21596 member_declared_type (const_tree member
)
21598 return (DECL_BIT_FIELD_TYPE (member
)
21599 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
21602 /* Get the decl's label, as described by its RTL. This may be different
21603 from the DECL_NAME name used in the source file. */
21606 static const char *
21607 decl_start_label (tree decl
)
21610 const char *fnname
;
21612 x
= DECL_RTL (decl
);
21613 gcc_assert (MEM_P (x
));
21616 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
21618 fnname
= XSTR (x
, 0);
21623 /* For variable-length arrays that have been previously generated, but
21624 may be incomplete due to missing subscript info, fill the subscript
21625 info. Return TRUE if this is one of those cases. */
21627 fill_variable_array_bounds (tree type
)
21629 if (TREE_ASM_WRITTEN (type
)
21630 && TREE_CODE (type
) == ARRAY_TYPE
21631 && variably_modified_type_p (type
, NULL
))
21633 dw_die_ref array_die
= lookup_type_die (type
);
21636 add_subscript_info (array_die
, type
, !is_ada ());
21642 /* These routines generate the internal representation of the DIE's for
21643 the compilation unit. Debugging information is collected by walking
21644 the declaration trees passed in from dwarf2out_decl(). */
21647 gen_array_type_die (tree type
, dw_die_ref context_die
)
21649 dw_die_ref array_die
;
21651 /* GNU compilers represent multidimensional array types as sequences of one
21652 dimensional array types whose element types are themselves array types.
21653 We sometimes squish that down to a single array_type DIE with multiple
21654 subscripts in the Dwarf debugging info. The draft Dwarf specification
21655 say that we are allowed to do this kind of compression in C, because
21656 there is no difference between an array of arrays and a multidimensional
21657 array. We don't do this for Ada to remain as close as possible to the
21658 actual representation, which is especially important against the language
21659 flexibilty wrt arrays of variable size. */
21661 bool collapse_nested_arrays
= !is_ada ();
21663 if (fill_variable_array_bounds (type
))
21666 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
21669 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
21670 DW_TAG_string_type doesn't have DW_AT_type attribute). */
21671 if (TYPE_STRING_FLAG (type
)
21672 && TREE_CODE (type
) == ARRAY_TYPE
21674 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
21676 HOST_WIDE_INT size
;
21678 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
21679 add_name_attribute (array_die
, type_tag (type
));
21680 equate_type_number_to_die (type
, array_die
);
21681 size
= int_size_in_bytes (type
);
21683 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
21684 /* ??? We can't annotate types late, but for LTO we may not
21685 generate a location early either (gfortran.dg/save_6.f90). */
21686 else if (! (early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
21687 && TYPE_DOMAIN (type
) != NULL_TREE
21688 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
)
21690 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
21691 tree rszdecl
= szdecl
;
21693 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
21694 if (!DECL_P (szdecl
))
21696 if (TREE_CODE (szdecl
) == INDIRECT_REF
21697 && DECL_P (TREE_OPERAND (szdecl
, 0)))
21699 rszdecl
= TREE_OPERAND (szdecl
, 0);
21700 if (int_size_in_bytes (TREE_TYPE (rszdecl
))
21701 != DWARF2_ADDR_SIZE
)
21709 dw_loc_list_ref loc
21710 = loc_list_from_tree (rszdecl
, szdecl
== rszdecl
? 2 : 0,
21714 add_AT_location_description (array_die
, DW_AT_string_length
,
21716 if (size
!= DWARF2_ADDR_SIZE
)
21717 add_AT_unsigned (array_die
, dwarf_version
>= 5
21718 ? DW_AT_string_length_byte_size
21719 : DW_AT_byte_size
, size
);
21726 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
21727 add_name_attribute (array_die
, type_tag (type
));
21728 equate_type_number_to_die (type
, array_die
);
21730 if (TREE_CODE (type
) == VECTOR_TYPE
)
21731 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
21733 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
21735 && TREE_CODE (type
) == ARRAY_TYPE
21736 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
21737 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
21738 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
21741 /* We default the array ordering. Debuggers will probably do the right
21742 things even if DW_AT_ordering is not present. It's not even an issue
21743 until we start to get into multidimensional arrays anyway. If a debugger
21744 is ever caught doing the Wrong Thing for multi-dimensional arrays,
21745 then we'll have to put the DW_AT_ordering attribute back in. (But if
21746 and when we find out that we need to put these in, we will only do so
21747 for multidimensional arrays. */
21748 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
21751 if (TREE_CODE (type
) == VECTOR_TYPE
)
21753 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
21754 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
21755 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
, NULL
);
21756 add_bound_info (subrange_die
, DW_AT_upper_bound
,
21757 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1), NULL
);
21760 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
21762 /* Add representation of the type of the elements of this array type and
21763 emit the corresponding DIE if we haven't done it already. */
21764 element_type
= TREE_TYPE (type
);
21765 if (collapse_nested_arrays
)
21766 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
21768 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
21770 element_type
= TREE_TYPE (element_type
);
21773 add_type_attribute (array_die
, element_type
, TYPE_UNQUALIFIED
,
21774 TREE_CODE (type
) == ARRAY_TYPE
21775 && TYPE_REVERSE_STORAGE_ORDER (type
),
21778 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
21779 if (TYPE_ARTIFICIAL (type
))
21780 add_AT_flag (array_die
, DW_AT_artificial
, 1);
21782 if (get_AT (array_die
, DW_AT_name
))
21783 add_pubtype (type
, array_die
);
21785 add_alignment_attribute (array_die
, type
);
21788 /* This routine generates DIE for array with hidden descriptor, details
21789 are filled into *info by a langhook. */
21792 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
21793 dw_die_ref context_die
)
21795 const dw_die_ref scope_die
= scope_die_for (type
, context_die
);
21796 const dw_die_ref array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
21797 struct loc_descr_context context
= { type
, info
->base_decl
, NULL
,
21799 enum dwarf_tag subrange_tag
= DW_TAG_subrange_type
;
21802 add_name_attribute (array_die
, type_tag (type
));
21803 equate_type_number_to_die (type
, array_die
);
21805 if (info
->ndimensions
> 1)
21806 switch (info
->ordering
)
21808 case array_descr_ordering_row_major
:
21809 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
21811 case array_descr_ordering_column_major
:
21812 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
21818 if (dwarf_version
>= 3 || !dwarf_strict
)
21820 if (info
->data_location
)
21821 add_scalar_info (array_die
, DW_AT_data_location
, info
->data_location
,
21822 dw_scalar_form_exprloc
, &context
);
21823 if (info
->associated
)
21824 add_scalar_info (array_die
, DW_AT_associated
, info
->associated
,
21825 dw_scalar_form_constant
21826 | dw_scalar_form_exprloc
21827 | dw_scalar_form_reference
, &context
);
21828 if (info
->allocated
)
21829 add_scalar_info (array_die
, DW_AT_allocated
, info
->allocated
,
21830 dw_scalar_form_constant
21831 | dw_scalar_form_exprloc
21832 | dw_scalar_form_reference
, &context
);
21835 const enum dwarf_attribute attr
21836 = (info
->stride_in_bits
) ? DW_AT_bit_stride
: DW_AT_byte_stride
;
21838 = (info
->stride_in_bits
)
21839 ? dw_scalar_form_constant
21840 : (dw_scalar_form_constant
21841 | dw_scalar_form_exprloc
21842 | dw_scalar_form_reference
);
21844 add_scalar_info (array_die
, attr
, info
->stride
, forms
, &context
);
21847 if (dwarf_version
>= 5)
21851 add_scalar_info (array_die
, DW_AT_rank
, info
->rank
,
21852 dw_scalar_form_constant
21853 | dw_scalar_form_exprloc
, &context
);
21854 subrange_tag
= DW_TAG_generic_subrange
;
21855 context
.placeholder_arg
= true;
21859 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
21861 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
21863 dw_die_ref subrange_die
= new_die (subrange_tag
, array_die
, NULL
);
21865 if (info
->dimen
[dim
].bounds_type
)
21866 add_type_attribute (subrange_die
,
21867 info
->dimen
[dim
].bounds_type
, TYPE_UNQUALIFIED
,
21868 false, context_die
);
21869 if (info
->dimen
[dim
].lower_bound
)
21870 add_bound_info (subrange_die
, DW_AT_lower_bound
,
21871 info
->dimen
[dim
].lower_bound
, &context
);
21872 if (info
->dimen
[dim
].upper_bound
)
21873 add_bound_info (subrange_die
, DW_AT_upper_bound
,
21874 info
->dimen
[dim
].upper_bound
, &context
);
21875 if ((dwarf_version
>= 3 || !dwarf_strict
) && info
->dimen
[dim
].stride
)
21876 add_scalar_info (subrange_die
, DW_AT_byte_stride
,
21877 info
->dimen
[dim
].stride
,
21878 dw_scalar_form_constant
21879 | dw_scalar_form_exprloc
21880 | dw_scalar_form_reference
,
21884 gen_type_die (info
->element_type
, context_die
);
21885 add_type_attribute (array_die
, info
->element_type
, TYPE_UNQUALIFIED
,
21886 TREE_CODE (type
) == ARRAY_TYPE
21887 && TYPE_REVERSE_STORAGE_ORDER (type
),
21890 if (get_AT (array_die
, DW_AT_name
))
21891 add_pubtype (type
, array_die
);
21893 add_alignment_attribute (array_die
, type
);
21898 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
21900 tree origin
= decl_ultimate_origin (decl
);
21901 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
21903 if (origin
!= NULL
)
21904 add_abstract_origin_attribute (decl_die
, origin
);
21907 add_name_and_src_coords_attributes (decl_die
, decl
);
21908 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
21909 TYPE_UNQUALIFIED
, false, context_die
);
21912 if (DECL_ABSTRACT_P (decl
))
21913 equate_decl_number_to_die (decl
, decl_die
);
21915 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
21919 /* Walk through the list of incomplete types again, trying once more to
21920 emit full debugging info for them. */
21923 retry_incomplete_types (void)
21928 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
21929 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
21930 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
21931 vec_safe_truncate (incomplete_types
, 0);
21934 /* Determine what tag to use for a record type. */
21936 static enum dwarf_tag
21937 record_type_tag (tree type
)
21939 if (! lang_hooks
.types
.classify_record
)
21940 return DW_TAG_structure_type
;
21942 switch (lang_hooks
.types
.classify_record (type
))
21944 case RECORD_IS_STRUCT
:
21945 return DW_TAG_structure_type
;
21947 case RECORD_IS_CLASS
:
21948 return DW_TAG_class_type
;
21950 case RECORD_IS_INTERFACE
:
21951 if (dwarf_version
>= 3 || !dwarf_strict
)
21952 return DW_TAG_interface_type
;
21953 return DW_TAG_structure_type
;
21956 gcc_unreachable ();
21960 /* Generate a DIE to represent an enumeration type. Note that these DIEs
21961 include all of the information about the enumeration values also. Each
21962 enumerated type name/value is listed as a child of the enumerated type
21966 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
21968 dw_die_ref type_die
= lookup_type_die (type
);
21969 dw_die_ref orig_type_die
= type_die
;
21971 if (type_die
== NULL
)
21973 type_die
= new_die (DW_TAG_enumeration_type
,
21974 scope_die_for (type
, context_die
), type
);
21975 equate_type_number_to_die (type
, type_die
);
21976 add_name_attribute (type_die
, type_tag (type
));
21977 if ((dwarf_version
>= 4 || !dwarf_strict
)
21978 && ENUM_IS_SCOPED (type
))
21979 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
21980 if (ENUM_IS_OPAQUE (type
) && TYPE_SIZE (type
))
21981 add_AT_flag (type_die
, DW_AT_declaration
, 1);
21983 add_AT_unsigned (type_die
, DW_AT_encoding
,
21984 TYPE_UNSIGNED (type
)
21988 else if (! TYPE_SIZE (type
) || ENUM_IS_OPAQUE (type
))
21991 remove_AT (type_die
, DW_AT_declaration
);
21993 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
21994 given enum type is incomplete, do not generate the DW_AT_byte_size
21995 attribute or the DW_AT_element_list attribute. */
21996 if (TYPE_SIZE (type
))
22000 if (!ENUM_IS_OPAQUE (type
))
22001 TREE_ASM_WRITTEN (type
) = 1;
22002 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_byte_size
))
22003 add_byte_size_attribute (type_die
, type
);
22004 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_alignment
))
22005 add_alignment_attribute (type_die
, type
);
22006 if ((dwarf_version
>= 3 || !dwarf_strict
)
22007 && (!orig_type_die
|| !get_AT (type_die
, DW_AT_type
)))
22009 tree underlying
= lang_hooks
.types
.enum_underlying_base_type (type
);
22010 add_type_attribute (type_die
, underlying
, TYPE_UNQUALIFIED
, false,
22013 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
22015 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_decl_file
))
22016 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
22017 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_accessibility
))
22018 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
22021 /* If the first reference to this type was as the return type of an
22022 inline function, then it may not have a parent. Fix this now. */
22023 if (type_die
->die_parent
== NULL
)
22024 add_child_die (scope_die_for (type
, context_die
), type_die
);
22026 for (link
= TYPE_VALUES (type
);
22027 link
!= NULL
; link
= TREE_CHAIN (link
))
22029 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
22030 tree value
= TREE_VALUE (link
);
22032 gcc_assert (!ENUM_IS_OPAQUE (type
));
22033 add_name_attribute (enum_die
,
22034 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
22036 if (TREE_CODE (value
) == CONST_DECL
)
22037 value
= DECL_INITIAL (value
);
22039 if (simple_type_size_in_bits (TREE_TYPE (value
))
22040 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
22042 /* For constant forms created by add_AT_unsigned DWARF
22043 consumers (GDB, elfutils, etc.) always zero extend
22044 the value. Only when the actual value is negative
22045 do we need to use add_AT_int to generate a constant
22046 form that can represent negative values. */
22047 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
22048 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
22049 add_AT_unsigned (enum_die
, DW_AT_const_value
,
22050 (unsigned HOST_WIDE_INT
) val
);
22052 add_AT_int (enum_die
, DW_AT_const_value
, val
);
22055 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
22056 that here. TODO: This should be re-worked to use correct
22057 signed/unsigned double tags for all cases. */
22058 add_AT_wide (enum_die
, DW_AT_const_value
, wi::to_wide (value
));
22061 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
22062 if (TYPE_ARTIFICIAL (type
)
22063 && (!orig_type_die
|| !get_AT (type_die
, DW_AT_artificial
)))
22064 add_AT_flag (type_die
, DW_AT_artificial
, 1);
22067 add_AT_flag (type_die
, DW_AT_declaration
, 1);
22069 add_pubtype (type
, type_die
);
22074 /* Generate a DIE to represent either a real live formal parameter decl or to
22075 represent just the type of some formal parameter position in some function
22078 Note that this routine is a bit unusual because its argument may be a
22079 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
22080 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
22081 node. If it's the former then this function is being called to output a
22082 DIE to represent a formal parameter object (or some inlining thereof). If
22083 it's the latter, then this function is only being called to output a
22084 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
22085 argument type of some subprogram type.
22086 If EMIT_NAME_P is true, name and source coordinate attributes
22090 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
22091 dw_die_ref context_die
)
22093 tree node_or_origin
= node
? node
: origin
;
22094 tree ultimate_origin
;
22095 dw_die_ref parm_die
= NULL
;
22097 if (DECL_P (node_or_origin
))
22099 parm_die
= lookup_decl_die (node
);
22101 /* If the contexts differ, we may not be talking about the same
22103 ??? When in LTO the DIE parent is the "abstract" copy and the
22104 context_die is the specification "copy". But this whole block
22105 should eventually be no longer needed. */
22106 if (parm_die
&& parm_die
->die_parent
!= context_die
&& !in_lto_p
)
22108 if (!DECL_ABSTRACT_P (node
))
22110 /* This can happen when creating an inlined instance, in
22111 which case we need to create a new DIE that will get
22112 annotated with DW_AT_abstract_origin. */
22116 gcc_unreachable ();
22119 if (parm_die
&& parm_die
->die_parent
== NULL
)
22121 /* Check that parm_die already has the right attributes that
22122 we would have added below. If any attributes are
22123 missing, fall through to add them. */
22124 if (! DECL_ABSTRACT_P (node_or_origin
)
22125 && !get_AT (parm_die
, DW_AT_location
)
22126 && !get_AT (parm_die
, DW_AT_const_value
))
22127 /* We are missing location info, and are about to add it. */
22131 add_child_die (context_die
, parm_die
);
22137 /* If we have a previously generated DIE, use it, unless this is an
22138 concrete instance (origin != NULL), in which case we need a new
22139 DIE with a corresponding DW_AT_abstract_origin. */
22141 if (parm_die
&& origin
== NULL
)
22142 reusing_die
= true;
22145 parm_die
= new_die (DW_TAG_formal_parameter
, context_die
, node
);
22146 reusing_die
= false;
22149 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
22151 case tcc_declaration
:
22152 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
22153 if (node
|| ultimate_origin
)
22154 origin
= ultimate_origin
;
22159 if (origin
!= NULL
)
22160 add_abstract_origin_attribute (parm_die
, origin
);
22161 else if (emit_name_p
)
22162 add_name_and_src_coords_attributes (parm_die
, node
);
22164 || (! DECL_ABSTRACT_P (node_or_origin
)
22165 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
22166 decl_function_context
22167 (node_or_origin
))))
22169 tree type
= TREE_TYPE (node_or_origin
);
22170 if (decl_by_reference_p (node_or_origin
))
22171 add_type_attribute (parm_die
, TREE_TYPE (type
),
22173 false, context_die
);
22175 add_type_attribute (parm_die
, type
,
22176 decl_quals (node_or_origin
),
22177 false, context_die
);
22179 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
22180 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22182 if (node
&& node
!= origin
)
22183 equate_decl_number_to_die (node
, parm_die
);
22184 if (! DECL_ABSTRACT_P (node_or_origin
))
22185 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
22191 /* We were called with some kind of a ..._TYPE node. */
22192 add_type_attribute (parm_die
, node_or_origin
, TYPE_UNQUALIFIED
, false,
22197 gcc_unreachable ();
22203 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
22204 children DW_TAG_formal_parameter DIEs representing the arguments of the
22207 PARM_PACK must be a function parameter pack.
22208 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
22209 must point to the subsequent arguments of the function PACK_ARG belongs to.
22210 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
22211 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
22212 following the last one for which a DIE was generated. */
22215 gen_formal_parameter_pack_die (tree parm_pack
,
22217 dw_die_ref subr_die
,
22221 dw_die_ref parm_pack_die
;
22223 gcc_assert (parm_pack
22224 && lang_hooks
.function_parameter_pack_p (parm_pack
)
22227 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
22228 add_src_coords_attributes (parm_pack_die
, parm_pack
);
22230 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
22232 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
22235 gen_formal_parameter_die (arg
, NULL
,
22236 false /* Don't emit name attribute. */,
22241 return parm_pack_die
;
22244 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
22245 at the end of an (ANSI prototyped) formal parameters list. */
22248 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
22250 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
22253 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
22254 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
22255 parameters as specified in some function type specification (except for
22256 those which appear as part of a function *definition*). */
22259 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
22262 tree formal_type
= NULL
;
22263 tree first_parm_type
;
22266 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
22268 arg
= DECL_ARGUMENTS (function_or_method_type
);
22269 function_or_method_type
= TREE_TYPE (function_or_method_type
);
22274 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
22276 /* Make our first pass over the list of formal parameter types and output a
22277 DW_TAG_formal_parameter DIE for each one. */
22278 for (link
= first_parm_type
; link
; )
22280 dw_die_ref parm_die
;
22282 formal_type
= TREE_VALUE (link
);
22283 if (formal_type
== void_type_node
)
22286 /* Output a (nameless) DIE to represent the formal parameter itself. */
22287 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
22288 true /* Emit name attribute. */,
22290 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
22291 && link
== first_parm_type
)
22293 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22294 if (dwarf_version
>= 3 || !dwarf_strict
)
22295 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
22297 else if (arg
&& DECL_ARTIFICIAL (arg
))
22298 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22300 link
= TREE_CHAIN (link
);
22302 arg
= DECL_CHAIN (arg
);
22305 /* If this function type has an ellipsis, add a
22306 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
22307 if (formal_type
!= void_type_node
)
22308 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
22310 /* Make our second (and final) pass over the list of formal parameter types
22311 and output DIEs to represent those types (as necessary). */
22312 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
22313 link
&& TREE_VALUE (link
);
22314 link
= TREE_CHAIN (link
))
22315 gen_type_die (TREE_VALUE (link
), context_die
);
22318 /* We want to generate the DIE for TYPE so that we can generate the
22319 die for MEMBER, which has been defined; we will need to refer back
22320 to the member declaration nested within TYPE. If we're trying to
22321 generate minimal debug info for TYPE, processing TYPE won't do the
22322 trick; we need to attach the member declaration by hand. */
22325 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
22327 gen_type_die (type
, context_die
);
22329 /* If we're trying to avoid duplicate debug info, we may not have
22330 emitted the member decl for this function. Emit it now. */
22331 if (TYPE_STUB_DECL (type
)
22332 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
22333 && ! lookup_decl_die (member
))
22335 dw_die_ref type_die
;
22336 gcc_assert (!decl_ultimate_origin (member
));
22338 type_die
= lookup_type_die_strip_naming_typedef (type
);
22339 if (TREE_CODE (member
) == FUNCTION_DECL
)
22340 gen_subprogram_die (member
, type_die
);
22341 else if (TREE_CODE (member
) == FIELD_DECL
)
22343 /* Ignore the nameless fields that are used to skip bits but handle
22344 C++ anonymous unions and structs. */
22345 if (DECL_NAME (member
) != NULL_TREE
22346 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
22347 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
22349 struct vlr_context vlr_ctx
= {
22350 DECL_CONTEXT (member
), /* struct_type */
22351 NULL_TREE
/* variant_part_offset */
22353 gen_type_die (member_declared_type (member
), type_die
);
22354 gen_field_die (member
, &vlr_ctx
, type_die
);
22358 gen_variable_die (member
, NULL_TREE
, type_die
);
22362 /* Forward declare these functions, because they are mutually recursive
22363 with their set_block_* pairing functions. */
22364 static void set_decl_origin_self (tree
);
22366 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
22367 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
22368 that it points to the node itself, thus indicating that the node is its
22369 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
22370 the given node is NULL, recursively descend the decl/block tree which
22371 it is the root of, and for each other ..._DECL or BLOCK node contained
22372 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
22373 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
22374 values to point to themselves. */
22377 set_block_origin_self (tree stmt
)
22379 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
22381 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
22386 for (local_decl
= BLOCK_VARS (stmt
);
22387 local_decl
!= NULL_TREE
;
22388 local_decl
= DECL_CHAIN (local_decl
))
22389 /* Do not recurse on nested functions since the inlining status
22390 of parent and child can be different as per the DWARF spec. */
22391 if (TREE_CODE (local_decl
) != FUNCTION_DECL
22392 && !DECL_EXTERNAL (local_decl
))
22393 set_decl_origin_self (local_decl
);
22399 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
22400 subblock
!= NULL_TREE
;
22401 subblock
= BLOCK_CHAIN (subblock
))
22402 set_block_origin_self (subblock
); /* Recurse. */
22407 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
22408 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
22409 node to so that it points to the node itself, thus indicating that the
22410 node represents its own (abstract) origin. Additionally, if the
22411 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
22412 the decl/block tree of which the given node is the root of, and for
22413 each other ..._DECL or BLOCK node contained therein whose
22414 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
22415 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
22416 point to themselves. */
22419 set_decl_origin_self (tree decl
)
22421 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
22423 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
22424 if (TREE_CODE (decl
) == FUNCTION_DECL
)
22428 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
22429 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
22430 if (DECL_INITIAL (decl
) != NULL_TREE
22431 && DECL_INITIAL (decl
) != error_mark_node
)
22432 set_block_origin_self (DECL_INITIAL (decl
));
22437 /* Mark the early DIE for DECL as the abstract instance. */
22440 dwarf2out_abstract_function (tree decl
)
22442 dw_die_ref old_die
;
22444 /* Make sure we have the actual abstract inline, not a clone. */
22445 decl
= DECL_ORIGIN (decl
);
22447 if (DECL_IGNORED_P (decl
))
22450 old_die
= lookup_decl_die (decl
);
22451 /* With early debug we always have an old DIE unless we are in LTO
22452 and the user did not compile but only link with debug. */
22453 if (in_lto_p
&& ! old_die
)
22455 gcc_assert (old_die
!= NULL
);
22456 if (get_AT (old_die
, DW_AT_inline
)
22457 || get_AT (old_die
, DW_AT_abstract_origin
))
22458 /* We've already generated the abstract instance. */
22461 /* Go ahead and put DW_AT_inline on the DIE. */
22462 if (DECL_DECLARED_INLINE_P (decl
))
22464 if (cgraph_function_possibly_inlined_p (decl
))
22465 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_inlined
);
22467 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
22471 if (cgraph_function_possibly_inlined_p (decl
))
22472 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_inlined
);
22474 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_not_inlined
);
22477 if (DECL_DECLARED_INLINE_P (decl
)
22478 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
22479 add_AT_flag (old_die
, DW_AT_artificial
, 1);
22481 set_decl_origin_self (decl
);
22484 /* Helper function of premark_used_types() which gets called through
22487 Marks the DIE of a given type in *SLOT as perennial, so it never gets
22488 marked as unused by prune_unused_types. */
22491 premark_used_types_helper (tree
const &type
, void *)
22495 die
= lookup_type_die (type
);
22497 die
->die_perennial_p
= 1;
22501 /* Helper function of premark_types_used_by_global_vars which gets called
22502 through htab_traverse.
22504 Marks the DIE of a given type in *SLOT as perennial, so it never gets
22505 marked as unused by prune_unused_types. The DIE of the type is marked
22506 only if the global variable using the type will actually be emitted. */
22509 premark_types_used_by_global_vars_helper (types_used_by_vars_entry
**slot
,
22512 struct types_used_by_vars_entry
*entry
;
22515 entry
= (struct types_used_by_vars_entry
*) *slot
;
22516 gcc_assert (entry
->type
!= NULL
22517 && entry
->var_decl
!= NULL
);
22518 die
= lookup_type_die (entry
->type
);
22521 /* Ask cgraph if the global variable really is to be emitted.
22522 If yes, then we'll keep the DIE of ENTRY->TYPE. */
22523 varpool_node
*node
= varpool_node::get (entry
->var_decl
);
22524 if (node
&& node
->definition
)
22526 die
->die_perennial_p
= 1;
22527 /* Keep the parent DIEs as well. */
22528 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
22529 die
->die_perennial_p
= 1;
22535 /* Mark all members of used_types_hash as perennial. */
22538 premark_used_types (struct function
*fun
)
22540 if (fun
&& fun
->used_types_hash
)
22541 fun
->used_types_hash
->traverse
<void *, premark_used_types_helper
> (NULL
);
22544 /* Mark all members of types_used_by_vars_entry as perennial. */
22547 premark_types_used_by_global_vars (void)
22549 if (types_used_by_vars_hash
)
22550 types_used_by_vars_hash
22551 ->traverse
<void *, premark_types_used_by_global_vars_helper
> (NULL
);
22554 /* Generate a DW_TAG_call_site DIE in function DECL under SUBR_DIE
22555 for CA_LOC call arg loc node. */
22558 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
22559 struct call_arg_loc_node
*ca_loc
)
22561 dw_die_ref stmt_die
= NULL
, die
;
22562 tree block
= ca_loc
->block
;
22565 && block
!= DECL_INITIAL (decl
)
22566 && TREE_CODE (block
) == BLOCK
)
22568 stmt_die
= BLOCK_DIE (block
);
22571 block
= BLOCK_SUPERCONTEXT (block
);
22573 if (stmt_die
== NULL
)
22574 stmt_die
= subr_die
;
22575 die
= new_die (dwarf_TAG (DW_TAG_call_site
), stmt_die
, NULL_TREE
);
22576 add_AT_lbl_id (die
, dwarf_AT (DW_AT_call_return_pc
), ca_loc
->label
);
22577 if (ca_loc
->tail_call_p
)
22578 add_AT_flag (die
, dwarf_AT (DW_AT_call_tail_call
), 1);
22579 if (ca_loc
->symbol_ref
)
22581 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
22583 add_AT_die_ref (die
, dwarf_AT (DW_AT_call_origin
), tdie
);
22585 add_AT_addr (die
, dwarf_AT (DW_AT_call_origin
), ca_loc
->symbol_ref
,
22591 /* Generate a DIE to represent a declared function (either file-scope or
22595 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
22597 tree origin
= decl_ultimate_origin (decl
);
22598 dw_die_ref subr_die
;
22599 dw_die_ref old_die
= lookup_decl_die (decl
);
22601 /* This function gets called multiple times for different stages of
22602 the debug process. For example, for func() in this code:
22606 void func() { ... }
22609 ...we get called 4 times. Twice in early debug and twice in
22615 1. Once while generating func() within the namespace. This is
22616 the declaration. The declaration bit below is set, as the
22617 context is the namespace.
22619 A new DIE will be generated with DW_AT_declaration set.
22621 2. Once for func() itself. This is the specification. The
22622 declaration bit below is clear as the context is the CU.
22624 We will use the cached DIE from (1) to create a new DIE with
22625 DW_AT_specification pointing to the declaration in (1).
22627 Late debug via rest_of_handle_final()
22628 -------------------------------------
22630 3. Once generating func() within the namespace. This is also the
22631 declaration, as in (1), but this time we will early exit below
22632 as we have a cached DIE and a declaration needs no additional
22633 annotations (no locations), as the source declaration line
22636 4. Once for func() itself. As in (2), this is the specification,
22637 but this time we will re-use the cached DIE, and just annotate
22638 it with the location information that should now be available.
22640 For something without namespaces, but with abstract instances, we
22641 are also called a multiple times:
22646 Base (); // constructor declaration (1)
22649 Base::Base () { } // constructor specification (2)
22654 1. Once for the Base() constructor by virtue of it being a
22655 member of the Base class. This is done via
22656 rest_of_type_compilation.
22658 This is a declaration, so a new DIE will be created with
22661 2. Once for the Base() constructor definition, but this time
22662 while generating the abstract instance of the base
22663 constructor (__base_ctor) which is being generated via early
22664 debug of reachable functions.
22666 Even though we have a cached version of the declaration (1),
22667 we will create a DW_AT_specification of the declaration DIE
22670 3. Once for the __base_ctor itself, but this time, we generate
22671 an DW_AT_abstract_origin version of the DW_AT_specification in
22674 Late debug via rest_of_handle_final
22675 -----------------------------------
22677 4. One final time for the __base_ctor (which will have a cached
22678 DIE with DW_AT_abstract_origin created in (3). This time,
22679 we will just annotate the location information now
22682 int declaration
= (current_function_decl
!= decl
22683 || class_or_namespace_scope_p (context_die
));
22685 /* A declaration that has been previously dumped needs no
22686 additional information. */
22687 if (old_die
&& declaration
)
22690 /* Now that the C++ front end lazily declares artificial member fns, we
22691 might need to retrofit the declaration into its class. */
22692 if (!declaration
&& !origin
&& !old_die
22693 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
22694 && !class_or_namespace_scope_p (context_die
)
22695 && debug_info_level
> DINFO_LEVEL_TERSE
)
22696 old_die
= force_decl_die (decl
);
22698 /* A concrete instance, tag a new DIE with DW_AT_abstract_origin. */
22699 if (origin
!= NULL
)
22701 gcc_assert (!declaration
|| local_scope_p (context_die
));
22703 /* Fixup die_parent for the abstract instance of a nested
22704 inline function. */
22705 if (old_die
&& old_die
->die_parent
== NULL
)
22706 add_child_die (context_die
, old_die
);
22708 if (old_die
&& get_AT_ref (old_die
, DW_AT_abstract_origin
))
22710 /* If we have a DW_AT_abstract_origin we have a working
22712 subr_die
= old_die
;
22716 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22717 add_abstract_origin_attribute (subr_die
, origin
);
22718 /* This is where the actual code for a cloned function is.
22719 Let's emit linkage name attribute for it. This helps
22720 debuggers to e.g, set breakpoints into
22721 constructors/destructors when the user asks "break
22723 add_linkage_name (subr_die
, decl
);
22726 /* A cached copy, possibly from early dwarf generation. Reuse as
22727 much as possible. */
22730 if (!get_AT_flag (old_die
, DW_AT_declaration
)
22731 /* We can have a normal definition following an inline one in the
22732 case of redefinition of GNU C extern inlines.
22733 It seems reasonable to use AT_specification in this case. */
22734 && !get_AT (old_die
, DW_AT_inline
))
22736 /* Detect and ignore this case, where we are trying to output
22737 something we have already output. */
22738 if (get_AT (old_die
, DW_AT_low_pc
)
22739 || get_AT (old_die
, DW_AT_ranges
))
22742 /* If we have no location information, this must be a
22743 partially generated DIE from early dwarf generation.
22744 Fall through and generate it. */
22747 /* If the definition comes from the same place as the declaration,
22748 maybe use the old DIE. We always want the DIE for this function
22749 that has the *_pc attributes to be under comp_unit_die so the
22750 debugger can find it. We also need to do this for abstract
22751 instances of inlines, since the spec requires the out-of-line copy
22752 to have the same parent. For local class methods, this doesn't
22753 apply; we just use the old DIE. */
22754 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
22755 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
22756 if (((is_unit_die (old_die
->die_parent
)
22757 /* This condition fixes the inconsistency/ICE with the
22758 following Fortran test (or some derivative thereof) while
22759 building libgfortran:
22763 logical function funky (FLAG)
22768 || (old_die
->die_parent
22769 && old_die
->die_parent
->die_tag
== DW_TAG_module
)
22770 || local_scope_p (old_die
->die_parent
)
22771 || context_die
== NULL
)
22772 && (DECL_ARTIFICIAL (decl
)
22773 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
22774 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
22775 == (unsigned) s
.line
)
22776 && (!debug_column_info
22778 || (get_AT_unsigned (old_die
, DW_AT_decl_column
)
22779 == (unsigned) s
.column
)))))
22780 /* With LTO if there's an abstract instance for
22781 the old DIE, this is a concrete instance and
22782 thus re-use the DIE. */
22783 || get_AT (old_die
, DW_AT_abstract_origin
))
22785 subr_die
= old_die
;
22787 /* Clear out the declaration attribute, but leave the
22788 parameters so they can be augmented with location
22789 information later. Unless this was a declaration, in
22790 which case, wipe out the nameless parameters and recreate
22791 them further down. */
22792 if (remove_AT (subr_die
, DW_AT_declaration
))
22795 remove_AT (subr_die
, DW_AT_object_pointer
);
22796 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
22799 /* Make a specification pointing to the previously built
22803 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22804 add_AT_specification (subr_die
, old_die
);
22805 add_pubname (decl
, subr_die
);
22806 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
22807 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
22808 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
22809 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
22810 if (debug_column_info
22812 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
22813 != (unsigned) s
.column
))
22814 add_AT_unsigned (subr_die
, DW_AT_decl_column
, s
.column
);
22816 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
22817 emit the real type on the definition die. */
22818 if (is_cxx () && debug_info_level
> DINFO_LEVEL_TERSE
)
22820 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
22821 if (die
== auto_die
|| die
== decltype_auto_die
)
22822 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
22823 TYPE_UNQUALIFIED
, false, context_die
);
22826 /* When we process the method declaration, we haven't seen
22827 the out-of-class defaulted definition yet, so we have to
22829 if ((dwarf_version
>= 5 || ! dwarf_strict
)
22830 && !get_AT (subr_die
, DW_AT_defaulted
))
22833 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22835 if (defaulted
!= -1)
22837 /* Other values must have been handled before. */
22838 gcc_assert (defaulted
== DW_DEFAULTED_out_of_class
);
22839 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
22844 /* Create a fresh DIE for anything else. */
22847 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22849 if (TREE_PUBLIC (decl
))
22850 add_AT_flag (subr_die
, DW_AT_external
, 1);
22852 add_name_and_src_coords_attributes (subr_die
, decl
);
22853 add_pubname (decl
, subr_die
);
22854 if (debug_info_level
> DINFO_LEVEL_TERSE
)
22856 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
22857 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
22858 TYPE_UNQUALIFIED
, false, context_die
);
22861 add_pure_or_virtual_attribute (subr_die
, decl
);
22862 if (DECL_ARTIFICIAL (decl
))
22863 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
22865 if (TREE_THIS_VOLATILE (decl
) && (dwarf_version
>= 5 || !dwarf_strict
))
22866 add_AT_flag (subr_die
, DW_AT_noreturn
, 1);
22868 add_alignment_attribute (subr_die
, decl
);
22870 add_accessibility_attribute (subr_die
, decl
);
22873 /* Unless we have an existing non-declaration DIE, equate the new
22875 if (!old_die
|| is_declaration_die (old_die
))
22876 equate_decl_number_to_die (decl
, subr_die
);
22880 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
22882 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
22884 /* If this is an explicit function declaration then generate
22885 a DW_AT_explicit attribute. */
22886 if ((dwarf_version
>= 3 || !dwarf_strict
)
22887 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22888 DW_AT_explicit
) == 1)
22889 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
22891 /* If this is a C++11 deleted special function member then generate
22892 a DW_AT_deleted attribute. */
22893 if ((dwarf_version
>= 5 || !dwarf_strict
)
22894 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22895 DW_AT_deleted
) == 1)
22896 add_AT_flag (subr_die
, DW_AT_deleted
, 1);
22898 /* If this is a C++11 defaulted special function member then
22899 generate a DW_AT_defaulted attribute. */
22900 if (dwarf_version
>= 5 || !dwarf_strict
)
22903 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22905 if (defaulted
!= -1)
22906 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
22909 /* If this is a C++11 non-static member function with & ref-qualifier
22910 then generate a DW_AT_reference attribute. */
22911 if ((dwarf_version
>= 5 || !dwarf_strict
)
22912 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22913 DW_AT_reference
) == 1)
22914 add_AT_flag (subr_die
, DW_AT_reference
, 1);
22916 /* If this is a C++11 non-static member function with &&
22917 ref-qualifier then generate a DW_AT_reference attribute. */
22918 if ((dwarf_version
>= 5 || !dwarf_strict
)
22919 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22920 DW_AT_rvalue_reference
)
22922 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
22925 /* For non DECL_EXTERNALs, if range information is available, fill
22926 the DIE with it. */
22927 else if (!DECL_EXTERNAL (decl
) && !early_dwarf
)
22929 HOST_WIDE_INT cfa_fb_offset
;
22931 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
22933 if (!crtl
->has_bb_partition
)
22935 dw_fde_ref fde
= fun
->fde
;
22936 if (fde
->dw_fde_begin
)
22938 /* We have already generated the labels. */
22939 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
22940 fde
->dw_fde_end
, false);
22944 /* Create start/end labels and add the range. */
22945 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
22946 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
22947 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
22948 current_function_funcdef_no
);
22949 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
22950 current_function_funcdef_no
);
22951 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
22955 #if VMS_DEBUGGING_INFO
22956 /* HP OpenVMS Industry Standard 64: DWARF Extensions
22957 Section 2.3 Prologue and Epilogue Attributes:
22958 When a breakpoint is set on entry to a function, it is generally
22959 desirable for execution to be suspended, not on the very first
22960 instruction of the function, but rather at a point after the
22961 function's frame has been set up, after any language defined local
22962 declaration processing has been completed, and before execution of
22963 the first statement of the function begins. Debuggers generally
22964 cannot properly determine where this point is. Similarly for a
22965 breakpoint set on exit from a function. The prologue and epilogue
22966 attributes allow a compiler to communicate the location(s) to use. */
22969 if (fde
->dw_fde_vms_end_prologue
)
22970 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
22971 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
22973 if (fde
->dw_fde_vms_begin_epilogue
)
22974 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
22975 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
22982 /* Generate pubnames entries for the split function code ranges. */
22983 dw_fde_ref fde
= fun
->fde
;
22985 if (fde
->dw_fde_second_begin
)
22987 if (dwarf_version
>= 3 || !dwarf_strict
)
22989 /* We should use ranges for non-contiguous code section
22990 addresses. Use the actual code range for the initial
22991 section, since the HOT/COLD labels might precede an
22992 alignment offset. */
22993 bool range_list_added
= false;
22994 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
22995 fde
->dw_fde_end
, &range_list_added
,
22997 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
22998 fde
->dw_fde_second_end
,
22999 &range_list_added
, false);
23000 if (range_list_added
)
23005 /* There is no real support in DW2 for this .. so we make
23006 a work-around. First, emit the pub name for the segment
23007 containing the function label. Then make and emit a
23008 simplified subprogram DIE for the second segment with the
23009 name pre-fixed by __hot/cold_sect_of_. We use the same
23010 linkage name for the second die so that gdb will find both
23011 sections when given "b foo". */
23012 const char *name
= NULL
;
23013 tree decl_name
= DECL_NAME (decl
);
23014 dw_die_ref seg_die
;
23016 /* Do the 'primary' section. */
23017 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
23018 fde
->dw_fde_end
, false);
23020 /* Build a minimal DIE for the secondary section. */
23021 seg_die
= new_die (DW_TAG_subprogram
,
23022 subr_die
->die_parent
, decl
);
23024 if (TREE_PUBLIC (decl
))
23025 add_AT_flag (seg_die
, DW_AT_external
, 1);
23027 if (decl_name
!= NULL
23028 && IDENTIFIER_POINTER (decl_name
) != NULL
)
23030 name
= dwarf2_name (decl
, 1);
23031 if (! DECL_ARTIFICIAL (decl
))
23032 add_src_coords_attributes (seg_die
, decl
);
23034 add_linkage_name (seg_die
, decl
);
23036 gcc_assert (name
!= NULL
);
23037 add_pure_or_virtual_attribute (seg_die
, decl
);
23038 if (DECL_ARTIFICIAL (decl
))
23039 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
23041 name
= concat ("__second_sect_of_", name
, NULL
);
23042 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
23043 fde
->dw_fde_second_end
, false);
23044 add_name_attribute (seg_die
, name
);
23045 if (want_pubnames ())
23046 add_pubname_string (name
, seg_die
);
23050 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
23054 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
23056 /* We define the "frame base" as the function's CFA. This is more
23057 convenient for several reasons: (1) It's stable across the prologue
23058 and epilogue, which makes it better than just a frame pointer,
23059 (2) With dwarf3, there exists a one-byte encoding that allows us
23060 to reference the .debug_frame data by proxy, but failing that,
23061 (3) We can at least reuse the code inspection and interpretation
23062 code that determines the CFA position at various points in the
23064 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
23066 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
23067 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
23071 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
23072 if (list
->dw_loc_next
)
23073 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
23075 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
23078 /* Compute a displacement from the "steady-state frame pointer" to
23079 the CFA. The former is what all stack slots and argument slots
23080 will reference in the rtl; the latter is what we've told the
23081 debugger about. We'll need to adjust all frame_base references
23082 by this displacement. */
23083 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
23085 if (fun
->static_chain_decl
)
23087 /* DWARF requires here a location expression that computes the
23088 address of the enclosing subprogram's frame base. The machinery
23089 in tree-nested.c is supposed to store this specific address in the
23090 last field of the FRAME record. */
23091 const tree frame_type
23092 = TREE_TYPE (TREE_TYPE (fun
->static_chain_decl
));
23093 const tree fb_decl
= tree_last (TYPE_FIELDS (frame_type
));
23096 = build1 (INDIRECT_REF
, frame_type
, fun
->static_chain_decl
);
23097 fb_expr
= build3 (COMPONENT_REF
, TREE_TYPE (fb_decl
),
23098 fb_expr
, fb_decl
, NULL_TREE
);
23100 add_AT_location_description (subr_die
, DW_AT_static_link
,
23101 loc_list_from_tree (fb_expr
, 0, NULL
));
23104 resolve_variable_values ();
23107 /* Generate child dies for template paramaters. */
23108 if (early_dwarf
&& debug_info_level
> DINFO_LEVEL_TERSE
)
23109 gen_generic_params_dies (decl
);
23111 /* Now output descriptions of the arguments for this function. This gets
23112 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
23113 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
23114 `...' at the end of the formal parameter list. In order to find out if
23115 there was a trailing ellipsis or not, we must instead look at the type
23116 associated with the FUNCTION_DECL. This will be a node of type
23117 FUNCTION_TYPE. If the chain of type nodes hanging off of this
23118 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
23119 an ellipsis at the end. */
23121 /* In the case where we are describing a mere function declaration, all we
23122 need to do here (and all we *can* do here) is to describe the *types* of
23123 its formal parameters. */
23124 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
23126 else if (declaration
)
23127 gen_formal_types_die (decl
, subr_die
);
23130 /* Generate DIEs to represent all known formal parameters. */
23131 tree parm
= DECL_ARGUMENTS (decl
);
23132 tree generic_decl
= early_dwarf
23133 ? lang_hooks
.decls
.get_generic_function_decl (decl
) : NULL
;
23134 tree generic_decl_parm
= generic_decl
23135 ? DECL_ARGUMENTS (generic_decl
)
23138 /* Now we want to walk the list of parameters of the function and
23139 emit their relevant DIEs.
23141 We consider the case of DECL being an instance of a generic function
23142 as well as it being a normal function.
23144 If DECL is an instance of a generic function we walk the
23145 parameters of the generic function declaration _and_ the parameters of
23146 DECL itself. This is useful because we want to emit specific DIEs for
23147 function parameter packs and those are declared as part of the
23148 generic function declaration. In that particular case,
23149 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
23150 That DIE has children DIEs representing the set of arguments
23151 of the pack. Note that the set of pack arguments can be empty.
23152 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
23155 Otherwise, we just consider the parameters of DECL. */
23156 while (generic_decl_parm
|| parm
)
23158 if (generic_decl_parm
23159 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
23160 gen_formal_parameter_pack_die (generic_decl_parm
,
23165 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, NULL
, subr_die
);
23168 && parm
== DECL_ARGUMENTS (decl
)
23169 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
23171 && (dwarf_version
>= 3 || !dwarf_strict
))
23172 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
23174 parm
= DECL_CHAIN (parm
);
23177 parm
= DECL_CHAIN (parm
);
23179 if (generic_decl_parm
)
23180 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
23183 /* Decide whether we need an unspecified_parameters DIE at the end.
23184 There are 2 more cases to do this for: 1) the ansi ... declaration -
23185 this is detectable when the end of the arg list is not a
23186 void_type_node 2) an unprototyped function declaration (not a
23187 definition). This just means that we have no info about the
23188 parameters at all. */
23191 if (prototype_p (TREE_TYPE (decl
)))
23193 /* This is the prototyped case, check for.... */
23194 if (stdarg_p (TREE_TYPE (decl
)))
23195 gen_unspecified_parameters_die (decl
, subr_die
);
23197 else if (DECL_INITIAL (decl
) == NULL_TREE
)
23198 gen_unspecified_parameters_die (decl
, subr_die
);
23202 if (subr_die
!= old_die
)
23203 /* Add the calling convention attribute if requested. */
23204 add_calling_convention_attribute (subr_die
, decl
);
23206 /* Output Dwarf info for all of the stuff within the body of the function
23207 (if it has one - it may be just a declaration).
23209 OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
23210 a function. This BLOCK actually represents the outermost binding contour
23211 for the function, i.e. the contour in which the function's formal
23212 parameters and labels get declared. Curiously, it appears that the front
23213 end doesn't actually put the PARM_DECL nodes for the current function onto
23214 the BLOCK_VARS list for this outer scope, but are strung off of the
23215 DECL_ARGUMENTS list for the function instead.
23217 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
23218 the LABEL_DECL nodes for the function however, and we output DWARF info
23219 for those in decls_for_scope. Just within the `outer_scope' there will be
23220 a BLOCK node representing the function's outermost pair of curly braces,
23221 and any blocks used for the base and member initializers of a C++
23222 constructor function. */
23223 tree outer_scope
= DECL_INITIAL (decl
);
23224 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
23226 int call_site_note_count
= 0;
23227 int tail_call_site_note_count
= 0;
23229 /* Emit a DW_TAG_variable DIE for a named return value. */
23230 if (DECL_NAME (DECL_RESULT (decl
)))
23231 gen_decl_die (DECL_RESULT (decl
), NULL
, NULL
, subr_die
);
23233 /* The first time through decls_for_scope we will generate the
23234 DIEs for the locals. The second time, we fill in the
23236 decls_for_scope (outer_scope
, subr_die
);
23238 if (call_arg_locations
&& (!dwarf_strict
|| dwarf_version
>= 5))
23240 struct call_arg_loc_node
*ca_loc
;
23241 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
23243 dw_die_ref die
= NULL
;
23244 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
23247 for (arg
= (ca_loc
->call_arg_loc_note
!= NULL_RTX
23248 ? XEXP (ca_loc
->call_arg_loc_note
, 0)
23250 arg
; arg
= next_arg
)
23252 dw_loc_descr_ref reg
, val
;
23253 machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
23254 dw_die_ref cdie
, tdie
= NULL
;
23256 next_arg
= XEXP (arg
, 1);
23257 if (REG_P (XEXP (XEXP (arg
, 0), 0))
23259 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
23260 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
23261 && REGNO (XEXP (XEXP (arg
, 0), 0))
23262 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
23263 next_arg
= XEXP (next_arg
, 1);
23264 if (mode
== VOIDmode
)
23266 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
23267 if (mode
== VOIDmode
)
23268 mode
= GET_MODE (XEXP (arg
, 0));
23270 if (mode
== VOIDmode
|| mode
== BLKmode
)
23272 /* Get dynamic information about call target only if we
23273 have no static information: we cannot generate both
23274 DW_AT_call_origin and DW_AT_call_target
23276 if (ca_loc
->symbol_ref
== NULL_RTX
)
23278 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
23280 tloc
= XEXP (XEXP (arg
, 0), 1);
23283 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
23284 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
23286 tlocc
= XEXP (XEXP (arg
, 0), 1);
23291 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
23292 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
23293 VAR_INIT_STATUS_INITIALIZED
);
23294 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
23296 rtx mem
= XEXP (XEXP (arg
, 0), 0);
23297 reg
= mem_loc_descriptor (XEXP (mem
, 0),
23298 get_address_mode (mem
),
23300 VAR_INIT_STATUS_INITIALIZED
);
23302 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
23303 == DEBUG_PARAMETER_REF
)
23306 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
23307 tdie
= lookup_decl_die (tdecl
);
23314 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
23315 != DEBUG_PARAMETER_REF
)
23317 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
23319 VAR_INIT_STATUS_INITIALIZED
);
23323 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
23324 cdie
= new_die (dwarf_TAG (DW_TAG_call_site_parameter
), die
,
23327 add_AT_loc (cdie
, DW_AT_location
, reg
);
23328 else if (tdie
!= NULL
)
23329 add_AT_die_ref (cdie
, dwarf_AT (DW_AT_call_parameter
),
23331 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_value
), val
);
23332 if (next_arg
!= XEXP (arg
, 1))
23334 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
23335 if (mode
== VOIDmode
)
23336 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
23337 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
23340 VAR_INIT_STATUS_INITIALIZED
);
23342 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_data_value
),
23347 && (ca_loc
->symbol_ref
|| tloc
))
23348 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
23349 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
23351 dw_loc_descr_ref tval
= NULL
;
23353 if (tloc
!= NULL_RTX
)
23354 tval
= mem_loc_descriptor (tloc
,
23355 GET_MODE (tloc
) == VOIDmode
23356 ? Pmode
: GET_MODE (tloc
),
23358 VAR_INIT_STATUS_INITIALIZED
);
23360 add_AT_loc (die
, dwarf_AT (DW_AT_call_target
), tval
);
23361 else if (tlocc
!= NULL_RTX
)
23363 tval
= mem_loc_descriptor (tlocc
,
23364 GET_MODE (tlocc
) == VOIDmode
23365 ? Pmode
: GET_MODE (tlocc
),
23367 VAR_INIT_STATUS_INITIALIZED
);
23370 dwarf_AT (DW_AT_call_target_clobbered
),
23376 call_site_note_count
++;
23377 if (ca_loc
->tail_call_p
)
23378 tail_call_site_note_count
++;
23382 call_arg_locations
= NULL
;
23383 call_arg_loc_last
= NULL
;
23384 if (tail_call_site_count
>= 0
23385 && tail_call_site_count
== tail_call_site_note_count
23386 && (!dwarf_strict
|| dwarf_version
>= 5))
23388 if (call_site_count
>= 0
23389 && call_site_count
== call_site_note_count
)
23390 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_calls
), 1);
23392 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_tail_calls
), 1);
23394 call_site_count
= -1;
23395 tail_call_site_count
= -1;
23398 /* Mark used types after we have created DIEs for the functions scopes. */
23399 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
23402 /* Returns a hash value for X (which really is a die_struct). */
23405 block_die_hasher::hash (die_struct
*d
)
23407 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
23410 /* Return nonzero if decl_id and die_parent of die_struct X is the same
23411 as decl_id and die_parent of die_struct Y. */
23414 block_die_hasher::equal (die_struct
*x
, die_struct
*y
)
23416 return x
->decl_id
== y
->decl_id
&& x
->die_parent
== y
->die_parent
;
23419 /* Hold information about markers for inlined entry points. */
23420 struct GTY ((for_user
)) inline_entry_data
23422 /* The block that's the inlined_function_outer_scope for an inlined
23426 /* The label at the inlined entry point. */
23427 const char *label_pfx
;
23428 unsigned int label_num
;
23430 /* The view number to be used as the inlined entry point. */
23434 struct inline_entry_data_hasher
: ggc_ptr_hash
<inline_entry_data
>
23436 typedef tree compare_type
;
23437 static inline hashval_t
hash (const inline_entry_data
*);
23438 static inline bool equal (const inline_entry_data
*, const_tree
);
23441 /* Hash table routines for inline_entry_data. */
23444 inline_entry_data_hasher::hash (const inline_entry_data
*data
)
23446 return htab_hash_pointer (data
->block
);
23450 inline_entry_data_hasher::equal (const inline_entry_data
*data
,
23453 return data
->block
== block
;
23456 /* Inlined entry points pending DIE creation in this compilation unit. */
23458 static GTY(()) hash_table
<inline_entry_data_hasher
> *inline_entry_data_table
;
23461 /* Return TRUE if DECL, which may have been previously generated as
23462 OLD_DIE, is a candidate for a DW_AT_specification. DECLARATION is
23463 true if decl (or its origin) is either an extern declaration or a
23464 class/namespace scoped declaration.
23466 The declare_in_namespace support causes us to get two DIEs for one
23467 variable, both of which are declarations. We want to avoid
23468 considering one to be a specification, so we must test for
23469 DECLARATION and DW_AT_declaration. */
23471 decl_will_get_specification_p (dw_die_ref old_die
, tree decl
, bool declaration
)
23473 return (old_die
&& TREE_STATIC (decl
) && !declaration
23474 && get_AT_flag (old_die
, DW_AT_declaration
) == 1);
23477 /* Return true if DECL is a local static. */
23480 local_function_static (tree decl
)
23482 gcc_assert (VAR_P (decl
));
23483 return TREE_STATIC (decl
)
23484 && DECL_CONTEXT (decl
)
23485 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
;
23488 /* Generate a DIE to represent a declared data object.
23489 Either DECL or ORIGIN must be non-null. */
23492 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
23494 HOST_WIDE_INT off
= 0;
23496 tree decl_or_origin
= decl
? decl
: origin
;
23497 tree ultimate_origin
;
23498 dw_die_ref var_die
;
23499 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
23500 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
23501 || class_or_namespace_scope_p (context_die
));
23502 bool specialization_p
= false;
23503 bool no_linkage_name
= false;
23505 /* While C++ inline static data members have definitions inside of the
23506 class, force the first DIE to be a declaration, then let gen_member_die
23507 reparent it to the class context and call gen_variable_die again
23508 to create the outside of the class DIE for the definition. */
23512 && DECL_CONTEXT (decl
)
23513 && TYPE_P (DECL_CONTEXT (decl
))
23514 && lang_hooks
.decls
.decl_dwarf_attribute (decl
, DW_AT_inline
) != -1)
23516 declaration
= true;
23517 if (dwarf_version
< 5)
23518 no_linkage_name
= true;
23521 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
23522 if (decl
|| ultimate_origin
)
23523 origin
= ultimate_origin
;
23524 com_decl
= fortran_common (decl_or_origin
, &off
);
23526 /* Symbol in common gets emitted as a child of the common block, in the form
23527 of a data member. */
23530 dw_die_ref com_die
;
23531 dw_loc_list_ref loc
= NULL
;
23532 die_node com_die_arg
;
23534 var_die
= lookup_decl_die (decl_or_origin
);
23537 if (! early_dwarf
&& get_AT (var_die
, DW_AT_location
) == NULL
)
23539 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2, NULL
);
23544 /* Optimize the common case. */
23545 if (single_element_loc_list_p (loc
)
23546 && loc
->expr
->dw_loc_opc
== DW_OP_addr
23547 && loc
->expr
->dw_loc_next
== NULL
23548 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
23551 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
23552 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
23553 = plus_constant (GET_MODE (x
), x
, off
);
23556 loc_list_plus_const (loc
, off
);
23558 add_AT_location_description (var_die
, DW_AT_location
, loc
);
23559 remove_AT (var_die
, DW_AT_declaration
);
23565 if (common_block_die_table
== NULL
)
23566 common_block_die_table
= hash_table
<block_die_hasher
>::create_ggc (10);
23568 com_die_arg
.decl_id
= DECL_UID (com_decl
);
23569 com_die_arg
.die_parent
= context_die
;
23570 com_die
= common_block_die_table
->find (&com_die_arg
);
23572 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
23573 if (com_die
== NULL
)
23576 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
23579 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
23580 add_name_and_src_coords_attributes (com_die
, com_decl
);
23583 add_AT_location_description (com_die
, DW_AT_location
, loc
);
23584 /* Avoid sharing the same loc descriptor between
23585 DW_TAG_common_block and DW_TAG_variable. */
23586 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
23588 else if (DECL_EXTERNAL (decl_or_origin
))
23589 add_AT_flag (com_die
, DW_AT_declaration
, 1);
23590 if (want_pubnames ())
23591 add_pubname_string (cnam
, com_die
); /* ??? needed? */
23592 com_die
->decl_id
= DECL_UID (com_decl
);
23593 slot
= common_block_die_table
->find_slot (com_die
, INSERT
);
23596 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
23598 add_AT_location_description (com_die
, DW_AT_location
, loc
);
23599 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
23600 remove_AT (com_die
, DW_AT_declaration
);
23602 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
23603 add_name_and_src_coords_attributes (var_die
, decl_or_origin
);
23604 add_type_attribute (var_die
, TREE_TYPE (decl_or_origin
),
23605 decl_quals (decl_or_origin
), false,
23607 add_alignment_attribute (var_die
, decl
);
23608 add_AT_flag (var_die
, DW_AT_external
, 1);
23613 /* Optimize the common case. */
23614 if (single_element_loc_list_p (loc
)
23615 && loc
->expr
->dw_loc_opc
== DW_OP_addr
23616 && loc
->expr
->dw_loc_next
== NULL
23617 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
23619 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
23620 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
23621 = plus_constant (GET_MODE (x
), x
, off
);
23624 loc_list_plus_const (loc
, off
);
23626 add_AT_location_description (var_die
, DW_AT_location
, loc
);
23628 else if (DECL_EXTERNAL (decl_or_origin
))
23629 add_AT_flag (var_die
, DW_AT_declaration
, 1);
23631 equate_decl_number_to_die (decl
, var_die
);
23639 /* A declaration that has been previously dumped, needs no
23640 further annotations, since it doesn't need location on
23641 the second pass. */
23644 else if (decl_will_get_specification_p (old_die
, decl
, declaration
)
23645 && !get_AT (old_die
, DW_AT_specification
))
23647 /* Fall-thru so we can make a new variable die along with a
23648 DW_AT_specification. */
23650 else if (origin
&& old_die
->die_parent
!= context_die
)
23652 /* If we will be creating an inlined instance, we need a
23653 new DIE that will get annotated with
23654 DW_AT_abstract_origin. */
23655 gcc_assert (!DECL_ABSTRACT_P (decl
));
23659 /* If a DIE was dumped early, it still needs location info.
23660 Skip to where we fill the location bits. */
23663 /* ??? In LTRANS we cannot annotate early created variably
23664 modified type DIEs without copying them and adjusting all
23665 references to them. Thus we dumped them again. Also add a
23666 reference to them but beware of -g0 compile and -g link
23667 in which case the reference will be already present. */
23668 tree type
= TREE_TYPE (decl_or_origin
);
23670 && ! get_AT (var_die
, DW_AT_type
)
23671 && variably_modified_type_p
23672 (type
, decl_function_context (decl_or_origin
)))
23674 if (decl_by_reference_p (decl_or_origin
))
23675 add_type_attribute (var_die
, TREE_TYPE (type
),
23676 TYPE_UNQUALIFIED
, false, context_die
);
23678 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
),
23679 false, context_die
);
23682 goto gen_variable_die_location
;
23686 /* For static data members, the declaration in the class is supposed
23687 to have DW_TAG_member tag in DWARF{3,4} and we emit it for compatibility
23688 also in DWARF2; the specification should still be DW_TAG_variable
23689 referencing the DW_TAG_member DIE. */
23690 if (declaration
&& class_scope_p (context_die
) && dwarf_version
< 5)
23691 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
23693 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
23695 if (origin
!= NULL
)
23696 add_abstract_origin_attribute (var_die
, origin
);
23698 /* Loop unrolling can create multiple blocks that refer to the same
23699 static variable, so we must test for the DW_AT_declaration flag.
23701 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
23702 copy decls and set the DECL_ABSTRACT_P flag on them instead of
23705 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
23706 else if (decl_will_get_specification_p (old_die
, decl
, declaration
))
23708 /* This is a definition of a C++ class level static. */
23709 add_AT_specification (var_die
, old_die
);
23710 specialization_p
= true;
23711 if (DECL_NAME (decl
))
23713 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
23714 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
23716 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
23717 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
23719 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
23720 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
23722 if (debug_column_info
23724 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
23725 != (unsigned) s
.column
))
23726 add_AT_unsigned (var_die
, DW_AT_decl_column
, s
.column
);
23728 if (old_die
->die_tag
== DW_TAG_member
)
23729 add_linkage_name (var_die
, decl
);
23733 add_name_and_src_coords_attributes (var_die
, decl
, no_linkage_name
);
23735 if ((origin
== NULL
&& !specialization_p
)
23737 && !DECL_ABSTRACT_P (decl_or_origin
)
23738 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
23739 decl_function_context
23740 (decl_or_origin
))))
23742 tree type
= TREE_TYPE (decl_or_origin
);
23744 if (decl_by_reference_p (decl_or_origin
))
23745 add_type_attribute (var_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
23748 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
), false,
23752 if (origin
== NULL
&& !specialization_p
)
23754 if (TREE_PUBLIC (decl
))
23755 add_AT_flag (var_die
, DW_AT_external
, 1);
23757 if (DECL_ARTIFICIAL (decl
))
23758 add_AT_flag (var_die
, DW_AT_artificial
, 1);
23760 add_alignment_attribute (var_die
, decl
);
23762 add_accessibility_attribute (var_die
, decl
);
23766 add_AT_flag (var_die
, DW_AT_declaration
, 1);
23768 if (decl
&& (DECL_ABSTRACT_P (decl
)
23769 || !old_die
|| is_declaration_die (old_die
)))
23770 equate_decl_number_to_die (decl
, var_die
);
23772 gen_variable_die_location
:
23774 && (! DECL_ABSTRACT_P (decl_or_origin
)
23775 /* Local static vars are shared between all clones/inlines,
23776 so emit DW_AT_location on the abstract DIE if DECL_RTL is
23778 || (VAR_P (decl_or_origin
)
23779 && TREE_STATIC (decl_or_origin
)
23780 && DECL_RTL_SET_P (decl_or_origin
))))
23783 add_pubname (decl_or_origin
, var_die
);
23785 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
23789 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
23791 if ((dwarf_version
>= 4 || !dwarf_strict
)
23792 && lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
23793 DW_AT_const_expr
) == 1
23794 && !get_AT (var_die
, DW_AT_const_expr
)
23795 && !specialization_p
)
23796 add_AT_flag (var_die
, DW_AT_const_expr
, 1);
23800 int inl
= lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
23803 && !get_AT (var_die
, DW_AT_inline
)
23804 && !specialization_p
)
23805 add_AT_unsigned (var_die
, DW_AT_inline
, inl
);
23809 /* Generate a DIE to represent a named constant. */
23812 gen_const_die (tree decl
, dw_die_ref context_die
)
23814 dw_die_ref const_die
;
23815 tree type
= TREE_TYPE (decl
);
23817 const_die
= lookup_decl_die (decl
);
23821 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
23822 equate_decl_number_to_die (decl
, const_die
);
23823 add_name_and_src_coords_attributes (const_die
, decl
);
23824 add_type_attribute (const_die
, type
, TYPE_QUAL_CONST
, false, context_die
);
23825 if (TREE_PUBLIC (decl
))
23826 add_AT_flag (const_die
, DW_AT_external
, 1);
23827 if (DECL_ARTIFICIAL (decl
))
23828 add_AT_flag (const_die
, DW_AT_artificial
, 1);
23829 tree_add_const_value_attribute_for_decl (const_die
, decl
);
23832 /* Generate a DIE to represent a label identifier. */
23835 gen_label_die (tree decl
, dw_die_ref context_die
)
23837 tree origin
= decl_ultimate_origin (decl
);
23838 dw_die_ref lbl_die
= lookup_decl_die (decl
);
23840 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
23844 lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
23845 equate_decl_number_to_die (decl
, lbl_die
);
23847 if (origin
!= NULL
)
23848 add_abstract_origin_attribute (lbl_die
, origin
);
23850 add_name_and_src_coords_attributes (lbl_die
, decl
);
23853 if (DECL_ABSTRACT_P (decl
))
23854 equate_decl_number_to_die (decl
, lbl_die
);
23855 else if (! early_dwarf
)
23857 insn
= DECL_RTL_IF_SET (decl
);
23859 /* Deleted labels are programmer specified labels which have been
23860 eliminated because of various optimizations. We still emit them
23861 here so that it is possible to put breakpoints on them. */
23865 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
23867 /* When optimization is enabled (via -O) some parts of the compiler
23868 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
23869 represent source-level labels which were explicitly declared by
23870 the user. This really shouldn't be happening though, so catch
23871 it if it ever does happen. */
23872 gcc_assert (!as_a
<rtx_insn
*> (insn
)->deleted ());
23874 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
23875 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
23879 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
23880 && CODE_LABEL_NUMBER (insn
) != -1)
23882 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
23883 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
23888 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
23889 attributes to the DIE for a block STMT, to describe where the inlined
23890 function was called from. This is similar to add_src_coords_attributes. */
23893 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
23895 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
23897 if (dwarf_version
>= 3 || !dwarf_strict
)
23899 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
23900 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
23901 if (debug_column_info
&& s
.column
)
23902 add_AT_unsigned (die
, DW_AT_call_column
, s
.column
);
23907 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
23908 Add low_pc and high_pc attributes to the DIE for a block STMT. */
23911 add_high_low_attributes (tree stmt
, dw_die_ref die
)
23913 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
23915 if (inline_entry_data
**iedp
23916 = !inline_entry_data_table
? NULL
23917 : inline_entry_data_table
->find_slot_with_hash (stmt
,
23918 htab_hash_pointer (stmt
),
23921 inline_entry_data
*ied
= *iedp
;
23922 gcc_assert (MAY_HAVE_DEBUG_MARKER_INSNS
);
23923 gcc_assert (debug_inline_points
);
23924 gcc_assert (inlined_function_outer_scope_p (stmt
));
23926 ASM_GENERATE_INTERNAL_LABEL (label
, ied
->label_pfx
, ied
->label_num
);
23927 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
23929 if (debug_variable_location_views
&& !ZERO_VIEW_P (ied
->view
)
23932 if (!output_asm_line_debug_info ())
23933 add_AT_unsigned (die
, DW_AT_GNU_entry_view
, ied
->view
);
23936 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", ied
->view
);
23937 /* FIXME: this will resolve to a small number. Could we
23938 possibly emit smaller data? Ideally we'd emit a
23939 uleb128, but that would make the size of DIEs
23940 impossible for the compiler to compute, since it's
23941 the assembler that computes the value of the view
23942 label in this case. Ideally, we'd have a single form
23943 encompassing both the address and the view, and
23944 indirecting them through a table might make things
23945 easier, but even that would be more wasteful,
23946 space-wise, than what we have now. */
23947 add_AT_symview (die
, DW_AT_GNU_entry_view
, label
);
23951 inline_entry_data_table
->clear_slot (iedp
);
23954 if (BLOCK_FRAGMENT_CHAIN (stmt
)
23955 && (dwarf_version
>= 3 || !dwarf_strict
))
23957 tree chain
, superblock
= NULL_TREE
;
23959 dw_attr_node
*attr
= NULL
;
23961 if (!debug_inline_points
&& inlined_function_outer_scope_p (stmt
))
23963 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
23964 BLOCK_NUMBER (stmt
));
23965 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
23968 /* Optimize duplicate .debug_ranges lists or even tails of
23969 lists. If this BLOCK has same ranges as its supercontext,
23970 lookup DW_AT_ranges attribute in the supercontext (and
23971 recursively so), verify that the ranges_table contains the
23972 right values and use it instead of adding a new .debug_range. */
23973 for (chain
= stmt
, pdie
= die
;
23974 BLOCK_SAME_RANGE (chain
);
23975 chain
= BLOCK_SUPERCONTEXT (chain
))
23977 dw_attr_node
*new_attr
;
23979 pdie
= pdie
->die_parent
;
23982 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
23984 new_attr
= get_AT (pdie
, DW_AT_ranges
);
23985 if (new_attr
== NULL
23986 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
23989 superblock
= BLOCK_SUPERCONTEXT (chain
);
23992 && ((*ranges_table
)[attr
->dw_attr_val
.v
.val_offset
].num
23993 == BLOCK_NUMBER (superblock
))
23994 && BLOCK_FRAGMENT_CHAIN (superblock
))
23996 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
;
23997 unsigned long supercnt
= 0, thiscnt
= 0;
23998 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
23999 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
24002 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
].num
24003 == BLOCK_NUMBER (chain
));
24005 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
+ 1].num
== 0);
24006 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
24007 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
24009 gcc_assert (supercnt
>= thiscnt
);
24010 add_AT_range_list (die
, DW_AT_ranges
, off
+ supercnt
- thiscnt
,
24012 note_rnglist_head (off
+ supercnt
- thiscnt
);
24016 unsigned int offset
= add_ranges (stmt
, true);
24017 add_AT_range_list (die
, DW_AT_ranges
, offset
, false);
24018 note_rnglist_head (offset
);
24020 bool prev_in_cold
= BLOCK_IN_COLD_SECTION_P (stmt
);
24021 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
24024 add_ranges (chain
, prev_in_cold
!= BLOCK_IN_COLD_SECTION_P (chain
));
24025 prev_in_cold
= BLOCK_IN_COLD_SECTION_P (chain
);
24026 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
24033 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
24034 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
24035 BLOCK_NUMBER (stmt
));
24036 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
24037 BLOCK_NUMBER (stmt
));
24038 add_AT_low_high_pc (die
, label
, label_high
, false);
24042 /* Generate a DIE for a lexical block. */
24045 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
)
24047 dw_die_ref old_die
= BLOCK_DIE (stmt
);
24048 dw_die_ref stmt_die
= NULL
;
24051 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
24052 BLOCK_DIE (stmt
) = stmt_die
;
24055 if (BLOCK_ABSTRACT (stmt
))
24059 /* This must have been generated early and it won't even
24060 need location information since it's a DW_AT_inline
24063 for (dw_die_ref c
= context_die
; c
; c
= c
->die_parent
)
24064 if (c
->die_tag
== DW_TAG_inlined_subroutine
24065 || c
->die_tag
== DW_TAG_subprogram
)
24067 gcc_assert (get_AT (c
, DW_AT_inline
));
24073 else if (BLOCK_ABSTRACT_ORIGIN (stmt
))
24075 /* If this is an inlined instance, create a new lexical die for
24076 anything below to attach DW_AT_abstract_origin to. */
24079 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
24080 BLOCK_DIE (stmt
) = stmt_die
;
24084 tree origin
= block_ultimate_origin (stmt
);
24085 if (origin
!= NULL_TREE
&& origin
!= stmt
)
24086 add_abstract_origin_attribute (stmt_die
, origin
);
24090 stmt_die
= old_die
;
24092 /* A non abstract block whose blocks have already been reordered
24093 should have the instruction range for this block. If so, set the
24094 high/low attributes. */
24095 if (!early_dwarf
&& !BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
24097 gcc_assert (stmt_die
);
24098 add_high_low_attributes (stmt
, stmt_die
);
24101 decls_for_scope (stmt
, stmt_die
);
24104 /* Generate a DIE for an inlined subprogram. */
24107 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
)
24111 /* The instance of function that is effectively being inlined shall not
24113 gcc_assert (! BLOCK_ABSTRACT (stmt
));
24115 decl
= block_ultimate_origin (stmt
);
24117 /* Make sure any inlined functions are known to be inlineable. */
24118 gcc_checking_assert (DECL_ABSTRACT_P (decl
)
24119 || cgraph_function_possibly_inlined_p (decl
));
24121 if (! BLOCK_ABSTRACT (stmt
))
24123 dw_die_ref subr_die
24124 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
24126 if (call_arg_locations
|| debug_inline_points
)
24127 BLOCK_DIE (stmt
) = subr_die
;
24128 add_abstract_origin_attribute (subr_die
, decl
);
24129 if (TREE_ASM_WRITTEN (stmt
))
24130 add_high_low_attributes (stmt
, subr_die
);
24131 add_call_src_coords_attributes (stmt
, subr_die
);
24133 decls_for_scope (stmt
, subr_die
);
24137 /* Generate a DIE for a field in a record, or structure. CTX is required: see
24138 the comment for VLR_CONTEXT. */
24141 gen_field_die (tree decl
, struct vlr_context
*ctx
, dw_die_ref context_die
)
24143 dw_die_ref decl_die
;
24145 if (TREE_TYPE (decl
) == error_mark_node
)
24148 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
24149 add_name_and_src_coords_attributes (decl_die
, decl
);
24150 add_type_attribute (decl_die
, member_declared_type (decl
), decl_quals (decl
),
24151 TYPE_REVERSE_STORAGE_ORDER (DECL_FIELD_CONTEXT (decl
)),
24154 if (DECL_BIT_FIELD_TYPE (decl
))
24156 add_byte_size_attribute (decl_die
, decl
);
24157 add_bit_size_attribute (decl_die
, decl
);
24158 add_bit_offset_attribute (decl_die
, decl
, ctx
);
24161 add_alignment_attribute (decl_die
, decl
);
24163 /* If we have a variant part offset, then we are supposed to process a member
24164 of a QUAL_UNION_TYPE, which is how we represent variant parts in
24166 gcc_assert (ctx
->variant_part_offset
== NULL_TREE
24167 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != QUAL_UNION_TYPE
);
24168 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
24169 add_data_member_location_attribute (decl_die
, decl
, ctx
);
24171 if (DECL_ARTIFICIAL (decl
))
24172 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
24174 add_accessibility_attribute (decl_die
, decl
);
24176 /* Equate decl number to die, so that we can look up this decl later on. */
24177 equate_decl_number_to_die (decl
, decl_die
);
24180 /* Generate a DIE for a pointer to a member type. TYPE can be an
24181 OFFSET_TYPE, for a pointer to data member, or a RECORD_TYPE, for a
24182 pointer to member function. */
24185 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
24187 if (lookup_type_die (type
))
24190 dw_die_ref ptr_die
= new_die (DW_TAG_ptr_to_member_type
,
24191 scope_die_for (type
, context_die
), type
);
24193 equate_type_number_to_die (type
, ptr_die
);
24194 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
24195 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
24196 add_type_attribute (ptr_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
24198 add_alignment_attribute (ptr_die
, type
);
24200 if (TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
24201 && TREE_CODE (TREE_TYPE (type
)) != METHOD_TYPE
)
24203 dw_loc_descr_ref op
= new_loc_descr (DW_OP_plus
, 0, 0);
24204 add_AT_loc (ptr_die
, DW_AT_use_location
, op
);
24208 static char *producer_string
;
24210 /* Return a heap allocated producer string including command line options
24211 if -grecord-gcc-switches. */
24214 gen_producer_string (void)
24217 auto_vec
<const char *> switches
;
24218 const char *language_string
= lang_hooks
.name
;
24219 char *producer
, *tail
;
24221 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
24222 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
24224 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
24225 switch (save_decoded_options
[j
].opt_index
)
24232 case OPT_auxbase_strip
:
24241 case OPT_SPECIAL_unknown
:
24242 case OPT_SPECIAL_ignore
:
24243 case OPT_SPECIAL_program_name
:
24244 case OPT_SPECIAL_input_file
:
24245 case OPT_grecord_gcc_switches
:
24246 case OPT__output_pch_
:
24247 case OPT_fdiagnostics_show_location_
:
24248 case OPT_fdiagnostics_show_option
:
24249 case OPT_fdiagnostics_show_caret
:
24250 case OPT_fdiagnostics_color_
:
24251 case OPT_fverbose_asm
:
24253 case OPT__sysroot_
:
24255 case OPT_nostdinc__
:
24256 case OPT_fpreprocessed
:
24257 case OPT_fltrans_output_list_
:
24258 case OPT_fresolution_
:
24259 case OPT_fdebug_prefix_map_
:
24260 case OPT_fmacro_prefix_map_
:
24261 case OPT_ffile_prefix_map_
:
24262 case OPT_fcompare_debug
:
24263 case OPT_fchecking
:
24264 case OPT_fchecking_
:
24265 /* Ignore these. */
24268 if (cl_options
[save_decoded_options
[j
].opt_index
].flags
24269 & CL_NO_DWARF_RECORD
)
24271 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
24273 switch (save_decoded_options
[j
].canonical_option
[0][1])
24280 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
24287 switches
.safe_push (save_decoded_options
[j
].orig_option_with_args_text
);
24288 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
24292 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
24294 sprintf (tail
, "%s %s", language_string
, version_string
);
24297 FOR_EACH_VEC_ELT (switches
, j
, p
)
24301 memcpy (tail
+ 1, p
, len
);
24309 /* Given a C and/or C++ language/version string return the "highest".
24310 C++ is assumed to be "higher" than C in this case. Used for merging
24311 LTO translation unit languages. */
24312 static const char *
24313 highest_c_language (const char *lang1
, const char *lang2
)
24315 if (strcmp ("GNU C++17", lang1
) == 0 || strcmp ("GNU C++17", lang2
) == 0)
24316 return "GNU C++17";
24317 if (strcmp ("GNU C++14", lang1
) == 0 || strcmp ("GNU C++14", lang2
) == 0)
24318 return "GNU C++14";
24319 if (strcmp ("GNU C++11", lang1
) == 0 || strcmp ("GNU C++11", lang2
) == 0)
24320 return "GNU C++11";
24321 if (strcmp ("GNU C++98", lang1
) == 0 || strcmp ("GNU C++98", lang2
) == 0)
24322 return "GNU C++98";
24324 if (strcmp ("GNU C17", lang1
) == 0 || strcmp ("GNU C17", lang2
) == 0)
24326 if (strcmp ("GNU C11", lang1
) == 0 || strcmp ("GNU C11", lang2
) == 0)
24328 if (strcmp ("GNU C99", lang1
) == 0 || strcmp ("GNU C99", lang2
) == 0)
24330 if (strcmp ("GNU C89", lang1
) == 0 || strcmp ("GNU C89", lang2
) == 0)
24333 gcc_unreachable ();
24337 /* Generate the DIE for the compilation unit. */
24340 gen_compile_unit_die (const char *filename
)
24343 const char *language_string
= lang_hooks
.name
;
24346 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
24350 add_name_attribute (die
, filename
);
24351 /* Don't add cwd for <built-in>. */
24352 if (filename
[0] != '<')
24353 add_comp_dir_attribute (die
);
24356 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
24358 /* If our producer is LTO try to figure out a common language to use
24359 from the global list of translation units. */
24360 if (strcmp (language_string
, "GNU GIMPLE") == 0)
24364 const char *common_lang
= NULL
;
24366 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
24368 if (!TRANSLATION_UNIT_LANGUAGE (t
))
24371 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
24372 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
24374 else if (strncmp (common_lang
, "GNU C", 5) == 0
24375 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
24376 /* Mixing C and C++ is ok, use C++ in that case. */
24377 common_lang
= highest_c_language (common_lang
,
24378 TRANSLATION_UNIT_LANGUAGE (t
));
24381 /* Fall back to C. */
24382 common_lang
= NULL
;
24388 language_string
= common_lang
;
24391 language
= DW_LANG_C
;
24392 if (strncmp (language_string
, "GNU C", 5) == 0
24393 && ISDIGIT (language_string
[5]))
24395 language
= DW_LANG_C89
;
24396 if (dwarf_version
>= 3 || !dwarf_strict
)
24398 if (strcmp (language_string
, "GNU C89") != 0)
24399 language
= DW_LANG_C99
;
24401 if (dwarf_version
>= 5 /* || !dwarf_strict */)
24402 if (strcmp (language_string
, "GNU C11") == 0
24403 || strcmp (language_string
, "GNU C17") == 0)
24404 language
= DW_LANG_C11
;
24407 else if (strncmp (language_string
, "GNU C++", 7) == 0)
24409 language
= DW_LANG_C_plus_plus
;
24410 if (dwarf_version
>= 5 /* || !dwarf_strict */)
24412 if (strcmp (language_string
, "GNU C++11") == 0)
24413 language
= DW_LANG_C_plus_plus_11
;
24414 else if (strcmp (language_string
, "GNU C++14") == 0)
24415 language
= DW_LANG_C_plus_plus_14
;
24416 else if (strcmp (language_string
, "GNU C++17") == 0)
24418 language
= DW_LANG_C_plus_plus_14
;
24421 else if (strcmp (language_string
, "GNU F77") == 0)
24422 language
= DW_LANG_Fortran77
;
24423 else if (dwarf_version
>= 3 || !dwarf_strict
)
24425 if (strcmp (language_string
, "GNU Ada") == 0)
24426 language
= DW_LANG_Ada95
;
24427 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
24429 language
= DW_LANG_Fortran95
;
24430 if (dwarf_version
>= 5 /* || !dwarf_strict */)
24432 if (strcmp (language_string
, "GNU Fortran2003") == 0)
24433 language
= DW_LANG_Fortran03
;
24434 else if (strcmp (language_string
, "GNU Fortran2008") == 0)
24435 language
= DW_LANG_Fortran08
;
24438 else if (strcmp (language_string
, "GNU Objective-C") == 0)
24439 language
= DW_LANG_ObjC
;
24440 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
24441 language
= DW_LANG_ObjC_plus_plus
;
24442 else if (dwarf_version
>= 5 || !dwarf_strict
)
24444 if (strcmp (language_string
, "GNU Go") == 0)
24445 language
= DW_LANG_Go
;
24448 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
24449 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
24450 language
= DW_LANG_Fortran90
;
24451 /* Likewise for Ada. */
24452 else if (strcmp (language_string
, "GNU Ada") == 0)
24453 language
= DW_LANG_Ada83
;
24455 add_AT_unsigned (die
, DW_AT_language
, language
);
24459 case DW_LANG_Fortran77
:
24460 case DW_LANG_Fortran90
:
24461 case DW_LANG_Fortran95
:
24462 case DW_LANG_Fortran03
:
24463 case DW_LANG_Fortran08
:
24464 /* Fortran has case insensitive identifiers and the front-end
24465 lowercases everything. */
24466 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
24469 /* The default DW_ID_case_sensitive doesn't need to be specified. */
24475 /* Generate the DIE for a base class. */
24478 gen_inheritance_die (tree binfo
, tree access
, tree type
,
24479 dw_die_ref context_die
)
24481 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
24482 struct vlr_context ctx
= { type
, NULL
};
24484 add_type_attribute (die
, BINFO_TYPE (binfo
), TYPE_UNQUALIFIED
, false,
24486 add_data_member_location_attribute (die
, binfo
, &ctx
);
24488 if (BINFO_VIRTUAL_P (binfo
))
24489 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
24491 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
24492 children, otherwise the default is DW_ACCESS_public. In DWARF2
24493 the default has always been DW_ACCESS_private. */
24494 if (access
== access_public_node
)
24496 if (dwarf_version
== 2
24497 || context_die
->die_tag
== DW_TAG_class_type
)
24498 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
24500 else if (access
== access_protected_node
)
24501 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
24502 else if (dwarf_version
> 2
24503 && context_die
->die_tag
!= DW_TAG_class_type
)
24504 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
24507 /* Return whether DECL is a FIELD_DECL that represents the variant part of a
24510 is_variant_part (tree decl
)
24512 return (TREE_CODE (decl
) == FIELD_DECL
24513 && TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
);
24516 /* Check that OPERAND is a reference to a field in STRUCT_TYPE. If it is,
24517 return the FIELD_DECL. Return NULL_TREE otherwise. */
24520 analyze_discr_in_predicate (tree operand
, tree struct_type
)
24522 bool continue_stripping
= true;
24523 while (continue_stripping
)
24524 switch (TREE_CODE (operand
))
24527 operand
= TREE_OPERAND (operand
, 0);
24530 continue_stripping
= false;
24534 /* Match field access to members of struct_type only. */
24535 if (TREE_CODE (operand
) == COMPONENT_REF
24536 && TREE_CODE (TREE_OPERAND (operand
, 0)) == PLACEHOLDER_EXPR
24537 && TREE_TYPE (TREE_OPERAND (operand
, 0)) == struct_type
24538 && TREE_CODE (TREE_OPERAND (operand
, 1)) == FIELD_DECL
)
24539 return TREE_OPERAND (operand
, 1);
24544 /* Check that SRC is a constant integer that can be represented as a native
24545 integer constant (either signed or unsigned). If so, store it into DEST and
24546 return true. Return false otherwise. */
24549 get_discr_value (tree src
, dw_discr_value
*dest
)
24551 tree discr_type
= TREE_TYPE (src
);
24553 if (lang_hooks
.types
.get_debug_type
)
24555 tree debug_type
= lang_hooks
.types
.get_debug_type (discr_type
);
24556 if (debug_type
!= NULL
)
24557 discr_type
= debug_type
;
24560 if (TREE_CODE (src
) != INTEGER_CST
|| !INTEGRAL_TYPE_P (discr_type
))
24563 /* Signedness can vary between the original type and the debug type. This
24564 can happen for character types in Ada for instance: the character type
24565 used for code generation can be signed, to be compatible with the C one,
24566 but from a debugger point of view, it must be unsigned. */
24567 bool is_orig_unsigned
= TYPE_UNSIGNED (TREE_TYPE (src
));
24568 bool is_debug_unsigned
= TYPE_UNSIGNED (discr_type
);
24570 if (is_orig_unsigned
!= is_debug_unsigned
)
24571 src
= fold_convert (discr_type
, src
);
24573 if (!(is_debug_unsigned
? tree_fits_uhwi_p (src
) : tree_fits_shwi_p (src
)))
24576 dest
->pos
= is_debug_unsigned
;
24577 if (is_debug_unsigned
)
24578 dest
->v
.uval
= tree_to_uhwi (src
);
24580 dest
->v
.sval
= tree_to_shwi (src
);
24585 /* Try to extract synthetic properties out of VARIANT_PART_DECL, which is a
24586 FIELD_DECL in STRUCT_TYPE that represents a variant part. If unsuccessful,
24587 store NULL_TREE in DISCR_DECL. Otherwise:
24589 - store the discriminant field in STRUCT_TYPE that controls the variant
24590 part to *DISCR_DECL
24592 - put in *DISCR_LISTS_P an array where for each variant, the item
24593 represents the corresponding matching list of discriminant values.
24595 - put in *DISCR_LISTS_LENGTH the number of variants, which is the size of
24598 Note that when the array is allocated (i.e. when the analysis is
24599 successful), it is up to the caller to free the array. */
24602 analyze_variants_discr (tree variant_part_decl
,
24605 dw_discr_list_ref
**discr_lists_p
,
24606 unsigned *discr_lists_length
)
24608 tree variant_part_type
= TREE_TYPE (variant_part_decl
);
24610 dw_discr_list_ref
*discr_lists
;
24613 /* Compute how many variants there are in this variant part. */
24614 *discr_lists_length
= 0;
24615 for (variant
= TYPE_FIELDS (variant_part_type
);
24616 variant
!= NULL_TREE
;
24617 variant
= DECL_CHAIN (variant
))
24618 ++*discr_lists_length
;
24620 *discr_decl
= NULL_TREE
;
24622 = (dw_discr_list_ref
*) xcalloc (*discr_lists_length
,
24623 sizeof (**discr_lists_p
));
24624 discr_lists
= *discr_lists_p
;
24626 /* And then analyze all variants to extract discriminant information for all
24627 of them. This analysis is conservative: as soon as we detect something we
24628 do not support, abort everything and pretend we found nothing. */
24629 for (variant
= TYPE_FIELDS (variant_part_type
), i
= 0;
24630 variant
!= NULL_TREE
;
24631 variant
= DECL_CHAIN (variant
), ++i
)
24633 tree match_expr
= DECL_QUALIFIER (variant
);
24635 /* Now, try to analyze the predicate and deduce a discriminant for
24637 if (match_expr
== boolean_true_node
)
24638 /* Typically happens for the default variant: it matches all cases that
24639 previous variants rejected. Don't output any matching value for
24643 /* The following loop tries to iterate over each discriminant
24644 possibility: single values or ranges. */
24645 while (match_expr
!= NULL_TREE
)
24647 tree next_round_match_expr
;
24648 tree candidate_discr
= NULL_TREE
;
24649 dw_discr_list_ref new_node
= NULL
;
24651 /* Possibilities are matched one after the other by nested
24652 TRUTH_ORIF_EXPR expressions. Process the current possibility and
24653 continue with the rest at next iteration. */
24654 if (TREE_CODE (match_expr
) == TRUTH_ORIF_EXPR
)
24656 next_round_match_expr
= TREE_OPERAND (match_expr
, 0);
24657 match_expr
= TREE_OPERAND (match_expr
, 1);
24660 next_round_match_expr
= NULL_TREE
;
24662 if (match_expr
== boolean_false_node
)
24663 /* This sub-expression matches nothing: just wait for the next
24667 else if (TREE_CODE (match_expr
) == EQ_EXPR
)
24669 /* We are matching: <discr_field> == <integer_cst>
24670 This sub-expression matches a single value. */
24671 tree integer_cst
= TREE_OPERAND (match_expr
, 1);
24674 = analyze_discr_in_predicate (TREE_OPERAND (match_expr
, 0),
24677 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
24678 if (!get_discr_value (integer_cst
,
24679 &new_node
->dw_discr_lower_bound
))
24681 new_node
->dw_discr_range
= false;
24684 else if (TREE_CODE (match_expr
) == TRUTH_ANDIF_EXPR
)
24686 /* We are matching:
24687 <discr_field> > <integer_cst>
24688 && <discr_field> < <integer_cst>.
24689 This sub-expression matches the range of values between the
24690 two matched integer constants. Note that comparisons can be
24691 inclusive or exclusive. */
24692 tree candidate_discr_1
, candidate_discr_2
;
24693 tree lower_cst
, upper_cst
;
24694 bool lower_cst_included
, upper_cst_included
;
24695 tree lower_op
= TREE_OPERAND (match_expr
, 0);
24696 tree upper_op
= TREE_OPERAND (match_expr
, 1);
24698 /* When the comparison is exclusive, the integer constant is not
24699 the discriminant range bound we are looking for: we will have
24700 to increment or decrement it. */
24701 if (TREE_CODE (lower_op
) == GE_EXPR
)
24702 lower_cst_included
= true;
24703 else if (TREE_CODE (lower_op
) == GT_EXPR
)
24704 lower_cst_included
= false;
24708 if (TREE_CODE (upper_op
) == LE_EXPR
)
24709 upper_cst_included
= true;
24710 else if (TREE_CODE (upper_op
) == LT_EXPR
)
24711 upper_cst_included
= false;
24715 /* Extract the discriminant from the first operand and check it
24716 is consistant with the same analysis in the second
24719 = analyze_discr_in_predicate (TREE_OPERAND (lower_op
, 0),
24722 = analyze_discr_in_predicate (TREE_OPERAND (upper_op
, 0),
24724 if (candidate_discr_1
== candidate_discr_2
)
24725 candidate_discr
= candidate_discr_1
;
24729 /* Extract bounds from both. */
24730 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
24731 lower_cst
= TREE_OPERAND (lower_op
, 1);
24732 upper_cst
= TREE_OPERAND (upper_op
, 1);
24734 if (!lower_cst_included
)
24736 = fold_build2 (PLUS_EXPR
, TREE_TYPE (lower_cst
), lower_cst
,
24737 build_int_cst (TREE_TYPE (lower_cst
), 1));
24738 if (!upper_cst_included
)
24740 = fold_build2 (MINUS_EXPR
, TREE_TYPE (upper_cst
), upper_cst
,
24741 build_int_cst (TREE_TYPE (upper_cst
), 1));
24743 if (!get_discr_value (lower_cst
,
24744 &new_node
->dw_discr_lower_bound
)
24745 || !get_discr_value (upper_cst
,
24746 &new_node
->dw_discr_upper_bound
))
24749 new_node
->dw_discr_range
= true;
24753 /* Unsupported sub-expression: we cannot determine the set of
24754 matching discriminant values. Abort everything. */
24757 /* If the discriminant info is not consistant with what we saw so
24758 far, consider the analysis failed and abort everything. */
24759 if (candidate_discr
== NULL_TREE
24760 || (*discr_decl
!= NULL_TREE
&& candidate_discr
!= *discr_decl
))
24763 *discr_decl
= candidate_discr
;
24765 if (new_node
!= NULL
)
24767 new_node
->dw_discr_next
= discr_lists
[i
];
24768 discr_lists
[i
] = new_node
;
24770 match_expr
= next_round_match_expr
;
24774 /* If we reach this point, we could match everything we were interested
24779 /* Clean all data structure and return no result. */
24780 free (*discr_lists_p
);
24781 *discr_lists_p
= NULL
;
24782 *discr_decl
= NULL_TREE
;
24785 /* Generate a DIE to represent VARIANT_PART_DECL, a variant part that is part
24786 of STRUCT_TYPE, a record type. This new DIE is emitted as the next child
24789 Variant parts are supposed to be implemented as a FIELD_DECL whose type is a
24790 QUAL_UNION_TYPE: this is the VARIANT_PART_DECL parameter. The members for
24791 this type, which are record types, represent the available variants and each
24792 has a DECL_QUALIFIER attribute. The discriminant and the discriminant
24793 values are inferred from these attributes.
24795 In trees, the offsets for the fields inside these sub-records are relative
24796 to the variant part itself, whereas the corresponding DIEs should have
24797 offset attributes that are relative to the embedding record base address.
24798 This is why the caller must provide a VARIANT_PART_OFFSET expression: it
24799 must be an expression that computes the offset of the variant part to
24800 describe in DWARF. */
24803 gen_variant_part (tree variant_part_decl
, struct vlr_context
*vlr_ctx
,
24804 dw_die_ref context_die
)
24806 const tree variant_part_type
= TREE_TYPE (variant_part_decl
);
24807 tree variant_part_offset
= vlr_ctx
->variant_part_offset
;
24808 struct loc_descr_context ctx
= {
24809 vlr_ctx
->struct_type
, /* context_type */
24810 NULL_TREE
, /* base_decl */
24812 false, /* placeholder_arg */
24813 false /* placeholder_seen */
24816 /* The FIELD_DECL node in STRUCT_TYPE that acts as the discriminant, or
24817 NULL_TREE if there is no such field. */
24818 tree discr_decl
= NULL_TREE
;
24819 dw_discr_list_ref
*discr_lists
;
24820 unsigned discr_lists_length
= 0;
24823 dw_die_ref dwarf_proc_die
= NULL
;
24824 dw_die_ref variant_part_die
24825 = new_die (DW_TAG_variant_part
, context_die
, variant_part_type
);
24827 equate_decl_number_to_die (variant_part_decl
, variant_part_die
);
24829 analyze_variants_discr (variant_part_decl
, vlr_ctx
->struct_type
,
24830 &discr_decl
, &discr_lists
, &discr_lists_length
);
24832 if (discr_decl
!= NULL_TREE
)
24834 dw_die_ref discr_die
= lookup_decl_die (discr_decl
);
24837 add_AT_die_ref (variant_part_die
, DW_AT_discr
, discr_die
);
24839 /* We have no DIE for the discriminant, so just discard all
24840 discrimimant information in the output. */
24841 discr_decl
= NULL_TREE
;
24844 /* If the offset for this variant part is more complex than a constant,
24845 create a DWARF procedure for it so that we will not have to generate DWARF
24846 expressions for it for each member. */
24847 if (TREE_CODE (variant_part_offset
) != INTEGER_CST
24848 && (dwarf_version
>= 3 || !dwarf_strict
))
24850 const tree dwarf_proc_fndecl
24851 = build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
24852 build_function_type (TREE_TYPE (variant_part_offset
),
24854 const tree dwarf_proc_call
= build_call_expr (dwarf_proc_fndecl
, 0);
24855 const dw_loc_descr_ref dwarf_proc_body
24856 = loc_descriptor_from_tree (variant_part_offset
, 0, &ctx
);
24858 dwarf_proc_die
= new_dwarf_proc_die (dwarf_proc_body
,
24859 dwarf_proc_fndecl
, context_die
);
24860 if (dwarf_proc_die
!= NULL
)
24861 variant_part_offset
= dwarf_proc_call
;
24864 /* Output DIEs for all variants. */
24866 for (tree variant
= TYPE_FIELDS (variant_part_type
);
24867 variant
!= NULL_TREE
;
24868 variant
= DECL_CHAIN (variant
), ++i
)
24870 tree variant_type
= TREE_TYPE (variant
);
24871 dw_die_ref variant_die
;
24873 /* All variants (i.e. members of a variant part) are supposed to be
24874 encoded as structures. Sub-variant parts are QUAL_UNION_TYPE fields
24875 under these records. */
24876 gcc_assert (TREE_CODE (variant_type
) == RECORD_TYPE
);
24878 variant_die
= new_die (DW_TAG_variant
, variant_part_die
, variant_type
);
24879 equate_decl_number_to_die (variant
, variant_die
);
24881 /* Output discriminant values this variant matches, if any. */
24882 if (discr_decl
== NULL
|| discr_lists
[i
] == NULL
)
24883 /* In the case we have discriminant information at all, this is
24884 probably the default variant: as the standard says, don't
24885 output any discriminant value/list attribute. */
24887 else if (discr_lists
[i
]->dw_discr_next
== NULL
24888 && !discr_lists
[i
]->dw_discr_range
)
24889 /* If there is only one accepted value, don't bother outputting a
24891 add_discr_value (variant_die
, &discr_lists
[i
]->dw_discr_lower_bound
);
24893 add_discr_list (variant_die
, discr_lists
[i
]);
24895 for (tree member
= TYPE_FIELDS (variant_type
);
24896 member
!= NULL_TREE
;
24897 member
= DECL_CHAIN (member
))
24899 struct vlr_context vlr_sub_ctx
= {
24900 vlr_ctx
->struct_type
, /* struct_type */
24901 NULL
/* variant_part_offset */
24903 if (is_variant_part (member
))
24905 /* All offsets for fields inside variant parts are relative to
24906 the top-level embedding RECORD_TYPE's base address. On the
24907 other hand, offsets in GCC's types are relative to the
24908 nested-most variant part. So we have to sum offsets each time
24911 vlr_sub_ctx
.variant_part_offset
24912 = fold_build2 (PLUS_EXPR
, TREE_TYPE (variant_part_offset
),
24913 variant_part_offset
, byte_position (member
));
24914 gen_variant_part (member
, &vlr_sub_ctx
, variant_die
);
24918 vlr_sub_ctx
.variant_part_offset
= variant_part_offset
;
24919 gen_decl_die (member
, NULL
, &vlr_sub_ctx
, variant_die
);
24924 free (discr_lists
);
24927 /* Generate a DIE for a class member. */
24930 gen_member_die (tree type
, dw_die_ref context_die
)
24933 tree binfo
= TYPE_BINFO (type
);
24935 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
24937 /* If this is not an incomplete type, output descriptions of each of its
24938 members. Note that as we output the DIEs necessary to represent the
24939 members of this record or union type, we will also be trying to output
24940 DIEs to represent the *types* of those members. However the `type'
24941 function (above) will specifically avoid generating type DIEs for member
24942 types *within* the list of member DIEs for this (containing) type except
24943 for those types (of members) which are explicitly marked as also being
24944 members of this (containing) type themselves. The g++ front- end can
24945 force any given type to be treated as a member of some other (containing)
24946 type by setting the TYPE_CONTEXT of the given (member) type to point to
24947 the TREE node representing the appropriate (containing) type. */
24949 /* First output info about the base classes. */
24952 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
24956 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
24957 gen_inheritance_die (base
,
24958 (accesses
? (*accesses
)[i
] : access_public_node
),
24963 /* Now output info about the data members and type members. */
24964 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
24966 struct vlr_context vlr_ctx
= { type
, NULL_TREE
};
24967 bool static_inline_p
24968 = (TREE_STATIC (member
)
24969 && (lang_hooks
.decls
.decl_dwarf_attribute (member
, DW_AT_inline
)
24972 /* Ignore clones. */
24973 if (DECL_ABSTRACT_ORIGIN (member
))
24976 /* If we thought we were generating minimal debug info for TYPE
24977 and then changed our minds, some of the member declarations
24978 may have already been defined. Don't define them again, but
24979 do put them in the right order. */
24981 if (dw_die_ref child
= lookup_decl_die (member
))
24983 /* Handle inline static data members, which only have in-class
24985 dw_die_ref ref
= NULL
;
24986 if (child
->die_tag
== DW_TAG_variable
24987 && child
->die_parent
== comp_unit_die ())
24989 ref
= get_AT_ref (child
, DW_AT_specification
);
24990 /* For C++17 inline static data members followed by redundant
24991 out of class redeclaration, we might get here with
24992 child being the DIE created for the out of class
24993 redeclaration and with its DW_AT_specification being
24994 the DIE created for in-class definition. We want to
24995 reparent the latter, and don't want to create another
24996 DIE with DW_AT_specification in that case, because
24997 we already have one. */
25000 && ref
->die_tag
== DW_TAG_variable
25001 && ref
->die_parent
== comp_unit_die ()
25002 && get_AT (ref
, DW_AT_specification
) == NULL
)
25006 static_inline_p
= false;
25010 if (child
->die_tag
== DW_TAG_variable
25011 && child
->die_parent
== comp_unit_die ()
25014 reparent_child (child
, context_die
);
25015 if (dwarf_version
< 5)
25016 child
->die_tag
= DW_TAG_member
;
25019 splice_child_die (context_die
, child
);
25022 /* Do not generate standard DWARF for variant parts if we are generating
25023 the corresponding GNAT encodings: DIEs generated for both would
25024 conflict in our mappings. */
25025 else if (is_variant_part (member
)
25026 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
)
25028 vlr_ctx
.variant_part_offset
= byte_position (member
);
25029 gen_variant_part (member
, &vlr_ctx
, context_die
);
25033 vlr_ctx
.variant_part_offset
= NULL_TREE
;
25034 gen_decl_die (member
, NULL
, &vlr_ctx
, context_die
);
25037 /* For C++ inline static data members emit immediately a DW_TAG_variable
25038 DIE that will refer to that DW_TAG_member/DW_TAG_variable through
25039 DW_AT_specification. */
25040 if (static_inline_p
)
25042 int old_extern
= DECL_EXTERNAL (member
);
25043 DECL_EXTERNAL (member
) = 0;
25044 gen_decl_die (member
, NULL
, NULL
, comp_unit_die ());
25045 DECL_EXTERNAL (member
) = old_extern
;
25050 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
25051 is set, we pretend that the type was never defined, so we only get the
25052 member DIEs needed by later specification DIEs. */
25055 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
25056 enum debug_info_usage usage
)
25058 if (TREE_ASM_WRITTEN (type
))
25060 /* Fill in the bound of variable-length fields in late dwarf if
25061 still incomplete. */
25062 if (!early_dwarf
&& variably_modified_type_p (type
, NULL
))
25063 for (tree member
= TYPE_FIELDS (type
);
25065 member
= DECL_CHAIN (member
))
25066 fill_variable_array_bounds (TREE_TYPE (member
));
25070 dw_die_ref type_die
= lookup_type_die (type
);
25071 dw_die_ref scope_die
= 0;
25073 int complete
= (TYPE_SIZE (type
)
25074 && (! TYPE_STUB_DECL (type
)
25075 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
25076 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
25077 complete
= complete
&& should_emit_struct_debug (type
, usage
);
25079 if (type_die
&& ! complete
)
25082 if (TYPE_CONTEXT (type
) != NULL_TREE
25083 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
25084 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
25087 scope_die
= scope_die_for (type
, context_die
);
25089 /* Generate child dies for template paramaters. */
25090 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
25091 schedule_generic_params_dies_gen (type
);
25093 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
25094 /* First occurrence of type or toplevel definition of nested class. */
25096 dw_die_ref old_die
= type_die
;
25098 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
25099 ? record_type_tag (type
) : DW_TAG_union_type
,
25101 equate_type_number_to_die (type
, type_die
);
25103 add_AT_specification (type_die
, old_die
);
25105 add_name_attribute (type_die
, type_tag (type
));
25108 remove_AT (type_die
, DW_AT_declaration
);
25110 /* If this type has been completed, then give it a byte_size attribute and
25111 then give a list of members. */
25112 if (complete
&& !ns_decl
)
25114 /* Prevent infinite recursion in cases where the type of some member of
25115 this type is expressed in terms of this type itself. */
25116 TREE_ASM_WRITTEN (type
) = 1;
25117 add_byte_size_attribute (type_die
, type
);
25118 add_alignment_attribute (type_die
, type
);
25119 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
25121 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
25122 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
25125 /* If the first reference to this type was as the return type of an
25126 inline function, then it may not have a parent. Fix this now. */
25127 if (type_die
->die_parent
== NULL
)
25128 add_child_die (scope_die
, type_die
);
25130 gen_member_die (type
, type_die
);
25132 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
25133 if (TYPE_ARTIFICIAL (type
))
25134 add_AT_flag (type_die
, DW_AT_artificial
, 1);
25136 /* GNU extension: Record what type our vtable lives in. */
25137 if (TYPE_VFIELD (type
))
25139 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
25141 gen_type_die (vtype
, context_die
);
25142 add_AT_die_ref (type_die
, DW_AT_containing_type
,
25143 lookup_type_die (vtype
));
25148 add_AT_flag (type_die
, DW_AT_declaration
, 1);
25150 /* We don't need to do this for function-local types. */
25151 if (TYPE_STUB_DECL (type
)
25152 && ! decl_function_context (TYPE_STUB_DECL (type
)))
25153 vec_safe_push (incomplete_types
, type
);
25156 if (get_AT (type_die
, DW_AT_name
))
25157 add_pubtype (type
, type_die
);
25160 /* Generate a DIE for a subroutine _type_. */
25163 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
25165 tree return_type
= TREE_TYPE (type
);
25166 dw_die_ref subr_die
25167 = new_die (DW_TAG_subroutine_type
,
25168 scope_die_for (type
, context_die
), type
);
25170 equate_type_number_to_die (type
, subr_die
);
25171 add_prototyped_attribute (subr_die
, type
);
25172 add_type_attribute (subr_die
, return_type
, TYPE_UNQUALIFIED
, false,
25174 add_alignment_attribute (subr_die
, type
);
25175 gen_formal_types_die (type
, subr_die
);
25177 if (get_AT (subr_die
, DW_AT_name
))
25178 add_pubtype (type
, subr_die
);
25179 if ((dwarf_version
>= 5 || !dwarf_strict
)
25180 && lang_hooks
.types
.type_dwarf_attribute (type
, DW_AT_reference
) != -1)
25181 add_AT_flag (subr_die
, DW_AT_reference
, 1);
25182 if ((dwarf_version
>= 5 || !dwarf_strict
)
25183 && lang_hooks
.types
.type_dwarf_attribute (type
,
25184 DW_AT_rvalue_reference
) != -1)
25185 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
25188 /* Generate a DIE for a type definition. */
25191 gen_typedef_die (tree decl
, dw_die_ref context_die
)
25193 dw_die_ref type_die
;
25196 if (TREE_ASM_WRITTEN (decl
))
25198 if (DECL_ORIGINAL_TYPE (decl
))
25199 fill_variable_array_bounds (DECL_ORIGINAL_TYPE (decl
));
25203 /* As we avoid creating DIEs for local typedefs (see decl_ultimate_origin
25204 checks in process_scope_var and modified_type_die), this should be called
25205 only for original types. */
25206 gcc_assert (decl_ultimate_origin (decl
) == NULL
25207 || decl_ultimate_origin (decl
) == decl
);
25209 TREE_ASM_WRITTEN (decl
) = 1;
25210 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
25212 add_name_and_src_coords_attributes (type_die
, decl
);
25213 if (DECL_ORIGINAL_TYPE (decl
))
25215 type
= DECL_ORIGINAL_TYPE (decl
);
25216 if (type
== error_mark_node
)
25219 gcc_assert (type
!= TREE_TYPE (decl
));
25220 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
25224 type
= TREE_TYPE (decl
);
25225 if (type
== error_mark_node
)
25228 if (is_naming_typedef_decl (TYPE_NAME (type
)))
25230 /* Here, we are in the case of decl being a typedef naming
25231 an anonymous type, e.g:
25232 typedef struct {...} foo;
25233 In that case TREE_TYPE (decl) is not a typedef variant
25234 type and TYPE_NAME of the anonymous type is set to the
25235 TYPE_DECL of the typedef. This construct is emitted by
25238 TYPE is the anonymous struct named by the typedef
25239 DECL. As we need the DW_AT_type attribute of the
25240 DW_TAG_typedef to point to the DIE of TYPE, let's
25241 generate that DIE right away. add_type_attribute
25242 called below will then pick (via lookup_type_die) that
25243 anonymous struct DIE. */
25244 if (!TREE_ASM_WRITTEN (type
))
25245 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
25247 /* This is a GNU Extension. We are adding a
25248 DW_AT_linkage_name attribute to the DIE of the
25249 anonymous struct TYPE. The value of that attribute
25250 is the name of the typedef decl naming the anonymous
25251 struct. This greatly eases the work of consumers of
25252 this debug info. */
25253 add_linkage_name_raw (lookup_type_die (type
), decl
);
25257 add_type_attribute (type_die
, type
, decl_quals (decl
), false,
25260 if (is_naming_typedef_decl (decl
))
25261 /* We want that all subsequent calls to lookup_type_die with
25262 TYPE in argument yield the DW_TAG_typedef we have just
25264 equate_type_number_to_die (type
, type_die
);
25266 add_alignment_attribute (type_die
, TREE_TYPE (decl
));
25268 add_accessibility_attribute (type_die
, decl
);
25270 if (DECL_ABSTRACT_P (decl
))
25271 equate_decl_number_to_die (decl
, type_die
);
25273 if (get_AT (type_die
, DW_AT_name
))
25274 add_pubtype (decl
, type_die
);
25277 /* Generate a DIE for a struct, class, enum or union type. */
25280 gen_tagged_type_die (tree type
,
25281 dw_die_ref context_die
,
25282 enum debug_info_usage usage
)
25284 if (type
== NULL_TREE
25285 || !is_tagged_type (type
))
25288 if (TREE_ASM_WRITTEN (type
))
25290 /* If this is a nested type whose containing class hasn't been written
25291 out yet, writing it out will cover this one, too. This does not apply
25292 to instantiations of member class templates; they need to be added to
25293 the containing class as they are generated. FIXME: This hurts the
25294 idea of combining type decls from multiple TUs, since we can't predict
25295 what set of template instantiations we'll get. */
25296 else if (TYPE_CONTEXT (type
)
25297 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
25298 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
25300 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
25302 if (TREE_ASM_WRITTEN (type
))
25305 /* If that failed, attach ourselves to the stub. */
25306 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
25308 else if (TYPE_CONTEXT (type
) != NULL_TREE
25309 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
25311 /* If this type is local to a function that hasn't been written
25312 out yet, use a NULL context for now; it will be fixed up in
25313 decls_for_scope. */
25314 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
25315 /* A declaration DIE doesn't count; nested types need to go in the
25317 if (context_die
&& is_declaration_die (context_die
))
25318 context_die
= NULL
;
25321 context_die
= declare_in_namespace (type
, context_die
);
25323 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
25325 /* This might have been written out by the call to
25326 declare_in_namespace. */
25327 if (!TREE_ASM_WRITTEN (type
))
25328 gen_enumeration_type_die (type
, context_die
);
25331 gen_struct_or_union_type_die (type
, context_die
, usage
);
25333 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
25334 it up if it is ever completed. gen_*_type_die will set it for us
25335 when appropriate. */
25338 /* Generate a type description DIE. */
25341 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
25342 enum debug_info_usage usage
)
25344 struct array_descr_info info
;
25346 if (type
== NULL_TREE
|| type
== error_mark_node
)
25349 if (flag_checking
&& type
)
25350 verify_type (type
);
25352 if (TYPE_NAME (type
) != NULL_TREE
25353 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
25354 && is_redundant_typedef (TYPE_NAME (type
))
25355 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
25356 /* The DECL of this type is a typedef we don't want to emit debug
25357 info for but we want debug info for its underlying typedef.
25358 This can happen for e.g, the injected-class-name of a C++
25360 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
25362 /* If TYPE is a typedef type variant, let's generate debug info
25363 for the parent typedef which TYPE is a type of. */
25364 if (typedef_variant_p (type
))
25366 if (TREE_ASM_WRITTEN (type
))
25369 tree name
= TYPE_NAME (type
);
25370 tree origin
= decl_ultimate_origin (name
);
25371 if (origin
!= NULL
&& origin
!= name
)
25373 gen_decl_die (origin
, NULL
, NULL
, context_die
);
25377 /* Prevent broken recursion; we can't hand off to the same type. */
25378 gcc_assert (DECL_ORIGINAL_TYPE (name
) != type
);
25380 /* Give typedefs the right scope. */
25381 context_die
= scope_die_for (type
, context_die
);
25383 TREE_ASM_WRITTEN (type
) = 1;
25385 gen_decl_die (name
, NULL
, NULL
, context_die
);
25389 /* If type is an anonymous tagged type named by a typedef, let's
25390 generate debug info for the typedef. */
25391 if (is_naming_typedef_decl (TYPE_NAME (type
)))
25393 /* Give typedefs the right scope. */
25394 context_die
= scope_die_for (type
, context_die
);
25396 gen_decl_die (TYPE_NAME (type
), NULL
, NULL
, context_die
);
25400 if (lang_hooks
.types
.get_debug_type
)
25402 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
25404 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
25406 gen_type_die_with_usage (debug_type
, context_die
, usage
);
25411 /* We are going to output a DIE to represent the unqualified version
25412 of this type (i.e. without any const or volatile qualifiers) so
25413 get the main variant (i.e. the unqualified version) of this type
25414 now. (Vectors and arrays are special because the debugging info is in the
25415 cloned type itself. Similarly function/method types can contain extra
25416 ref-qualification). */
25417 if (TREE_CODE (type
) == FUNCTION_TYPE
25418 || TREE_CODE (type
) == METHOD_TYPE
)
25420 /* For function/method types, can't use type_main_variant here,
25421 because that can have different ref-qualifiers for C++,
25422 but try to canonicalize. */
25423 tree main
= TYPE_MAIN_VARIANT (type
);
25424 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
25425 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
25426 && check_base_type (t
, main
)
25427 && check_lang_type (t
, type
))
25433 else if (TREE_CODE (type
) != VECTOR_TYPE
25434 && TREE_CODE (type
) != ARRAY_TYPE
)
25435 type
= type_main_variant (type
);
25437 /* If this is an array type with hidden descriptor, handle it first. */
25438 if (!TREE_ASM_WRITTEN (type
)
25439 && lang_hooks
.types
.get_array_descr_info
)
25441 memset (&info
, 0, sizeof (info
));
25442 if (lang_hooks
.types
.get_array_descr_info (type
, &info
))
25444 /* Fortran sometimes emits array types with no dimension. */
25445 gcc_assert (info
.ndimensions
>= 0
25446 && (info
.ndimensions
25447 <= DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN
));
25448 gen_descr_array_type_die (type
, &info
, context_die
);
25449 TREE_ASM_WRITTEN (type
) = 1;
25454 if (TREE_ASM_WRITTEN (type
))
25456 /* Variable-length types may be incomplete even if
25457 TREE_ASM_WRITTEN. For such types, fall through to
25458 gen_array_type_die() and possibly fill in
25459 DW_AT_{upper,lower}_bound attributes. */
25460 if ((TREE_CODE (type
) != ARRAY_TYPE
25461 && TREE_CODE (type
) != RECORD_TYPE
25462 && TREE_CODE (type
) != UNION_TYPE
25463 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
25464 || !variably_modified_type_p (type
, NULL
))
25468 switch (TREE_CODE (type
))
25474 case REFERENCE_TYPE
:
25475 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
25476 ensures that the gen_type_die recursion will terminate even if the
25477 type is recursive. Recursive types are possible in Ada. */
25478 /* ??? We could perhaps do this for all types before the switch
25480 TREE_ASM_WRITTEN (type
) = 1;
25482 /* For these types, all that is required is that we output a DIE (or a
25483 set of DIEs) to represent the "basis" type. */
25484 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25485 DINFO_USAGE_IND_USE
);
25489 /* This code is used for C++ pointer-to-data-member types.
25490 Output a description of the relevant class type. */
25491 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
25492 DINFO_USAGE_IND_USE
);
25494 /* Output a description of the type of the object pointed to. */
25495 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25496 DINFO_USAGE_IND_USE
);
25498 /* Now output a DIE to represent this pointer-to-data-member type
25500 gen_ptr_to_mbr_type_die (type
, context_die
);
25503 case FUNCTION_TYPE
:
25504 /* Force out return type (in case it wasn't forced out already). */
25505 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25506 DINFO_USAGE_DIR_USE
);
25507 gen_subroutine_type_die (type
, context_die
);
25511 /* Force out return type (in case it wasn't forced out already). */
25512 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25513 DINFO_USAGE_DIR_USE
);
25514 gen_subroutine_type_die (type
, context_die
);
25519 gen_array_type_die (type
, context_die
);
25522 case ENUMERAL_TYPE
:
25525 case QUAL_UNION_TYPE
:
25526 gen_tagged_type_die (type
, context_die
, usage
);
25532 case FIXED_POINT_TYPE
:
25535 /* No DIEs needed for fundamental types. */
25540 /* Just use DW_TAG_unspecified_type. */
25542 dw_die_ref type_die
= lookup_type_die (type
);
25543 if (type_die
== NULL
)
25545 tree name
= TYPE_IDENTIFIER (type
);
25546 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
25548 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
25549 equate_type_number_to_die (type
, type_die
);
25555 if (is_cxx_auto (type
))
25557 tree name
= TYPE_IDENTIFIER (type
);
25558 dw_die_ref
*die
= (name
== get_identifier ("auto")
25559 ? &auto_die
: &decltype_auto_die
);
25562 *die
= new_die (DW_TAG_unspecified_type
,
25563 comp_unit_die (), NULL_TREE
);
25564 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
25566 equate_type_number_to_die (type
, *die
);
25569 gcc_unreachable ();
25572 TREE_ASM_WRITTEN (type
) = 1;
25576 gen_type_die (tree type
, dw_die_ref context_die
)
25578 if (type
!= error_mark_node
)
25580 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
25583 dw_die_ref die
= lookup_type_die (type
);
25590 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
25591 things which are local to the given block. */
25594 gen_block_die (tree stmt
, dw_die_ref context_die
)
25596 int must_output_die
= 0;
25599 /* Ignore blocks that are NULL. */
25600 if (stmt
== NULL_TREE
)
25603 inlined_func
= inlined_function_outer_scope_p (stmt
);
25605 /* If the block is one fragment of a non-contiguous block, do not
25606 process the variables, since they will have been done by the
25607 origin block. Do process subblocks. */
25608 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
25612 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
25613 gen_block_die (sub
, context_die
);
25618 /* Determine if we need to output any Dwarf DIEs at all to represent this
25621 /* The outer scopes for inlinings *must* always be represented. We
25622 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
25623 must_output_die
= 1;
25624 else if (BLOCK_DIE (stmt
))
25625 /* If we already have a DIE then it was filled early. Meanwhile
25626 we might have pruned all BLOCK_VARS as optimized out but we
25627 still want to generate high/low PC attributes so output it. */
25628 must_output_die
= 1;
25629 else if (TREE_USED (stmt
)
25630 || TREE_ASM_WRITTEN (stmt
)
25631 || BLOCK_ABSTRACT (stmt
))
25633 /* Determine if this block directly contains any "significant"
25634 local declarations which we will need to output DIEs for. */
25635 if (debug_info_level
> DINFO_LEVEL_TERSE
)
25637 /* We are not in terse mode so any local declaration that
25638 is not ignored for debug purposes counts as being a
25639 "significant" one. */
25640 if (BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
25641 must_output_die
= 1;
25643 for (tree var
= BLOCK_VARS (stmt
); var
; var
= DECL_CHAIN (var
))
25644 if (!DECL_IGNORED_P (var
))
25646 must_output_die
= 1;
25650 else if (!dwarf2out_ignore_block (stmt
))
25651 must_output_die
= 1;
25654 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
25655 DIE for any block which contains no significant local declarations at
25656 all. Rather, in such cases we just call `decls_for_scope' so that any
25657 needed Dwarf info for any sub-blocks will get properly generated. Note
25658 that in terse mode, our definition of what constitutes a "significant"
25659 local declaration gets restricted to include only inlined function
25660 instances and local (nested) function definitions. */
25661 if (must_output_die
)
25665 /* If STMT block is abstract, that means we have been called
25666 indirectly from dwarf2out_abstract_function.
25667 That function rightfully marks the descendent blocks (of
25668 the abstract function it is dealing with) as being abstract,
25669 precisely to prevent us from emitting any
25670 DW_TAG_inlined_subroutine DIE as a descendent
25671 of an abstract function instance. So in that case, we should
25672 not call gen_inlined_subroutine_die.
25674 Later though, when cgraph asks dwarf2out to emit info
25675 for the concrete instance of the function decl into which
25676 the concrete instance of STMT got inlined, the later will lead
25677 to the generation of a DW_TAG_inlined_subroutine DIE. */
25678 if (! BLOCK_ABSTRACT (stmt
))
25679 gen_inlined_subroutine_die (stmt
, context_die
);
25682 gen_lexical_block_die (stmt
, context_die
);
25685 decls_for_scope (stmt
, context_die
);
25688 /* Process variable DECL (or variable with origin ORIGIN) within
25689 block STMT and add it to CONTEXT_DIE. */
25691 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
25694 tree decl_or_origin
= decl
? decl
: origin
;
25696 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
25697 die
= lookup_decl_die (decl_or_origin
);
25698 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
)
25700 if (TYPE_DECL_IS_STUB (decl_or_origin
))
25701 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
25703 die
= lookup_decl_die (decl_or_origin
);
25704 /* Avoid re-creating the DIE late if it was optimized as unused early. */
25705 if (! die
&& ! early_dwarf
)
25711 /* Avoid creating DIEs for local typedefs and concrete static variables that
25712 will only be pruned later. */
25713 if ((origin
|| decl_ultimate_origin (decl
))
25714 && (TREE_CODE (decl_or_origin
) == TYPE_DECL
25715 || (VAR_P (decl_or_origin
) && TREE_STATIC (decl_or_origin
))))
25717 origin
= decl_ultimate_origin (decl_or_origin
);
25718 if (decl
&& VAR_P (decl
) && die
!= NULL
)
25720 die
= lookup_decl_die (origin
);
25722 equate_decl_number_to_die (decl
, die
);
25727 if (die
!= NULL
&& die
->die_parent
== NULL
)
25728 add_child_die (context_die
, die
);
25729 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
25732 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
25733 stmt
, context_die
);
25737 if (decl
&& DECL_P (decl
))
25739 die
= lookup_decl_die (decl
);
25741 /* Early created DIEs do not have a parent as the decls refer
25742 to the function as DECL_CONTEXT rather than the BLOCK. */
25743 if (die
&& die
->die_parent
== NULL
)
25745 gcc_assert (in_lto_p
);
25746 add_child_die (context_die
, die
);
25750 gen_decl_die (decl
, origin
, NULL
, context_die
);
25754 /* Generate all of the decls declared within a given scope and (recursively)
25755 all of its sub-blocks. */
25758 decls_for_scope (tree stmt
, dw_die_ref context_die
)
25764 /* Ignore NULL blocks. */
25765 if (stmt
== NULL_TREE
)
25768 /* Output the DIEs to represent all of the data objects and typedefs
25769 declared directly within this block but not within any nested
25770 sub-blocks. Also, nested function and tag DIEs have been
25771 generated with a parent of NULL; fix that up now. We don't
25772 have to do this if we're at -g1. */
25773 if (debug_info_level
> DINFO_LEVEL_TERSE
)
25775 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
25776 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
25777 /* BLOCK_NONLOCALIZED_VARs simply generate DIE stubs with abstract
25778 origin - avoid doing this twice as we have no good way to see
25779 if we've done it once already. */
25781 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
25783 decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
25784 if (decl
== current_function_decl
)
25785 /* Ignore declarations of the current function, while they
25786 are declarations, gen_subprogram_die would treat them
25787 as definitions again, because they are equal to
25788 current_function_decl and endlessly recurse. */;
25789 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
25790 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
25792 process_scope_var (stmt
, NULL_TREE
, decl
, context_die
);
25796 /* Even if we're at -g1, we need to process the subblocks in order to get
25797 inlined call information. */
25799 /* Output the DIEs to represent all sub-blocks (and the items declared
25800 therein) of this block. */
25801 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
25803 subblocks
= BLOCK_CHAIN (subblocks
))
25804 gen_block_die (subblocks
, context_die
);
25807 /* Is this a typedef we can avoid emitting? */
25810 is_redundant_typedef (const_tree decl
)
25812 if (TYPE_DECL_IS_STUB (decl
))
25815 if (DECL_ARTIFICIAL (decl
)
25816 && DECL_CONTEXT (decl
)
25817 && is_tagged_type (DECL_CONTEXT (decl
))
25818 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
25819 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
25820 /* Also ignore the artificial member typedef for the class name. */
25826 /* Return TRUE if TYPE is a typedef that names a type for linkage
25827 purposes. This kind of typedefs is produced by the C++ FE for
25830 typedef struct {...} foo;
25832 In that case, there is no typedef variant type produced for foo.
25833 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
25837 is_naming_typedef_decl (const_tree decl
)
25839 if (decl
== NULL_TREE
25840 || TREE_CODE (decl
) != TYPE_DECL
25841 || DECL_NAMELESS (decl
)
25842 || !is_tagged_type (TREE_TYPE (decl
))
25843 || DECL_IS_BUILTIN (decl
)
25844 || is_redundant_typedef (decl
)
25845 /* It looks like Ada produces TYPE_DECLs that are very similar
25846 to C++ naming typedefs but that have different
25847 semantics. Let's be specific to c++ for now. */
25851 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
25852 && TYPE_NAME (TREE_TYPE (decl
)) == decl
25853 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
25854 != TYPE_NAME (TREE_TYPE (decl
))));
25857 /* Looks up the DIE for a context. */
25859 static inline dw_die_ref
25860 lookup_context_die (tree context
)
25864 /* Find die that represents this context. */
25865 if (TYPE_P (context
))
25867 context
= TYPE_MAIN_VARIANT (context
);
25868 dw_die_ref ctx
= lookup_type_die (context
);
25871 return strip_naming_typedef (context
, ctx
);
25874 return lookup_decl_die (context
);
25876 return comp_unit_die ();
25879 /* Returns the DIE for a context. */
25881 static inline dw_die_ref
25882 get_context_die (tree context
)
25886 /* Find die that represents this context. */
25887 if (TYPE_P (context
))
25889 context
= TYPE_MAIN_VARIANT (context
);
25890 return strip_naming_typedef (context
, force_type_die (context
));
25893 return force_decl_die (context
);
25895 return comp_unit_die ();
25898 /* Returns the DIE for decl. A DIE will always be returned. */
25901 force_decl_die (tree decl
)
25903 dw_die_ref decl_die
;
25904 unsigned saved_external_flag
;
25905 tree save_fn
= NULL_TREE
;
25906 decl_die
= lookup_decl_die (decl
);
25909 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
25911 decl_die
= lookup_decl_die (decl
);
25915 switch (TREE_CODE (decl
))
25917 case FUNCTION_DECL
:
25918 /* Clear current_function_decl, so that gen_subprogram_die thinks
25919 that this is a declaration. At this point, we just want to force
25920 declaration die. */
25921 save_fn
= current_function_decl
;
25922 current_function_decl
= NULL_TREE
;
25923 gen_subprogram_die (decl
, context_die
);
25924 current_function_decl
= save_fn
;
25928 /* Set external flag to force declaration die. Restore it after
25929 gen_decl_die() call. */
25930 saved_external_flag
= DECL_EXTERNAL (decl
);
25931 DECL_EXTERNAL (decl
) = 1;
25932 gen_decl_die (decl
, NULL
, NULL
, context_die
);
25933 DECL_EXTERNAL (decl
) = saved_external_flag
;
25936 case NAMESPACE_DECL
:
25937 if (dwarf_version
>= 3 || !dwarf_strict
)
25938 dwarf2out_decl (decl
);
25940 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
25941 decl_die
= comp_unit_die ();
25944 case TRANSLATION_UNIT_DECL
:
25945 decl_die
= comp_unit_die ();
25949 gcc_unreachable ();
25952 /* We should be able to find the DIE now. */
25954 decl_die
= lookup_decl_die (decl
);
25955 gcc_assert (decl_die
);
25961 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
25962 always returned. */
25965 force_type_die (tree type
)
25967 dw_die_ref type_die
;
25969 type_die
= lookup_type_die (type
);
25972 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
25974 type_die
= modified_type_die (type
, TYPE_QUALS_NO_ADDR_SPACE (type
),
25975 false, context_die
);
25976 gcc_assert (type_die
);
25981 /* Force out any required namespaces to be able to output DECL,
25982 and return the new context_die for it, if it's changed. */
25985 setup_namespace_context (tree thing
, dw_die_ref context_die
)
25987 tree context
= (DECL_P (thing
)
25988 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
25989 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
25990 /* Force out the namespace. */
25991 context_die
= force_decl_die (context
);
25993 return context_die
;
25996 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
25997 type) within its namespace, if appropriate.
25999 For compatibility with older debuggers, namespace DIEs only contain
26000 declarations; all definitions are emitted at CU scope, with
26001 DW_AT_specification pointing to the declaration (like with class
26005 declare_in_namespace (tree thing
, dw_die_ref context_die
)
26007 dw_die_ref ns_context
;
26009 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26010 return context_die
;
26012 /* External declarations in the local scope only need to be emitted
26013 once, not once in the namespace and once in the scope.
26015 This avoids declaring the `extern' below in the
26016 namespace DIE as well as in the innermost scope:
26029 if (DECL_P (thing
) && DECL_EXTERNAL (thing
) && local_scope_p (context_die
))
26030 return context_die
;
26032 /* If this decl is from an inlined function, then don't try to emit it in its
26033 namespace, as we will get confused. It would have already been emitted
26034 when the abstract instance of the inline function was emitted anyways. */
26035 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
26036 return context_die
;
26038 ns_context
= setup_namespace_context (thing
, context_die
);
26040 if (ns_context
!= context_die
)
26044 if (DECL_P (thing
))
26045 gen_decl_die (thing
, NULL
, NULL
, ns_context
);
26047 gen_type_die (thing
, ns_context
);
26049 return context_die
;
26052 /* Generate a DIE for a namespace or namespace alias. */
26055 gen_namespace_die (tree decl
, dw_die_ref context_die
)
26057 dw_die_ref namespace_die
;
26059 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
26060 they are an alias of. */
26061 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
26063 /* Output a real namespace or module. */
26064 context_die
= setup_namespace_context (decl
, comp_unit_die ());
26065 namespace_die
= new_die (is_fortran ()
26066 ? DW_TAG_module
: DW_TAG_namespace
,
26067 context_die
, decl
);
26068 /* For Fortran modules defined in different CU don't add src coords. */
26069 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
26071 const char *name
= dwarf2_name (decl
, 0);
26073 add_name_attribute (namespace_die
, name
);
26076 add_name_and_src_coords_attributes (namespace_die
, decl
);
26077 if (DECL_EXTERNAL (decl
))
26078 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
26079 equate_decl_number_to_die (decl
, namespace_die
);
26083 /* Output a namespace alias. */
26085 /* Force out the namespace we are an alias of, if necessary. */
26086 dw_die_ref origin_die
26087 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
26089 if (DECL_FILE_SCOPE_P (decl
)
26090 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
26091 context_die
= setup_namespace_context (decl
, comp_unit_die ());
26092 /* Now create the namespace alias DIE. */
26093 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
26094 add_name_and_src_coords_attributes (namespace_die
, decl
);
26095 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
26096 equate_decl_number_to_die (decl
, namespace_die
);
26098 if ((dwarf_version
>= 5 || !dwarf_strict
)
26099 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
26100 DW_AT_export_symbols
) == 1)
26101 add_AT_flag (namespace_die
, DW_AT_export_symbols
, 1);
26103 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
26104 if (want_pubnames ())
26105 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
26108 /* Generate Dwarf debug information for a decl described by DECL.
26109 The return value is currently only meaningful for PARM_DECLs,
26110 for all other decls it returns NULL.
26112 If DECL is a FIELD_DECL, CTX is required: see the comment for VLR_CONTEXT.
26113 It can be NULL otherwise. */
26116 gen_decl_die (tree decl
, tree origin
, struct vlr_context
*ctx
,
26117 dw_die_ref context_die
)
26119 tree decl_or_origin
= decl
? decl
: origin
;
26120 tree class_origin
= NULL
, ultimate_origin
;
26122 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
26125 switch (TREE_CODE (decl_or_origin
))
26131 if (!is_fortran () && !is_ada ())
26133 /* The individual enumerators of an enum type get output when we output
26134 the Dwarf representation of the relevant enum type itself. */
26138 /* Emit its type. */
26139 gen_type_die (TREE_TYPE (decl
), context_die
);
26141 /* And its containing namespace. */
26142 context_die
= declare_in_namespace (decl
, context_die
);
26144 gen_const_die (decl
, context_die
);
26147 case FUNCTION_DECL
:
26150 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
26151 on local redeclarations of global functions. That seems broken. */
26152 if (current_function_decl
!= decl
)
26153 /* This is only a declaration. */;
26156 /* We should have abstract copies already and should not generate
26157 stray type DIEs in late LTO dumping. */
26161 /* If we're emitting a clone, emit info for the abstract instance. */
26162 else if (origin
|| DECL_ORIGIN (decl
) != decl
)
26163 dwarf2out_abstract_function (origin
26164 ? DECL_ORIGIN (origin
)
26165 : DECL_ABSTRACT_ORIGIN (decl
));
26167 /* If we're emitting a possibly inlined function emit it as
26168 abstract instance. */
26169 else if (cgraph_function_possibly_inlined_p (decl
)
26170 && ! DECL_ABSTRACT_P (decl
)
26171 && ! class_or_namespace_scope_p (context_die
)
26172 /* dwarf2out_abstract_function won't emit a die if this is just
26173 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
26174 that case, because that works only if we have a die. */
26175 && DECL_INITIAL (decl
) != NULL_TREE
)
26176 dwarf2out_abstract_function (decl
);
26178 /* Otherwise we're emitting the primary DIE for this decl. */
26179 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
26181 /* Before we describe the FUNCTION_DECL itself, make sure that we
26182 have its containing type. */
26184 origin
= decl_class_context (decl
);
26185 if (origin
!= NULL_TREE
)
26186 gen_type_die (origin
, context_die
);
26188 /* And its return type. */
26189 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
26191 /* And its virtual context. */
26192 if (DECL_VINDEX (decl
) != NULL_TREE
)
26193 gen_type_die (DECL_CONTEXT (decl
), context_die
);
26195 /* Make sure we have a member DIE for decl. */
26196 if (origin
!= NULL_TREE
)
26197 gen_type_die_for_member (origin
, decl
, context_die
);
26199 /* And its containing namespace. */
26200 context_die
= declare_in_namespace (decl
, context_die
);
26203 /* Now output a DIE to represent the function itself. */
26205 gen_subprogram_die (decl
, context_die
);
26209 /* If we are in terse mode, don't generate any DIEs to represent any
26210 actual typedefs. */
26211 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26214 /* In the special case of a TYPE_DECL node representing the declaration
26215 of some type tag, if the given TYPE_DECL is marked as having been
26216 instantiated from some other (original) TYPE_DECL node (e.g. one which
26217 was generated within the original definition of an inline function) we
26218 used to generate a special (abbreviated) DW_TAG_structure_type,
26219 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
26220 should be actually referencing those DIEs, as variable DIEs with that
26221 type would be emitted already in the abstract origin, so it was always
26222 removed during unused type prunning. Don't add anything in this
26224 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
26227 if (is_redundant_typedef (decl
))
26228 gen_type_die (TREE_TYPE (decl
), context_die
);
26230 /* Output a DIE to represent the typedef itself. */
26231 gen_typedef_die (decl
, context_die
);
26235 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
26236 gen_label_die (decl
, context_die
);
26241 /* If we are in terse mode, don't generate any DIEs to represent any
26242 variable declarations or definitions. */
26243 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26246 /* Avoid generating stray type DIEs during late dwarf dumping.
26247 All types have been dumped early. */
26249 /* ??? But in LTRANS we cannot annotate early created variably
26250 modified type DIEs without copying them and adjusting all
26251 references to them. Dump them again as happens for inlining
26252 which copies both the decl and the types. */
26253 /* ??? And even non-LTO needs to re-visit type DIEs to fill
26254 in VLA bound information for example. */
26255 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
26256 current_function_decl
)))
26258 /* Output any DIEs that are needed to specify the type of this data
26260 if (decl_by_reference_p (decl_or_origin
))
26261 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
26263 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
26268 /* And its containing type. */
26269 class_origin
= decl_class_context (decl_or_origin
);
26270 if (class_origin
!= NULL_TREE
)
26271 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
26273 /* And its containing namespace. */
26274 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
26277 /* Now output the DIE to represent the data object itself. This gets
26278 complicated because of the possibility that the VAR_DECL really
26279 represents an inlined instance of a formal parameter for an inline
26281 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
26282 if (ultimate_origin
!= NULL_TREE
26283 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
26284 gen_formal_parameter_die (decl
, origin
,
26285 true /* Emit name attribute. */,
26288 gen_variable_die (decl
, origin
, context_die
);
26292 gcc_assert (ctx
!= NULL
&& ctx
->struct_type
!= NULL
);
26293 /* Ignore the nameless fields that are used to skip bits but handle C++
26294 anonymous unions and structs. */
26295 if (DECL_NAME (decl
) != NULL_TREE
26296 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
26297 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
26299 gen_type_die (member_declared_type (decl
), context_die
);
26300 gen_field_die (decl
, ctx
, context_die
);
26305 /* Avoid generating stray type DIEs during late dwarf dumping.
26306 All types have been dumped early. */
26308 /* ??? But in LTRANS we cannot annotate early created variably
26309 modified type DIEs without copying them and adjusting all
26310 references to them. Dump them again as happens for inlining
26311 which copies both the decl and the types. */
26312 /* ??? And even non-LTO needs to re-visit type DIEs to fill
26313 in VLA bound information for example. */
26314 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
26315 current_function_decl
)))
26317 if (DECL_BY_REFERENCE (decl_or_origin
))
26318 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
26320 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
26322 return gen_formal_parameter_die (decl
, origin
,
26323 true /* Emit name attribute. */,
26326 case NAMESPACE_DECL
:
26327 if (dwarf_version
>= 3 || !dwarf_strict
)
26328 gen_namespace_die (decl
, context_die
);
26331 case IMPORTED_DECL
:
26332 dwarf2out_imported_module_or_decl_1 (decl
, DECL_NAME (decl
),
26333 DECL_CONTEXT (decl
), context_die
);
26336 case NAMELIST_DECL
:
26337 gen_namelist_decl (DECL_NAME (decl
), context_die
,
26338 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
26342 /* Probably some frontend-internal decl. Assume we don't care. */
26343 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
26350 /* Output initial debug information for global DECL. Called at the
26351 end of the parsing process.
26353 This is the initial debug generation process. As such, the DIEs
26354 generated may be incomplete. A later debug generation pass
26355 (dwarf2out_late_global_decl) will augment the information generated
26356 in this pass (e.g., with complete location info). */
26359 dwarf2out_early_global_decl (tree decl
)
26363 /* gen_decl_die() will set DECL_ABSTRACT because
26364 cgraph_function_possibly_inlined_p() returns true. This is in
26365 turn will cause DW_AT_inline attributes to be set.
26367 This happens because at early dwarf generation, there is no
26368 cgraph information, causing cgraph_function_possibly_inlined_p()
26369 to return true. Trick cgraph_function_possibly_inlined_p()
26370 while we generate dwarf early. */
26371 bool save
= symtab
->global_info_ready
;
26372 symtab
->global_info_ready
= true;
26374 /* We don't handle TYPE_DECLs. If required, they'll be reached via
26375 other DECLs and they can point to template types or other things
26376 that dwarf2out can't handle when done via dwarf2out_decl. */
26377 if (TREE_CODE (decl
) != TYPE_DECL
26378 && TREE_CODE (decl
) != PARM_DECL
)
26380 if (TREE_CODE (decl
) == FUNCTION_DECL
)
26382 tree save_fndecl
= current_function_decl
;
26384 /* For nested functions, make sure we have DIEs for the parents first
26385 so that all nested DIEs are generated at the proper scope in the
26387 tree context
= decl_function_context (decl
);
26388 if (context
!= NULL
)
26390 dw_die_ref context_die
= lookup_decl_die (context
);
26391 current_function_decl
= context
;
26393 /* Avoid emitting DIEs multiple times, but still process CONTEXT
26394 enough so that it lands in its own context. This avoids type
26395 pruning issues later on. */
26396 if (context_die
== NULL
|| is_declaration_die (context_die
))
26397 dwarf2out_decl (context
);
26400 /* Emit an abstract origin of a function first. This happens
26401 with C++ constructor clones for example and makes
26402 dwarf2out_abstract_function happy which requires the early
26403 DIE of the abstract instance to be present. */
26404 tree origin
= DECL_ABSTRACT_ORIGIN (decl
);
26405 dw_die_ref origin_die
;
26407 /* Do not emit the DIE multiple times but make sure to
26408 process it fully here in case we just saw a declaration. */
26409 && ((origin_die
= lookup_decl_die (origin
)) == NULL
26410 || is_declaration_die (origin_die
)))
26412 current_function_decl
= origin
;
26413 dwarf2out_decl (origin
);
26416 /* Emit the DIE for decl but avoid doing that multiple times. */
26417 dw_die_ref old_die
;
26418 if ((old_die
= lookup_decl_die (decl
)) == NULL
26419 || is_declaration_die (old_die
))
26421 current_function_decl
= decl
;
26422 dwarf2out_decl (decl
);
26425 current_function_decl
= save_fndecl
;
26428 dwarf2out_decl (decl
);
26430 symtab
->global_info_ready
= save
;
26433 /* Return whether EXPR is an expression with the following pattern:
26434 INDIRECT_REF (NOP_EXPR (INTEGER_CST)). */
26437 is_trivial_indirect_ref (tree expr
)
26439 if (expr
== NULL_TREE
|| TREE_CODE (expr
) != INDIRECT_REF
)
26442 tree nop
= TREE_OPERAND (expr
, 0);
26443 if (nop
== NULL_TREE
|| TREE_CODE (nop
) != NOP_EXPR
)
26446 tree int_cst
= TREE_OPERAND (nop
, 0);
26447 return int_cst
!= NULL_TREE
&& TREE_CODE (int_cst
) == INTEGER_CST
;
26450 /* Output debug information for global decl DECL. Called from
26451 toplev.c after compilation proper has finished. */
26454 dwarf2out_late_global_decl (tree decl
)
26456 /* Fill-in any location information we were unable to determine
26457 on the first pass. */
26460 dw_die_ref die
= lookup_decl_die (decl
);
26462 /* We may have to generate early debug late for LTO in case debug
26463 was not enabled at compile-time or the target doesn't support
26464 the LTO early debug scheme. */
26465 if (! die
&& in_lto_p
)
26467 dwarf2out_decl (decl
);
26468 die
= lookup_decl_die (decl
);
26473 /* We get called via the symtab code invoking late_global_decl
26474 for symbols that are optimized out.
26476 Do not add locations for those, except if they have a
26477 DECL_VALUE_EXPR, in which case they are relevant for debuggers.
26478 Still don't add a location if the DECL_VALUE_EXPR is not a trivial
26479 INDIRECT_REF expression, as this could generate relocations to
26480 text symbols in LTO object files, which is invalid. */
26481 varpool_node
*node
= varpool_node::get (decl
);
26482 if ((! node
|| ! node
->definition
)
26483 && ! (DECL_HAS_VALUE_EXPR_P (decl
)
26484 && is_trivial_indirect_ref (DECL_VALUE_EXPR (decl
))))
26485 tree_add_const_value_attribute_for_decl (die
, decl
);
26487 add_location_or_const_value_attribute (die
, decl
, false);
26492 /* Output debug information for type decl DECL. Called from toplev.c
26493 and from language front ends (to record built-in types). */
26495 dwarf2out_type_decl (tree decl
, int local
)
26500 dwarf2out_decl (decl
);
26504 /* Output debug information for imported module or decl DECL.
26505 NAME is non-NULL name in the lexical block if the decl has been renamed.
26506 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
26507 that DECL belongs to.
26508 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
26510 dwarf2out_imported_module_or_decl_1 (tree decl
,
26512 tree lexical_block
,
26513 dw_die_ref lexical_block_die
)
26515 expanded_location xloc
;
26516 dw_die_ref imported_die
= NULL
;
26517 dw_die_ref at_import_die
;
26519 if (TREE_CODE (decl
) == IMPORTED_DECL
)
26521 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
26522 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
26526 xloc
= expand_location (input_location
);
26528 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
26530 at_import_die
= force_type_die (TREE_TYPE (decl
));
26531 /* For namespace N { typedef void T; } using N::T; base_type_die
26532 returns NULL, but DW_TAG_imported_declaration requires
26533 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
26534 if (!at_import_die
)
26536 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
26537 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
26538 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
26539 gcc_assert (at_import_die
);
26544 at_import_die
= lookup_decl_die (decl
);
26545 if (!at_import_die
)
26547 /* If we're trying to avoid duplicate debug info, we may not have
26548 emitted the member decl for this field. Emit it now. */
26549 if (TREE_CODE (decl
) == FIELD_DECL
)
26551 tree type
= DECL_CONTEXT (decl
);
26553 if (TYPE_CONTEXT (type
)
26554 && TYPE_P (TYPE_CONTEXT (type
))
26555 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
26556 DINFO_USAGE_DIR_USE
))
26558 gen_type_die_for_member (type
, decl
,
26559 get_context_die (TYPE_CONTEXT (type
)));
26561 if (TREE_CODE (decl
) == NAMELIST_DECL
)
26562 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
26563 get_context_die (DECL_CONTEXT (decl
)),
26566 at_import_die
= force_decl_die (decl
);
26570 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
26572 if (dwarf_version
>= 3 || !dwarf_strict
)
26573 imported_die
= new_die (DW_TAG_imported_module
,
26580 imported_die
= new_die (DW_TAG_imported_declaration
,
26584 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
26585 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
26586 if (debug_column_info
&& xloc
.column
)
26587 add_AT_unsigned (imported_die
, DW_AT_decl_column
, xloc
.column
);
26589 add_AT_string (imported_die
, DW_AT_name
,
26590 IDENTIFIER_POINTER (name
));
26591 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
26594 /* Output debug information for imported module or decl DECL.
26595 NAME is non-NULL name in context if the decl has been renamed.
26596 CHILD is true if decl is one of the renamed decls as part of
26597 importing whole module.
26598 IMPLICIT is set if this hook is called for an implicit import
26599 such as inline namespace. */
26602 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
26603 bool child
, bool implicit
)
26605 /* dw_die_ref at_import_die; */
26606 dw_die_ref scope_die
;
26608 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26613 /* For DWARF5, just DW_AT_export_symbols on the DW_TAG_namespace
26614 should be enough, for DWARF4 and older even if we emit as extension
26615 DW_AT_export_symbols add the implicit DW_TAG_imported_module anyway
26616 for the benefit of consumers unaware of DW_AT_export_symbols. */
26618 && dwarf_version
>= 5
26619 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
26620 DW_AT_export_symbols
) == 1)
26625 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
26626 We need decl DIE for reference and scope die. First, get DIE for the decl
26629 /* Get the scope die for decl context. Use comp_unit_die for global module
26630 or decl. If die is not found for non globals, force new die. */
26632 && TYPE_P (context
)
26633 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
26636 scope_die
= get_context_die (context
);
26640 /* DW_TAG_imported_module was introduced in the DWARFv3 specification, so
26641 there is nothing we can do, here. */
26642 if (dwarf_version
< 3 && dwarf_strict
)
26645 gcc_assert (scope_die
->die_child
);
26646 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
26647 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
26648 scope_die
= scope_die
->die_child
;
26651 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
26652 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
26655 /* Output debug information for namelists. */
26658 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
26660 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
26664 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26667 gcc_assert (scope_die
!= NULL
);
26668 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
26669 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
26671 /* If there are no item_decls, we have a nondefining namelist, e.g.
26672 with USE association; hence, set DW_AT_declaration. */
26673 if (item_decls
== NULL_TREE
)
26675 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
26679 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
26681 nml_item_ref_die
= lookup_decl_die (value
);
26682 if (!nml_item_ref_die
)
26683 nml_item_ref_die
= force_decl_die (value
);
26685 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
26686 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
26692 /* Write the debugging output for DECL and return the DIE. */
26695 dwarf2out_decl (tree decl
)
26697 dw_die_ref context_die
= comp_unit_die ();
26699 switch (TREE_CODE (decl
))
26704 case FUNCTION_DECL
:
26705 /* If we're a nested function, initially use a parent of NULL; if we're
26706 a plain function, this will be fixed up in decls_for_scope. If
26707 we're a method, it will be ignored, since we already have a DIE.
26708 Avoid doing this late though since clones of class methods may
26709 otherwise end up in limbo and create type DIEs late. */
26711 && decl_function_context (decl
)
26712 /* But if we're in terse mode, we don't care about scope. */
26713 && debug_info_level
> DINFO_LEVEL_TERSE
)
26714 context_die
= NULL
;
26718 /* For local statics lookup proper context die. */
26719 if (local_function_static (decl
))
26720 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
26722 /* If we are in terse mode, don't generate any DIEs to represent any
26723 variable declarations or definitions. */
26724 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26729 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26731 if (!is_fortran () && !is_ada ())
26733 if (TREE_STATIC (decl
) && decl_function_context (decl
))
26734 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
26737 case NAMESPACE_DECL
:
26738 case IMPORTED_DECL
:
26739 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26741 if (lookup_decl_die (decl
) != NULL
)
26746 /* Don't emit stubs for types unless they are needed by other DIEs. */
26747 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
26750 /* Don't bother trying to generate any DIEs to represent any of the
26751 normal built-in types for the language we are compiling. */
26752 if (DECL_IS_BUILTIN (decl
))
26755 /* If we are in terse mode, don't generate any DIEs for types. */
26756 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26759 /* If we're a function-scope tag, initially use a parent of NULL;
26760 this will be fixed up in decls_for_scope. */
26761 if (decl_function_context (decl
))
26762 context_die
= NULL
;
26766 case NAMELIST_DECL
:
26773 gen_decl_die (decl
, NULL
, NULL
, context_die
);
26777 dw_die_ref die
= lookup_decl_die (decl
);
26783 /* Write the debugging output for DECL. */
26786 dwarf2out_function_decl (tree decl
)
26788 dwarf2out_decl (decl
);
26789 call_arg_locations
= NULL
;
26790 call_arg_loc_last
= NULL
;
26791 call_site_count
= -1;
26792 tail_call_site_count
= -1;
26793 decl_loc_table
->empty ();
26794 cached_dw_loc_list_table
->empty ();
26797 /* Output a marker (i.e. a label) for the beginning of the generated code for
26798 a lexical block. */
26801 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
26802 unsigned int blocknum
)
26804 switch_to_section (current_function_section ());
26805 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
26808 /* Output a marker (i.e. a label) for the end of the generated code for a
26812 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
26814 switch_to_section (current_function_section ());
26815 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
26818 /* Returns nonzero if it is appropriate not to emit any debugging
26819 information for BLOCK, because it doesn't contain any instructions.
26821 Don't allow this for blocks with nested functions or local classes
26822 as we would end up with orphans, and in the presence of scheduling
26823 we may end up calling them anyway. */
26826 dwarf2out_ignore_block (const_tree block
)
26831 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
26832 if (TREE_CODE (decl
) == FUNCTION_DECL
26833 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
26835 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
26837 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
26838 if (TREE_CODE (decl
) == FUNCTION_DECL
26839 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
26846 /* Hash table routines for file_hash. */
26849 dwarf_file_hasher::equal (dwarf_file_data
*p1
, const char *p2
)
26851 return filename_cmp (p1
->filename
, p2
) == 0;
26855 dwarf_file_hasher::hash (dwarf_file_data
*p
)
26857 return htab_hash_string (p
->filename
);
26860 /* Lookup FILE_NAME (in the list of filenames that we know about here in
26861 dwarf2out.c) and return its "index". The index of each (known) filename is
26862 just a unique number which is associated with only that one filename. We
26863 need such numbers for the sake of generating labels (in the .debug_sfnames
26864 section) and references to those files numbers (in the .debug_srcinfo
26865 and .debug_macinfo sections). If the filename given as an argument is not
26866 found in our current list, add it to the list and assign it the next
26867 available unique index number. */
26869 static struct dwarf_file_data
*
26870 lookup_filename (const char *file_name
)
26872 struct dwarf_file_data
* created
;
26877 dwarf_file_data
**slot
26878 = file_table
->find_slot_with_hash (file_name
, htab_hash_string (file_name
),
26883 created
= ggc_alloc
<dwarf_file_data
> ();
26884 created
->filename
= file_name
;
26885 created
->emitted_number
= 0;
26890 /* If the assembler will construct the file table, then translate the compiler
26891 internal file table number into the assembler file table number, and emit
26892 a .file directive if we haven't already emitted one yet. The file table
26893 numbers are different because we prune debug info for unused variables and
26894 types, which may include filenames. */
26897 maybe_emit_file (struct dwarf_file_data
* fd
)
26899 if (! fd
->emitted_number
)
26901 if (last_emitted_file
)
26902 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
26904 fd
->emitted_number
= 1;
26905 last_emitted_file
= fd
;
26907 if (output_asm_line_debug_info ())
26909 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
26910 output_quoted_string (asm_out_file
,
26911 remap_debug_filename (fd
->filename
));
26912 fputc ('\n', asm_out_file
);
26916 return fd
->emitted_number
;
26919 /* Schedule generation of a DW_AT_const_value attribute to DIE.
26920 That generation should happen after function debug info has been
26921 generated. The value of the attribute is the constant value of ARG. */
26924 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
26926 die_arg_entry entry
;
26931 gcc_assert (early_dwarf
);
26933 if (!tmpl_value_parm_die_table
)
26934 vec_alloc (tmpl_value_parm_die_table
, 32);
26938 vec_safe_push (tmpl_value_parm_die_table
, entry
);
26941 /* Return TRUE if T is an instance of generic type, FALSE
26945 generic_type_p (tree t
)
26947 if (t
== NULL_TREE
|| !TYPE_P (t
))
26949 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
26952 /* Schedule the generation of the generic parameter dies for the
26953 instance of generic type T. The proper generation itself is later
26954 done by gen_scheduled_generic_parms_dies. */
26957 schedule_generic_params_dies_gen (tree t
)
26959 if (!generic_type_p (t
))
26962 gcc_assert (early_dwarf
);
26964 if (!generic_type_instances
)
26965 vec_alloc (generic_type_instances
, 256);
26967 vec_safe_push (generic_type_instances
, t
);
26970 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
26971 by append_entry_to_tmpl_value_parm_die_table. This function must
26972 be called after function DIEs have been generated. */
26975 gen_remaining_tmpl_value_param_die_attribute (void)
26977 if (tmpl_value_parm_die_table
)
26982 /* We do this in two phases - first get the cases we can
26983 handle during early-finish, preserving those we cannot
26984 (containing symbolic constants where we don't yet know
26985 whether we are going to output the referenced symbols).
26986 For those we try again at late-finish. */
26988 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
26990 if (!e
->die
->removed
26991 && !tree_add_const_value_attribute (e
->die
, e
->arg
))
26993 dw_loc_descr_ref loc
= NULL
;
26995 && (dwarf_version
>= 5 || !dwarf_strict
))
26996 loc
= loc_descriptor_from_tree (e
->arg
, 2, NULL
);
26998 add_AT_loc (e
->die
, DW_AT_location
, loc
);
27000 (*tmpl_value_parm_die_table
)[j
++] = *e
;
27003 tmpl_value_parm_die_table
->truncate (j
);
27007 /* Generate generic parameters DIEs for instances of generic types
27008 that have been previously scheduled by
27009 schedule_generic_params_dies_gen. This function must be called
27010 after all the types of the CU have been laid out. */
27013 gen_scheduled_generic_parms_dies (void)
27018 if (!generic_type_instances
)
27021 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
27022 if (COMPLETE_TYPE_P (t
))
27023 gen_generic_params_dies (t
);
27025 generic_type_instances
= NULL
;
27029 /* Replace DW_AT_name for the decl with name. */
27032 dwarf2out_set_name (tree decl
, tree name
)
27035 dw_attr_node
*attr
;
27038 die
= TYPE_SYMTAB_DIE (decl
);
27042 dname
= dwarf2_name (name
, 0);
27046 attr
= get_AT (die
, DW_AT_name
);
27049 struct indirect_string_node
*node
;
27051 node
= find_AT_string (dname
);
27052 /* replace the string. */
27053 attr
->dw_attr_val
.v
.val_str
= node
;
27057 add_name_attribute (die
, dname
);
27060 /* True if before or during processing of the first function being emitted. */
27061 static bool in_first_function_p
= true;
27062 /* True if loc_note during dwarf2out_var_location call might still be
27063 before first real instruction at address equal to .Ltext0. */
27064 static bool maybe_at_text_label_p
= true;
27065 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
27066 static unsigned int first_loclabel_num_not_at_text_label
;
27068 /* Look ahead for a real insn, or for a begin stmt marker. */
27071 dwarf2out_next_real_insn (rtx_insn
*loc_note
)
27073 rtx_insn
*next_real
= NEXT_INSN (loc_note
);
27076 if (INSN_P (next_real
))
27079 next_real
= NEXT_INSN (next_real
);
27084 /* Called by the final INSN scan whenever we see a var location. We
27085 use it to drop labels in the right places, and throw the location in
27086 our lookup table. */
27089 dwarf2out_var_location (rtx_insn
*loc_note
)
27091 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
27092 struct var_loc_node
*newloc
;
27093 rtx_insn
*next_real
, *next_note
;
27094 rtx_insn
*call_insn
= NULL
;
27095 static const char *last_label
;
27096 static const char *last_postcall_label
;
27097 static bool last_in_cold_section_p
;
27098 static rtx_insn
*expected_next_loc_note
;
27101 var_loc_view view
= 0;
27103 if (!NOTE_P (loc_note
))
27105 if (CALL_P (loc_note
))
27107 maybe_reset_location_view (loc_note
, cur_line_info_table
);
27109 if (SIBLING_CALL_P (loc_note
))
27110 tail_call_site_count
++;
27111 if (find_reg_note (loc_note
, REG_CALL_ARG_LOCATION
, NULL_RTX
))
27113 call_insn
= loc_note
;
27117 next_real
= dwarf2out_next_real_insn (call_insn
);
27119 cached_next_real_insn
= NULL
;
27122 if (optimize
== 0 && !flag_var_tracking
)
27124 /* When the var-tracking pass is not running, there is no note
27125 for indirect calls whose target is compile-time known. In this
27126 case, process such calls specifically so that we generate call
27127 sites for them anyway. */
27128 rtx x
= PATTERN (loc_note
);
27129 if (GET_CODE (x
) == PARALLEL
)
27130 x
= XVECEXP (x
, 0, 0);
27131 if (GET_CODE (x
) == SET
)
27133 if (GET_CODE (x
) == CALL
)
27136 || GET_CODE (XEXP (x
, 0)) != SYMBOL_REF
27137 || !SYMBOL_REF_DECL (XEXP (x
, 0))
27138 || (TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0)))
27141 call_insn
= loc_note
;
27145 next_real
= dwarf2out_next_real_insn (call_insn
);
27147 cached_next_real_insn
= NULL
;
27152 else if (!debug_variable_location_views
)
27153 gcc_unreachable ();
27155 maybe_reset_location_view (loc_note
, cur_line_info_table
);
27160 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
27161 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
27164 /* Optimize processing a large consecutive sequence of location
27165 notes so we don't spend too much time in next_real_insn. If the
27166 next insn is another location note, remember the next_real_insn
27167 calculation for next time. */
27168 next_real
= cached_next_real_insn
;
27171 if (expected_next_loc_note
!= loc_note
)
27175 next_note
= NEXT_INSN (loc_note
);
27177 || next_note
->deleted ()
27178 || ! NOTE_P (next_note
)
27179 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
27180 && NOTE_KIND (next_note
) != NOTE_INSN_BEGIN_STMT
27181 && NOTE_KIND (next_note
) != NOTE_INSN_INLINE_ENTRY
))
27185 next_real
= dwarf2out_next_real_insn (loc_note
);
27189 expected_next_loc_note
= next_note
;
27190 cached_next_real_insn
= next_real
;
27193 cached_next_real_insn
= NULL
;
27195 /* If there are no instructions which would be affected by this note,
27196 don't do anything. */
27198 && next_real
== NULL_RTX
27199 && !NOTE_DURING_CALL_P (loc_note
))
27204 if (next_real
== NULL_RTX
)
27205 next_real
= get_last_insn ();
27207 /* If there were any real insns between note we processed last time
27208 and this note (or if it is the first note), clear
27209 last_{,postcall_}label so that they are not reused this time. */
27210 if (last_var_location_insn
== NULL_RTX
27211 || last_var_location_insn
!= next_real
27212 || last_in_cold_section_p
!= in_cold_section_p
)
27215 last_postcall_label
= NULL
;
27221 = NOTE_DURING_CALL_P (loc_note
) ? last_postcall_label
: last_label
;
27222 view
= cur_line_info_table
->view
;
27223 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
27224 newloc
= add_var_loc_to_decl (decl
, loc_note
, label
, view
);
27225 if (newloc
== NULL
)
27234 /* If there were no real insns between note we processed last time
27235 and this note, use the label we emitted last time. Otherwise
27236 create a new label and emit it. */
27237 if (last_label
== NULL
)
27239 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
27240 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
27242 last_label
= ggc_strdup (loclabel
);
27243 /* See if loclabel might be equal to .Ltext0. If yes,
27244 bump first_loclabel_num_not_at_text_label. */
27245 if (!have_multiple_function_sections
27246 && in_first_function_p
27247 && maybe_at_text_label_p
)
27249 static rtx_insn
*last_start
;
27251 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
27252 if (insn
== last_start
)
27254 else if (!NONDEBUG_INSN_P (insn
))
27258 rtx body
= PATTERN (insn
);
27259 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
27261 /* Inline asm could occupy zero bytes. */
27262 else if (GET_CODE (body
) == ASM_INPUT
27263 || asm_noperands (body
) >= 0)
27265 #ifdef HAVE_ATTR_length /* ??? We don't include insn-attr.h. */
27266 else if (HAVE_ATTR_length
&& get_attr_min_length (insn
) == 0)
27271 /* Assume insn has non-zero length. */
27272 maybe_at_text_label_p
= false;
27276 if (maybe_at_text_label_p
)
27278 last_start
= loc_note
;
27279 first_loclabel_num_not_at_text_label
= loclabel_num
;
27284 gcc_assert ((loc_note
== NULL_RTX
&& call_insn
!= NULL_RTX
)
27285 || (loc_note
!= NULL_RTX
&& call_insn
== NULL_RTX
));
27289 struct call_arg_loc_node
*ca_loc
27290 = ggc_cleared_alloc
<call_arg_loc_node
> ();
27291 rtx_insn
*prev
= call_insn
;
27293 ca_loc
->call_arg_loc_note
27294 = find_reg_note (call_insn
, REG_CALL_ARG_LOCATION
, NULL_RTX
);
27295 ca_loc
->next
= NULL
;
27296 ca_loc
->label
= last_label
;
27299 || (NONJUMP_INSN_P (prev
)
27300 && GET_CODE (PATTERN (prev
)) == SEQUENCE
27301 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
27302 if (!CALL_P (prev
))
27303 prev
= as_a
<rtx_sequence
*> (PATTERN (prev
))->insn (0);
27304 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
27306 /* Look for a SYMBOL_REF in the "prev" instruction. */
27307 rtx x
= get_call_rtx_from (PATTERN (prev
));
27310 /* Try to get the call symbol, if any. */
27311 if (MEM_P (XEXP (x
, 0)))
27313 /* First, look for a memory access to a symbol_ref. */
27314 if (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
27315 && SYMBOL_REF_DECL (XEXP (x
, 0))
27316 && TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0))) == FUNCTION_DECL
)
27317 ca_loc
->symbol_ref
= XEXP (x
, 0);
27318 /* Otherwise, look at a compile-time known user-level function
27322 && TREE_CODE (MEM_EXPR (x
)) == FUNCTION_DECL
)
27323 ca_loc
->symbol_ref
= XEXP (DECL_RTL (MEM_EXPR (x
)), 0);
27326 ca_loc
->block
= insn_scope (prev
);
27327 if (call_arg_locations
)
27328 call_arg_loc_last
->next
= ca_loc
;
27330 call_arg_locations
= ca_loc
;
27331 call_arg_loc_last
= ca_loc
;
27333 else if (loc_note
!= NULL_RTX
&& !NOTE_DURING_CALL_P (loc_note
))
27335 newloc
->label
= last_label
;
27336 newloc
->view
= view
;
27340 if (!last_postcall_label
)
27342 sprintf (loclabel
, "%s-1", last_label
);
27343 last_postcall_label
= ggc_strdup (loclabel
);
27345 newloc
->label
= last_postcall_label
;
27346 /* ??? This view is at last_label, not last_label-1, but we
27347 could only assume view at last_label-1 is zero if we could
27348 assume calls always have length greater than one. This is
27349 probably true in general, though there might be a rare
27350 exception to this rule, e.g. if a call insn is optimized out
27351 by target magic. Then, even the -1 in the label will be
27352 wrong, which might invalidate the range. Anyway, using view,
27353 though technically possibly incorrect, will work as far as
27354 ranges go: since L-1 is in the middle of the call insn,
27355 (L-1).0 and (L-1).V shouldn't make any difference, and having
27356 the loclist entry refer to the .loc entry might be useful, so
27357 leave it like this. */
27358 newloc
->view
= view
;
27361 if (var_loc_p
&& flag_debug_asm
)
27363 const char *name
, *sep
, *patstr
;
27364 if (decl
&& DECL_NAME (decl
))
27365 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
27368 if (NOTE_VAR_LOCATION_LOC (loc_note
))
27371 patstr
= str_pattern_slim (NOTE_VAR_LOCATION_LOC (loc_note
));
27378 fprintf (asm_out_file
, "\t%s DEBUG %s%s%s\n", ASM_COMMENT_START
,
27379 name
, sep
, patstr
);
27382 last_var_location_insn
= next_real
;
27383 last_in_cold_section_p
= in_cold_section_p
;
27386 /* Check whether BLOCK, a lexical block, is nested within OUTER, or is
27387 OUTER itself. If BOTHWAYS, check not only that BLOCK can reach
27388 OUTER through BLOCK_SUPERCONTEXT links, but also that there is a
27389 path from OUTER to BLOCK through BLOCK_SUBBLOCKs and
27390 BLOCK_FRAGMENT_ORIGIN links. */
27392 block_within_block_p (tree block
, tree outer
, bool bothways
)
27394 if (block
== outer
)
27397 /* Quickly check that OUTER is up BLOCK's supercontext chain. */
27398 for (tree context
= BLOCK_SUPERCONTEXT (block
);
27400 context
= BLOCK_SUPERCONTEXT (context
))
27401 if (!context
|| TREE_CODE (context
) != BLOCK
)
27407 /* Now check that each block is actually referenced by its
27409 for (tree context
= BLOCK_SUPERCONTEXT (block
); ;
27410 context
= BLOCK_SUPERCONTEXT (context
))
27412 if (BLOCK_FRAGMENT_ORIGIN (context
))
27414 gcc_assert (!BLOCK_SUBBLOCKS (context
));
27415 context
= BLOCK_FRAGMENT_ORIGIN (context
);
27417 for (tree sub
= BLOCK_SUBBLOCKS (context
);
27419 sub
= BLOCK_CHAIN (sub
))
27422 if (context
== outer
)
27429 /* Called during final while assembling the marker of the entry point
27430 for an inlined function. */
27433 dwarf2out_inline_entry (tree block
)
27435 gcc_assert (debug_inline_points
);
27437 /* If we can't represent it, don't bother. */
27438 if (!(dwarf_version
>= 3 || !dwarf_strict
))
27441 gcc_assert (DECL_P (block_ultimate_origin (block
)));
27443 /* Sanity check the block tree. This would catch a case in which
27444 BLOCK got removed from the tree reachable from the outermost
27445 lexical block, but got retained in markers. It would still link
27446 back to its parents, but some ancestor would be missing a link
27447 down the path to the sub BLOCK. If the block got removed, its
27448 BLOCK_NUMBER will not be a usable value. */
27450 gcc_assert (block_within_block_p (block
,
27451 DECL_INITIAL (current_function_decl
),
27454 gcc_assert (inlined_function_outer_scope_p (block
));
27455 gcc_assert (!BLOCK_DIE (block
));
27457 if (BLOCK_FRAGMENT_ORIGIN (block
))
27458 block
= BLOCK_FRAGMENT_ORIGIN (block
);
27459 /* Can the entry point ever not be at the beginning of an
27460 unfragmented lexical block? */
27461 else if (!(BLOCK_FRAGMENT_CHAIN (block
)
27462 || (cur_line_info_table
27463 && !ZERO_VIEW_P (cur_line_info_table
->view
))))
27466 if (!inline_entry_data_table
)
27467 inline_entry_data_table
27468 = hash_table
<inline_entry_data_hasher
>::create_ggc (10);
27471 inline_entry_data
**iedp
27472 = inline_entry_data_table
->find_slot_with_hash (block
,
27473 htab_hash_pointer (block
),
27476 /* ??? Ideally, we'd record all entry points for the same inlined
27477 function (some may have been duplicated by e.g. unrolling), but
27478 we have no way to represent that ATM. */
27481 inline_entry_data
*ied
= *iedp
= ggc_cleared_alloc
<inline_entry_data
> ();
27482 ied
->block
= block
;
27483 ied
->label_pfx
= BLOCK_INLINE_ENTRY_LABEL
;
27484 ied
->label_num
= BLOCK_NUMBER (block
);
27485 if (cur_line_info_table
)
27486 ied
->view
= cur_line_info_table
->view
;
27488 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27490 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_INLINE_ENTRY_LABEL
,
27491 BLOCK_NUMBER (block
));
27492 ASM_OUTPUT_LABEL (asm_out_file
, label
);
27495 /* Called from finalize_size_functions for size functions so that their body
27496 can be encoded in the debug info to describe the layout of variable-length
27500 dwarf2out_size_function (tree decl
)
27502 function_to_dwarf_procedure (decl
);
27505 /* Note in one location list that text section has changed. */
27508 var_location_switch_text_section_1 (var_loc_list
**slot
, void *)
27510 var_loc_list
*list
= *slot
;
27512 list
->last_before_switch
27513 = list
->last
->next
? list
->last
->next
: list
->last
;
27517 /* Note in all location lists that text section has changed. */
27520 var_location_switch_text_section (void)
27522 if (decl_loc_table
== NULL
)
27525 decl_loc_table
->traverse
<void *, var_location_switch_text_section_1
> (NULL
);
27528 /* Create a new line number table. */
27530 static dw_line_info_table
*
27531 new_line_info_table (void)
27533 dw_line_info_table
*table
;
27535 table
= ggc_cleared_alloc
<dw_line_info_table
> ();
27536 table
->file_num
= 1;
27537 table
->line_num
= 1;
27538 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
27539 FORCE_RESET_NEXT_VIEW (table
->view
);
27540 table
->symviews_since_reset
= 0;
27545 /* Lookup the "current" table into which we emit line info, so
27546 that we don't have to do it for every source line. */
27549 set_cur_line_info_table (section
*sec
)
27551 dw_line_info_table
*table
;
27553 if (sec
== text_section
)
27554 table
= text_section_line_info
;
27555 else if (sec
== cold_text_section
)
27557 table
= cold_text_section_line_info
;
27560 cold_text_section_line_info
= table
= new_line_info_table ();
27561 table
->end_label
= cold_end_label
;
27566 const char *end_label
;
27568 if (crtl
->has_bb_partition
)
27570 if (in_cold_section_p
)
27571 end_label
= crtl
->subsections
.cold_section_end_label
;
27573 end_label
= crtl
->subsections
.hot_section_end_label
;
27577 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27578 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
27579 current_function_funcdef_no
);
27580 end_label
= ggc_strdup (label
);
27583 table
= new_line_info_table ();
27584 table
->end_label
= end_label
;
27586 vec_safe_push (separate_line_info
, table
);
27589 if (output_asm_line_debug_info ())
27590 table
->is_stmt
= (cur_line_info_table
27591 ? cur_line_info_table
->is_stmt
27592 : DWARF_LINE_DEFAULT_IS_STMT_START
);
27593 cur_line_info_table
= table
;
27597 /* We need to reset the locations at the beginning of each
27598 function. We can't do this in the end_function hook, because the
27599 declarations that use the locations won't have been output when
27600 that hook is called. Also compute have_multiple_function_sections here. */
27603 dwarf2out_begin_function (tree fun
)
27605 section
*sec
= function_section (fun
);
27607 if (sec
!= text_section
)
27608 have_multiple_function_sections
= true;
27610 if (crtl
->has_bb_partition
&& !cold_text_section
)
27612 gcc_assert (current_function_decl
== fun
);
27613 cold_text_section
= unlikely_text_section ();
27614 switch_to_section (cold_text_section
);
27615 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
27616 switch_to_section (sec
);
27619 dwarf2out_note_section_used ();
27620 call_site_count
= 0;
27621 tail_call_site_count
= 0;
27623 set_cur_line_info_table (sec
);
27624 FORCE_RESET_NEXT_VIEW (cur_line_info_table
->view
);
27627 /* Helper function of dwarf2out_end_function, called only after emitting
27628 the very first function into assembly. Check if some .debug_loc range
27629 might end with a .LVL* label that could be equal to .Ltext0.
27630 In that case we must force using absolute addresses in .debug_loc ranges,
27631 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
27632 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
27634 Set have_multiple_function_sections to true in that case and
27635 terminate htab traversal. */
27638 find_empty_loc_ranges_at_text_label (var_loc_list
**slot
, int)
27640 var_loc_list
*entry
= *slot
;
27641 struct var_loc_node
*node
;
27643 node
= entry
->first
;
27644 if (node
&& node
->next
&& node
->next
->label
)
27647 const char *label
= node
->next
->label
;
27648 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
27650 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
27652 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
27653 if (strcmp (label
, loclabel
) == 0)
27655 have_multiple_function_sections
= true;
27663 /* Hook called after emitting a function into assembly.
27664 This does something only for the very first function emitted. */
27667 dwarf2out_end_function (unsigned int)
27669 if (in_first_function_p
27670 && !have_multiple_function_sections
27671 && first_loclabel_num_not_at_text_label
27673 decl_loc_table
->traverse
<int, find_empty_loc_ranges_at_text_label
> (0);
27674 in_first_function_p
= false;
27675 maybe_at_text_label_p
= false;
27678 /* Temporary holder for dwarf2out_register_main_translation_unit. Used to let
27679 front-ends register a translation unit even before dwarf2out_init is
27681 static tree main_translation_unit
= NULL_TREE
;
27683 /* Hook called by front-ends after they built their main translation unit.
27684 Associate comp_unit_die to UNIT. */
27687 dwarf2out_register_main_translation_unit (tree unit
)
27689 gcc_assert (TREE_CODE (unit
) == TRANSLATION_UNIT_DECL
27690 && main_translation_unit
== NULL_TREE
);
27691 main_translation_unit
= unit
;
27692 /* If dwarf2out_init has not been called yet, it will perform the association
27693 itself looking at main_translation_unit. */
27694 if (decl_die_table
!= NULL
)
27695 equate_decl_number_to_die (unit
, comp_unit_die ());
27698 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
27701 push_dw_line_info_entry (dw_line_info_table
*table
,
27702 enum dw_line_info_opcode opcode
, unsigned int val
)
27704 dw_line_info_entry e
;
27707 vec_safe_push (table
->entries
, e
);
27710 /* Output a label to mark the beginning of a source code line entry
27711 and record information relating to this source line, in
27712 'line_info_table' for later output of the .debug_line section. */
27713 /* ??? The discriminator parameter ought to be unsigned. */
27716 dwarf2out_source_line (unsigned int line
, unsigned int column
,
27717 const char *filename
,
27718 int discriminator
, bool is_stmt
)
27720 unsigned int file_num
;
27721 dw_line_info_table
*table
;
27722 static var_loc_view lvugid
;
27724 if (debug_info_level
< DINFO_LEVEL_TERSE
)
27727 table
= cur_line_info_table
;
27731 if (debug_variable_location_views
27732 && output_asm_line_debug_info ()
27733 && table
&& !RESETTING_VIEW_P (table
->view
))
27735 /* If we're using the assembler to compute view numbers, we
27736 can't issue a .loc directive for line zero, so we can't
27737 get a view number at this point. We might attempt to
27738 compute it from the previous view, or equate it to a
27739 subsequent view (though it might not be there!), but
27740 since we're omitting the line number entry, we might as
27741 well omit the view number as well. That means pretending
27742 it's a view number zero, which might very well turn out
27743 to be correct. ??? Extend the assembler so that the
27744 compiler could emit e.g. ".locview .LVU#", to output a
27745 view without changing line number information. We'd then
27746 have to count it in symviews_since_reset; when it's omitted,
27747 it doesn't count. */
27749 zero_view_p
= BITMAP_GGC_ALLOC ();
27750 bitmap_set_bit (zero_view_p
, table
->view
);
27751 if (flag_debug_asm
)
27753 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27754 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", table
->view
);
27755 fprintf (asm_out_file
, "\t%s line 0, omitted view ",
27756 ASM_COMMENT_START
);
27757 assemble_name (asm_out_file
, label
);
27758 putc ('\n', asm_out_file
);
27760 table
->view
= ++lvugid
;
27765 /* The discriminator column was added in dwarf4. Simplify the below
27766 by simply removing it if we're not supposed to output it. */
27767 if (dwarf_version
< 4 && dwarf_strict
)
27770 if (!debug_column_info
)
27773 file_num
= maybe_emit_file (lookup_filename (filename
));
27775 /* ??? TODO: Elide duplicate line number entries. Traditionally,
27776 the debugger has used the second (possibly duplicate) line number
27777 at the beginning of the function to mark the end of the prologue.
27778 We could eliminate any other duplicates within the function. For
27779 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
27780 that second line number entry. */
27781 /* Recall that this end-of-prologue indication is *not* the same thing
27782 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
27783 to which the hook corresponds, follows the last insn that was
27784 emitted by gen_prologue. What we need is to precede the first insn
27785 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
27786 insn that corresponds to something the user wrote. These may be
27787 very different locations once scheduling is enabled. */
27789 if (0 && file_num
== table
->file_num
27790 && line
== table
->line_num
27791 && column
== table
->column_num
27792 && discriminator
== table
->discrim_num
27793 && is_stmt
== table
->is_stmt
)
27796 switch_to_section (current_function_section ());
27798 /* If requested, emit something human-readable. */
27799 if (flag_debug_asm
)
27801 if (debug_column_info
)
27802 fprintf (asm_out_file
, "\t%s %s:%d:%d\n", ASM_COMMENT_START
,
27803 filename
, line
, column
);
27805 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
27809 if (output_asm_line_debug_info ())
27811 /* Emit the .loc directive understood by GNU as. */
27812 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
27813 file_num, line, is_stmt, discriminator */
27814 fputs ("\t.loc ", asm_out_file
);
27815 fprint_ul (asm_out_file
, file_num
);
27816 putc (' ', asm_out_file
);
27817 fprint_ul (asm_out_file
, line
);
27818 putc (' ', asm_out_file
);
27819 fprint_ul (asm_out_file
, column
);
27821 if (is_stmt
!= table
->is_stmt
)
27823 fputs (" is_stmt ", asm_out_file
);
27824 putc (is_stmt
? '1' : '0', asm_out_file
);
27826 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
27828 gcc_assert (discriminator
> 0);
27829 fputs (" discriminator ", asm_out_file
);
27830 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
27832 if (debug_variable_location_views
)
27834 if (!RESETTING_VIEW_P (table
->view
))
27836 table
->symviews_since_reset
++;
27837 if (table
->symviews_since_reset
> symview_upper_bound
)
27838 symview_upper_bound
= table
->symviews_since_reset
;
27839 /* When we're using the assembler to compute view
27840 numbers, we output symbolic labels after "view" in
27841 .loc directives, and the assembler will set them for
27842 us, so that we can refer to the view numbers in
27843 location lists. The only exceptions are when we know
27844 a view will be zero: "-0" is a forced reset, used
27845 e.g. in the beginning of functions, whereas "0" tells
27846 the assembler to check that there was a PC change
27847 since the previous view, in a way that implicitly
27848 resets the next view. */
27849 fputs (" view ", asm_out_file
);
27850 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27851 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", table
->view
);
27852 assemble_name (asm_out_file
, label
);
27853 table
->view
= ++lvugid
;
27857 table
->symviews_since_reset
= 0;
27858 if (FORCE_RESETTING_VIEW_P (table
->view
))
27859 fputs (" view -0", asm_out_file
);
27861 fputs (" view 0", asm_out_file
);
27862 /* Mark the present view as a zero view. Earlier debug
27863 binds may have already added its id to loclists to be
27864 emitted later, so we can't reuse the id for something
27865 else. However, it's good to know whether a view is
27866 known to be zero, because then we may be able to
27867 optimize out locviews that are all zeros, so take
27868 note of it in zero_view_p. */
27870 zero_view_p
= BITMAP_GGC_ALLOC ();
27871 bitmap_set_bit (zero_view_p
, lvugid
);
27872 table
->view
= ++lvugid
;
27875 putc ('\n', asm_out_file
);
27879 unsigned int label_num
= ++line_info_label_num
;
27881 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
27883 if (debug_variable_location_views
&& !RESETTING_VIEW_P (table
->view
))
27884 push_dw_line_info_entry (table
, LI_adv_address
, label_num
);
27886 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
27887 if (debug_variable_location_views
)
27889 bool resetting
= FORCE_RESETTING_VIEW_P (table
->view
);
27893 if (flag_debug_asm
)
27894 fprintf (asm_out_file
, "\t%s view %s%d\n",
27896 resetting
? "-" : "",
27901 if (file_num
!= table
->file_num
)
27902 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
27903 if (discriminator
!= table
->discrim_num
)
27904 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
27905 if (is_stmt
!= table
->is_stmt
)
27906 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
27907 push_dw_line_info_entry (table
, LI_set_line
, line
);
27908 if (debug_column_info
)
27909 push_dw_line_info_entry (table
, LI_set_column
, column
);
27912 table
->file_num
= file_num
;
27913 table
->line_num
= line
;
27914 table
->column_num
= column
;
27915 table
->discrim_num
= discriminator
;
27916 table
->is_stmt
= is_stmt
;
27917 table
->in_use
= true;
27920 /* Record the beginning of a new source file. */
27923 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
27925 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
27928 e
.code
= DW_MACINFO_start_file
;
27930 e
.info
= ggc_strdup (filename
);
27931 vec_safe_push (macinfo_table
, e
);
27935 /* Record the end of a source file. */
27938 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
27940 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
27943 e
.code
= DW_MACINFO_end_file
;
27946 vec_safe_push (macinfo_table
, e
);
27950 /* Called from debug_define in toplev.c. The `buffer' parameter contains
27951 the tail part of the directive line, i.e. the part which is past the
27952 initial whitespace, #, whitespace, directive-name, whitespace part. */
27955 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
27956 const char *buffer ATTRIBUTE_UNUSED
)
27958 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
27961 /* Insert a dummy first entry to be able to optimize the whole
27962 predefined macro block using DW_MACRO_import. */
27963 if (macinfo_table
->is_empty () && lineno
<= 1)
27968 vec_safe_push (macinfo_table
, e
);
27970 e
.code
= DW_MACINFO_define
;
27972 e
.info
= ggc_strdup (buffer
);
27973 vec_safe_push (macinfo_table
, e
);
27977 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
27978 the tail part of the directive line, i.e. the part which is past the
27979 initial whitespace, #, whitespace, directive-name, whitespace part. */
27982 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
27983 const char *buffer ATTRIBUTE_UNUSED
)
27985 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
27988 /* Insert a dummy first entry to be able to optimize the whole
27989 predefined macro block using DW_MACRO_import. */
27990 if (macinfo_table
->is_empty () && lineno
<= 1)
27995 vec_safe_push (macinfo_table
, e
);
27997 e
.code
= DW_MACINFO_undef
;
27999 e
.info
= ggc_strdup (buffer
);
28000 vec_safe_push (macinfo_table
, e
);
28004 /* Helpers to manipulate hash table of CUs. */
28006 struct macinfo_entry_hasher
: nofree_ptr_hash
<macinfo_entry
>
28008 static inline hashval_t
hash (const macinfo_entry
*);
28009 static inline bool equal (const macinfo_entry
*, const macinfo_entry
*);
28013 macinfo_entry_hasher::hash (const macinfo_entry
*entry
)
28015 return htab_hash_string (entry
->info
);
28019 macinfo_entry_hasher::equal (const macinfo_entry
*entry1
,
28020 const macinfo_entry
*entry2
)
28022 return !strcmp (entry1
->info
, entry2
->info
);
28025 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
28027 /* Output a single .debug_macinfo entry. */
28030 output_macinfo_op (macinfo_entry
*ref
)
28034 struct indirect_string_node
*node
;
28035 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28036 struct dwarf_file_data
*fd
;
28040 case DW_MACINFO_start_file
:
28041 fd
= lookup_filename (ref
->info
);
28042 file_num
= maybe_emit_file (fd
);
28043 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
28044 dw2_asm_output_data_uleb128 (ref
->lineno
,
28045 "Included from line number %lu",
28046 (unsigned long) ref
->lineno
);
28047 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
28049 case DW_MACINFO_end_file
:
28050 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
28052 case DW_MACINFO_define
:
28053 case DW_MACINFO_undef
:
28054 len
= strlen (ref
->info
) + 1;
28056 && len
> DWARF_OFFSET_SIZE
28057 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
28058 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
28060 ref
->code
= ref
->code
== DW_MACINFO_define
28061 ? DW_MACRO_define_strp
: DW_MACRO_undef_strp
;
28062 output_macinfo_op (ref
);
28065 dw2_asm_output_data (1, ref
->code
,
28066 ref
->code
== DW_MACINFO_define
28067 ? "Define macro" : "Undefine macro");
28068 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
28069 (unsigned long) ref
->lineno
);
28070 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
28072 case DW_MACRO_define_strp
:
28073 case DW_MACRO_undef_strp
:
28074 node
= find_AT_string (ref
->info
);
28076 && (node
->form
== DW_FORM_strp
28077 || node
->form
== dwarf_FORM (DW_FORM_strx
)));
28078 dw2_asm_output_data (1, ref
->code
,
28079 ref
->code
== DW_MACRO_define_strp
28080 ? "Define macro strp"
28081 : "Undefine macro strp");
28082 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
28083 (unsigned long) ref
->lineno
);
28084 if (node
->form
== DW_FORM_strp
)
28085 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
28086 debug_str_section
, "The macro: \"%s\"",
28089 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
28092 case DW_MACRO_import
:
28093 dw2_asm_output_data (1, ref
->code
, "Import");
28094 ASM_GENERATE_INTERNAL_LABEL (label
,
28095 DEBUG_MACRO_SECTION_LABEL
,
28096 ref
->lineno
+ macinfo_label_base
);
28097 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
28100 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
28101 ASM_COMMENT_START
, (unsigned long) ref
->code
);
28106 /* Attempt to make a sequence of define/undef macinfo ops shareable with
28107 other compilation unit .debug_macinfo sections. IDX is the first
28108 index of a define/undef, return the number of ops that should be
28109 emitted in a comdat .debug_macinfo section and emit
28110 a DW_MACRO_import entry referencing it.
28111 If the define/undef entry should be emitted normally, return 0. */
28114 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
28115 macinfo_hash_type
**macinfo_htab
)
28117 macinfo_entry
*first
, *second
, *cur
, *inc
;
28118 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
28119 unsigned char checksum
[16];
28120 struct md5_ctx ctx
;
28121 char *grp_name
, *tail
;
28123 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
28124 macinfo_entry
**slot
;
28126 first
= &(*macinfo_table
)[idx
];
28127 second
= &(*macinfo_table
)[idx
+ 1];
28129 /* Optimize only if there are at least two consecutive define/undef ops,
28130 and either all of them are before first DW_MACINFO_start_file
28131 with lineno {0,1} (i.e. predefined macro block), or all of them are
28132 in some included header file. */
28133 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
28135 if (vec_safe_is_empty (files
))
28137 if (first
->lineno
> 1 || second
->lineno
> 1)
28140 else if (first
->lineno
== 0)
28143 /* Find the last define/undef entry that can be grouped together
28144 with first and at the same time compute md5 checksum of their
28145 codes, linenumbers and strings. */
28146 md5_init_ctx (&ctx
);
28147 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
28148 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
28150 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
28154 unsigned char code
= cur
->code
;
28155 md5_process_bytes (&code
, 1, &ctx
);
28156 checksum_uleb128 (cur
->lineno
, &ctx
);
28157 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
28159 md5_finish_ctx (&ctx
, checksum
);
28162 /* From the containing include filename (if any) pick up just
28163 usable characters from its basename. */
28164 if (vec_safe_is_empty (files
))
28167 base
= lbasename (files
->last ().info
);
28168 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
28169 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
28170 encoded_filename_len
++;
28171 /* Count . at the end. */
28172 if (encoded_filename_len
)
28173 encoded_filename_len
++;
28175 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
28176 linebuf_len
= strlen (linebuf
);
28178 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
28179 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
28181 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
28182 tail
= grp_name
+ 4;
28183 if (encoded_filename_len
)
28185 for (i
= 0; base
[i
]; i
++)
28186 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
28190 memcpy (tail
, linebuf
, linebuf_len
);
28191 tail
+= linebuf_len
;
28193 for (i
= 0; i
< 16; i
++)
28194 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
28196 /* Construct a macinfo_entry for DW_MACRO_import
28197 in the empty vector entry before the first define/undef. */
28198 inc
= &(*macinfo_table
)[idx
- 1];
28199 inc
->code
= DW_MACRO_import
;
28201 inc
->info
= ggc_strdup (grp_name
);
28202 if (!*macinfo_htab
)
28203 *macinfo_htab
= new macinfo_hash_type (10);
28204 /* Avoid emitting duplicates. */
28205 slot
= (*macinfo_htab
)->find_slot (inc
, INSERT
);
28210 /* If such an entry has been used before, just emit
28211 a DW_MACRO_import op. */
28213 output_macinfo_op (inc
);
28214 /* And clear all macinfo_entry in the range to avoid emitting them
28215 in the second pass. */
28216 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
28225 inc
->lineno
= (*macinfo_htab
)->elements ();
28226 output_macinfo_op (inc
);
28231 /* Save any strings needed by the macinfo table in the debug str
28232 table. All strings must be collected into the table by the time
28233 index_string is called. */
28236 save_macinfo_strings (void)
28240 macinfo_entry
*ref
;
28242 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
28246 /* Match the logic in output_macinfo_op to decide on
28247 indirect strings. */
28248 case DW_MACINFO_define
:
28249 case DW_MACINFO_undef
:
28250 len
= strlen (ref
->info
) + 1;
28252 && len
> DWARF_OFFSET_SIZE
28253 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
28254 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
28255 set_indirect_string (find_AT_string (ref
->info
));
28257 case DW_MACRO_define_strp
:
28258 case DW_MACRO_undef_strp
:
28259 set_indirect_string (find_AT_string (ref
->info
));
28267 /* Output macinfo section(s). */
28270 output_macinfo (const char *debug_line_label
, bool early_lto_debug
)
28273 unsigned long length
= vec_safe_length (macinfo_table
);
28274 macinfo_entry
*ref
;
28275 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
28276 macinfo_hash_type
*macinfo_htab
= NULL
;
28277 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
28282 /* output_macinfo* uses these interchangeably. */
28283 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_define
28284 && (int) DW_MACINFO_undef
== (int) DW_MACRO_undef
28285 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_start_file
28286 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_end_file
);
28288 /* AIX Assembler inserts the length, so adjust the reference to match the
28289 offset expected by debuggers. */
28290 strcpy (dl_section_ref
, debug_line_label
);
28291 if (XCOFF_DEBUGGING_INFO
)
28292 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
28294 /* For .debug_macro emit the section header. */
28295 if (!dwarf_strict
|| dwarf_version
>= 5)
28297 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
28298 "DWARF macro version number");
28299 if (DWARF_OFFSET_SIZE
== 8)
28300 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
28302 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
28303 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_line_label
,
28304 debug_line_section
, NULL
);
28307 /* In the first loop, it emits the primary .debug_macinfo section
28308 and after each emitted op the macinfo_entry is cleared.
28309 If a longer range of define/undef ops can be optimized using
28310 DW_MACRO_import, the DW_MACRO_import op is emitted and kept in
28311 the vector before the first define/undef in the range and the
28312 whole range of define/undef ops is not emitted and kept. */
28313 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
28317 case DW_MACINFO_start_file
:
28318 vec_safe_push (files
, *ref
);
28320 case DW_MACINFO_end_file
:
28321 if (!vec_safe_is_empty (files
))
28324 case DW_MACINFO_define
:
28325 case DW_MACINFO_undef
:
28326 if ((!dwarf_strict
|| dwarf_version
>= 5)
28327 && HAVE_COMDAT_GROUP
28328 && vec_safe_length (files
) != 1
28331 && (*macinfo_table
)[i
- 1].code
== 0)
28333 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
28342 /* A dummy entry may be inserted at the beginning to be able
28343 to optimize the whole block of predefined macros. */
28349 output_macinfo_op (ref
);
28357 /* Save the number of transparent includes so we can adjust the
28358 label number for the fat LTO object DWARF. */
28359 unsigned macinfo_label_base_adj
= macinfo_htab
->elements ();
28361 delete macinfo_htab
;
28362 macinfo_htab
= NULL
;
28364 /* If any DW_MACRO_import were used, on those DW_MACRO_import entries
28365 terminate the current chain and switch to a new comdat .debug_macinfo
28366 section and emit the define/undef entries within it. */
28367 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
28372 case DW_MACRO_import
:
28374 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28375 tree comdat_key
= get_identifier (ref
->info
);
28376 /* Terminate the previous .debug_macinfo section. */
28377 dw2_asm_output_data (1, 0, "End compilation unit");
28378 targetm
.asm_out
.named_section (debug_macinfo_section_name
,
28382 ? SECTION_EXCLUDE
: 0),
28384 ASM_GENERATE_INTERNAL_LABEL (label
,
28385 DEBUG_MACRO_SECTION_LABEL
,
28386 ref
->lineno
+ macinfo_label_base
);
28387 ASM_OUTPUT_LABEL (asm_out_file
, label
);
28390 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
28391 "DWARF macro version number");
28392 if (DWARF_OFFSET_SIZE
== 8)
28393 dw2_asm_output_data (1, 1, "Flags: 64-bit");
28395 dw2_asm_output_data (1, 0, "Flags: 32-bit");
28398 case DW_MACINFO_define
:
28399 case DW_MACINFO_undef
:
28400 output_macinfo_op (ref
);
28405 gcc_unreachable ();
28408 macinfo_label_base
+= macinfo_label_base_adj
;
28411 /* Initialize the various sections and labels for dwarf output and prefix
28412 them with PREFIX if non-NULL. Returns the generation (zero based
28413 number of times function was called). */
28416 init_sections_and_labels (bool early_lto_debug
)
28418 /* As we may get called multiple times have a generation count for
28420 static unsigned generation
= 0;
28422 if (early_lto_debug
)
28424 if (!dwarf_split_debug_info
)
28426 debug_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
28427 SECTION_DEBUG
| SECTION_EXCLUDE
,
28429 debug_abbrev_section
= get_section (DEBUG_LTO_ABBREV_SECTION
,
28430 SECTION_DEBUG
| SECTION_EXCLUDE
,
28432 debug_macinfo_section_name
28433 = ((dwarf_strict
&& dwarf_version
< 5)
28434 ? DEBUG_LTO_MACINFO_SECTION
: DEBUG_LTO_MACRO_SECTION
);
28435 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28437 | SECTION_EXCLUDE
, NULL
);
28441 /* ??? Which of the following do we need early? */
28442 debug_info_section
= get_section (DEBUG_LTO_DWO_INFO_SECTION
,
28443 SECTION_DEBUG
| SECTION_EXCLUDE
,
28445 debug_abbrev_section
= get_section (DEBUG_LTO_DWO_ABBREV_SECTION
,
28446 SECTION_DEBUG
| SECTION_EXCLUDE
,
28448 debug_skeleton_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
28450 | SECTION_EXCLUDE
, NULL
);
28451 debug_skeleton_abbrev_section
28452 = get_section (DEBUG_LTO_ABBREV_SECTION
,
28453 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28454 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
28455 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
28458 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
28459 stay in the main .o, but the skeleton_line goes into the split
28461 debug_skeleton_line_section
28462 = get_section (DEBUG_LTO_LINE_SECTION
,
28463 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28464 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
28465 DEBUG_SKELETON_LINE_SECTION_LABEL
,
28467 debug_str_offsets_section
28468 = get_section (DEBUG_LTO_DWO_STR_OFFSETS_SECTION
,
28469 SECTION_DEBUG
| SECTION_EXCLUDE
,
28471 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
28472 DEBUG_SKELETON_INFO_SECTION_LABEL
,
28474 debug_str_dwo_section
= get_section (DEBUG_LTO_STR_DWO_SECTION
,
28475 DEBUG_STR_DWO_SECTION_FLAGS
,
28477 debug_macinfo_section_name
28478 = ((dwarf_strict
&& dwarf_version
< 5)
28479 ? DEBUG_LTO_DWO_MACINFO_SECTION
: DEBUG_LTO_DWO_MACRO_SECTION
);
28480 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28481 SECTION_DEBUG
| SECTION_EXCLUDE
,
28484 /* For macro info and the file table we have to refer to a
28485 debug_line section. */
28486 debug_line_section
= get_section (DEBUG_LTO_LINE_SECTION
,
28487 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28488 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
28489 DEBUG_LINE_SECTION_LABEL
, generation
);
28491 debug_str_section
= get_section (DEBUG_LTO_STR_SECTION
,
28492 DEBUG_STR_SECTION_FLAGS
28493 | SECTION_EXCLUDE
, NULL
);
28494 if (!dwarf_split_debug_info
)
28495 debug_line_str_section
28496 = get_section (DEBUG_LTO_LINE_STR_SECTION
,
28497 DEBUG_STR_SECTION_FLAGS
| SECTION_EXCLUDE
, NULL
);
28501 if (!dwarf_split_debug_info
)
28503 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
28504 SECTION_DEBUG
, NULL
);
28505 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
28506 SECTION_DEBUG
, NULL
);
28507 debug_loc_section
= get_section (dwarf_version
>= 5
28508 ? DEBUG_LOCLISTS_SECTION
28509 : DEBUG_LOC_SECTION
,
28510 SECTION_DEBUG
, NULL
);
28511 debug_macinfo_section_name
28512 = ((dwarf_strict
&& dwarf_version
< 5)
28513 ? DEBUG_MACINFO_SECTION
: DEBUG_MACRO_SECTION
);
28514 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28515 SECTION_DEBUG
, NULL
);
28519 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
28520 SECTION_DEBUG
| SECTION_EXCLUDE
,
28522 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
28523 SECTION_DEBUG
| SECTION_EXCLUDE
,
28525 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
28526 SECTION_DEBUG
, NULL
);
28527 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
28528 SECTION_DEBUG
, NULL
);
28529 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
28530 SECTION_DEBUG
, NULL
);
28531 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
28532 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
28535 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
28536 stay in the main .o, but the skeleton_line goes into the
28538 debug_skeleton_line_section
28539 = get_section (DEBUG_DWO_LINE_SECTION
,
28540 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28541 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
28542 DEBUG_SKELETON_LINE_SECTION_LABEL
,
28544 debug_str_offsets_section
28545 = get_section (DEBUG_DWO_STR_OFFSETS_SECTION
,
28546 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28547 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
28548 DEBUG_SKELETON_INFO_SECTION_LABEL
,
28550 debug_loc_section
= get_section (dwarf_version
>= 5
28551 ? DEBUG_DWO_LOCLISTS_SECTION
28552 : DEBUG_DWO_LOC_SECTION
,
28553 SECTION_DEBUG
| SECTION_EXCLUDE
,
28555 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
28556 DEBUG_STR_DWO_SECTION_FLAGS
,
28558 debug_macinfo_section_name
28559 = ((dwarf_strict
&& dwarf_version
< 5)
28560 ? DEBUG_DWO_MACINFO_SECTION
: DEBUG_DWO_MACRO_SECTION
);
28561 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28562 SECTION_DEBUG
| SECTION_EXCLUDE
,
28565 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
28566 SECTION_DEBUG
, NULL
);
28567 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
28568 SECTION_DEBUG
, NULL
);
28569 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
28570 SECTION_DEBUG
, NULL
);
28571 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
28572 SECTION_DEBUG
, NULL
);
28573 debug_str_section
= get_section (DEBUG_STR_SECTION
,
28574 DEBUG_STR_SECTION_FLAGS
, NULL
);
28575 if (!dwarf_split_debug_info
&& !output_asm_line_debug_info ())
28576 debug_line_str_section
= get_section (DEBUG_LINE_STR_SECTION
,
28577 DEBUG_STR_SECTION_FLAGS
, NULL
);
28579 debug_ranges_section
= get_section (dwarf_version
>= 5
28580 ? DEBUG_RNGLISTS_SECTION
28581 : DEBUG_RANGES_SECTION
,
28582 SECTION_DEBUG
, NULL
);
28583 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
28584 SECTION_DEBUG
, NULL
);
28587 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
28588 DEBUG_ABBREV_SECTION_LABEL
, generation
);
28589 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
28590 DEBUG_INFO_SECTION_LABEL
, generation
);
28591 info_section_emitted
= false;
28592 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
28593 DEBUG_LINE_SECTION_LABEL
, generation
);
28594 /* There are up to 4 unique ranges labels per generation.
28595 See also output_rnglists. */
28596 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
28597 DEBUG_RANGES_SECTION_LABEL
, generation
* 4);
28598 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
28599 ASM_GENERATE_INTERNAL_LABEL (ranges_base_label
,
28600 DEBUG_RANGES_SECTION_LABEL
,
28601 1 + generation
* 4);
28602 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
28603 DEBUG_ADDR_SECTION_LABEL
, generation
);
28604 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
28605 (dwarf_strict
&& dwarf_version
< 5)
28606 ? DEBUG_MACINFO_SECTION_LABEL
28607 : DEBUG_MACRO_SECTION_LABEL
, generation
);
28608 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
,
28612 return generation
- 1;
28615 /* Set up for Dwarf output at the start of compilation. */
28618 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
28620 /* Allocate the file_table. */
28621 file_table
= hash_table
<dwarf_file_hasher
>::create_ggc (50);
28623 #ifndef DWARF2_LINENO_DEBUGGING_INFO
28624 /* Allocate the decl_die_table. */
28625 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (10);
28627 /* Allocate the decl_loc_table. */
28628 decl_loc_table
= hash_table
<decl_loc_hasher
>::create_ggc (10);
28630 /* Allocate the cached_dw_loc_list_table. */
28631 cached_dw_loc_list_table
= hash_table
<dw_loc_list_hasher
>::create_ggc (10);
28633 /* Allocate the initial hunk of the abbrev_die_table. */
28634 vec_alloc (abbrev_die_table
, 256);
28635 /* Zero-th entry is allocated, but unused. */
28636 abbrev_die_table
->quick_push (NULL
);
28638 /* Allocate the dwarf_proc_stack_usage_map. */
28639 dwarf_proc_stack_usage_map
= new hash_map
<dw_die_ref
, int>;
28641 /* Allocate the pubtypes and pubnames vectors. */
28642 vec_alloc (pubname_table
, 32);
28643 vec_alloc (pubtype_table
, 32);
28645 vec_alloc (incomplete_types
, 64);
28647 vec_alloc (used_rtx_array
, 32);
28649 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28650 vec_alloc (macinfo_table
, 64);
28653 /* If front-ends already registered a main translation unit but we were not
28654 ready to perform the association, do this now. */
28655 if (main_translation_unit
!= NULL_TREE
)
28656 equate_decl_number_to_die (main_translation_unit
, comp_unit_die ());
28659 /* Called before compile () starts outputtting functions, variables
28660 and toplevel asms into assembly. */
28663 dwarf2out_assembly_start (void)
28665 if (text_section_line_info
)
28668 #ifndef DWARF2_LINENO_DEBUGGING_INFO
28669 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
28670 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
28671 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
28672 COLD_TEXT_SECTION_LABEL
, 0);
28673 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
28675 switch_to_section (text_section
);
28676 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
28679 /* Make sure the line number table for .text always exists. */
28680 text_section_line_info
= new_line_info_table ();
28681 text_section_line_info
->end_label
= text_end_label
;
28683 #ifdef DWARF2_LINENO_DEBUGGING_INFO
28684 cur_line_info_table
= text_section_line_info
;
28687 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
28688 && dwarf2out_do_cfi_asm ()
28689 && !dwarf2out_do_eh_frame ())
28690 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
28693 /* A helper function for dwarf2out_finish called through
28694 htab_traverse. Assign a string its index. All strings must be
28695 collected into the table by the time index_string is called,
28696 because the indexing code relies on htab_traverse to traverse nodes
28697 in the same order for each run. */
28700 index_string (indirect_string_node
**h
, unsigned int *index
)
28702 indirect_string_node
*node
= *h
;
28704 find_string_form (node
);
28705 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28707 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
28708 node
->index
= *index
;
28714 /* A helper function for output_indirect_strings called through
28715 htab_traverse. Output the offset to a string and update the
28719 output_index_string_offset (indirect_string_node
**h
, unsigned int *offset
)
28721 indirect_string_node
*node
= *h
;
28723 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28725 /* Assert that this node has been assigned an index. */
28726 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
28727 && node
->index
!= NOT_INDEXED
);
28728 dw2_asm_output_data (DWARF_OFFSET_SIZE
, *offset
,
28729 "indexed string 0x%x: %s", node
->index
, node
->str
);
28730 *offset
+= strlen (node
->str
) + 1;
28735 /* A helper function for dwarf2out_finish called through
28736 htab_traverse. Output the indexed string. */
28739 output_index_string (indirect_string_node
**h
, unsigned int *cur_idx
)
28741 struct indirect_string_node
*node
= *h
;
28743 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28745 /* Assert that the strings are output in the same order as their
28746 indexes were assigned. */
28747 gcc_assert (*cur_idx
== node
->index
);
28748 assemble_string (node
->str
, strlen (node
->str
) + 1);
28754 /* A helper function for output_indirect_strings. Counts the number
28755 of index strings offsets. Must match the logic of the functions
28756 output_index_string[_offsets] above. */
28758 count_index_strings (indirect_string_node
**h
, unsigned int *last_idx
)
28760 struct indirect_string_node
*node
= *h
;
28762 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28767 /* A helper function for dwarf2out_finish called through
28768 htab_traverse. Emit one queued .debug_str string. */
28771 output_indirect_string (indirect_string_node
**h
, enum dwarf_form form
)
28773 struct indirect_string_node
*node
= *h
;
28775 node
->form
= find_string_form (node
);
28776 if (node
->form
== form
&& node
->refcount
> 0)
28778 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
28779 assemble_string (node
->str
, strlen (node
->str
) + 1);
28785 /* Output the indexed string table. */
28788 output_indirect_strings (void)
28790 switch_to_section (debug_str_section
);
28791 if (!dwarf_split_debug_info
)
28792 debug_str_hash
->traverse
<enum dwarf_form
,
28793 output_indirect_string
> (DW_FORM_strp
);
28796 unsigned int offset
= 0;
28797 unsigned int cur_idx
= 0;
28799 if (skeleton_debug_str_hash
)
28800 skeleton_debug_str_hash
->traverse
<enum dwarf_form
,
28801 output_indirect_string
> (DW_FORM_strp
);
28803 switch_to_section (debug_str_offsets_section
);
28804 /* For DWARF5 the .debug_str_offsets[.dwo] section needs a unit
28805 header. Note that we don't need to generate a label to the
28806 actual index table following the header here, because this is
28807 for the split dwarf case only. In an .dwo file there is only
28808 one string offsets table (and one debug info section). But
28809 if we would start using string offset tables for the main (or
28810 skeleton) unit, then we have to add a DW_AT_str_offsets_base
28811 pointing to the actual index after the header. Split dwarf
28812 units will never have a string offsets base attribute. When
28813 a split unit is moved into a .dwp file the string offsets can
28814 be found through the .debug_cu_index section table. */
28815 if (dwarf_version
>= 5)
28817 unsigned int last_idx
= 0;
28818 unsigned long str_offsets_length
;
28820 debug_str_hash
->traverse_noresize
28821 <unsigned int *, count_index_strings
> (&last_idx
);
28822 str_offsets_length
= last_idx
* DWARF_OFFSET_SIZE
+ 4;
28823 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
28824 dw2_asm_output_data (4, 0xffffffff,
28825 "Escape value for 64-bit DWARF extension");
28826 dw2_asm_output_data (DWARF_OFFSET_SIZE
, str_offsets_length
,
28827 "Length of string offsets unit");
28828 dw2_asm_output_data (2, 5, "DWARF string offsets version");
28829 dw2_asm_output_data (2, 0, "Header zero padding");
28831 debug_str_hash
->traverse_noresize
28832 <unsigned int *, output_index_string_offset
> (&offset
);
28833 switch_to_section (debug_str_dwo_section
);
28834 debug_str_hash
->traverse_noresize
<unsigned int *, output_index_string
>
28839 /* Callback for htab_traverse to assign an index to an entry in the
28840 table, and to write that entry to the .debug_addr section. */
28843 output_addr_table_entry (addr_table_entry
**slot
, unsigned int *cur_index
)
28845 addr_table_entry
*entry
= *slot
;
28847 if (entry
->refcount
== 0)
28849 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
28850 || entry
->index
== NOT_INDEXED
);
28854 gcc_assert (entry
->index
== *cur_index
);
28857 switch (entry
->kind
)
28860 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
28861 "0x%x", entry
->index
);
28863 case ate_kind_rtx_dtprel
:
28864 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
28865 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
28868 fputc ('\n', asm_out_file
);
28870 case ate_kind_label
:
28871 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
28872 "0x%x", entry
->index
);
28875 gcc_unreachable ();
28880 /* A helper function for dwarf2out_finish. Counts the number
28881 of indexed addresses. Must match the logic of the functions
28882 output_addr_table_entry above. */
28884 count_index_addrs (addr_table_entry
**slot
, unsigned int *last_idx
)
28886 addr_table_entry
*entry
= *slot
;
28888 if (entry
->refcount
> 0)
28893 /* Produce the .debug_addr section. */
28896 output_addr_table (void)
28898 unsigned int index
= 0;
28899 if (addr_index_table
== NULL
|| addr_index_table
->size () == 0)
28902 switch_to_section (debug_addr_section
);
28904 ->traverse_noresize
<unsigned int *, output_addr_table_entry
> (&index
);
28907 #if ENABLE_ASSERT_CHECKING
28908 /* Verify that all marks are clear. */
28911 verify_marks_clear (dw_die_ref die
)
28915 gcc_assert (! die
->die_mark
);
28916 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
28918 #endif /* ENABLE_ASSERT_CHECKING */
28920 /* Clear the marks for a die and its children.
28921 Be cool if the mark isn't set. */
28924 prune_unmark_dies (dw_die_ref die
)
28930 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
28933 /* Given LOC that is referenced by a DIE we're marking as used, find all
28934 referenced DWARF procedures it references and mark them as used. */
28937 prune_unused_types_walk_loc_descr (dw_loc_descr_ref loc
)
28939 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
28940 switch (loc
->dw_loc_opc
)
28942 case DW_OP_implicit_pointer
:
28943 case DW_OP_convert
:
28944 case DW_OP_reinterpret
:
28945 case DW_OP_GNU_implicit_pointer
:
28946 case DW_OP_GNU_convert
:
28947 case DW_OP_GNU_reinterpret
:
28948 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
)
28949 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
28951 case DW_OP_GNU_variable_value
:
28952 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
28955 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
28958 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
28959 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
28960 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
28965 case DW_OP_call_ref
:
28966 case DW_OP_const_type
:
28967 case DW_OP_GNU_const_type
:
28968 case DW_OP_GNU_parameter_ref
:
28969 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
);
28970 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
28972 case DW_OP_regval_type
:
28973 case DW_OP_deref_type
:
28974 case DW_OP_GNU_regval_type
:
28975 case DW_OP_GNU_deref_type
:
28976 gcc_assert (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_die_ref
);
28977 prune_unused_types_mark (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
, 1);
28979 case DW_OP_entry_value
:
28980 case DW_OP_GNU_entry_value
:
28981 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
);
28982 prune_unused_types_walk_loc_descr (loc
->dw_loc_oprnd1
.v
.val_loc
);
28989 /* Given DIE that we're marking as used, find any other dies
28990 it references as attributes and mark them as used. */
28993 prune_unused_types_walk_attribs (dw_die_ref die
)
28998 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29000 switch (AT_class (a
))
29002 /* Make sure DWARF procedures referenced by location descriptions will
29004 case dw_val_class_loc
:
29005 prune_unused_types_walk_loc_descr (AT_loc (a
));
29007 case dw_val_class_loc_list
:
29008 for (dw_loc_list_ref list
= AT_loc_list (a
);
29010 list
= list
->dw_loc_next
)
29011 prune_unused_types_walk_loc_descr (list
->expr
);
29014 case dw_val_class_view_list
:
29015 /* This points to a loc_list in another attribute, so it's
29016 already covered. */
29019 case dw_val_class_die_ref
:
29020 /* A reference to another DIE.
29021 Make sure that it will get emitted.
29022 If it was broken out into a comdat group, don't follow it. */
29023 if (! AT_ref (a
)->comdat_type_p
29024 || a
->dw_attr
== DW_AT_specification
)
29025 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
29028 case dw_val_class_str
:
29029 /* Set the string's refcount to 0 so that prune_unused_types_mark
29030 accounts properly for it. */
29031 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
29040 /* Mark the generic parameters and arguments children DIEs of DIE. */
29043 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
29047 if (die
== NULL
|| die
->die_child
== NULL
)
29049 c
= die
->die_child
;
29052 if (is_template_parameter (c
))
29053 prune_unused_types_mark (c
, 1);
29055 } while (c
&& c
!= die
->die_child
);
29058 /* Mark DIE as being used. If DOKIDS is true, then walk down
29059 to DIE's children. */
29062 prune_unused_types_mark (dw_die_ref die
, int dokids
)
29066 if (die
->die_mark
== 0)
29068 /* We haven't done this node yet. Mark it as used. */
29070 /* If this is the DIE of a generic type instantiation,
29071 mark the children DIEs that describe its generic parms and
29073 prune_unused_types_mark_generic_parms_dies (die
);
29075 /* We also have to mark its parents as used.
29076 (But we don't want to mark our parent's kids due to this,
29077 unless it is a class.) */
29078 if (die
->die_parent
)
29079 prune_unused_types_mark (die
->die_parent
,
29080 class_scope_p (die
->die_parent
));
29082 /* Mark any referenced nodes. */
29083 prune_unused_types_walk_attribs (die
);
29085 /* If this node is a specification,
29086 also mark the definition, if it exists. */
29087 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
29088 prune_unused_types_mark (die
->die_definition
, 1);
29091 if (dokids
&& die
->die_mark
!= 2)
29093 /* We need to walk the children, but haven't done so yet.
29094 Remember that we've walked the kids. */
29097 /* If this is an array type, we need to make sure our
29098 kids get marked, even if they're types. If we're
29099 breaking out types into comdat sections, do this
29100 for all type definitions. */
29101 if (die
->die_tag
== DW_TAG_array_type
29102 || (use_debug_types
29103 && is_type_die (die
) && ! is_declaration_die (die
)))
29104 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
29106 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
29110 /* For local classes, look if any static member functions were emitted
29111 and if so, mark them. */
29114 prune_unused_types_walk_local_classes (dw_die_ref die
)
29118 if (die
->die_mark
== 2)
29121 switch (die
->die_tag
)
29123 case DW_TAG_structure_type
:
29124 case DW_TAG_union_type
:
29125 case DW_TAG_class_type
:
29128 case DW_TAG_subprogram
:
29129 if (!get_AT_flag (die
, DW_AT_declaration
)
29130 || die
->die_definition
!= NULL
)
29131 prune_unused_types_mark (die
, 1);
29138 /* Mark children. */
29139 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
29142 /* Walk the tree DIE and mark types that we actually use. */
29145 prune_unused_types_walk (dw_die_ref die
)
29149 /* Don't do anything if this node is already marked and
29150 children have been marked as well. */
29151 if (die
->die_mark
== 2)
29154 switch (die
->die_tag
)
29156 case DW_TAG_structure_type
:
29157 case DW_TAG_union_type
:
29158 case DW_TAG_class_type
:
29159 if (die
->die_perennial_p
)
29162 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
29163 if (c
->die_tag
== DW_TAG_subprogram
)
29166 /* Finding used static member functions inside of classes
29167 is needed just for local classes, because for other classes
29168 static member function DIEs with DW_AT_specification
29169 are emitted outside of the DW_TAG_*_type. If we ever change
29170 it, we'd need to call this even for non-local classes. */
29172 prune_unused_types_walk_local_classes (die
);
29174 /* It's a type node --- don't mark it. */
29177 case DW_TAG_const_type
:
29178 case DW_TAG_packed_type
:
29179 case DW_TAG_pointer_type
:
29180 case DW_TAG_reference_type
:
29181 case DW_TAG_rvalue_reference_type
:
29182 case DW_TAG_volatile_type
:
29183 case DW_TAG_typedef
:
29184 case DW_TAG_array_type
:
29185 case DW_TAG_interface_type
:
29186 case DW_TAG_friend
:
29187 case DW_TAG_enumeration_type
:
29188 case DW_TAG_subroutine_type
:
29189 case DW_TAG_string_type
:
29190 case DW_TAG_set_type
:
29191 case DW_TAG_subrange_type
:
29192 case DW_TAG_ptr_to_member_type
:
29193 case DW_TAG_file_type
:
29194 /* Type nodes are useful only when other DIEs reference them --- don't
29198 case DW_TAG_dwarf_procedure
:
29199 /* Likewise for DWARF procedures. */
29201 if (die
->die_perennial_p
)
29207 /* Mark everything else. */
29211 if (die
->die_mark
== 0)
29215 /* Now, mark any dies referenced from here. */
29216 prune_unused_types_walk_attribs (die
);
29221 /* Mark children. */
29222 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
29225 /* Increment the string counts on strings referred to from DIE's
29229 prune_unused_types_update_strings (dw_die_ref die
)
29234 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29235 if (AT_class (a
) == dw_val_class_str
)
29237 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
29239 /* Avoid unnecessarily putting strings that are used less than
29240 twice in the hash table. */
29242 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
29244 indirect_string_node
**slot
29245 = debug_str_hash
->find_slot_with_hash (s
->str
,
29246 htab_hash_string (s
->str
),
29248 gcc_assert (*slot
== NULL
);
29254 /* Mark DIE and its children as removed. */
29257 mark_removed (dw_die_ref die
)
29260 die
->removed
= true;
29261 FOR_EACH_CHILD (die
, c
, mark_removed (c
));
29264 /* Remove from the tree DIE any dies that aren't marked. */
29267 prune_unused_types_prune (dw_die_ref die
)
29271 gcc_assert (die
->die_mark
);
29272 prune_unused_types_update_strings (die
);
29274 if (! die
->die_child
)
29277 c
= die
->die_child
;
29279 dw_die_ref prev
= c
, next
;
29280 for (c
= c
->die_sib
; ! c
->die_mark
; c
= next
)
29281 if (c
== die
->die_child
)
29283 /* No marked children between 'prev' and the end of the list. */
29285 /* No marked children at all. */
29286 die
->die_child
= NULL
;
29289 prev
->die_sib
= c
->die_sib
;
29290 die
->die_child
= prev
;
29303 if (c
!= prev
->die_sib
)
29305 prune_unused_types_prune (c
);
29306 } while (c
!= die
->die_child
);
29309 /* Remove dies representing declarations that we never use. */
29312 prune_unused_types (void)
29315 limbo_die_node
*node
;
29316 comdat_type_node
*ctnode
;
29317 pubname_entry
*pub
;
29318 dw_die_ref base_type
;
29320 #if ENABLE_ASSERT_CHECKING
29321 /* All the marks should already be clear. */
29322 verify_marks_clear (comp_unit_die ());
29323 for (node
= limbo_die_list
; node
; node
= node
->next
)
29324 verify_marks_clear (node
->die
);
29325 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29326 verify_marks_clear (ctnode
->root_die
);
29327 #endif /* ENABLE_ASSERT_CHECKING */
29329 /* Mark types that are used in global variables. */
29330 premark_types_used_by_global_vars ();
29332 /* Set the mark on nodes that are actually used. */
29333 prune_unused_types_walk (comp_unit_die ());
29334 for (node
= limbo_die_list
; node
; node
= node
->next
)
29335 prune_unused_types_walk (node
->die
);
29336 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29338 prune_unused_types_walk (ctnode
->root_die
);
29339 prune_unused_types_mark (ctnode
->type_die
, 1);
29342 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
29343 are unusual in that they are pubnames that are the children of pubtypes.
29344 They should only be marked via their parent DW_TAG_enumeration_type die,
29345 not as roots in themselves. */
29346 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
29347 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
29348 prune_unused_types_mark (pub
->die
, 1);
29349 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
29350 prune_unused_types_mark (base_type
, 1);
29352 /* For -fvar-tracking-assignments, also set the mark on nodes that could be
29353 referenced by DW_TAG_call_site DW_AT_call_origin (i.e. direct call
29355 cgraph_node
*cnode
;
29356 FOR_EACH_FUNCTION (cnode
)
29357 if (cnode
->referred_to_p (false))
29359 dw_die_ref die
= lookup_decl_die (cnode
->decl
);
29360 if (die
== NULL
|| die
->die_mark
)
29362 for (cgraph_edge
*e
= cnode
->callers
; e
; e
= e
->next_caller
)
29363 if (e
->caller
!= cnode
29364 && opt_for_fn (e
->caller
->decl
, flag_var_tracking_assignments
))
29366 prune_unused_types_mark (die
, 1);
29371 if (debug_str_hash
)
29372 debug_str_hash
->empty ();
29373 if (skeleton_debug_str_hash
)
29374 skeleton_debug_str_hash
->empty ();
29375 prune_unused_types_prune (comp_unit_die ());
29376 for (limbo_die_node
**pnode
= &limbo_die_list
; *pnode
; )
29379 if (!node
->die
->die_mark
)
29380 *pnode
= node
->next
;
29383 prune_unused_types_prune (node
->die
);
29384 pnode
= &node
->next
;
29387 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29388 prune_unused_types_prune (ctnode
->root_die
);
29390 /* Leave the marks clear. */
29391 prune_unmark_dies (comp_unit_die ());
29392 for (node
= limbo_die_list
; node
; node
= node
->next
)
29393 prune_unmark_dies (node
->die
);
29394 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29395 prune_unmark_dies (ctnode
->root_die
);
29398 /* Helpers to manipulate hash table of comdat type units. */
29400 struct comdat_type_hasher
: nofree_ptr_hash
<comdat_type_node
>
29402 static inline hashval_t
hash (const comdat_type_node
*);
29403 static inline bool equal (const comdat_type_node
*, const comdat_type_node
*);
29407 comdat_type_hasher::hash (const comdat_type_node
*type_node
)
29410 memcpy (&h
, type_node
->signature
, sizeof (h
));
29415 comdat_type_hasher::equal (const comdat_type_node
*type_node_1
,
29416 const comdat_type_node
*type_node_2
)
29418 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
29419 DWARF_TYPE_SIGNATURE_SIZE
));
29422 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
29423 to the location it would have been added, should we know its
29424 DECL_ASSEMBLER_NAME when we added other attributes. This will
29425 probably improve compactness of debug info, removing equivalent
29426 abbrevs, and hide any differences caused by deferring the
29427 computation of the assembler name, triggered by e.g. PCH. */
29430 move_linkage_attr (dw_die_ref die
)
29432 unsigned ix
= vec_safe_length (die
->die_attr
);
29433 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
29435 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
29436 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
29440 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
29442 if (prev
->dw_attr
== DW_AT_decl_line
29443 || prev
->dw_attr
== DW_AT_decl_column
29444 || prev
->dw_attr
== DW_AT_name
)
29448 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
29450 die
->die_attr
->pop ();
29451 die
->die_attr
->quick_insert (ix
, linkage
);
29455 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
29456 referenced from typed stack ops and count how often they are used. */
29459 mark_base_types (dw_loc_descr_ref loc
)
29461 dw_die_ref base_type
= NULL
;
29463 for (; loc
; loc
= loc
->dw_loc_next
)
29465 switch (loc
->dw_loc_opc
)
29467 case DW_OP_regval_type
:
29468 case DW_OP_deref_type
:
29469 case DW_OP_GNU_regval_type
:
29470 case DW_OP_GNU_deref_type
:
29471 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
29473 case DW_OP_convert
:
29474 case DW_OP_reinterpret
:
29475 case DW_OP_GNU_convert
:
29476 case DW_OP_GNU_reinterpret
:
29477 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
29480 case DW_OP_const_type
:
29481 case DW_OP_GNU_const_type
:
29482 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29484 case DW_OP_entry_value
:
29485 case DW_OP_GNU_entry_value
:
29486 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
29491 gcc_assert (base_type
->die_parent
== comp_unit_die ());
29492 if (base_type
->die_mark
)
29493 base_type
->die_mark
++;
29496 base_types
.safe_push (base_type
);
29497 base_type
->die_mark
= 1;
29502 /* Comparison function for sorting marked base types. */
29505 base_type_cmp (const void *x
, const void *y
)
29507 dw_die_ref dx
= *(const dw_die_ref
*) x
;
29508 dw_die_ref dy
= *(const dw_die_ref
*) y
;
29509 unsigned int byte_size1
, byte_size2
;
29510 unsigned int encoding1
, encoding2
;
29511 unsigned int align1
, align2
;
29512 if (dx
->die_mark
> dy
->die_mark
)
29514 if (dx
->die_mark
< dy
->die_mark
)
29516 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
29517 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
29518 if (byte_size1
< byte_size2
)
29520 if (byte_size1
> byte_size2
)
29522 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
29523 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
29524 if (encoding1
< encoding2
)
29526 if (encoding1
> encoding2
)
29528 align1
= get_AT_unsigned (dx
, DW_AT_alignment
);
29529 align2
= get_AT_unsigned (dy
, DW_AT_alignment
);
29530 if (align1
< align2
)
29532 if (align1
> align2
)
29537 /* Move base types marked by mark_base_types as early as possible
29538 in the CU, sorted by decreasing usage count both to make the
29539 uleb128 references as small as possible and to make sure they
29540 will have die_offset already computed by calc_die_sizes when
29541 sizes of typed stack loc ops is computed. */
29544 move_marked_base_types (void)
29547 dw_die_ref base_type
, die
, c
;
29549 if (base_types
.is_empty ())
29552 /* Sort by decreasing usage count, they will be added again in that
29554 base_types
.qsort (base_type_cmp
);
29555 die
= comp_unit_die ();
29556 c
= die
->die_child
;
29559 dw_die_ref prev
= c
;
29561 while (c
->die_mark
)
29563 remove_child_with_prev (c
, prev
);
29564 /* As base types got marked, there must be at least
29565 one node other than DW_TAG_base_type. */
29566 gcc_assert (die
->die_child
!= NULL
);
29570 while (c
!= die
->die_child
);
29571 gcc_assert (die
->die_child
);
29572 c
= die
->die_child
;
29573 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
29575 base_type
->die_mark
= 0;
29576 base_type
->die_sib
= c
->die_sib
;
29577 c
->die_sib
= base_type
;
29582 /* Helper function for resolve_addr, attempt to resolve
29583 one CONST_STRING, return true if successful. Similarly verify that
29584 SYMBOL_REFs refer to variables emitted in the current CU. */
29587 resolve_one_addr (rtx
*addr
)
29591 if (GET_CODE (rtl
) == CONST_STRING
)
29593 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
29594 tree t
= build_string (len
, XSTR (rtl
, 0));
29595 tree tlen
= size_int (len
- 1);
29597 = build_array_type (char_type_node
, build_index_type (tlen
));
29598 rtl
= lookup_constant_def (t
);
29599 if (!rtl
|| !MEM_P (rtl
))
29601 rtl
= XEXP (rtl
, 0);
29602 if (GET_CODE (rtl
) == SYMBOL_REF
29603 && SYMBOL_REF_DECL (rtl
)
29604 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
29606 vec_safe_push (used_rtx_array
, rtl
);
29611 if (GET_CODE (rtl
) == SYMBOL_REF
29612 && SYMBOL_REF_DECL (rtl
))
29614 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
29616 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
29619 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
29623 if (GET_CODE (rtl
) == CONST
)
29625 subrtx_ptr_iterator::array_type array
;
29626 FOR_EACH_SUBRTX_PTR (iter
, array
, &XEXP (rtl
, 0), ALL
)
29627 if (!resolve_one_addr (*iter
))
29634 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
29635 if possible, and create DW_TAG_dwarf_procedure that can be referenced
29636 from DW_OP_implicit_pointer if the string hasn't been seen yet. */
29639 string_cst_pool_decl (tree t
)
29641 rtx rtl
= output_constant_def (t
, 1);
29642 unsigned char *array
;
29643 dw_loc_descr_ref l
;
29648 if (!rtl
|| !MEM_P (rtl
))
29650 rtl
= XEXP (rtl
, 0);
29651 if (GET_CODE (rtl
) != SYMBOL_REF
29652 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
29655 decl
= SYMBOL_REF_DECL (rtl
);
29656 if (!lookup_decl_die (decl
))
29658 len
= TREE_STRING_LENGTH (t
);
29659 vec_safe_push (used_rtx_array
, rtl
);
29660 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
29661 array
= ggc_vec_alloc
<unsigned char> (len
);
29662 memcpy (array
, TREE_STRING_POINTER (t
), len
);
29663 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
29664 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
29665 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
29666 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
29667 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
29668 add_AT_loc (ref
, DW_AT_location
, l
);
29669 equate_decl_number_to_die (decl
, ref
);
29674 /* Helper function of resolve_addr_in_expr. LOC is
29675 a DW_OP_addr followed by DW_OP_stack_value, either at the start
29676 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
29677 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
29678 with DW_OP_implicit_pointer if possible
29679 and return true, if unsuccessful, return false. */
29682 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
29684 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
29685 HOST_WIDE_INT offset
= 0;
29686 dw_die_ref ref
= NULL
;
29689 if (GET_CODE (rtl
) == CONST
29690 && GET_CODE (XEXP (rtl
, 0)) == PLUS
29691 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
29693 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
29694 rtl
= XEXP (XEXP (rtl
, 0), 0);
29696 if (GET_CODE (rtl
) == CONST_STRING
)
29698 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
29699 tree t
= build_string (len
, XSTR (rtl
, 0));
29700 tree tlen
= size_int (len
- 1);
29703 = build_array_type (char_type_node
, build_index_type (tlen
));
29704 rtl
= string_cst_pool_decl (t
);
29708 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
29710 decl
= SYMBOL_REF_DECL (rtl
);
29711 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
29713 ref
= lookup_decl_die (decl
);
29714 if (ref
&& (get_AT (ref
, DW_AT_location
)
29715 || get_AT (ref
, DW_AT_const_value
)))
29717 loc
->dw_loc_opc
= dwarf_OP (DW_OP_implicit_pointer
);
29718 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
29719 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
29720 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
29721 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29722 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
29723 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
29731 /* Helper function for resolve_addr, handle one location
29732 expression, return false if at least one CONST_STRING or SYMBOL_REF in
29733 the location list couldn't be resolved. */
29736 resolve_addr_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
29738 dw_loc_descr_ref keep
= NULL
;
29739 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
29740 switch (loc
->dw_loc_opc
)
29743 if (!resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
29746 || prev
->dw_loc_opc
== DW_OP_piece
29747 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
29748 && loc
->dw_loc_next
29749 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
29750 && (!dwarf_strict
|| dwarf_version
>= 5)
29751 && optimize_one_addr_into_implicit_ptr (loc
))
29756 case DW_OP_GNU_addr_index
:
29758 case DW_OP_GNU_const_index
:
29760 if ((loc
->dw_loc_opc
== DW_OP_GNU_addr_index
29761 || loc
->dw_loc_opc
== DW_OP_addrx
)
29762 || ((loc
->dw_loc_opc
== DW_OP_GNU_const_index
29763 || loc
->dw_loc_opc
== DW_OP_constx
)
29766 rtx rtl
= loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
;
29767 if (!resolve_one_addr (&rtl
))
29769 remove_addr_table_entry (loc
->dw_loc_oprnd1
.val_entry
);
29770 loc
->dw_loc_oprnd1
.val_entry
29771 = add_addr_table_entry (rtl
, ate_kind_rtx
);
29774 case DW_OP_const4u
:
29775 case DW_OP_const8u
:
29777 && !resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
29780 case DW_OP_plus_uconst
:
29781 if (size_of_loc_descr (loc
)
29782 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
29784 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
29786 dw_loc_descr_ref repl
29787 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
29788 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
29789 add_loc_descr (&repl
, loc
->dw_loc_next
);
29793 case DW_OP_implicit_value
:
29794 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
29795 && !resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
))
29798 case DW_OP_implicit_pointer
:
29799 case DW_OP_GNU_implicit_pointer
:
29800 case DW_OP_GNU_parameter_ref
:
29801 case DW_OP_GNU_variable_value
:
29802 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
29805 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
29808 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
29809 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
29810 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29812 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
)
29815 && loc
->dw_loc_next
== NULL
29816 && AT_class (a
) == dw_val_class_loc
)
29817 switch (a
->dw_attr
)
29819 /* Following attributes allow both exprloc and reference,
29820 so if the whole expression is DW_OP_GNU_variable_value
29821 alone we could transform it into reference. */
29822 case DW_AT_byte_size
:
29823 case DW_AT_bit_size
:
29824 case DW_AT_lower_bound
:
29825 case DW_AT_upper_bound
:
29826 case DW_AT_bit_stride
:
29828 case DW_AT_allocated
:
29829 case DW_AT_associated
:
29830 case DW_AT_byte_stride
:
29831 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
29832 a
->dw_attr_val
.val_entry
= NULL
;
29833 a
->dw_attr_val
.v
.val_die_ref
.die
29834 = loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29835 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
29844 case DW_OP_const_type
:
29845 case DW_OP_regval_type
:
29846 case DW_OP_deref_type
:
29847 case DW_OP_convert
:
29848 case DW_OP_reinterpret
:
29849 case DW_OP_GNU_const_type
:
29850 case DW_OP_GNU_regval_type
:
29851 case DW_OP_GNU_deref_type
:
29852 case DW_OP_GNU_convert
:
29853 case DW_OP_GNU_reinterpret
:
29854 while (loc
->dw_loc_next
29855 && (loc
->dw_loc_next
->dw_loc_opc
== DW_OP_convert
29856 || loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
))
29858 dw_die_ref base1
, base2
;
29859 unsigned enc1
, enc2
, size1
, size2
;
29860 if (loc
->dw_loc_opc
== DW_OP_regval_type
29861 || loc
->dw_loc_opc
== DW_OP_deref_type
29862 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
29863 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
29864 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
29865 else if (loc
->dw_loc_oprnd1
.val_class
29866 == dw_val_class_unsigned_const
)
29869 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29870 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
29871 == dw_val_class_unsigned_const
)
29873 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29874 gcc_assert (base1
->die_tag
== DW_TAG_base_type
29875 && base2
->die_tag
== DW_TAG_base_type
);
29876 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
29877 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
29878 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
29879 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
29881 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
29882 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
29886 /* Optimize away next DW_OP_convert after
29887 adjusting LOC's base type die reference. */
29888 if (loc
->dw_loc_opc
== DW_OP_regval_type
29889 || loc
->dw_loc_opc
== DW_OP_deref_type
29890 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
29891 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
29892 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
29894 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
29895 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
29898 /* Don't change integer DW_OP_convert after e.g. floating
29899 point typed stack entry. */
29900 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
29901 keep
= loc
->dw_loc_next
;
29911 /* Helper function of resolve_addr. DIE had DW_AT_location of
29912 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
29913 and DW_OP_addr couldn't be resolved. resolve_addr has already
29914 removed the DW_AT_location attribute. This function attempts to
29915 add a new DW_AT_location attribute with DW_OP_implicit_pointer
29916 to it or DW_AT_const_value attribute, if possible. */
29919 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
29922 || lookup_decl_die (decl
) != die
29923 || DECL_EXTERNAL (decl
)
29924 || !TREE_STATIC (decl
)
29925 || DECL_INITIAL (decl
) == NULL_TREE
29926 || DECL_P (DECL_INITIAL (decl
))
29927 || get_AT (die
, DW_AT_const_value
))
29930 tree init
= DECL_INITIAL (decl
);
29931 HOST_WIDE_INT offset
= 0;
29932 /* For variables that have been optimized away and thus
29933 don't have a memory location, see if we can emit
29934 DW_AT_const_value instead. */
29935 if (tree_add_const_value_attribute (die
, init
))
29937 if (dwarf_strict
&& dwarf_version
< 5)
29939 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
29940 and ADDR_EXPR refers to a decl that has DW_AT_location or
29941 DW_AT_const_value (but isn't addressable, otherwise
29942 resolving the original DW_OP_addr wouldn't fail), see if
29943 we can add DW_OP_implicit_pointer. */
29945 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
29946 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
29948 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
29949 init
= TREE_OPERAND (init
, 0);
29952 if (TREE_CODE (init
) != ADDR_EXPR
)
29954 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
29955 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
29956 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
29957 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
29958 && TREE_OPERAND (init
, 0) != decl
))
29961 dw_loc_descr_ref l
;
29963 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
29965 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
29968 decl
= SYMBOL_REF_DECL (rtl
);
29971 decl
= TREE_OPERAND (init
, 0);
29972 ref
= lookup_decl_die (decl
);
29974 || (!get_AT (ref
, DW_AT_location
)
29975 && !get_AT (ref
, DW_AT_const_value
)))
29977 l
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
29978 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
29979 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
29980 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29981 add_AT_loc (die
, DW_AT_location
, l
);
29985 /* Return NULL if l is a DWARF expression, or first op that is not
29986 valid DWARF expression. */
29988 static dw_loc_descr_ref
29989 non_dwarf_expression (dw_loc_descr_ref l
)
29993 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
29995 switch (l
->dw_loc_opc
)
29998 case DW_OP_implicit_value
:
29999 case DW_OP_stack_value
:
30000 case DW_OP_implicit_pointer
:
30001 case DW_OP_GNU_implicit_pointer
:
30002 case DW_OP_GNU_parameter_ref
:
30004 case DW_OP_bit_piece
:
30009 l
= l
->dw_loc_next
;
30014 /* Return adjusted copy of EXPR:
30015 If it is empty DWARF expression, return it.
30016 If it is valid non-empty DWARF expression,
30017 return copy of EXPR with DW_OP_deref appended to it.
30018 If it is DWARF expression followed by DW_OP_reg{N,x}, return
30019 copy of the DWARF expression with DW_OP_breg{N,x} <0> appended.
30020 If it is DWARF expression followed by DW_OP_stack_value, return
30021 copy of the DWARF expression without anything appended.
30022 Otherwise, return NULL. */
30024 static dw_loc_descr_ref
30025 copy_deref_exprloc (dw_loc_descr_ref expr
)
30027 dw_loc_descr_ref tail
= NULL
;
30032 dw_loc_descr_ref l
= non_dwarf_expression (expr
);
30033 if (l
&& l
->dw_loc_next
)
30038 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
30039 tail
= new_loc_descr ((enum dwarf_location_atom
)
30040 (DW_OP_breg0
+ (l
->dw_loc_opc
- DW_OP_reg0
)),
30043 switch (l
->dw_loc_opc
)
30046 tail
= new_loc_descr (DW_OP_bregx
,
30047 l
->dw_loc_oprnd1
.v
.val_unsigned
, 0);
30049 case DW_OP_stack_value
:
30056 tail
= new_loc_descr (DW_OP_deref
, 0, 0);
30058 dw_loc_descr_ref ret
= NULL
, *p
= &ret
;
30061 *p
= new_loc_descr (expr
->dw_loc_opc
, 0, 0);
30062 (*p
)->dw_loc_oprnd1
= expr
->dw_loc_oprnd1
;
30063 (*p
)->dw_loc_oprnd2
= expr
->dw_loc_oprnd2
;
30064 p
= &(*p
)->dw_loc_next
;
30065 expr
= expr
->dw_loc_next
;
30071 /* For DW_AT_string_length attribute with DW_OP_GNU_variable_value
30072 reference to a variable or argument, adjust it if needed and return:
30073 -1 if the DW_AT_string_length attribute and DW_AT_{string_length_,}byte_size
30074 attribute if present should be removed
30075 0 keep the attribute perhaps with minor modifications, no need to rescan
30076 1 if the attribute has been successfully adjusted. */
30079 optimize_string_length (dw_attr_node
*a
)
30081 dw_loc_descr_ref l
= AT_loc (a
), lv
;
30083 if (l
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
30085 tree decl
= l
->dw_loc_oprnd1
.v
.val_decl_ref
;
30086 die
= lookup_decl_die (decl
);
30089 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30090 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= die
;
30091 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30097 die
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30099 /* DWARF5 allows reference class, so we can then reference the DIE.
30100 Only do this for DW_OP_GNU_variable_value DW_OP_stack_value. */
30101 if (l
->dw_loc_next
!= NULL
&& dwarf_version
>= 5)
30103 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
30104 a
->dw_attr_val
.val_entry
= NULL
;
30105 a
->dw_attr_val
.v
.val_die_ref
.die
= die
;
30106 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
30110 dw_attr_node
*av
= get_AT (die
, DW_AT_location
);
30112 bool non_dwarf_expr
= false;
30115 return dwarf_strict
? -1 : 0;
30116 switch (AT_class (av
))
30118 case dw_val_class_loc_list
:
30119 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
30120 if (d
->expr
&& non_dwarf_expression (d
->expr
))
30121 non_dwarf_expr
= true;
30123 case dw_val_class_view_list
:
30124 gcc_unreachable ();
30125 case dw_val_class_loc
:
30128 return dwarf_strict
? -1 : 0;
30129 if (non_dwarf_expression (lv
))
30130 non_dwarf_expr
= true;
30133 return dwarf_strict
? -1 : 0;
30136 /* If it is safe to transform DW_OP_GNU_variable_value DW_OP_stack_value
30137 into DW_OP_call4 or DW_OP_GNU_variable_value into
30138 DW_OP_call4 DW_OP_deref, do so. */
30139 if (!non_dwarf_expr
30140 && (l
->dw_loc_next
!= NULL
|| AT_class (av
) == dw_val_class_loc
))
30142 l
->dw_loc_opc
= DW_OP_call4
;
30143 if (l
->dw_loc_next
)
30144 l
->dw_loc_next
= NULL
;
30146 l
->dw_loc_next
= new_loc_descr (DW_OP_deref
, 0, 0);
30150 /* For DW_OP_GNU_variable_value DW_OP_stack_value, we can just
30151 copy over the DW_AT_location attribute from die to a. */
30152 if (l
->dw_loc_next
!= NULL
)
30154 a
->dw_attr_val
= av
->dw_attr_val
;
30158 dw_loc_list_ref list
, *p
;
30159 switch (AT_class (av
))
30161 case dw_val_class_loc_list
:
30164 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
30166 lv
= copy_deref_exprloc (d
->expr
);
30169 *p
= new_loc_list (lv
, d
->begin
, d
->vbegin
, d
->end
, d
->vend
, d
->section
);
30170 p
= &(*p
)->dw_loc_next
;
30172 else if (!dwarf_strict
&& d
->expr
)
30176 return dwarf_strict
? -1 : 0;
30177 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
30179 *AT_loc_list_ptr (a
) = list
;
30181 case dw_val_class_loc
:
30182 lv
= copy_deref_exprloc (AT_loc (av
));
30184 return dwarf_strict
? -1 : 0;
30185 a
->dw_attr_val
.v
.val_loc
= lv
;
30188 gcc_unreachable ();
30192 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
30193 an address in .rodata section if the string literal is emitted there,
30194 or remove the containing location list or replace DW_AT_const_value
30195 with DW_AT_location and empty location expression, if it isn't found
30196 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
30197 to something that has been emitted in the current CU. */
30200 resolve_addr (dw_die_ref die
)
30204 dw_loc_list_ref
*curr
, *start
, loc
;
30206 bool remove_AT_byte_size
= false;
30208 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30209 switch (AT_class (a
))
30211 case dw_val_class_loc_list
:
30212 start
= curr
= AT_loc_list_ptr (a
);
30215 /* The same list can be referenced more than once. See if we have
30216 already recorded the result from a previous pass. */
30218 *curr
= loc
->dw_loc_next
;
30219 else if (!loc
->resolved_addr
)
30221 /* As things stand, we do not expect or allow one die to
30222 reference a suffix of another die's location list chain.
30223 References must be identical or completely separate.
30224 There is therefore no need to cache the result of this
30225 pass on any list other than the first; doing so
30226 would lead to unnecessary writes. */
30229 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
30230 if (!resolve_addr_in_expr (a
, (*curr
)->expr
))
30232 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
30233 dw_loc_descr_ref l
= (*curr
)->expr
;
30235 if (next
&& (*curr
)->ll_symbol
)
30237 gcc_assert (!next
->ll_symbol
);
30238 next
->ll_symbol
= (*curr
)->ll_symbol
;
30239 next
->vl_symbol
= (*curr
)->vl_symbol
;
30241 if (dwarf_split_debug_info
)
30242 remove_loc_list_addr_table_entries (l
);
30247 mark_base_types ((*curr
)->expr
);
30248 curr
= &(*curr
)->dw_loc_next
;
30252 loc
->resolved_addr
= 1;
30256 loc
->dw_loc_next
= *start
;
30261 remove_AT (die
, a
->dw_attr
);
30265 case dw_val_class_view_list
:
30267 gcc_checking_assert (a
->dw_attr
== DW_AT_GNU_locviews
);
30268 gcc_checking_assert (dwarf2out_locviews_in_attribute ());
30269 dw_val_node
*llnode
30270 = view_list_to_loc_list_val_node (&a
->dw_attr_val
);
30271 /* If we no longer have a loclist, or it no longer needs
30272 views, drop this attribute. */
30273 if (!llnode
|| !llnode
->v
.val_loc_list
->vl_symbol
)
30275 remove_AT (die
, a
->dw_attr
);
30280 case dw_val_class_loc
:
30282 dw_loc_descr_ref l
= AT_loc (a
);
30283 /* DW_OP_GNU_variable_value DW_OP_stack_value or
30284 DW_OP_GNU_variable_value in DW_AT_string_length can be converted
30285 into DW_OP_call4 or DW_OP_call4 DW_OP_deref, which is standard
30286 DWARF4 unlike DW_OP_GNU_variable_value. Or for DWARF5
30287 DW_OP_GNU_variable_value DW_OP_stack_value can be replaced
30288 with DW_FORM_ref referencing the same DIE as
30289 DW_OP_GNU_variable_value used to reference. */
30290 if (a
->dw_attr
== DW_AT_string_length
30292 && l
->dw_loc_opc
== DW_OP_GNU_variable_value
30293 && (l
->dw_loc_next
== NULL
30294 || (l
->dw_loc_next
->dw_loc_next
== NULL
30295 && l
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
)))
30297 switch (optimize_string_length (a
))
30300 remove_AT (die
, a
->dw_attr
);
30302 /* If we drop DW_AT_string_length, we need to drop also
30303 DW_AT_{string_length_,}byte_size. */
30304 remove_AT_byte_size
= true;
30309 /* Even if we keep the optimized DW_AT_string_length,
30310 it might have changed AT_class, so process it again. */
30315 /* For -gdwarf-2 don't attempt to optimize
30316 DW_AT_data_member_location containing
30317 DW_OP_plus_uconst - older consumers might
30318 rely on it being that op instead of a more complex,
30319 but shorter, location description. */
30320 if ((dwarf_version
> 2
30321 || a
->dw_attr
!= DW_AT_data_member_location
30323 || l
->dw_loc_opc
!= DW_OP_plus_uconst
30324 || l
->dw_loc_next
!= NULL
)
30325 && !resolve_addr_in_expr (a
, l
))
30327 if (dwarf_split_debug_info
)
30328 remove_loc_list_addr_table_entries (l
);
30330 && l
->dw_loc_next
== NULL
30331 && l
->dw_loc_opc
== DW_OP_addr
30332 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
30333 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
30334 && a
->dw_attr
== DW_AT_location
)
30336 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
30337 remove_AT (die
, a
->dw_attr
);
30339 optimize_location_into_implicit_ptr (die
, decl
);
30342 if (a
->dw_attr
== DW_AT_string_length
)
30343 /* If we drop DW_AT_string_length, we need to drop also
30344 DW_AT_{string_length_,}byte_size. */
30345 remove_AT_byte_size
= true;
30346 remove_AT (die
, a
->dw_attr
);
30350 mark_base_types (l
);
30353 case dw_val_class_addr
:
30354 if (a
->dw_attr
== DW_AT_const_value
30355 && !resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
))
30357 if (AT_index (a
) != NOT_INDEXED
)
30358 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
30359 remove_AT (die
, a
->dw_attr
);
30362 if ((die
->die_tag
== DW_TAG_call_site
30363 && a
->dw_attr
== DW_AT_call_origin
)
30364 || (die
->die_tag
== DW_TAG_GNU_call_site
30365 && a
->dw_attr
== DW_AT_abstract_origin
))
30367 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
30368 dw_die_ref tdie
= lookup_decl_die (tdecl
);
30371 && DECL_EXTERNAL (tdecl
)
30372 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
30373 && (cdie
= lookup_context_die (DECL_CONTEXT (tdecl
))))
30375 dw_die_ref pdie
= cdie
;
30376 /* Make sure we don't add these DIEs into type units.
30377 We could emit skeleton DIEs for context (namespaces,
30378 outer structs/classes) and a skeleton DIE for the
30379 innermost context with DW_AT_signature pointing to the
30380 type unit. See PR78835. */
30381 while (pdie
&& pdie
->die_tag
!= DW_TAG_type_unit
)
30382 pdie
= pdie
->die_parent
;
30385 /* Creating a full DIE for tdecl is overly expensive and
30386 at this point even wrong when in the LTO phase
30387 as it can end up generating new type DIEs we didn't
30388 output and thus optimize_external_refs will crash. */
30389 tdie
= new_die (DW_TAG_subprogram
, cdie
, NULL_TREE
);
30390 add_AT_flag (tdie
, DW_AT_external
, 1);
30391 add_AT_flag (tdie
, DW_AT_declaration
, 1);
30392 add_linkage_attr (tdie
, tdecl
);
30393 add_name_and_src_coords_attributes (tdie
, tdecl
, true);
30394 equate_decl_number_to_die (tdecl
, tdie
);
30399 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
30400 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
30401 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
30405 if (AT_index (a
) != NOT_INDEXED
)
30406 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
30407 remove_AT (die
, a
->dw_attr
);
30416 if (remove_AT_byte_size
)
30417 remove_AT (die
, dwarf_version
>= 5
30418 ? DW_AT_string_length_byte_size
30419 : DW_AT_byte_size
);
30421 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
30424 /* Helper routines for optimize_location_lists.
30425 This pass tries to share identical local lists in .debug_loc
30428 /* Iteratively hash operands of LOC opcode into HSTATE. */
30431 hash_loc_operands (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
30433 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
30434 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
30436 switch (loc
->dw_loc_opc
)
30438 case DW_OP_const4u
:
30439 case DW_OP_const8u
:
30443 case DW_OP_const1u
:
30444 case DW_OP_const1s
:
30445 case DW_OP_const2u
:
30446 case DW_OP_const2s
:
30447 case DW_OP_const4s
:
30448 case DW_OP_const8s
:
30452 case DW_OP_plus_uconst
:
30488 case DW_OP_deref_size
:
30489 case DW_OP_xderef_size
:
30490 hstate
.add_object (val1
->v
.val_int
);
30497 gcc_assert (val1
->val_class
== dw_val_class_loc
);
30498 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
30499 hstate
.add_object (offset
);
30502 case DW_OP_implicit_value
:
30503 hstate
.add_object (val1
->v
.val_unsigned
);
30504 switch (val2
->val_class
)
30506 case dw_val_class_const
:
30507 hstate
.add_object (val2
->v
.val_int
);
30509 case dw_val_class_vec
:
30511 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
30512 unsigned int len
= val2
->v
.val_vec
.length
;
30514 hstate
.add_int (elt_size
);
30515 hstate
.add_int (len
);
30516 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
30519 case dw_val_class_const_double
:
30520 hstate
.add_object (val2
->v
.val_double
.low
);
30521 hstate
.add_object (val2
->v
.val_double
.high
);
30523 case dw_val_class_wide_int
:
30524 hstate
.add (val2
->v
.val_wide
->get_val (),
30525 get_full_len (*val2
->v
.val_wide
)
30526 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
30528 case dw_val_class_addr
:
30529 inchash::add_rtx (val2
->v
.val_addr
, hstate
);
30532 gcc_unreachable ();
30536 case DW_OP_bit_piece
:
30537 hstate
.add_object (val1
->v
.val_int
);
30538 hstate
.add_object (val2
->v
.val_int
);
30544 unsigned char dtprel
= 0xd1;
30545 hstate
.add_object (dtprel
);
30547 inchash::add_rtx (val1
->v
.val_addr
, hstate
);
30549 case DW_OP_GNU_addr_index
:
30551 case DW_OP_GNU_const_index
:
30556 unsigned char dtprel
= 0xd1;
30557 hstate
.add_object (dtprel
);
30559 inchash::add_rtx (val1
->val_entry
->addr
.rtl
, hstate
);
30562 case DW_OP_implicit_pointer
:
30563 case DW_OP_GNU_implicit_pointer
:
30564 hstate
.add_int (val2
->v
.val_int
);
30566 case DW_OP_entry_value
:
30567 case DW_OP_GNU_entry_value
:
30568 hstate
.add_object (val1
->v
.val_loc
);
30570 case DW_OP_regval_type
:
30571 case DW_OP_deref_type
:
30572 case DW_OP_GNU_regval_type
:
30573 case DW_OP_GNU_deref_type
:
30575 unsigned int byte_size
30576 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
30577 unsigned int encoding
30578 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
30579 hstate
.add_object (val1
->v
.val_int
);
30580 hstate
.add_object (byte_size
);
30581 hstate
.add_object (encoding
);
30584 case DW_OP_convert
:
30585 case DW_OP_reinterpret
:
30586 case DW_OP_GNU_convert
:
30587 case DW_OP_GNU_reinterpret
:
30588 if (val1
->val_class
== dw_val_class_unsigned_const
)
30590 hstate
.add_object (val1
->v
.val_unsigned
);
30594 case DW_OP_const_type
:
30595 case DW_OP_GNU_const_type
:
30597 unsigned int byte_size
30598 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
30599 unsigned int encoding
30600 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
30601 hstate
.add_object (byte_size
);
30602 hstate
.add_object (encoding
);
30603 if (loc
->dw_loc_opc
!= DW_OP_const_type
30604 && loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
30606 hstate
.add_object (val2
->val_class
);
30607 switch (val2
->val_class
)
30609 case dw_val_class_const
:
30610 hstate
.add_object (val2
->v
.val_int
);
30612 case dw_val_class_vec
:
30614 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
30615 unsigned int len
= val2
->v
.val_vec
.length
;
30617 hstate
.add_object (elt_size
);
30618 hstate
.add_object (len
);
30619 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
30622 case dw_val_class_const_double
:
30623 hstate
.add_object (val2
->v
.val_double
.low
);
30624 hstate
.add_object (val2
->v
.val_double
.high
);
30626 case dw_val_class_wide_int
:
30627 hstate
.add (val2
->v
.val_wide
->get_val (),
30628 get_full_len (*val2
->v
.val_wide
)
30629 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
30632 gcc_unreachable ();
30638 /* Other codes have no operands. */
30643 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
30646 hash_locs (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
30648 dw_loc_descr_ref l
;
30649 bool sizes_computed
= false;
30650 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
30651 size_of_locs (loc
);
30653 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
30655 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
30656 hstate
.add_object (opc
);
30657 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
30659 size_of_locs (loc
);
30660 sizes_computed
= true;
30662 hash_loc_operands (l
, hstate
);
30666 /* Compute hash of the whole location list LIST_HEAD. */
30669 hash_loc_list (dw_loc_list_ref list_head
)
30671 dw_loc_list_ref curr
= list_head
;
30672 inchash::hash hstate
;
30674 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
30676 hstate
.add (curr
->begin
, strlen (curr
->begin
) + 1);
30677 hstate
.add (curr
->end
, strlen (curr
->end
) + 1);
30678 hstate
.add_object (curr
->vbegin
);
30679 hstate
.add_object (curr
->vend
);
30681 hstate
.add (curr
->section
, strlen (curr
->section
) + 1);
30682 hash_locs (curr
->expr
, hstate
);
30684 list_head
->hash
= hstate
.end ();
30687 /* Return true if X and Y opcodes have the same operands. */
30690 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
30692 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
30693 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
30694 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
30695 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
30697 switch (x
->dw_loc_opc
)
30699 case DW_OP_const4u
:
30700 case DW_OP_const8u
:
30704 case DW_OP_const1u
:
30705 case DW_OP_const1s
:
30706 case DW_OP_const2u
:
30707 case DW_OP_const2s
:
30708 case DW_OP_const4s
:
30709 case DW_OP_const8s
:
30713 case DW_OP_plus_uconst
:
30749 case DW_OP_deref_size
:
30750 case DW_OP_xderef_size
:
30751 return valx1
->v
.val_int
== valy1
->v
.val_int
;
30754 /* If splitting debug info, the use of DW_OP_GNU_addr_index
30755 can cause irrelevant differences in dw_loc_addr. */
30756 gcc_assert (valx1
->val_class
== dw_val_class_loc
30757 && valy1
->val_class
== dw_val_class_loc
30758 && (dwarf_split_debug_info
30759 || x
->dw_loc_addr
== y
->dw_loc_addr
));
30760 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
30761 case DW_OP_implicit_value
:
30762 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
30763 || valx2
->val_class
!= valy2
->val_class
)
30765 switch (valx2
->val_class
)
30767 case dw_val_class_const
:
30768 return valx2
->v
.val_int
== valy2
->v
.val_int
;
30769 case dw_val_class_vec
:
30770 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
30771 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
30772 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
30773 valx2
->v
.val_vec
.elt_size
30774 * valx2
->v
.val_vec
.length
) == 0;
30775 case dw_val_class_const_double
:
30776 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
30777 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
30778 case dw_val_class_wide_int
:
30779 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
30780 case dw_val_class_addr
:
30781 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
30783 gcc_unreachable ();
30786 case DW_OP_bit_piece
:
30787 return valx1
->v
.val_int
== valy1
->v
.val_int
30788 && valx2
->v
.val_int
== valy2
->v
.val_int
;
30791 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
30792 case DW_OP_GNU_addr_index
:
30794 case DW_OP_GNU_const_index
:
30797 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
30798 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
30799 return rtx_equal_p (ax1
, ay1
);
30801 case DW_OP_implicit_pointer
:
30802 case DW_OP_GNU_implicit_pointer
:
30803 return valx1
->val_class
== dw_val_class_die_ref
30804 && valx1
->val_class
== valy1
->val_class
30805 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
30806 && valx2
->v
.val_int
== valy2
->v
.val_int
;
30807 case DW_OP_entry_value
:
30808 case DW_OP_GNU_entry_value
:
30809 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
30810 case DW_OP_const_type
:
30811 case DW_OP_GNU_const_type
:
30812 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
30813 || valx2
->val_class
!= valy2
->val_class
)
30815 switch (valx2
->val_class
)
30817 case dw_val_class_const
:
30818 return valx2
->v
.val_int
== valy2
->v
.val_int
;
30819 case dw_val_class_vec
:
30820 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
30821 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
30822 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
30823 valx2
->v
.val_vec
.elt_size
30824 * valx2
->v
.val_vec
.length
) == 0;
30825 case dw_val_class_const_double
:
30826 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
30827 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
30828 case dw_val_class_wide_int
:
30829 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
30831 gcc_unreachable ();
30833 case DW_OP_regval_type
:
30834 case DW_OP_deref_type
:
30835 case DW_OP_GNU_regval_type
:
30836 case DW_OP_GNU_deref_type
:
30837 return valx1
->v
.val_int
== valy1
->v
.val_int
30838 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
30839 case DW_OP_convert
:
30840 case DW_OP_reinterpret
:
30841 case DW_OP_GNU_convert
:
30842 case DW_OP_GNU_reinterpret
:
30843 if (valx1
->val_class
!= valy1
->val_class
)
30845 if (valx1
->val_class
== dw_val_class_unsigned_const
)
30846 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
30847 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
30848 case DW_OP_GNU_parameter_ref
:
30849 return valx1
->val_class
== dw_val_class_die_ref
30850 && valx1
->val_class
== valy1
->val_class
30851 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
30853 /* Other codes have no operands. */
30858 /* Return true if DWARF location expressions X and Y are the same. */
30861 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
30863 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
30864 if (x
->dw_loc_opc
!= y
->dw_loc_opc
30865 || x
->dtprel
!= y
->dtprel
30866 || !compare_loc_operands (x
, y
))
30868 return x
== NULL
&& y
== NULL
;
30871 /* Hashtable helpers. */
30873 struct loc_list_hasher
: nofree_ptr_hash
<dw_loc_list_struct
>
30875 static inline hashval_t
hash (const dw_loc_list_struct
*);
30876 static inline bool equal (const dw_loc_list_struct
*,
30877 const dw_loc_list_struct
*);
30880 /* Return precomputed hash of location list X. */
30883 loc_list_hasher::hash (const dw_loc_list_struct
*x
)
30888 /* Return true if location lists A and B are the same. */
30891 loc_list_hasher::equal (const dw_loc_list_struct
*a
,
30892 const dw_loc_list_struct
*b
)
30896 if (a
->hash
!= b
->hash
)
30898 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
30899 if (strcmp (a
->begin
, b
->begin
) != 0
30900 || strcmp (a
->end
, b
->end
) != 0
30901 || (a
->section
== NULL
) != (b
->section
== NULL
)
30902 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
30903 || a
->vbegin
!= b
->vbegin
|| a
->vend
!= b
->vend
30904 || !compare_locs (a
->expr
, b
->expr
))
30906 return a
== NULL
&& b
== NULL
;
30909 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
30912 /* Recursively optimize location lists referenced from DIE
30913 children and share them whenever possible. */
30916 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type
*htab
)
30921 dw_loc_list_struct
**slot
;
30922 bool drop_locviews
= false;
30923 bool has_locviews
= false;
30925 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30926 if (AT_class (a
) == dw_val_class_loc_list
)
30928 dw_loc_list_ref list
= AT_loc_list (a
);
30929 /* TODO: perform some optimizations here, before hashing
30930 it and storing into the hash table. */
30931 hash_loc_list (list
);
30932 slot
= htab
->find_slot_with_hash (list
, list
->hash
, INSERT
);
30936 if (loc_list_has_views (list
))
30937 gcc_assert (list
->vl_symbol
);
30938 else if (list
->vl_symbol
)
30940 drop_locviews
= true;
30941 list
->vl_symbol
= NULL
;
30946 if (list
->vl_symbol
&& !(*slot
)->vl_symbol
)
30947 drop_locviews
= true;
30948 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
30951 else if (AT_class (a
) == dw_val_class_view_list
)
30953 gcc_checking_assert (a
->dw_attr
== DW_AT_GNU_locviews
);
30954 has_locviews
= true;
30958 if (drop_locviews
&& has_locviews
)
30959 remove_AT (die
, DW_AT_GNU_locviews
);
30961 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
30965 /* Recursively assign each location list a unique index into the debug_addr
30969 index_location_lists (dw_die_ref die
)
30975 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30976 if (AT_class (a
) == dw_val_class_loc_list
)
30978 dw_loc_list_ref list
= AT_loc_list (a
);
30979 dw_loc_list_ref curr
;
30980 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
30982 /* Don't index an entry that has already been indexed
30983 or won't be output. Make sure skip_loc_list_entry doesn't
30984 call size_of_locs, because that might cause circular dependency,
30985 index_location_lists requiring address table indexes to be
30986 computed, but adding new indexes through add_addr_table_entry
30987 and address table index computation requiring no new additions
30988 to the hash table. In the rare case of DWARF[234] >= 64KB
30989 location expression, we'll just waste unused address table entry
30991 if (curr
->begin_entry
!= NULL
30992 || skip_loc_list_entry (curr
))
30996 = add_addr_table_entry (xstrdup (curr
->begin
), ate_kind_label
);
31000 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
31003 /* Optimize location lists referenced from DIE
31004 children and share them whenever possible. */
31007 optimize_location_lists (dw_die_ref die
)
31009 loc_list_hash_type
htab (500);
31010 optimize_location_lists_1 (die
, &htab
);
31013 /* Traverse the limbo die list, and add parent/child links. The only
31014 dies without parents that should be here are concrete instances of
31015 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
31016 For concrete instances, we can get the parent die from the abstract
31020 flush_limbo_die_list (void)
31022 limbo_die_node
*node
;
31024 /* get_context_die calls force_decl_die, which can put new DIEs on the
31025 limbo list in LTO mode when nested functions are put in a different
31026 partition than that of their parent function. */
31027 while ((node
= limbo_die_list
))
31029 dw_die_ref die
= node
->die
;
31030 limbo_die_list
= node
->next
;
31032 if (die
->die_parent
== NULL
)
31034 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
31036 if (origin
&& origin
->die_parent
)
31037 add_child_die (origin
->die_parent
, die
);
31038 else if (is_cu_die (die
))
31040 else if (seen_error ())
31041 /* It's OK to be confused by errors in the input. */
31042 add_child_die (comp_unit_die (), die
);
31045 /* In certain situations, the lexical block containing a
31046 nested function can be optimized away, which results
31047 in the nested function die being orphaned. Likewise
31048 with the return type of that nested function. Force
31049 this to be a child of the containing function.
31051 It may happen that even the containing function got fully
31052 inlined and optimized out. In that case we are lost and
31053 assign the empty child. This should not be big issue as
31054 the function is likely unreachable too. */
31055 gcc_assert (node
->created_for
);
31057 if (DECL_P (node
->created_for
))
31058 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
31059 else if (TYPE_P (node
->created_for
))
31060 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
31062 origin
= comp_unit_die ();
31064 add_child_die (origin
, die
);
31070 /* Reset DIEs so we can output them again. */
31073 reset_dies (dw_die_ref die
)
31077 /* Remove stuff we re-generate. */
31079 die
->die_offset
= 0;
31080 die
->die_abbrev
= 0;
31081 remove_AT (die
, DW_AT_sibling
);
31083 FOR_EACH_CHILD (die
, c
, reset_dies (c
));
31086 /* Output stuff that dwarf requires at the end of every file,
31087 and generate the DWARF-2 debugging info. */
31090 dwarf2out_finish (const char *)
31092 comdat_type_node
*ctnode
;
31093 dw_die_ref main_comp_unit_die
;
31094 unsigned char checksum
[16];
31095 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
31097 /* Flush out any latecomers to the limbo party. */
31098 flush_limbo_die_list ();
31100 if (inline_entry_data_table
)
31101 gcc_assert (inline_entry_data_table
->elements () == 0);
31105 verify_die (comp_unit_die ());
31106 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
31107 verify_die (node
->die
);
31110 /* We shouldn't have any symbols with delayed asm names for
31111 DIEs generated after early finish. */
31112 gcc_assert (deferred_asm_name
== NULL
);
31114 gen_remaining_tmpl_value_param_die_attribute ();
31116 if (flag_generate_lto
|| flag_generate_offload
)
31118 gcc_assert (flag_fat_lto_objects
|| flag_generate_offload
);
31120 /* Prune stuff so that dwarf2out_finish runs successfully
31121 for the fat part of the object. */
31122 reset_dies (comp_unit_die ());
31123 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
31124 reset_dies (node
->die
);
31126 hash_table
<comdat_type_hasher
> comdat_type_table (100);
31127 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31129 comdat_type_node
**slot
31130 = comdat_type_table
.find_slot (ctnode
, INSERT
);
31132 /* Don't reset types twice. */
31133 if (*slot
!= HTAB_EMPTY_ENTRY
)
31136 /* Remove the pointer to the line table. */
31137 remove_AT (ctnode
->root_die
, DW_AT_stmt_list
);
31139 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31140 reset_dies (ctnode
->root_die
);
31145 /* Reset die CU symbol so we don't output it twice. */
31146 comp_unit_die ()->die_id
.die_symbol
= NULL
;
31148 /* Remove DW_AT_macro and DW_AT_stmt_list from the early output. */
31149 remove_AT (comp_unit_die (), DW_AT_stmt_list
);
31151 remove_AT (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
);
31153 /* Remove indirect string decisions. */
31154 debug_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
31155 if (debug_line_str_hash
)
31157 debug_line_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
31158 debug_line_str_hash
= NULL
;
31162 #if ENABLE_ASSERT_CHECKING
31164 dw_die_ref die
= comp_unit_die (), c
;
31165 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
31168 resolve_addr (comp_unit_die ());
31169 move_marked_base_types ();
31171 /* Initialize sections and labels used for actual assembler output. */
31172 unsigned generation
= init_sections_and_labels (false);
31174 /* Traverse the DIE's and add sibling attributes to those DIE's that
31176 add_sibling_attributes (comp_unit_die ());
31177 limbo_die_node
*node
;
31178 for (node
= cu_die_list
; node
; node
= node
->next
)
31179 add_sibling_attributes (node
->die
);
31180 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31181 add_sibling_attributes (ctnode
->root_die
);
31183 /* When splitting DWARF info, we put some attributes in the
31184 skeleton compile_unit DIE that remains in the .o, while
31185 most attributes go in the DWO compile_unit_die. */
31186 if (dwarf_split_debug_info
)
31188 limbo_die_node
*cu
;
31189 main_comp_unit_die
= gen_compile_unit_die (NULL
);
31190 if (dwarf_version
>= 5)
31191 main_comp_unit_die
->die_tag
= DW_TAG_skeleton_unit
;
31192 cu
= limbo_die_list
;
31193 gcc_assert (cu
->die
== main_comp_unit_die
);
31194 limbo_die_list
= limbo_die_list
->next
;
31195 cu
->next
= cu_die_list
;
31199 main_comp_unit_die
= comp_unit_die ();
31201 /* Output a terminator label for the .text section. */
31202 switch_to_section (text_section
);
31203 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
31204 if (cold_text_section
)
31206 switch_to_section (cold_text_section
);
31207 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
31210 /* We can only use the low/high_pc attributes if all of the code was
31212 if (!have_multiple_function_sections
31213 || (dwarf_version
< 3 && dwarf_strict
))
31215 /* Don't add if the CU has no associated code. */
31216 if (text_section_used
)
31217 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
31218 text_end_label
, true);
31224 bool range_list_added
= false;
31226 if (text_section_used
)
31227 add_ranges_by_labels (main_comp_unit_die
, text_section_label
,
31228 text_end_label
, &range_list_added
, true);
31229 if (cold_text_section_used
)
31230 add_ranges_by_labels (main_comp_unit_die
, cold_text_section_label
,
31231 cold_end_label
, &range_list_added
, true);
31233 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
31235 if (DECL_IGNORED_P (fde
->decl
))
31237 if (!fde
->in_std_section
)
31238 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
31239 fde
->dw_fde_end
, &range_list_added
,
31241 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
31242 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
31243 fde
->dw_fde_second_end
, &range_list_added
,
31247 if (range_list_added
)
31249 /* We need to give .debug_loc and .debug_ranges an appropriate
31250 "base address". Use zero so that these addresses become
31251 absolute. Historically, we've emitted the unexpected
31252 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
31253 Emit both to give time for other tools to adapt. */
31254 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
31255 if (! dwarf_strict
&& dwarf_version
< 4)
31256 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
31262 /* AIX Assembler inserts the length, so adjust the reference to match the
31263 offset expected by debuggers. */
31264 strcpy (dl_section_ref
, debug_line_section_label
);
31265 if (XCOFF_DEBUGGING_INFO
)
31266 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
31268 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31269 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
31273 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
31274 macinfo_section_label
);
31276 if (dwarf_split_debug_info
)
31278 if (have_location_lists
)
31280 /* Since we generate the loclists in the split DWARF .dwo
31281 file itself, we don't need to generate a loclists_base
31282 attribute for the split compile unit DIE. That attribute
31283 (and using relocatable sec_offset FORMs) isn't allowed
31284 for a split compile unit. Only if the .debug_loclists
31285 section was in the main file, would we need to generate a
31286 loclists_base attribute here (for the full or skeleton
31289 /* optimize_location_lists calculates the size of the lists,
31290 so index them first, and assign indices to the entries.
31291 Although optimize_location_lists will remove entries from
31292 the table, it only does so for duplicates, and therefore
31293 only reduces ref_counts to 1. */
31294 index_location_lists (comp_unit_die ());
31297 if (addr_index_table
!= NULL
)
31299 unsigned int index
= 0;
31301 ->traverse_noresize
<unsigned int *, index_addr_table_entry
>
31307 if (have_location_lists
)
31309 optimize_location_lists (comp_unit_die ());
31310 /* And finally assign indexes to the entries for -gsplit-dwarf. */
31311 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
31312 assign_location_list_indexes (comp_unit_die ());
31315 save_macinfo_strings ();
31317 if (dwarf_split_debug_info
)
31319 unsigned int index
= 0;
31321 /* Add attributes common to skeleton compile_units and
31322 type_units. Because these attributes include strings, it
31323 must be done before freezing the string table. Top-level
31324 skeleton die attrs are added when the skeleton type unit is
31325 created, so ensure it is created by this point. */
31326 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
31327 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
31330 /* Output all of the compilation units. We put the main one last so that
31331 the offsets are available to output_pubnames. */
31332 for (node
= cu_die_list
; node
; node
= node
->next
)
31333 output_comp_unit (node
->die
, 0, NULL
);
31335 hash_table
<comdat_type_hasher
> comdat_type_table (100);
31336 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31338 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
31340 /* Don't output duplicate types. */
31341 if (*slot
!= HTAB_EMPTY_ENTRY
)
31344 /* Add a pointer to the line table for the main compilation unit
31345 so that the debugger can make sense of DW_AT_decl_file
31347 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31348 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
31349 (!dwarf_split_debug_info
31351 : debug_skeleton_line_section_label
));
31353 output_comdat_type_unit (ctnode
);
31357 if (dwarf_split_debug_info
)
31360 struct md5_ctx ctx
;
31362 if (dwarf_version
>= 5 && !vec_safe_is_empty (ranges_table
))
31365 /* Compute a checksum of the comp_unit to use as the dwo_id. */
31366 md5_init_ctx (&ctx
);
31368 die_checksum (comp_unit_die (), &ctx
, &mark
);
31369 unmark_all_dies (comp_unit_die ());
31370 md5_finish_ctx (&ctx
, checksum
);
31372 if (dwarf_version
< 5)
31374 /* Use the first 8 bytes of the checksum as the dwo_id,
31375 and add it to both comp-unit DIEs. */
31376 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
31377 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
31380 /* Add the base offset of the ranges table to the skeleton
31382 if (!vec_safe_is_empty (ranges_table
))
31384 if (dwarf_version
>= 5)
31385 add_AT_lineptr (main_comp_unit_die
, DW_AT_rnglists_base
,
31386 ranges_base_label
);
31388 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
31389 ranges_section_label
);
31392 switch_to_section (debug_addr_section
);
31393 /* GNU DebugFission https://gcc.gnu.org/wiki/DebugFission
31394 which GCC uses to implement -gsplit-dwarf as DWARF GNU extension
31395 before DWARF5, didn't have a header for .debug_addr units.
31396 DWARF5 specifies a small header when address tables are used. */
31397 if (dwarf_version
>= 5)
31399 unsigned int last_idx
= 0;
31400 unsigned long addrs_length
;
31402 addr_index_table
->traverse_noresize
31403 <unsigned int *, count_index_addrs
> (&last_idx
);
31404 addrs_length
= last_idx
* DWARF2_ADDR_SIZE
+ 4;
31406 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
31407 dw2_asm_output_data (4, 0xffffffff,
31408 "Escape value for 64-bit DWARF extension");
31409 dw2_asm_output_data (DWARF_OFFSET_SIZE
, addrs_length
,
31410 "Length of Address Unit");
31411 dw2_asm_output_data (2, 5, "DWARF addr version");
31412 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
31413 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
31415 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
31416 output_addr_table ();
31419 /* Output the main compilation unit if non-empty or if .debug_macinfo
31420 or .debug_macro will be emitted. */
31421 output_comp_unit (comp_unit_die (), have_macinfo
,
31422 dwarf_split_debug_info
? checksum
: NULL
);
31424 if (dwarf_split_debug_info
&& info_section_emitted
)
31425 output_skeleton_debug_sections (main_comp_unit_die
, checksum
);
31427 /* Output the abbreviation table. */
31428 if (vec_safe_length (abbrev_die_table
) != 1)
31430 switch_to_section (debug_abbrev_section
);
31431 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
31432 output_abbrev_section ();
31435 /* Output location list section if necessary. */
31436 if (have_location_lists
)
31438 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
31439 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
31440 /* Output the location lists info. */
31441 switch_to_section (debug_loc_section
);
31442 if (dwarf_version
>= 5)
31444 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_LOC_SECTION_LABEL
, 2);
31445 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_LOC_SECTION_LABEL
, 3);
31446 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
31447 dw2_asm_output_data (4, 0xffffffff,
31448 "Initial length escape value indicating "
31449 "64-bit DWARF extension");
31450 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
31451 "Length of Location Lists");
31452 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
31453 output_dwarf_version ();
31454 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
31455 dw2_asm_output_data (1, 0, "Segment Size");
31456 dw2_asm_output_data (4, dwarf_split_debug_info
? loc_list_idx
: 0,
31457 "Offset Entry Count");
31459 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
31460 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
31462 unsigned int save_loc_list_idx
= loc_list_idx
;
31464 output_loclists_offsets (comp_unit_die ());
31465 gcc_assert (save_loc_list_idx
== loc_list_idx
);
31467 output_location_lists (comp_unit_die ());
31468 if (dwarf_version
>= 5)
31469 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
31472 output_pubtables ();
31474 /* Output the address range information if a CU (.debug_info section)
31475 was emitted. We output an empty table even if we had no functions
31476 to put in it. This because the consumer has no way to tell the
31477 difference between an empty table that we omitted and failure to
31478 generate a table that would have contained data. */
31479 if (info_section_emitted
)
31481 switch_to_section (debug_aranges_section
);
31485 /* Output ranges section if necessary. */
31486 if (!vec_safe_is_empty (ranges_table
))
31488 if (dwarf_version
>= 5)
31489 output_rnglists (generation
);
31494 /* Have to end the macro section. */
31497 switch_to_section (debug_macinfo_section
);
31498 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
31499 output_macinfo (!dwarf_split_debug_info
? debug_line_section_label
31500 : debug_skeleton_line_section_label
, false);
31501 dw2_asm_output_data (1, 0, "End compilation unit");
31504 /* Output the source line correspondence table. We must do this
31505 even if there is no line information. Otherwise, on an empty
31506 translation unit, we will generate a present, but empty,
31507 .debug_info section. IRIX 6.5 `nm' will then complain when
31508 examining the file. This is done late so that any filenames
31509 used by the debug_info section are marked as 'used'. */
31510 switch_to_section (debug_line_section
);
31511 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
31512 if (! output_asm_line_debug_info ())
31513 output_line_info (false);
31515 if (dwarf_split_debug_info
&& info_section_emitted
)
31517 switch_to_section (debug_skeleton_line_section
);
31518 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
31519 output_line_info (true);
31522 /* If we emitted any indirect strings, output the string table too. */
31523 if (debug_str_hash
|| skeleton_debug_str_hash
)
31524 output_indirect_strings ();
31525 if (debug_line_str_hash
)
31527 switch_to_section (debug_line_str_section
);
31528 const enum dwarf_form form
= DW_FORM_line_strp
;
31529 debug_line_str_hash
->traverse
<enum dwarf_form
,
31530 output_indirect_string
> (form
);
31533 /* ??? Move lvugid out of dwarf2out_source_line and reset it too? */
31534 symview_upper_bound
= 0;
31536 bitmap_clear (zero_view_p
);
31539 /* Returns a hash value for X (which really is a variable_value_struct). */
31542 variable_value_hasher::hash (variable_value_struct
*x
)
31544 return (hashval_t
) x
->decl_id
;
31547 /* Return nonzero if decl_id of variable_value_struct X is the same as
31551 variable_value_hasher::equal (variable_value_struct
*x
, tree y
)
31553 return x
->decl_id
== DECL_UID (y
);
31556 /* Helper function for resolve_variable_value, handle
31557 DW_OP_GNU_variable_value in one location expression.
31558 Return true if exprloc has been changed into loclist. */
31561 resolve_variable_value_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
31563 dw_loc_descr_ref next
;
31564 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= next
)
31566 next
= loc
->dw_loc_next
;
31567 if (loc
->dw_loc_opc
!= DW_OP_GNU_variable_value
31568 || loc
->dw_loc_oprnd1
.val_class
!= dw_val_class_decl_ref
)
31571 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
31572 if (DECL_CONTEXT (decl
) != current_function_decl
)
31575 dw_die_ref ref
= lookup_decl_die (decl
);
31578 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31579 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31580 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31583 dw_loc_list_ref l
= loc_list_from_tree (decl
, 0, NULL
);
31586 if (l
->dw_loc_next
)
31588 if (AT_class (a
) != dw_val_class_loc
)
31590 switch (a
->dw_attr
)
31592 /* Following attributes allow both exprloc and loclist
31593 classes, so we can change them into a loclist. */
31594 case DW_AT_location
:
31595 case DW_AT_string_length
:
31596 case DW_AT_return_addr
:
31597 case DW_AT_data_member_location
:
31598 case DW_AT_frame_base
:
31599 case DW_AT_segment
:
31600 case DW_AT_static_link
:
31601 case DW_AT_use_location
:
31602 case DW_AT_vtable_elem_location
:
31605 prev
->dw_loc_next
= NULL
;
31606 prepend_loc_descr_to_each (l
, AT_loc (a
));
31609 add_loc_descr_to_each (l
, next
);
31610 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
31611 a
->dw_attr_val
.val_entry
= NULL
;
31612 a
->dw_attr_val
.v
.val_loc_list
= l
;
31613 have_location_lists
= true;
31615 /* Following attributes allow both exprloc and reference,
31616 so if the whole expression is DW_OP_GNU_variable_value alone
31617 we could transform it into reference. */
31618 case DW_AT_byte_size
:
31619 case DW_AT_bit_size
:
31620 case DW_AT_lower_bound
:
31621 case DW_AT_upper_bound
:
31622 case DW_AT_bit_stride
:
31624 case DW_AT_allocated
:
31625 case DW_AT_associated
:
31626 case DW_AT_byte_stride
:
31627 if (prev
== NULL
&& next
== NULL
)
31635 /* Create DW_TAG_variable that we can refer to. */
31636 gen_decl_die (decl
, NULL_TREE
, NULL
,
31637 lookup_decl_die (current_function_decl
));
31638 ref
= lookup_decl_die (decl
);
31641 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31642 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31643 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31649 prev
->dw_loc_next
= l
->expr
;
31650 add_loc_descr (&prev
->dw_loc_next
, next
);
31651 free_loc_descr (loc
, NULL
);
31652 next
= prev
->dw_loc_next
;
31656 memcpy (loc
, l
->expr
, sizeof (dw_loc_descr_node
));
31657 add_loc_descr (&loc
, next
);
31665 /* Attempt to resolve DW_OP_GNU_variable_value using loc_list_from_tree. */
31668 resolve_variable_value (dw_die_ref die
)
31671 dw_loc_list_ref loc
;
31674 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31675 switch (AT_class (a
))
31677 case dw_val_class_loc
:
31678 if (!resolve_variable_value_in_expr (a
, AT_loc (a
)))
31681 case dw_val_class_loc_list
:
31682 loc
= AT_loc_list (a
);
31684 for (; loc
; loc
= loc
->dw_loc_next
)
31685 resolve_variable_value_in_expr (a
, loc
->expr
);
31692 /* Attempt to optimize DW_OP_GNU_variable_value refering to
31693 temporaries in the current function. */
31696 resolve_variable_values (void)
31698 if (!variable_value_hash
|| !current_function_decl
)
31701 struct variable_value_struct
*node
31702 = variable_value_hash
->find_with_hash (current_function_decl
,
31703 DECL_UID (current_function_decl
));
31710 FOR_EACH_VEC_SAFE_ELT (node
->dies
, i
, die
)
31711 resolve_variable_value (die
);
31714 /* Helper function for note_variable_value, handle one location
31718 note_variable_value_in_expr (dw_die_ref die
, dw_loc_descr_ref loc
)
31720 for (; loc
; loc
= loc
->dw_loc_next
)
31721 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
31722 && loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
31724 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
31725 dw_die_ref ref
= lookup_decl_die (decl
);
31726 if (! ref
&& (flag_generate_lto
|| flag_generate_offload
))
31728 /* ??? This is somewhat a hack because we do not create DIEs
31729 for variables not in BLOCK trees early but when generating
31730 early LTO output we need the dw_val_class_decl_ref to be
31731 fully resolved. For fat LTO objects we'd also like to
31732 undo this after LTO dwarf output. */
31733 gcc_assert (DECL_CONTEXT (decl
));
31734 dw_die_ref ctx
= lookup_decl_die (DECL_CONTEXT (decl
));
31735 gcc_assert (ctx
!= NULL
);
31736 gen_decl_die (decl
, NULL_TREE
, NULL
, ctx
);
31737 ref
= lookup_decl_die (decl
);
31738 gcc_assert (ref
!= NULL
);
31742 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31743 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31744 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31748 && DECL_CONTEXT (decl
)
31749 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
31750 && lookup_decl_die (DECL_CONTEXT (decl
)))
31752 if (!variable_value_hash
)
31753 variable_value_hash
31754 = hash_table
<variable_value_hasher
>::create_ggc (10);
31756 tree fndecl
= DECL_CONTEXT (decl
);
31757 struct variable_value_struct
*node
;
31758 struct variable_value_struct
**slot
31759 = variable_value_hash
->find_slot_with_hash (fndecl
,
31764 node
= ggc_cleared_alloc
<variable_value_struct
> ();
31765 node
->decl_id
= DECL_UID (fndecl
);
31771 vec_safe_push (node
->dies
, die
);
31776 /* Walk the tree DIE and note DIEs with DW_OP_GNU_variable_value still
31777 with dw_val_class_decl_ref operand. */
31780 note_variable_value (dw_die_ref die
)
31784 dw_loc_list_ref loc
;
31787 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31788 switch (AT_class (a
))
31790 case dw_val_class_loc_list
:
31791 loc
= AT_loc_list (a
);
31793 if (!loc
->noted_variable_value
)
31795 loc
->noted_variable_value
= 1;
31796 for (; loc
; loc
= loc
->dw_loc_next
)
31797 note_variable_value_in_expr (die
, loc
->expr
);
31800 case dw_val_class_loc
:
31801 note_variable_value_in_expr (die
, AT_loc (a
));
31807 /* Mark children. */
31808 FOR_EACH_CHILD (die
, c
, note_variable_value (c
));
31811 /* Perform any cleanups needed after the early debug generation pass
31815 dwarf2out_early_finish (const char *filename
)
31818 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
31820 /* PCH might result in DW_AT_producer string being restored from the
31821 header compilation, so always fill it with empty string initially
31822 and overwrite only here. */
31823 dw_attr_node
*producer
= get_AT (comp_unit_die (), DW_AT_producer
);
31824 producer_string
= gen_producer_string ();
31825 producer
->dw_attr_val
.v
.val_str
->refcount
--;
31826 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
31828 /* Add the name for the main input file now. We delayed this from
31829 dwarf2out_init to avoid complications with PCH. */
31830 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
31831 add_comp_dir_attribute (comp_unit_die ());
31833 /* When emitting DWARF5 .debug_line_str, move DW_AT_name and
31834 DW_AT_comp_dir into .debug_line_str section. */
31835 if (!output_asm_line_debug_info ()
31836 && dwarf_version
>= 5
31837 && DWARF5_USE_DEBUG_LINE_STR
)
31839 for (int i
= 0; i
< 2; i
++)
31841 dw_attr_node
*a
= get_AT (comp_unit_die (),
31842 i
? DW_AT_comp_dir
: DW_AT_name
);
31844 || AT_class (a
) != dw_val_class_str
31845 || strlen (AT_string (a
)) + 1 <= DWARF_OFFSET_SIZE
)
31848 if (! debug_line_str_hash
)
31849 debug_line_str_hash
31850 = hash_table
<indirect_string_hasher
>::create_ggc (10);
31852 struct indirect_string_node
*node
31853 = find_AT_string_in_table (AT_string (a
), debug_line_str_hash
);
31854 set_indirect_string (node
);
31855 node
->form
= DW_FORM_line_strp
;
31856 a
->dw_attr_val
.v
.val_str
->refcount
--;
31857 a
->dw_attr_val
.v
.val_str
= node
;
31861 /* With LTO early dwarf was really finished at compile-time, so make
31862 sure to adjust the phase after annotating the LTRANS CU DIE. */
31865 early_dwarf_finished
= true;
31869 /* Walk through the list of incomplete types again, trying once more to
31870 emit full debugging info for them. */
31871 retry_incomplete_types ();
31873 /* The point here is to flush out the limbo list so that it is empty
31874 and we don't need to stream it for LTO. */
31875 flush_limbo_die_list ();
31877 gen_scheduled_generic_parms_dies ();
31878 gen_remaining_tmpl_value_param_die_attribute ();
31880 /* Add DW_AT_linkage_name for all deferred DIEs. */
31881 for (limbo_die_node
*node
= deferred_asm_name
; node
; node
= node
->next
)
31883 tree decl
= node
->created_for
;
31884 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
31885 /* A missing DECL_ASSEMBLER_NAME can be a constant DIE that
31886 ended up in deferred_asm_name before we knew it was
31887 constant and never written to disk. */
31888 && DECL_ASSEMBLER_NAME (decl
))
31890 add_linkage_attr (node
->die
, decl
);
31891 move_linkage_attr (node
->die
);
31894 deferred_asm_name
= NULL
;
31896 if (flag_eliminate_unused_debug_types
)
31897 prune_unused_types ();
31899 /* Generate separate COMDAT sections for type DIEs. */
31900 if (use_debug_types
)
31902 break_out_comdat_types (comp_unit_die ());
31904 /* Each new type_unit DIE was added to the limbo die list when created.
31905 Since these have all been added to comdat_type_list, clear the
31907 limbo_die_list
= NULL
;
31909 /* For each new comdat type unit, copy declarations for incomplete
31910 types to make the new unit self-contained (i.e., no direct
31911 references to the main compile unit). */
31912 for (comdat_type_node
*ctnode
= comdat_type_list
;
31913 ctnode
!= NULL
; ctnode
= ctnode
->next
)
31914 copy_decls_for_unworthy_types (ctnode
->root_die
);
31915 copy_decls_for_unworthy_types (comp_unit_die ());
31917 /* In the process of copying declarations from one unit to another,
31918 we may have left some declarations behind that are no longer
31919 referenced. Prune them. */
31920 prune_unused_types ();
31923 /* Traverse the DIE's and note DIEs with DW_OP_GNU_variable_value still
31924 with dw_val_class_decl_ref operand. */
31925 note_variable_value (comp_unit_die ());
31926 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
31927 note_variable_value (node
->die
);
31928 for (comdat_type_node
*ctnode
= comdat_type_list
; ctnode
!= NULL
;
31929 ctnode
= ctnode
->next
)
31930 note_variable_value (ctnode
->root_die
);
31931 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
31932 note_variable_value (node
->die
);
31934 /* The AT_pubnames attribute needs to go in all skeleton dies, including
31935 both the main_cu and all skeleton TUs. Making this call unconditional
31936 would end up either adding a second copy of the AT_pubnames attribute, or
31937 requiring a special case in add_top_level_skeleton_die_attrs. */
31938 if (!dwarf_split_debug_info
)
31939 add_AT_pubnames (comp_unit_die ());
31941 /* The early debug phase is now finished. */
31942 early_dwarf_finished
= true;
31944 /* Do not generate DWARF assembler now when not producing LTO bytecode. */
31945 if ((!flag_generate_lto
&& !flag_generate_offload
)
31946 /* FIXME: Disable debug info generation for (PE-)COFF targets since the
31947 copy_lto_debug_sections operation of the simple object support in
31948 libiberty is not implemented for them yet. */
31949 || TARGET_PECOFF
|| TARGET_COFF
)
31952 /* Now as we are going to output for LTO initialize sections and labels
31953 to the LTO variants. We don't need a random-seed postfix as other
31954 LTO sections as linking the LTO debug sections into one in a partial
31956 init_sections_and_labels (true);
31958 /* The output below is modeled after dwarf2out_finish with all
31959 location related output removed and some LTO specific changes.
31960 Some refactoring might make both smaller and easier to match up. */
31962 /* Traverse the DIE's and add add sibling attributes to those DIE's
31963 that have children. */
31964 add_sibling_attributes (comp_unit_die ());
31965 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
31966 add_sibling_attributes (node
->die
);
31967 for (comdat_type_node
*ctnode
= comdat_type_list
;
31968 ctnode
!= NULL
; ctnode
= ctnode
->next
)
31969 add_sibling_attributes (ctnode
->root_die
);
31971 /* AIX Assembler inserts the length, so adjust the reference to match the
31972 offset expected by debuggers. */
31973 strcpy (dl_section_ref
, debug_line_section_label
);
31974 if (XCOFF_DEBUGGING_INFO
)
31975 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
31977 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31978 add_AT_lineptr (comp_unit_die (), DW_AT_stmt_list
, dl_section_ref
);
31981 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
31982 macinfo_section_label
);
31984 save_macinfo_strings ();
31986 if (dwarf_split_debug_info
)
31988 unsigned int index
= 0;
31989 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
31992 /* Output all of the compilation units. We put the main one last so that
31993 the offsets are available to output_pubnames. */
31994 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
31995 output_comp_unit (node
->die
, 0, NULL
);
31997 hash_table
<comdat_type_hasher
> comdat_type_table (100);
31998 for (comdat_type_node
*ctnode
= comdat_type_list
;
31999 ctnode
!= NULL
; ctnode
= ctnode
->next
)
32001 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
32003 /* Don't output duplicate types. */
32004 if (*slot
!= HTAB_EMPTY_ENTRY
)
32007 /* Add a pointer to the line table for the main compilation unit
32008 so that the debugger can make sense of DW_AT_decl_file
32010 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32011 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
32012 (!dwarf_split_debug_info
32013 ? debug_line_section_label
32014 : debug_skeleton_line_section_label
));
32016 output_comdat_type_unit (ctnode
);
32020 /* Stick a unique symbol to the main debuginfo section. */
32021 compute_comp_unit_symbol (comp_unit_die ());
32023 /* Output the main compilation unit. We always need it if only for
32025 output_comp_unit (comp_unit_die (), true, NULL
);
32027 /* Output the abbreviation table. */
32028 if (vec_safe_length (abbrev_die_table
) != 1)
32030 switch_to_section (debug_abbrev_section
);
32031 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
32032 output_abbrev_section ();
32035 /* Have to end the macro section. */
32038 /* We have to save macinfo state if we need to output it again
32039 for the FAT part of the object. */
32040 vec
<macinfo_entry
, va_gc
> *saved_macinfo_table
= macinfo_table
;
32041 if (flag_fat_lto_objects
)
32042 macinfo_table
= macinfo_table
->copy ();
32044 switch_to_section (debug_macinfo_section
);
32045 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
32046 output_macinfo (debug_line_section_label
, true);
32047 dw2_asm_output_data (1, 0, "End compilation unit");
32049 if (flag_fat_lto_objects
)
32051 vec_free (macinfo_table
);
32052 macinfo_table
= saved_macinfo_table
;
32056 /* Emit a skeleton debug_line section. */
32057 switch_to_section (debug_line_section
);
32058 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
32059 output_line_info (true);
32061 /* If we emitted any indirect strings, output the string table too. */
32062 if (debug_str_hash
|| skeleton_debug_str_hash
)
32063 output_indirect_strings ();
32064 if (debug_line_str_hash
)
32066 switch_to_section (debug_line_str_section
);
32067 const enum dwarf_form form
= DW_FORM_line_strp
;
32068 debug_line_str_hash
->traverse
<enum dwarf_form
,
32069 output_indirect_string
> (form
);
32072 /* Switch back to the text section. */
32073 switch_to_section (text_section
);
32076 /* Reset all state within dwarf2out.c so that we can rerun the compiler
32077 within the same process. For use by toplev::finalize. */
32080 dwarf2out_c_finalize (void)
32082 last_var_location_insn
= NULL
;
32083 cached_next_real_insn
= NULL
;
32084 used_rtx_array
= NULL
;
32085 incomplete_types
= NULL
;
32086 debug_info_section
= NULL
;
32087 debug_skeleton_info_section
= NULL
;
32088 debug_abbrev_section
= NULL
;
32089 debug_skeleton_abbrev_section
= NULL
;
32090 debug_aranges_section
= NULL
;
32091 debug_addr_section
= NULL
;
32092 debug_macinfo_section
= NULL
;
32093 debug_line_section
= NULL
;
32094 debug_skeleton_line_section
= NULL
;
32095 debug_loc_section
= NULL
;
32096 debug_pubnames_section
= NULL
;
32097 debug_pubtypes_section
= NULL
;
32098 debug_str_section
= NULL
;
32099 debug_line_str_section
= NULL
;
32100 debug_str_dwo_section
= NULL
;
32101 debug_str_offsets_section
= NULL
;
32102 debug_ranges_section
= NULL
;
32103 debug_frame_section
= NULL
;
32105 debug_str_hash
= NULL
;
32106 debug_line_str_hash
= NULL
;
32107 skeleton_debug_str_hash
= NULL
;
32108 dw2_string_counter
= 0;
32109 have_multiple_function_sections
= false;
32110 text_section_used
= false;
32111 cold_text_section_used
= false;
32112 cold_text_section
= NULL
;
32113 current_unit_personality
= NULL
;
32115 early_dwarf
= false;
32116 early_dwarf_finished
= false;
32118 next_die_offset
= 0;
32119 single_comp_unit_die
= NULL
;
32120 comdat_type_list
= NULL
;
32121 limbo_die_list
= NULL
;
32123 decl_die_table
= NULL
;
32124 common_block_die_table
= NULL
;
32125 decl_loc_table
= NULL
;
32126 call_arg_locations
= NULL
;
32127 call_arg_loc_last
= NULL
;
32128 call_site_count
= -1;
32129 tail_call_site_count
= -1;
32130 cached_dw_loc_list_table
= NULL
;
32131 abbrev_die_table
= NULL
;
32132 delete dwarf_proc_stack_usage_map
;
32133 dwarf_proc_stack_usage_map
= NULL
;
32134 line_info_label_num
= 0;
32135 cur_line_info_table
= NULL
;
32136 text_section_line_info
= NULL
;
32137 cold_text_section_line_info
= NULL
;
32138 separate_line_info
= NULL
;
32139 info_section_emitted
= false;
32140 pubname_table
= NULL
;
32141 pubtype_table
= NULL
;
32142 macinfo_table
= NULL
;
32143 ranges_table
= NULL
;
32144 ranges_by_label
= NULL
;
32146 have_location_lists
= false;
32149 last_emitted_file
= NULL
;
32151 tmpl_value_parm_die_table
= NULL
;
32152 generic_type_instances
= NULL
;
32153 frame_pointer_fb_offset
= 0;
32154 frame_pointer_fb_offset_valid
= false;
32155 base_types
.release ();
32156 XDELETEVEC (producer_string
);
32157 producer_string
= NULL
;
32160 #include "gt-dwarf2out.h"