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
);
105 static bool is_redundant_typedef (const_tree
);
107 #ifndef XCOFF_DEBUGGING_INFO
108 #define XCOFF_DEBUGGING_INFO 0
111 #ifndef HAVE_XCOFF_DWARF_EXTRAS
112 #define HAVE_XCOFF_DWARF_EXTRAS 0
115 #ifdef VMS_DEBUGGING_INFO
116 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
118 /* Define this macro to be a nonzero value if the directory specifications
119 which are output in the debug info should end with a separator. */
120 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
121 /* Define this macro to evaluate to a nonzero value if GCC should refrain
122 from generating indirect strings in DWARF2 debug information, for instance
123 if your target is stuck with an old version of GDB that is unable to
124 process them properly or uses VMS Debug. */
125 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
127 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
128 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
131 /* ??? Poison these here until it can be done generically. They've been
132 totally replaced in this file; make sure it stays that way. */
133 #undef DWARF2_UNWIND_INFO
134 #undef DWARF2_FRAME_INFO
135 #if (GCC_VERSION >= 3000)
136 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
139 /* The size of the target's pointer type. */
141 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
144 /* Array of RTXes referenced by the debugging information, which therefore
145 must be kept around forever. */
146 static GTY(()) vec
<rtx
, va_gc
> *used_rtx_array
;
148 /* A pointer to the base of a list of incomplete types which might be
149 completed at some later time. incomplete_types_list needs to be a
150 vec<tree, va_gc> *because we want to tell the garbage collector about
152 static GTY(()) vec
<tree
, va_gc
> *incomplete_types
;
154 /* Pointers to various DWARF2 sections. */
155 static GTY(()) section
*debug_info_section
;
156 static GTY(()) section
*debug_skeleton_info_section
;
157 static GTY(()) section
*debug_abbrev_section
;
158 static GTY(()) section
*debug_skeleton_abbrev_section
;
159 static GTY(()) section
*debug_aranges_section
;
160 static GTY(()) section
*debug_addr_section
;
161 static GTY(()) section
*debug_macinfo_section
;
162 static const char *debug_macinfo_section_name
;
163 static unsigned macinfo_label_base
= 1;
164 static GTY(()) section
*debug_line_section
;
165 static GTY(()) section
*debug_skeleton_line_section
;
166 static GTY(()) section
*debug_loc_section
;
167 static GTY(()) section
*debug_pubnames_section
;
168 static GTY(()) section
*debug_pubtypes_section
;
169 static GTY(()) section
*debug_str_section
;
170 static GTY(()) section
*debug_line_str_section
;
171 static GTY(()) section
*debug_str_dwo_section
;
172 static GTY(()) section
*debug_str_offsets_section
;
173 static GTY(()) section
*debug_ranges_section
;
174 static GTY(()) section
*debug_frame_section
;
176 /* Maximum size (in bytes) of an artificially generated label. */
177 #define MAX_ARTIFICIAL_LABEL_BYTES 40
179 /* According to the (draft) DWARF 3 specification, the initial length
180 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
181 bytes are 0xffffffff, followed by the length stored in the next 8
184 However, the SGI/MIPS ABI uses an initial length which is equal to
185 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
187 #ifndef DWARF_INITIAL_LENGTH_SIZE
188 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
191 #ifndef DWARF_INITIAL_LENGTH_SIZE_STR
192 #define DWARF_INITIAL_LENGTH_SIZE_STR (DWARF_OFFSET_SIZE == 4 ? "-4" : "-12")
195 /* Round SIZE up to the nearest BOUNDARY. */
196 #define DWARF_ROUND(SIZE,BOUNDARY) \
197 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
199 /* CIE identifier. */
200 #if HOST_BITS_PER_WIDE_INT >= 64
201 #define DWARF_CIE_ID \
202 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
204 #define DWARF_CIE_ID DW_CIE_ID
208 /* A vector for a table that contains frame description
209 information for each routine. */
210 #define NOT_INDEXED (-1U)
211 #define NO_INDEX_ASSIGNED (-2U)
213 static GTY(()) vec
<dw_fde_ref
, va_gc
> *fde_vec
;
215 struct GTY((for_user
)) indirect_string_node
{
217 unsigned int refcount
;
218 enum dwarf_form form
;
223 struct indirect_string_hasher
: ggc_ptr_hash
<indirect_string_node
>
225 typedef const char *compare_type
;
227 static hashval_t
hash (indirect_string_node
*);
228 static bool equal (indirect_string_node
*, const char *);
231 static GTY (()) hash_table
<indirect_string_hasher
> *debug_str_hash
;
233 static GTY (()) hash_table
<indirect_string_hasher
> *debug_line_str_hash
;
235 /* With split_debug_info, both the comp_dir and dwo_name go in the
236 main object file, rather than the dwo, similar to the force_direct
237 parameter elsewhere but with additional complications:
239 1) The string is needed in both the main object file and the dwo.
240 That is, the comp_dir and dwo_name will appear in both places.
242 2) Strings can use four forms: DW_FORM_string, DW_FORM_strp,
243 DW_FORM_line_strp or DW_FORM_strx/GNU_str_index.
245 3) GCC chooses the form to use late, depending on the size and
248 Rather than forcing the all debug string handling functions and
249 callers to deal with these complications, simply use a separate,
250 special-cased string table for any attribute that should go in the
251 main object file. This limits the complexity to just the places
254 static GTY (()) hash_table
<indirect_string_hasher
> *skeleton_debug_str_hash
;
256 static GTY(()) int dw2_string_counter
;
258 /* True if the compilation unit places functions in more than one section. */
259 static GTY(()) bool have_multiple_function_sections
= false;
261 /* Whether the default text and cold text sections have been used at all. */
262 static GTY(()) bool text_section_used
= false;
263 static GTY(()) bool cold_text_section_used
= false;
265 /* The default cold text section. */
266 static GTY(()) section
*cold_text_section
;
268 /* The DIE for C++14 'auto' in a function return type. */
269 static GTY(()) dw_die_ref auto_die
;
271 /* The DIE for C++14 'decltype(auto)' in a function return type. */
272 static GTY(()) dw_die_ref decltype_auto_die
;
274 /* Forward declarations for functions defined in this file. */
276 static void output_call_frame_info (int);
277 static void dwarf2out_note_section_used (void);
279 /* Personality decl of current unit. Used only when assembler does not support
281 static GTY(()) rtx current_unit_personality
;
283 /* Whether an eh_frame section is required. */
284 static GTY(()) bool do_eh_frame
= false;
286 /* .debug_rnglists next index. */
287 static unsigned int rnglist_idx
;
289 /* Data and reference forms for relocatable data. */
290 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
291 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
293 #ifndef DEBUG_FRAME_SECTION
294 #define DEBUG_FRAME_SECTION ".debug_frame"
297 #ifndef FUNC_BEGIN_LABEL
298 #define FUNC_BEGIN_LABEL "LFB"
301 #ifndef FUNC_SECOND_SECT_LABEL
302 #define FUNC_SECOND_SECT_LABEL "LFSB"
305 #ifndef FUNC_END_LABEL
306 #define FUNC_END_LABEL "LFE"
309 #ifndef PROLOGUE_END_LABEL
310 #define PROLOGUE_END_LABEL "LPE"
313 #ifndef EPILOGUE_BEGIN_LABEL
314 #define EPILOGUE_BEGIN_LABEL "LEB"
317 #ifndef FRAME_BEGIN_LABEL
318 #define FRAME_BEGIN_LABEL "Lframe"
320 #define CIE_AFTER_SIZE_LABEL "LSCIE"
321 #define CIE_END_LABEL "LECIE"
322 #define FDE_LABEL "LSFDE"
323 #define FDE_AFTER_SIZE_LABEL "LASFDE"
324 #define FDE_END_LABEL "LEFDE"
325 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
326 #define LINE_NUMBER_END_LABEL "LELT"
327 #define LN_PROLOG_AS_LABEL "LASLTP"
328 #define LN_PROLOG_END_LABEL "LELTP"
329 #define DIE_LABEL_PREFIX "DW"
331 /* Match the base name of a file to the base name of a compilation unit. */
334 matches_main_base (const char *path
)
336 /* Cache the last query. */
337 static const char *last_path
= NULL
;
338 static int last_match
= 0;
339 if (path
!= last_path
)
342 int length
= base_of_path (path
, &base
);
344 last_match
= (length
== main_input_baselength
345 && memcmp (base
, main_input_basename
, length
) == 0);
350 #ifdef DEBUG_DEBUG_STRUCT
353 dump_struct_debug (tree type
, enum debug_info_usage usage
,
354 enum debug_struct_file criterion
, int generic
,
355 int matches
, int result
)
357 /* Find the type name. */
358 tree type_decl
= TYPE_STUB_DECL (type
);
360 const char *name
= 0;
361 if (TREE_CODE (t
) == TYPE_DECL
)
364 name
= IDENTIFIER_POINTER (t
);
366 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
368 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
369 matches
? "bas" : "hdr",
370 generic
? "gen" : "ord",
371 usage
== DINFO_USAGE_DFN
? ";" :
372 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
374 (void*) type_decl
, name
);
377 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
378 dump_struct_debug (type, usage, criterion, generic, matches, result)
382 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
387 /* Get the number of HOST_WIDE_INTs needed to represent the precision
388 of the number. Some constants have a large uniform precision, so
389 we get the precision needed for the actual value of the number. */
392 get_full_len (const wide_int
&op
)
394 int prec
= wi::min_precision (op
, UNSIGNED
);
395 return ((prec
+ HOST_BITS_PER_WIDE_INT
- 1)
396 / HOST_BITS_PER_WIDE_INT
);
400 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
402 enum debug_struct_file criterion
;
404 bool generic
= lang_hooks
.types
.generic_p (type
);
407 criterion
= debug_struct_generic
[usage
];
409 criterion
= debug_struct_ordinary
[usage
];
411 if (criterion
== DINFO_STRUCT_FILE_NONE
)
412 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
413 if (criterion
== DINFO_STRUCT_FILE_ANY
)
414 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
416 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
418 if (type_decl
!= NULL
)
420 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
421 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
423 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
424 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
427 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
430 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
431 switch to the data section instead, and write out a synthetic start label
432 for collect2 the first time around. */
435 switch_to_eh_frame_section (bool back ATTRIBUTE_UNUSED
)
437 if (eh_frame_section
== 0)
441 if (EH_TABLES_CAN_BE_READ_ONLY
)
447 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
449 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
451 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
454 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
455 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
456 && (per_encoding
& 0x70) != DW_EH_PE_absptr
457 && (per_encoding
& 0x70) != DW_EH_PE_aligned
458 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
459 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
460 ? 0 : SECTION_WRITE
);
463 flags
= SECTION_WRITE
;
465 #ifdef EH_FRAME_SECTION_NAME
466 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
468 eh_frame_section
= ((flags
== SECTION_WRITE
)
469 ? data_section
: readonly_data_section
);
470 #endif /* EH_FRAME_SECTION_NAME */
473 switch_to_section (eh_frame_section
);
475 #ifdef EH_FRAME_THROUGH_COLLECT2
476 /* We have no special eh_frame section. Emit special labels to guide
480 tree label
= get_file_function_name ("F");
481 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
482 targetm
.asm_out
.globalize_label (asm_out_file
,
483 IDENTIFIER_POINTER (label
));
484 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
489 /* Switch [BACK] to the eh or debug frame table section, depending on
493 switch_to_frame_table_section (int for_eh
, bool back
)
496 switch_to_eh_frame_section (back
);
499 if (!debug_frame_section
)
500 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
501 SECTION_DEBUG
, NULL
);
502 switch_to_section (debug_frame_section
);
506 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
508 enum dw_cfi_oprnd_type
509 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
514 case DW_CFA_GNU_window_save
:
515 case DW_CFA_remember_state
:
516 case DW_CFA_restore_state
:
517 return dw_cfi_oprnd_unused
;
520 case DW_CFA_advance_loc1
:
521 case DW_CFA_advance_loc2
:
522 case DW_CFA_advance_loc4
:
523 case DW_CFA_MIPS_advance_loc8
:
524 return dw_cfi_oprnd_addr
;
527 case DW_CFA_offset_extended
:
529 case DW_CFA_offset_extended_sf
:
530 case DW_CFA_def_cfa_sf
:
532 case DW_CFA_restore_extended
:
533 case DW_CFA_undefined
:
534 case DW_CFA_same_value
:
535 case DW_CFA_def_cfa_register
:
536 case DW_CFA_register
:
537 case DW_CFA_expression
:
538 case DW_CFA_val_expression
:
539 return dw_cfi_oprnd_reg_num
;
541 case DW_CFA_def_cfa_offset
:
542 case DW_CFA_GNU_args_size
:
543 case DW_CFA_def_cfa_offset_sf
:
544 return dw_cfi_oprnd_offset
;
546 case DW_CFA_def_cfa_expression
:
547 return dw_cfi_oprnd_loc
;
554 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
556 enum dw_cfi_oprnd_type
557 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
562 case DW_CFA_def_cfa_sf
:
564 case DW_CFA_offset_extended_sf
:
565 case DW_CFA_offset_extended
:
566 return dw_cfi_oprnd_offset
;
568 case DW_CFA_register
:
569 return dw_cfi_oprnd_reg_num
;
571 case DW_CFA_expression
:
572 case DW_CFA_val_expression
:
573 return dw_cfi_oprnd_loc
;
575 case DW_CFA_def_cfa_expression
:
576 return dw_cfi_oprnd_cfa_loc
;
579 return dw_cfi_oprnd_unused
;
583 /* Output one FDE. */
586 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
587 char *section_start_label
, int fde_encoding
, char *augmentation
,
588 bool any_lsda_needed
, int lsda_encoding
)
590 const char *begin
, *end
;
591 static unsigned int j
;
592 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
594 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
596 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
598 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
599 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
600 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
602 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
603 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
604 " indicating 64-bit DWARF extension");
605 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
608 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
611 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
613 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
614 debug_frame_section
, "FDE CIE offset");
616 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
617 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
621 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
622 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
623 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
624 "FDE initial location");
625 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
626 end
, begin
, "FDE address range");
630 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
631 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
638 int size
= size_of_encoded_value (lsda_encoding
);
640 if (lsda_encoding
== DW_EH_PE_aligned
)
642 int offset
= ( 4 /* Length */
644 + 2 * size_of_encoded_value (fde_encoding
)
645 + 1 /* Augmentation size */ );
646 int pad
= -offset
& (PTR_SIZE
- 1);
649 gcc_assert (size_of_uleb128 (size
) == 1);
652 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
654 if (fde
->uses_eh_lsda
)
656 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
657 fde
->funcdef_number
);
658 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
659 gen_rtx_SYMBOL_REF (Pmode
, l1
),
661 "Language Specific Data Area");
665 if (lsda_encoding
== DW_EH_PE_aligned
)
666 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
667 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
668 "Language Specific Data Area (none)");
672 dw2_asm_output_data_uleb128 (0, "Augmentation size");
675 /* Loop through the Call Frame Instructions associated with this FDE. */
676 fde
->dw_fde_current_label
= begin
;
678 size_t from
, until
, i
;
681 until
= vec_safe_length (fde
->dw_fde_cfi
);
683 if (fde
->dw_fde_second_begin
== NULL
)
686 until
= fde
->dw_fde_switch_cfi_index
;
688 from
= fde
->dw_fde_switch_cfi_index
;
690 for (i
= from
; i
< until
; i
++)
691 output_cfi ((*fde
->dw_fde_cfi
)[i
], fde
, for_eh
);
694 /* If we are to emit a ref/link from function bodies to their frame tables,
695 do it now. This is typically performed to make sure that tables
696 associated with functions are dragged with them and not discarded in
697 garbage collecting links. We need to do this on a per function basis to
698 cope with -ffunction-sections. */
700 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
701 /* Switch to the function section, emit the ref to the tables, and
702 switch *back* into the table section. */
703 switch_to_section (function_section (fde
->decl
));
704 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
705 switch_to_frame_table_section (for_eh
, true);
708 /* Pad the FDE out to an address sized boundary. */
709 ASM_OUTPUT_ALIGN (asm_out_file
,
710 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
711 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
716 /* Return true if frame description entry FDE is needed for EH. */
719 fde_needed_for_eh_p (dw_fde_ref fde
)
721 if (flag_asynchronous_unwind_tables
)
724 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
727 if (fde
->uses_eh_lsda
)
730 /* If exceptions are enabled, we have collected nothrow info. */
731 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
737 /* Output the call frame information used to record information
738 that relates to calculating the frame pointer, and records the
739 location of saved registers. */
742 output_call_frame_info (int for_eh
)
747 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
748 char section_start_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
749 bool any_lsda_needed
= false;
750 char augmentation
[6];
751 int augmentation_size
;
752 int fde_encoding
= DW_EH_PE_absptr
;
753 int per_encoding
= DW_EH_PE_absptr
;
754 int lsda_encoding
= DW_EH_PE_absptr
;
756 rtx personality
= NULL
;
759 /* Don't emit a CIE if there won't be any FDEs. */
763 /* Nothing to do if the assembler's doing it all. */
764 if (dwarf2out_do_cfi_asm ())
767 /* If we don't have any functions we'll want to unwind out of, don't emit
768 any EH unwind information. If we make FDEs linkonce, we may have to
769 emit an empty label for an FDE that wouldn't otherwise be emitted. We
770 want to avoid having an FDE kept around when the function it refers to
771 is discarded. Example where this matters: a primary function template
772 in C++ requires EH information, an explicit specialization doesn't. */
775 bool any_eh_needed
= false;
777 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
779 if (fde
->uses_eh_lsda
)
780 any_eh_needed
= any_lsda_needed
= true;
781 else if (fde_needed_for_eh_p (fde
))
782 any_eh_needed
= true;
783 else if (TARGET_USES_WEAK_UNWIND_INFO
)
784 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, 1, 1);
791 /* We're going to be generating comments, so turn on app. */
795 /* Switch to the proper frame section, first time. */
796 switch_to_frame_table_section (for_eh
, false);
798 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
799 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
801 /* Output the CIE. */
802 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
803 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
804 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
806 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
807 dw2_asm_output_data (4, 0xffffffff,
808 "Initial length escape value indicating 64-bit DWARF extension");
809 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
810 "Length of Common Information Entry");
812 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
814 /* Now that the CIE pointer is PC-relative for EH,
815 use 0 to identify the CIE. */
816 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
817 (for_eh
? 0 : DWARF_CIE_ID
),
818 "CIE Identifier Tag");
820 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
821 use CIE version 1, unless that would produce incorrect results
822 due to overflowing the return register column. */
823 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
825 if (return_reg
>= 256 || dwarf_version
> 2)
827 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
830 augmentation_size
= 0;
832 personality
= current_unit_personality
;
838 z Indicates that a uleb128 is present to size the
839 augmentation section.
840 L Indicates the encoding (and thus presence) of
841 an LSDA pointer in the FDE augmentation.
842 R Indicates a non-default pointer encoding for
844 P Indicates the presence of an encoding + language
845 personality routine in the CIE augmentation. */
847 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
848 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
849 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
851 p
= augmentation
+ 1;
855 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
856 assemble_external_libcall (personality
);
861 augmentation_size
+= 1;
863 if (fde_encoding
!= DW_EH_PE_absptr
)
866 augmentation_size
+= 1;
868 if (p
> augmentation
+ 1)
870 augmentation
[0] = 'z';
874 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
875 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
877 int offset
= ( 4 /* Length */
879 + 1 /* CIE version */
880 + strlen (augmentation
) + 1 /* Augmentation */
881 + size_of_uleb128 (1) /* Code alignment */
882 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
884 + 1 /* Augmentation size */
885 + 1 /* Personality encoding */ );
886 int pad
= -offset
& (PTR_SIZE
- 1);
888 augmentation_size
+= pad
;
890 /* Augmentations should be small, so there's scarce need to
891 iterate for a solution. Die if we exceed one uleb128 byte. */
892 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
896 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
897 if (dw_cie_version
>= 4)
899 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
900 dw2_asm_output_data (1, 0, "CIE Segment Size");
902 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
903 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
904 "CIE Data Alignment Factor");
906 if (dw_cie_version
== 1)
907 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
909 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
913 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
916 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
917 eh_data_format_name (per_encoding
));
918 dw2_asm_output_encoded_addr_rtx (per_encoding
,
924 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
925 eh_data_format_name (lsda_encoding
));
927 if (fde_encoding
!= DW_EH_PE_absptr
)
928 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
929 eh_data_format_name (fde_encoding
));
932 FOR_EACH_VEC_ELT (*cie_cfi_vec
, i
, cfi
)
933 output_cfi (cfi
, NULL
, for_eh
);
935 /* Pad the CIE out to an address sized boundary. */
936 ASM_OUTPUT_ALIGN (asm_out_file
,
937 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
938 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
940 /* Loop through all of the FDE's. */
941 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
945 /* Don't emit EH unwind info for leaf functions that don't need it. */
946 if (for_eh
&& !fde_needed_for_eh_p (fde
))
949 for (k
= 0; k
< (fde
->dw_fde_second_begin
? 2 : 1); k
++)
950 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
951 augmentation
, any_lsda_needed
, lsda_encoding
);
954 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
955 dw2_asm_output_data (4, 0, "End of Table");
957 /* Turn off app to make assembly quicker. */
962 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
965 dwarf2out_do_cfi_startproc (bool second
)
970 fprintf (asm_out_file
, "\t.cfi_startproc\n");
972 targetm
.asm_out
.post_cfi_startproc (asm_out_file
, current_function_decl
);
974 /* .cfi_personality and .cfi_lsda are only relevant to DWARF2
976 if (targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
)
979 rtx personality
= get_personality_function (current_function_decl
);
983 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
986 /* ??? The GAS support isn't entirely consistent. We have to
987 handle indirect support ourselves, but PC-relative is done
988 in the assembler. Further, the assembler can't handle any
989 of the weirder relocation types. */
990 if (enc
& DW_EH_PE_indirect
)
991 ref
= dw2_force_const_mem (ref
, true);
993 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
994 output_addr_const (asm_out_file
, ref
);
995 fputc ('\n', asm_out_file
);
998 if (crtl
->uses_eh_lsda
)
1000 char lab
[MAX_ARTIFICIAL_LABEL_BYTES
];
1002 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1003 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
1004 current_function_funcdef_no
);
1005 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
1006 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
1008 if (enc
& DW_EH_PE_indirect
)
1009 ref
= dw2_force_const_mem (ref
, true);
1011 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
1012 output_addr_const (asm_out_file
, ref
);
1013 fputc ('\n', asm_out_file
);
1017 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
1018 this allocation may be done before pass_final. */
1021 dwarf2out_alloc_current_fde (void)
1025 fde
= ggc_cleared_alloc
<dw_fde_node
> ();
1026 fde
->decl
= current_function_decl
;
1027 fde
->funcdef_number
= current_function_funcdef_no
;
1028 fde
->fde_index
= vec_safe_length (fde_vec
);
1029 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
1030 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
1031 fde
->nothrow
= crtl
->nothrow
;
1032 fde
->drap_reg
= INVALID_REGNUM
;
1033 fde
->vdrap_reg
= INVALID_REGNUM
;
1035 /* Record the FDE associated with this function. */
1037 vec_safe_push (fde_vec
, fde
);
1042 /* Output a marker (i.e. a label) for the beginning of a function, before
1046 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1047 unsigned int column ATTRIBUTE_UNUSED
,
1048 const char *file ATTRIBUTE_UNUSED
)
1050 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1056 current_function_func_begin_label
= NULL
;
1058 do_frame
= dwarf2out_do_frame ();
1060 /* ??? current_function_func_begin_label is also used by except.c for
1061 call-site information. We must emit this label if it might be used. */
1063 && (!flag_exceptions
1064 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1067 fnsec
= function_section (current_function_decl
);
1068 switch_to_section (fnsec
);
1069 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1070 current_function_funcdef_no
);
1071 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1072 current_function_funcdef_no
);
1073 dup_label
= xstrdup (label
);
1074 current_function_func_begin_label
= dup_label
;
1076 /* We can elide FDE allocation if we're not emitting frame unwind info. */
1080 /* Unlike the debug version, the EH version of frame unwind info is a per-
1081 function setting so we need to record whether we need it for the unit. */
1082 do_eh_frame
|= dwarf2out_do_eh_frame ();
1084 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1085 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1086 would include pass_dwarf2_frame. If we've not created the FDE yet,
1090 fde
= dwarf2out_alloc_current_fde ();
1092 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1093 fde
->dw_fde_begin
= dup_label
;
1094 fde
->dw_fde_current_label
= dup_label
;
1095 fde
->in_std_section
= (fnsec
== text_section
1096 || (cold_text_section
&& fnsec
== cold_text_section
));
1098 /* We only want to output line number information for the genuine dwarf2
1099 prologue case, not the eh frame case. */
1100 #ifdef DWARF2_DEBUGGING_INFO
1102 dwarf2out_source_line (line
, column
, file
, 0, true);
1105 if (dwarf2out_do_cfi_asm ())
1106 dwarf2out_do_cfi_startproc (false);
1109 rtx personality
= get_personality_function (current_function_decl
);
1110 if (!current_unit_personality
)
1111 current_unit_personality
= personality
;
1113 /* We cannot keep a current personality per function as without CFI
1114 asm, at the point where we emit the CFI data, there is no current
1115 function anymore. */
1116 if (personality
&& current_unit_personality
!= personality
)
1117 sorry ("multiple EH personalities are supported only with assemblers "
1118 "supporting .cfi_personality directive");
1122 /* Output a marker (i.e. a label) for the end of the generated code
1123 for a function prologue. This gets called *after* the prologue code has
1127 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1128 const char *file ATTRIBUTE_UNUSED
)
1130 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1132 /* Output a label to mark the endpoint of the code generated for this
1134 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1135 current_function_funcdef_no
);
1136 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1137 current_function_funcdef_no
);
1138 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1141 /* Output a marker (i.e. a label) for the beginning of the generated code
1142 for a function epilogue. This gets called *before* the prologue code has
1146 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1147 const char *file ATTRIBUTE_UNUSED
)
1149 dw_fde_ref fde
= cfun
->fde
;
1150 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1152 if (fde
->dw_fde_vms_begin_epilogue
)
1155 /* Output a label to mark the endpoint of the code generated for this
1157 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1158 current_function_funcdef_no
);
1159 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1160 current_function_funcdef_no
);
1161 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1164 /* Output a marker (i.e. a label) for the absolute end of the generated code
1165 for a function definition. This gets called *after* the epilogue code has
1169 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1170 const char *file ATTRIBUTE_UNUSED
)
1173 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1175 last_var_location_insn
= NULL
;
1176 cached_next_real_insn
= NULL
;
1178 if (dwarf2out_do_cfi_asm ())
1179 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1181 /* Output a label to mark the endpoint of the code generated for this
1183 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1184 current_function_funcdef_no
);
1185 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1187 gcc_assert (fde
!= NULL
);
1188 if (fde
->dw_fde_second_begin
== NULL
)
1189 fde
->dw_fde_end
= xstrdup (label
);
1193 dwarf2out_frame_finish (void)
1195 /* Output call frame information. */
1196 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1197 output_call_frame_info (0);
1199 /* Output another copy for the unwinder. */
1201 output_call_frame_info (1);
1204 /* Note that the current function section is being used for code. */
1207 dwarf2out_note_section_used (void)
1209 section
*sec
= current_function_section ();
1210 if (sec
== text_section
)
1211 text_section_used
= true;
1212 else if (sec
== cold_text_section
)
1213 cold_text_section_used
= true;
1216 static void var_location_switch_text_section (void);
1217 static void set_cur_line_info_table (section
*);
1220 dwarf2out_switch_text_section (void)
1222 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1224 dw_fde_ref fde
= cfun
->fde
;
1226 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1228 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_SECOND_SECT_LABEL
,
1229 current_function_funcdef_no
);
1231 fde
->dw_fde_second_begin
= ggc_strdup (label
);
1232 if (!in_cold_section_p
)
1234 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1235 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1239 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1240 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1242 have_multiple_function_sections
= true;
1244 /* There is no need to mark used sections when not debugging. */
1245 if (cold_text_section
!= NULL
)
1246 dwarf2out_note_section_used ();
1248 if (dwarf2out_do_cfi_asm ())
1249 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1251 /* Now do the real section switch. */
1252 sect
= current_function_section ();
1253 switch_to_section (sect
);
1255 fde
->second_in_std_section
1256 = (sect
== text_section
1257 || (cold_text_section
&& sect
== cold_text_section
));
1259 if (dwarf2out_do_cfi_asm ())
1260 dwarf2out_do_cfi_startproc (true);
1262 var_location_switch_text_section ();
1264 if (cold_text_section
!= NULL
)
1265 set_cur_line_info_table (sect
);
1268 /* And now, the subset of the debugging information support code necessary
1269 for emitting location expressions. */
1271 /* Data about a single source file. */
1272 struct GTY((for_user
)) dwarf_file_data
{
1273 const char * filename
;
1277 /* Describe an entry into the .debug_addr section. */
1281 ate_kind_rtx_dtprel
,
1285 struct GTY((for_user
)) addr_table_entry
{
1287 unsigned int refcount
;
1289 union addr_table_entry_struct_union
1291 rtx
GTY ((tag ("0"))) rtl
;
1292 char * GTY ((tag ("1"))) label
;
1294 GTY ((desc ("%1.kind"))) addr
;
1297 typedef unsigned int var_loc_view
;
1299 /* Location lists are ranges + location descriptions for that range,
1300 so you can track variables that are in different places over
1301 their entire life. */
1302 typedef struct GTY(()) dw_loc_list_struct
{
1303 dw_loc_list_ref dw_loc_next
;
1304 const char *begin
; /* Label and addr_entry for start of range */
1305 addr_table_entry
*begin_entry
;
1306 const char *end
; /* Label for end of range */
1307 char *ll_symbol
; /* Label for beginning of location list.
1308 Only on head of list. */
1309 char *vl_symbol
; /* Label for beginning of view list. Ditto. */
1310 const char *section
; /* Section this loclist is relative to */
1311 dw_loc_descr_ref expr
;
1312 var_loc_view vbegin
, vend
;
1314 /* True if all addresses in this and subsequent lists are known to be
1317 /* True if this list has been replaced by dw_loc_next. */
1319 /* True if it has been emitted into .debug_loc* / .debug_loclists*
1321 unsigned char emitted
: 1;
1322 /* True if hash field is index rather than hash value. */
1323 unsigned char num_assigned
: 1;
1324 /* True if .debug_loclists.dwo offset has been emitted for it already. */
1325 unsigned char offset_emitted
: 1;
1326 /* True if note_variable_value_in_expr has been called on it. */
1327 unsigned char noted_variable_value
: 1;
1328 /* True if the range should be emitted even if begin and end
1333 static dw_loc_descr_ref
int_loc_descriptor (poly_int64
);
1334 static dw_loc_descr_ref
uint_loc_descriptor (unsigned HOST_WIDE_INT
);
1336 /* Convert a DWARF stack opcode into its string name. */
1339 dwarf_stack_op_name (unsigned int op
)
1341 const char *name
= get_DW_OP_name (op
);
1346 return "OP_<unknown>";
1349 /* Return TRUE iff we're to output location view lists as a separate
1350 attribute next to the location lists, as an extension compatible
1351 with DWARF 2 and above. */
1354 dwarf2out_locviews_in_attribute ()
1356 return debug_variable_location_views
== 1;
1359 /* Return TRUE iff we're to output location view lists as part of the
1360 location lists, as proposed for standardization after DWARF 5. */
1363 dwarf2out_locviews_in_loclist ()
1365 #ifndef DW_LLE_view_pair
1368 return debug_variable_location_views
== -1;
1372 /* Return a pointer to a newly allocated location description. Location
1373 descriptions are simple expression terms that can be strung
1374 together to form more complicated location (address) descriptions. */
1376 static inline dw_loc_descr_ref
1377 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1378 unsigned HOST_WIDE_INT oprnd2
)
1380 dw_loc_descr_ref descr
= ggc_cleared_alloc
<dw_loc_descr_node
> ();
1382 descr
->dw_loc_opc
= op
;
1383 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1384 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1385 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1386 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1387 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1388 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1393 /* Add a location description term to a location description expression. */
1396 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1398 dw_loc_descr_ref
*d
;
1400 /* Find the end of the chain. */
1401 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1407 /* Compare two location operands for exact equality. */
1410 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1412 if (a
->val_class
!= b
->val_class
)
1414 switch (a
->val_class
)
1416 case dw_val_class_none
:
1418 case dw_val_class_addr
:
1419 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1421 case dw_val_class_offset
:
1422 case dw_val_class_unsigned_const
:
1423 case dw_val_class_const
:
1424 case dw_val_class_unsigned_const_implicit
:
1425 case dw_val_class_const_implicit
:
1426 case dw_val_class_range_list
:
1427 /* These are all HOST_WIDE_INT, signed or unsigned. */
1428 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1430 case dw_val_class_loc
:
1431 return a
->v
.val_loc
== b
->v
.val_loc
;
1432 case dw_val_class_loc_list
:
1433 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1434 case dw_val_class_view_list
:
1435 return a
->v
.val_view_list
== b
->v
.val_view_list
;
1436 case dw_val_class_die_ref
:
1437 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1438 case dw_val_class_fde_ref
:
1439 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1440 case dw_val_class_symview
:
1441 return strcmp (a
->v
.val_symbolic_view
, b
->v
.val_symbolic_view
) == 0;
1442 case dw_val_class_lbl_id
:
1443 case dw_val_class_lineptr
:
1444 case dw_val_class_macptr
:
1445 case dw_val_class_loclistsptr
:
1446 case dw_val_class_high_pc
:
1447 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1448 case dw_val_class_str
:
1449 return a
->v
.val_str
== b
->v
.val_str
;
1450 case dw_val_class_flag
:
1451 return a
->v
.val_flag
== b
->v
.val_flag
;
1452 case dw_val_class_file
:
1453 case dw_val_class_file_implicit
:
1454 return a
->v
.val_file
== b
->v
.val_file
;
1455 case dw_val_class_decl_ref
:
1456 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1458 case dw_val_class_const_double
:
1459 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1460 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1462 case dw_val_class_wide_int
:
1463 return *a
->v
.val_wide
== *b
->v
.val_wide
;
1465 case dw_val_class_vec
:
1467 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1468 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1470 return (a_len
== b_len
1471 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1474 case dw_val_class_data8
:
1475 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1477 case dw_val_class_vms_delta
:
1478 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1479 && !strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
));
1481 case dw_val_class_discr_value
:
1482 return (a
->v
.val_discr_value
.pos
== b
->v
.val_discr_value
.pos
1483 && a
->v
.val_discr_value
.v
.uval
== b
->v
.val_discr_value
.v
.uval
);
1484 case dw_val_class_discr_list
:
1485 /* It makes no sense comparing two discriminant value lists. */
1491 /* Compare two location atoms for exact equality. */
1494 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1496 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1499 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1500 address size, but since we always allocate cleared storage it
1501 should be zero for other types of locations. */
1502 if (a
->dtprel
!= b
->dtprel
)
1505 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1506 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1509 /* Compare two complete location expressions for exact equality. */
1512 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1518 if (a
== NULL
|| b
== NULL
)
1520 if (!loc_descr_equal_p_1 (a
, b
))
1529 /* Add a constant POLY_OFFSET to a location expression. */
1532 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, poly_int64 poly_offset
)
1534 dw_loc_descr_ref loc
;
1537 gcc_assert (*list_head
!= NULL
);
1539 if (known_eq (poly_offset
, 0))
1542 /* Find the end of the chain. */
1543 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1546 HOST_WIDE_INT offset
;
1547 if (!poly_offset
.is_constant (&offset
))
1549 loc
->dw_loc_next
= int_loc_descriptor (poly_offset
);
1550 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_plus
, 0, 0));
1555 if (loc
->dw_loc_opc
== DW_OP_fbreg
1556 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1557 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1558 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1559 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1561 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1562 offset. Don't optimize if an signed integer overflow would happen. */
1564 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1565 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1568 else if (offset
> 0)
1569 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1574 = uint_loc_descriptor (-(unsigned HOST_WIDE_INT
) offset
);
1575 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1579 /* Return a pointer to a newly allocated location description for
1582 static inline dw_loc_descr_ref
1583 new_reg_loc_descr (unsigned int reg
, poly_int64 offset
)
1585 HOST_WIDE_INT const_offset
;
1586 if (offset
.is_constant (&const_offset
))
1589 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1592 return new_loc_descr (DW_OP_bregx
, reg
, const_offset
);
1596 dw_loc_descr_ref ret
= new_reg_loc_descr (reg
, 0);
1597 loc_descr_plus_const (&ret
, offset
);
1602 /* Add a constant OFFSET to a location list. */
1605 loc_list_plus_const (dw_loc_list_ref list_head
, poly_int64 offset
)
1608 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1609 loc_descr_plus_const (&d
->expr
, offset
);
1612 #define DWARF_REF_SIZE \
1613 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1615 /* The number of bits that can be encoded by largest DW_FORM_dataN.
1616 In DWARF4 and earlier it is DW_FORM_data8 with 64 bits, in DWARF5
1617 DW_FORM_data16 with 128 bits. */
1618 #define DWARF_LARGEST_DATA_FORM_BITS \
1619 (dwarf_version >= 5 ? 128 : 64)
1621 /* Utility inline function for construction of ops that were GNU extension
1623 static inline enum dwarf_location_atom
1624 dwarf_OP (enum dwarf_location_atom op
)
1628 case DW_OP_implicit_pointer
:
1629 if (dwarf_version
< 5)
1630 return DW_OP_GNU_implicit_pointer
;
1633 case DW_OP_entry_value
:
1634 if (dwarf_version
< 5)
1635 return DW_OP_GNU_entry_value
;
1638 case DW_OP_const_type
:
1639 if (dwarf_version
< 5)
1640 return DW_OP_GNU_const_type
;
1643 case DW_OP_regval_type
:
1644 if (dwarf_version
< 5)
1645 return DW_OP_GNU_regval_type
;
1648 case DW_OP_deref_type
:
1649 if (dwarf_version
< 5)
1650 return DW_OP_GNU_deref_type
;
1654 if (dwarf_version
< 5)
1655 return DW_OP_GNU_convert
;
1658 case DW_OP_reinterpret
:
1659 if (dwarf_version
< 5)
1660 return DW_OP_GNU_reinterpret
;
1664 if (dwarf_version
< 5)
1665 return DW_OP_GNU_addr_index
;
1669 if (dwarf_version
< 5)
1670 return DW_OP_GNU_const_index
;
1679 /* Similarly for attributes. */
1680 static inline enum dwarf_attribute
1681 dwarf_AT (enum dwarf_attribute at
)
1685 case DW_AT_call_return_pc
:
1686 if (dwarf_version
< 5)
1687 return DW_AT_low_pc
;
1690 case DW_AT_call_tail_call
:
1691 if (dwarf_version
< 5)
1692 return DW_AT_GNU_tail_call
;
1695 case DW_AT_call_origin
:
1696 if (dwarf_version
< 5)
1697 return DW_AT_abstract_origin
;
1700 case DW_AT_call_target
:
1701 if (dwarf_version
< 5)
1702 return DW_AT_GNU_call_site_target
;
1705 case DW_AT_call_target_clobbered
:
1706 if (dwarf_version
< 5)
1707 return DW_AT_GNU_call_site_target_clobbered
;
1710 case DW_AT_call_parameter
:
1711 if (dwarf_version
< 5)
1712 return DW_AT_abstract_origin
;
1715 case DW_AT_call_value
:
1716 if (dwarf_version
< 5)
1717 return DW_AT_GNU_call_site_value
;
1720 case DW_AT_call_data_value
:
1721 if (dwarf_version
< 5)
1722 return DW_AT_GNU_call_site_data_value
;
1725 case DW_AT_call_all_calls
:
1726 if (dwarf_version
< 5)
1727 return DW_AT_GNU_all_call_sites
;
1730 case DW_AT_call_all_tail_calls
:
1731 if (dwarf_version
< 5)
1732 return DW_AT_GNU_all_tail_call_sites
;
1735 case DW_AT_dwo_name
:
1736 if (dwarf_version
< 5)
1737 return DW_AT_GNU_dwo_name
;
1740 case DW_AT_addr_base
:
1741 if (dwarf_version
< 5)
1742 return DW_AT_GNU_addr_base
;
1751 /* And similarly for tags. */
1752 static inline enum dwarf_tag
1753 dwarf_TAG (enum dwarf_tag tag
)
1757 case DW_TAG_call_site
:
1758 if (dwarf_version
< 5)
1759 return DW_TAG_GNU_call_site
;
1762 case DW_TAG_call_site_parameter
:
1763 if (dwarf_version
< 5)
1764 return DW_TAG_GNU_call_site_parameter
;
1773 /* And similarly for forms. */
1774 static inline enum dwarf_form
1775 dwarf_FORM (enum dwarf_form form
)
1780 if (dwarf_version
< 5)
1781 return DW_FORM_GNU_addr_index
;
1785 if (dwarf_version
< 5)
1786 return DW_FORM_GNU_str_index
;
1795 static unsigned long int get_base_type_offset (dw_die_ref
);
1797 /* Return the size of a location descriptor. */
1799 static unsigned long
1800 size_of_loc_descr (dw_loc_descr_ref loc
)
1802 unsigned long size
= 1;
1804 switch (loc
->dw_loc_opc
)
1807 size
+= DWARF2_ADDR_SIZE
;
1809 case DW_OP_GNU_addr_index
:
1811 case DW_OP_GNU_const_index
:
1813 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1814 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1833 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1836 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1841 case DW_OP_plus_uconst
:
1842 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1880 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1883 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1886 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1889 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1890 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1893 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1895 case DW_OP_bit_piece
:
1896 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1897 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1899 case DW_OP_deref_size
:
1900 case DW_OP_xderef_size
:
1909 case DW_OP_call_ref
:
1910 case DW_OP_GNU_variable_value
:
1911 size
+= DWARF_REF_SIZE
;
1913 case DW_OP_implicit_value
:
1914 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1915 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1917 case DW_OP_implicit_pointer
:
1918 case DW_OP_GNU_implicit_pointer
:
1919 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1921 case DW_OP_entry_value
:
1922 case DW_OP_GNU_entry_value
:
1924 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1925 size
+= size_of_uleb128 (op_size
) + op_size
;
1928 case DW_OP_const_type
:
1929 case DW_OP_GNU_const_type
:
1932 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1933 size
+= size_of_uleb128 (o
) + 1;
1934 switch (loc
->dw_loc_oprnd2
.val_class
)
1936 case dw_val_class_vec
:
1937 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1938 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1940 case dw_val_class_const
:
1941 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1943 case dw_val_class_const_double
:
1944 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
1946 case dw_val_class_wide_int
:
1947 size
+= (get_full_len (*loc
->dw_loc_oprnd2
.v
.val_wide
)
1948 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
1955 case DW_OP_regval_type
:
1956 case DW_OP_GNU_regval_type
:
1959 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1960 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1961 + size_of_uleb128 (o
);
1964 case DW_OP_deref_type
:
1965 case DW_OP_GNU_deref_type
:
1968 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1969 size
+= 1 + size_of_uleb128 (o
);
1973 case DW_OP_reinterpret
:
1974 case DW_OP_GNU_convert
:
1975 case DW_OP_GNU_reinterpret
:
1976 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
1977 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1981 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1982 size
+= size_of_uleb128 (o
);
1985 case DW_OP_GNU_parameter_ref
:
1995 /* Return the size of a series of location descriptors. */
1998 size_of_locs (dw_loc_descr_ref loc
)
2003 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
2004 field, to avoid writing to a PCH file. */
2005 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
2007 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
2009 size
+= size_of_loc_descr (l
);
2014 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
2016 l
->dw_loc_addr
= size
;
2017 size
+= size_of_loc_descr (l
);
2023 /* Return the size of the value in a DW_AT_discr_value attribute. */
2026 size_of_discr_value (dw_discr_value
*discr_value
)
2028 if (discr_value
->pos
)
2029 return size_of_uleb128 (discr_value
->v
.uval
);
2031 return size_of_sleb128 (discr_value
->v
.sval
);
2034 /* Return the size of the value in a DW_AT_discr_list attribute. */
2037 size_of_discr_list (dw_discr_list_ref discr_list
)
2041 for (dw_discr_list_ref list
= discr_list
;
2043 list
= list
->dw_discr_next
)
2045 /* One byte for the discriminant value descriptor, and then one or two
2046 LEB128 numbers, depending on whether it's a single case label or a
2049 size
+= size_of_discr_value (&list
->dw_discr_lower_bound
);
2050 if (list
->dw_discr_range
!= 0)
2051 size
+= size_of_discr_value (&list
->dw_discr_upper_bound
);
2056 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
2057 static void get_ref_die_offset_label (char *, dw_die_ref
);
2058 static unsigned long int get_ref_die_offset (dw_die_ref
);
2060 /* Output location description stack opcode's operands (if any).
2061 The for_eh_or_skip parameter controls whether register numbers are
2062 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2063 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2064 info). This should be suppressed for the cases that have not been converted
2065 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2068 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2070 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2071 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2073 switch (loc
->dw_loc_opc
)
2075 #ifdef DWARF2_DEBUGGING_INFO
2078 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
2083 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2084 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
2086 fputc ('\n', asm_out_file
);
2091 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
2096 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2097 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
2099 fputc ('\n', asm_out_file
);
2104 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2105 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
2112 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2113 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2115 dw2_asm_output_data (2, offset
, NULL
);
2118 case DW_OP_implicit_value
:
2119 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2120 switch (val2
->val_class
)
2122 case dw_val_class_const
:
2123 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
2125 case dw_val_class_vec
:
2127 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2128 unsigned int len
= val2
->v
.val_vec
.length
;
2132 if (elt_size
> sizeof (HOST_WIDE_INT
))
2137 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2140 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2141 "fp or vector constant word %u", i
);
2144 case dw_val_class_const_double
:
2146 unsigned HOST_WIDE_INT first
, second
;
2148 if (WORDS_BIG_ENDIAN
)
2150 first
= val2
->v
.val_double
.high
;
2151 second
= val2
->v
.val_double
.low
;
2155 first
= val2
->v
.val_double
.low
;
2156 second
= val2
->v
.val_double
.high
;
2158 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2160 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2164 case dw_val_class_wide_int
:
2167 int len
= get_full_len (*val2
->v
.val_wide
);
2168 if (WORDS_BIG_ENDIAN
)
2169 for (i
= len
- 1; i
>= 0; --i
)
2170 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2171 val2
->v
.val_wide
->elt (i
), NULL
);
2173 for (i
= 0; i
< len
; ++i
)
2174 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2175 val2
->v
.val_wide
->elt (i
), NULL
);
2178 case dw_val_class_addr
:
2179 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
2180 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
2195 case DW_OP_implicit_value
:
2196 /* We currently don't make any attempt to make sure these are
2197 aligned properly like we do for the main unwind info, so
2198 don't support emitting things larger than a byte if we're
2199 only doing unwinding. */
2204 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2207 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2210 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2213 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2215 case DW_OP_plus_uconst
:
2216 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2250 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2254 unsigned r
= val1
->v
.val_unsigned
;
2255 if (for_eh_or_skip
>= 0)
2256 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2257 gcc_assert (size_of_uleb128 (r
)
2258 == size_of_uleb128 (val1
->v
.val_unsigned
));
2259 dw2_asm_output_data_uleb128 (r
, NULL
);
2263 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2267 unsigned r
= val1
->v
.val_unsigned
;
2268 if (for_eh_or_skip
>= 0)
2269 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2270 gcc_assert (size_of_uleb128 (r
)
2271 == size_of_uleb128 (val1
->v
.val_unsigned
));
2272 dw2_asm_output_data_uleb128 (r
, NULL
);
2273 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2277 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2279 case DW_OP_bit_piece
:
2280 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2281 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
2283 case DW_OP_deref_size
:
2284 case DW_OP_xderef_size
:
2285 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2291 if (targetm
.asm_out
.output_dwarf_dtprel
)
2293 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
2296 fputc ('\n', asm_out_file
);
2303 #ifdef DWARF2_DEBUGGING_INFO
2304 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
2311 case DW_OP_GNU_addr_index
:
2313 case DW_OP_GNU_const_index
:
2315 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
2316 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
2317 "(index into .debug_addr)");
2323 unsigned long die_offset
2324 = get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2325 /* Make sure the offset has been computed and that we can encode it as
2327 gcc_assert (die_offset
> 0
2328 && die_offset
<= (loc
->dw_loc_opc
== DW_OP_call2
2331 dw2_asm_output_data ((loc
->dw_loc_opc
== DW_OP_call2
) ? 2 : 4,
2336 case DW_OP_call_ref
:
2337 case DW_OP_GNU_variable_value
:
2339 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2340 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2341 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2342 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2343 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2347 case DW_OP_implicit_pointer
:
2348 case DW_OP_GNU_implicit_pointer
:
2350 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2351 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2352 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2353 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2354 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2355 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2359 case DW_OP_entry_value
:
2360 case DW_OP_GNU_entry_value
:
2361 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
2362 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
2365 case DW_OP_const_type
:
2366 case DW_OP_GNU_const_type
:
2368 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
2370 dw2_asm_output_data_uleb128 (o
, NULL
);
2371 switch (val2
->val_class
)
2373 case dw_val_class_const
:
2374 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2375 dw2_asm_output_data (1, l
, NULL
);
2376 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
2378 case dw_val_class_vec
:
2380 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2381 unsigned int len
= val2
->v
.val_vec
.length
;
2386 dw2_asm_output_data (1, l
, NULL
);
2387 if (elt_size
> sizeof (HOST_WIDE_INT
))
2392 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2395 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2396 "fp or vector constant word %u", i
);
2399 case dw_val_class_const_double
:
2401 unsigned HOST_WIDE_INT first
, second
;
2402 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2404 dw2_asm_output_data (1, 2 * l
, NULL
);
2405 if (WORDS_BIG_ENDIAN
)
2407 first
= val2
->v
.val_double
.high
;
2408 second
= val2
->v
.val_double
.low
;
2412 first
= val2
->v
.val_double
.low
;
2413 second
= val2
->v
.val_double
.high
;
2415 dw2_asm_output_data (l
, first
, NULL
);
2416 dw2_asm_output_data (l
, second
, NULL
);
2419 case dw_val_class_wide_int
:
2422 int len
= get_full_len (*val2
->v
.val_wide
);
2423 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2425 dw2_asm_output_data (1, len
* l
, NULL
);
2426 if (WORDS_BIG_ENDIAN
)
2427 for (i
= len
- 1; i
>= 0; --i
)
2428 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2430 for (i
= 0; i
< len
; ++i
)
2431 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2439 case DW_OP_regval_type
:
2440 case DW_OP_GNU_regval_type
:
2442 unsigned r
= val1
->v
.val_unsigned
;
2443 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2445 if (for_eh_or_skip
>= 0)
2447 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2448 gcc_assert (size_of_uleb128 (r
)
2449 == size_of_uleb128 (val1
->v
.val_unsigned
));
2451 dw2_asm_output_data_uleb128 (r
, NULL
);
2452 dw2_asm_output_data_uleb128 (o
, NULL
);
2455 case DW_OP_deref_type
:
2456 case DW_OP_GNU_deref_type
:
2458 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2460 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2461 dw2_asm_output_data_uleb128 (o
, NULL
);
2465 case DW_OP_reinterpret
:
2466 case DW_OP_GNU_convert
:
2467 case DW_OP_GNU_reinterpret
:
2468 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2469 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2472 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2474 dw2_asm_output_data_uleb128 (o
, NULL
);
2478 case DW_OP_GNU_parameter_ref
:
2481 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2482 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2483 dw2_asm_output_data (4, o
, NULL
);
2488 /* Other codes have no operands. */
2493 /* Output a sequence of location operations.
2494 The for_eh_or_skip parameter controls whether register numbers are
2495 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2496 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2497 info). This should be suppressed for the cases that have not been converted
2498 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2501 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2503 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2505 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2506 /* Output the opcode. */
2507 if (for_eh_or_skip
>= 0
2508 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2510 unsigned r
= (opc
- DW_OP_breg0
);
2511 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2512 gcc_assert (r
<= 31);
2513 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2515 else if (for_eh_or_skip
>= 0
2516 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2518 unsigned r
= (opc
- DW_OP_reg0
);
2519 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2520 gcc_assert (r
<= 31);
2521 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2524 dw2_asm_output_data (1, opc
,
2525 "%s", dwarf_stack_op_name (opc
));
2527 /* Output the operand(s) (if any). */
2528 output_loc_operands (loc
, for_eh_or_skip
);
2532 /* Output location description stack opcode's operands (if any).
2533 The output is single bytes on a line, suitable for .cfi_escape. */
2536 output_loc_operands_raw (dw_loc_descr_ref loc
)
2538 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2539 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2541 switch (loc
->dw_loc_opc
)
2544 case DW_OP_GNU_addr_index
:
2546 case DW_OP_GNU_const_index
:
2548 case DW_OP_implicit_value
:
2549 /* We cannot output addresses in .cfi_escape, only bytes. */
2555 case DW_OP_deref_size
:
2556 case DW_OP_xderef_size
:
2557 fputc (',', asm_out_file
);
2558 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2563 fputc (',', asm_out_file
);
2564 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2569 fputc (',', asm_out_file
);
2570 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2575 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2576 fputc (',', asm_out_file
);
2577 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2585 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2586 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2588 fputc (',', asm_out_file
);
2589 dw2_asm_output_data_raw (2, offset
);
2595 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2596 gcc_assert (size_of_uleb128 (r
)
2597 == size_of_uleb128 (val1
->v
.val_unsigned
));
2598 fputc (',', asm_out_file
);
2599 dw2_asm_output_data_uleb128_raw (r
);
2604 case DW_OP_plus_uconst
:
2606 fputc (',', asm_out_file
);
2607 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2610 case DW_OP_bit_piece
:
2611 fputc (',', asm_out_file
);
2612 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2613 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2650 fputc (',', asm_out_file
);
2651 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2656 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2657 gcc_assert (size_of_uleb128 (r
)
2658 == size_of_uleb128 (val1
->v
.val_unsigned
));
2659 fputc (',', asm_out_file
);
2660 dw2_asm_output_data_uleb128_raw (r
);
2661 fputc (',', asm_out_file
);
2662 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2666 case DW_OP_implicit_pointer
:
2667 case DW_OP_entry_value
:
2668 case DW_OP_const_type
:
2669 case DW_OP_regval_type
:
2670 case DW_OP_deref_type
:
2672 case DW_OP_reinterpret
:
2673 case DW_OP_GNU_implicit_pointer
:
2674 case DW_OP_GNU_entry_value
:
2675 case DW_OP_GNU_const_type
:
2676 case DW_OP_GNU_regval_type
:
2677 case DW_OP_GNU_deref_type
:
2678 case DW_OP_GNU_convert
:
2679 case DW_OP_GNU_reinterpret
:
2680 case DW_OP_GNU_parameter_ref
:
2685 /* Other codes have no operands. */
2691 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2695 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2696 /* Output the opcode. */
2697 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2699 unsigned r
= (opc
- DW_OP_breg0
);
2700 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2701 gcc_assert (r
<= 31);
2702 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2704 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2706 unsigned r
= (opc
- DW_OP_reg0
);
2707 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2708 gcc_assert (r
<= 31);
2709 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2711 /* Output the opcode. */
2712 fprintf (asm_out_file
, "%#x", opc
);
2713 output_loc_operands_raw (loc
);
2715 if (!loc
->dw_loc_next
)
2717 loc
= loc
->dw_loc_next
;
2719 fputc (',', asm_out_file
);
2723 /* This function builds a dwarf location descriptor sequence from a
2724 dw_cfa_location, adding the given OFFSET to the result of the
2727 struct dw_loc_descr_node
*
2728 build_cfa_loc (dw_cfa_location
*cfa
, poly_int64 offset
)
2730 struct dw_loc_descr_node
*head
, *tmp
;
2732 offset
+= cfa
->offset
;
2736 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
2737 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2738 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2739 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2740 add_loc_descr (&head
, tmp
);
2741 loc_descr_plus_const (&head
, offset
);
2744 head
= new_reg_loc_descr (cfa
->reg
, offset
);
2749 /* This function builds a dwarf location descriptor sequence for
2750 the address at OFFSET from the CFA when stack is aligned to
2753 struct dw_loc_descr_node
*
2754 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2755 poly_int64 offset
, HOST_WIDE_INT alignment
)
2757 struct dw_loc_descr_node
*head
;
2758 unsigned int dwarf_fp
2759 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2761 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2762 if (cfa
->reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2764 head
= new_reg_loc_descr (dwarf_fp
, 0);
2765 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2766 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2767 loc_descr_plus_const (&head
, offset
);
2770 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2774 /* And now, the support for symbolic debugging information. */
2776 /* .debug_str support. */
2778 static void dwarf2out_init (const char *);
2779 static void dwarf2out_finish (const char *);
2780 static void dwarf2out_early_finish (const char *);
2781 static void dwarf2out_assembly_start (void);
2782 static void dwarf2out_define (unsigned int, const char *);
2783 static void dwarf2out_undef (unsigned int, const char *);
2784 static void dwarf2out_start_source_file (unsigned, const char *);
2785 static void dwarf2out_end_source_file (unsigned);
2786 static void dwarf2out_function_decl (tree
);
2787 static void dwarf2out_begin_block (unsigned, unsigned);
2788 static void dwarf2out_end_block (unsigned, unsigned);
2789 static bool dwarf2out_ignore_block (const_tree
);
2790 static void dwarf2out_early_global_decl (tree
);
2791 static void dwarf2out_late_global_decl (tree
);
2792 static void dwarf2out_type_decl (tree
, int);
2793 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool, bool);
2794 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2796 static void dwarf2out_abstract_function (tree
);
2797 static void dwarf2out_var_location (rtx_insn
*);
2798 static void dwarf2out_inline_entry (tree
);
2799 static void dwarf2out_size_function (tree
);
2800 static void dwarf2out_begin_function (tree
);
2801 static void dwarf2out_end_function (unsigned int);
2802 static void dwarf2out_register_main_translation_unit (tree unit
);
2803 static void dwarf2out_set_name (tree
, tree
);
2804 static void dwarf2out_register_external_die (tree decl
, const char *sym
,
2805 unsigned HOST_WIDE_INT off
);
2806 static bool dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
2807 unsigned HOST_WIDE_INT
*off
);
2809 /* The debug hooks structure. */
2811 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2815 dwarf2out_early_finish
,
2816 dwarf2out_assembly_start
,
2819 dwarf2out_start_source_file
,
2820 dwarf2out_end_source_file
,
2821 dwarf2out_begin_block
,
2822 dwarf2out_end_block
,
2823 dwarf2out_ignore_block
,
2824 dwarf2out_source_line
,
2825 dwarf2out_begin_prologue
,
2826 #if VMS_DEBUGGING_INFO
2827 dwarf2out_vms_end_prologue
,
2828 dwarf2out_vms_begin_epilogue
,
2830 debug_nothing_int_charstar
,
2831 debug_nothing_int_charstar
,
2833 dwarf2out_end_epilogue
,
2834 dwarf2out_begin_function
,
2835 dwarf2out_end_function
, /* end_function */
2836 dwarf2out_register_main_translation_unit
,
2837 dwarf2out_function_decl
, /* function_decl */
2838 dwarf2out_early_global_decl
,
2839 dwarf2out_late_global_decl
,
2840 dwarf2out_type_decl
, /* type_decl */
2841 dwarf2out_imported_module_or_decl
,
2842 dwarf2out_die_ref_for_decl
,
2843 dwarf2out_register_external_die
,
2844 debug_nothing_tree
, /* deferred_inline_function */
2845 /* The DWARF 2 backend tries to reduce debugging bloat by not
2846 emitting the abstract description of inline functions until
2847 something tries to reference them. */
2848 dwarf2out_abstract_function
, /* outlining_inline_function */
2849 debug_nothing_rtx_code_label
, /* label */
2850 debug_nothing_int
, /* handle_pch */
2851 dwarf2out_var_location
,
2852 dwarf2out_inline_entry
, /* inline_entry */
2853 dwarf2out_size_function
, /* size_function */
2854 dwarf2out_switch_text_section
,
2856 1, /* start_end_main_source_file */
2857 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2860 const struct gcc_debug_hooks dwarf2_lineno_debug_hooks
=
2863 debug_nothing_charstar
,
2864 debug_nothing_charstar
,
2865 dwarf2out_assembly_start
,
2866 debug_nothing_int_charstar
,
2867 debug_nothing_int_charstar
,
2868 debug_nothing_int_charstar
,
2870 debug_nothing_int_int
, /* begin_block */
2871 debug_nothing_int_int
, /* end_block */
2872 debug_true_const_tree
, /* ignore_block */
2873 dwarf2out_source_line
, /* source_line */
2874 debug_nothing_int_int_charstar
, /* begin_prologue */
2875 debug_nothing_int_charstar
, /* end_prologue */
2876 debug_nothing_int_charstar
, /* begin_epilogue */
2877 debug_nothing_int_charstar
, /* end_epilogue */
2878 debug_nothing_tree
, /* begin_function */
2879 debug_nothing_int
, /* end_function */
2880 debug_nothing_tree
, /* register_main_translation_unit */
2881 debug_nothing_tree
, /* function_decl */
2882 debug_nothing_tree
, /* early_global_decl */
2883 debug_nothing_tree
, /* late_global_decl */
2884 debug_nothing_tree_int
, /* type_decl */
2885 debug_nothing_tree_tree_tree_bool_bool
,/* imported_module_or_decl */
2886 debug_false_tree_charstarstar_uhwistar
,/* die_ref_for_decl */
2887 debug_nothing_tree_charstar_uhwi
, /* register_external_die */
2888 debug_nothing_tree
, /* deferred_inline_function */
2889 debug_nothing_tree
, /* outlining_inline_function */
2890 debug_nothing_rtx_code_label
, /* label */
2891 debug_nothing_int
, /* handle_pch */
2892 debug_nothing_rtx_insn
, /* var_location */
2893 debug_nothing_tree
, /* inline_entry */
2894 debug_nothing_tree
, /* size_function */
2895 debug_nothing_void
, /* switch_text_section */
2896 debug_nothing_tree_tree
, /* set_name */
2897 0, /* start_end_main_source_file */
2898 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
2901 /* NOTE: In the comments in this file, many references are made to
2902 "Debugging Information Entries". This term is abbreviated as `DIE'
2903 throughout the remainder of this file. */
2905 /* An internal representation of the DWARF output is built, and then
2906 walked to generate the DWARF debugging info. The walk of the internal
2907 representation is done after the entire program has been compiled.
2908 The types below are used to describe the internal representation. */
2910 /* Whether to put type DIEs into their own section .debug_types instead
2911 of making them part of the .debug_info section. Only supported for
2912 Dwarf V4 or higher and the user didn't disable them through
2913 -fno-debug-types-section. It is more efficient to put them in a
2914 separate comdat sections since the linker will then be able to
2915 remove duplicates. But not all tools support .debug_types sections
2916 yet. For Dwarf V5 or higher .debug_types doesn't exist any more,
2917 it is DW_UT_type unit type in .debug_info section. */
2919 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2921 /* Various DIE's use offsets relative to the beginning of the
2922 .debug_info section to refer to each other. */
2924 typedef long int dw_offset
;
2926 struct comdat_type_node
;
2928 /* The entries in the line_info table more-or-less mirror the opcodes
2929 that are used in the real dwarf line table. Arrays of these entries
2930 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2933 enum dw_line_info_opcode
{
2934 /* Emit DW_LNE_set_address; the operand is the label index. */
2937 /* Emit a row to the matrix with the given line. This may be done
2938 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2942 /* Emit a DW_LNS_set_file. */
2945 /* Emit a DW_LNS_set_column. */
2948 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2951 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2952 LI_set_prologue_end
,
2953 LI_set_epilogue_begin
,
2955 /* Emit a DW_LNE_set_discriminator. */
2956 LI_set_discriminator
,
2958 /* Output a Fixed Advance PC; the target PC is the label index; the
2959 base PC is the previous LI_adv_address or LI_set_address entry.
2960 We only use this when emitting debug views without assembler
2961 support, at explicit user request. Ideally, we should only use
2962 it when the offset might be zero but we can't tell: it's the only
2963 way to maybe change the PC without resetting the view number. */
2967 typedef struct GTY(()) dw_line_info_struct
{
2968 enum dw_line_info_opcode opcode
;
2970 } dw_line_info_entry
;
2973 struct GTY(()) dw_line_info_table
{
2974 /* The label that marks the end of this section. */
2975 const char *end_label
;
2977 /* The values for the last row of the matrix, as collected in the table.
2978 These are used to minimize the changes to the next row. */
2979 unsigned int file_num
;
2980 unsigned int line_num
;
2981 unsigned int column_num
;
2986 /* This denotes the NEXT view number.
2988 If it is 0, it is known that the NEXT view will be the first view
2991 If it is -1, we're forcing the view number to be reset, e.g. at a
2994 The meaning of other nonzero values depends on whether we're
2995 computing views internally or leaving it for the assembler to do
2996 so. If we're emitting them internally, view denotes the view
2997 number since the last known advance of PC. If we're leaving it
2998 for the assembler, it denotes the LVU label number that we're
2999 going to ask the assembler to assign. */
3002 /* This counts the number of symbolic views emitted in this table
3003 since the latest view reset. Its max value, over all tables,
3004 sets symview_upper_bound. */
3005 var_loc_view symviews_since_reset
;
3007 #define FORCE_RESET_NEXT_VIEW(x) ((x) = (var_loc_view)-1)
3008 #define RESET_NEXT_VIEW(x) ((x) = (var_loc_view)0)
3009 #define FORCE_RESETTING_VIEW_P(x) ((x) == (var_loc_view)-1)
3010 #define RESETTING_VIEW_P(x) ((x) == (var_loc_view)0 || FORCE_RESETTING_VIEW_P (x))
3012 vec
<dw_line_info_entry
, va_gc
> *entries
;
3015 /* This is an upper bound for view numbers that the assembler may
3016 assign to symbolic views output in this translation. It is used to
3017 decide how big a field to use to represent view numbers in
3018 symview-classed attributes. */
3020 static var_loc_view symview_upper_bound
;
3022 /* If we're keep track of location views and their reset points, and
3023 INSN is a reset point (i.e., it necessarily advances the PC), mark
3024 the next view in TABLE as reset. */
3027 maybe_reset_location_view (rtx_insn
*insn
, dw_line_info_table
*table
)
3029 if (!debug_internal_reset_location_views
)
3032 /* Maybe turn (part of?) this test into a default target hook. */
3035 if (targetm
.reset_location_view
)
3036 reset
= targetm
.reset_location_view (insn
);
3040 else if (JUMP_TABLE_DATA_P (insn
))
3042 else if (GET_CODE (insn
) == USE
3043 || GET_CODE (insn
) == CLOBBER
3044 || GET_CODE (insn
) == ASM_INPUT
3045 || asm_noperands (insn
) >= 0)
3047 else if (get_attr_min_length (insn
) > 0)
3050 if (reset
> 0 && !RESETTING_VIEW_P (table
->view
))
3051 RESET_NEXT_VIEW (table
->view
);
3054 /* Each DIE attribute has a field specifying the attribute kind,
3055 a link to the next attribute in the chain, and an attribute value.
3056 Attributes are typically linked below the DIE they modify. */
3058 typedef struct GTY(()) dw_attr_struct
{
3059 enum dwarf_attribute dw_attr
;
3060 dw_val_node dw_attr_val
;
3065 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
3066 The children of each node form a circular list linked by
3067 die_sib. die_child points to the node *before* the "first" child node. */
3069 typedef struct GTY((chain_circular ("%h.die_sib"), for_user
)) die_struct
{
3070 union die_symbol_or_type_node
3072 const char * GTY ((tag ("0"))) die_symbol
;
3073 comdat_type_node
*GTY ((tag ("1"))) die_type_node
;
3075 GTY ((desc ("%0.comdat_type_p"))) die_id
;
3076 vec
<dw_attr_node
, va_gc
> *die_attr
;
3077 dw_die_ref die_parent
;
3078 dw_die_ref die_child
;
3080 dw_die_ref die_definition
; /* ref from a specification to its definition */
3081 dw_offset die_offset
;
3082 unsigned long die_abbrev
;
3084 unsigned int decl_id
;
3085 enum dwarf_tag die_tag
;
3086 /* Die is used and must not be pruned as unused. */
3087 BOOL_BITFIELD die_perennial_p
: 1;
3088 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
3089 /* For an external ref to die_symbol if die_offset contains an extra
3090 offset to that symbol. */
3091 BOOL_BITFIELD with_offset
: 1;
3092 /* Whether this DIE was removed from the DIE tree, for example via
3093 prune_unused_types. We don't consider those present from the
3094 DIE lookup routines. */
3095 BOOL_BITFIELD removed
: 1;
3096 /* Lots of spare bits. */
3100 /* Set to TRUE while dwarf2out_early_global_decl is running. */
3101 static bool early_dwarf
;
3102 static bool early_dwarf_finished
;
3103 struct set_early_dwarf
{
3105 set_early_dwarf () : saved(early_dwarf
)
3107 gcc_assert (! early_dwarf_finished
);
3110 ~set_early_dwarf () { early_dwarf
= saved
; }
3113 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
3114 #define FOR_EACH_CHILD(die, c, expr) do { \
3115 c = die->die_child; \
3119 } while (c != die->die_child); \
3122 /* The pubname structure */
3124 typedef struct GTY(()) pubname_struct
{
3131 struct GTY(()) dw_ranges
{
3133 /* If this is positive, it's a block number, otherwise it's a
3134 bitwise-negated index into dw_ranges_by_label. */
3136 /* Index for the range list for DW_FORM_rnglistx. */
3137 unsigned int idx
: 31;
3138 /* True if this range might be possibly in a different section
3139 from previous entry. */
3140 unsigned int maybe_new_sec
: 1;
3143 /* A structure to hold a macinfo entry. */
3145 typedef struct GTY(()) macinfo_struct
{
3147 unsigned HOST_WIDE_INT lineno
;
3153 struct GTY(()) dw_ranges_by_label
{
3158 /* The comdat type node structure. */
3159 struct GTY(()) comdat_type_node
3161 dw_die_ref root_die
;
3162 dw_die_ref type_die
;
3163 dw_die_ref skeleton_die
;
3164 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
3165 comdat_type_node
*next
;
3168 /* A list of DIEs for which we can't determine ancestry (parent_die
3169 field) just yet. Later in dwarf2out_finish we will fill in the
3171 typedef struct GTY(()) limbo_die_struct
{
3173 /* The tree for which this DIE was created. We use this to
3174 determine ancestry later. */
3176 struct limbo_die_struct
*next
;
3180 typedef struct skeleton_chain_struct
3184 struct skeleton_chain_struct
*parent
;
3186 skeleton_chain_node
;
3188 /* Define a macro which returns nonzero for a TYPE_DECL which was
3189 implicitly generated for a type.
3191 Note that, unlike the C front-end (which generates a NULL named
3192 TYPE_DECL node for each complete tagged type, each array type,
3193 and each function type node created) the C++ front-end generates
3194 a _named_ TYPE_DECL node for each tagged type node created.
3195 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3196 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
3197 front-end, but for each type, tagged or not. */
3199 #define TYPE_DECL_IS_STUB(decl) \
3200 (DECL_NAME (decl) == NULL_TREE \
3201 || (DECL_ARTIFICIAL (decl) \
3202 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3203 /* This is necessary for stub decls that \
3204 appear in nested inline functions. */ \
3205 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3206 && (decl_ultimate_origin (decl) \
3207 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3209 /* Information concerning the compilation unit's programming
3210 language, and compiler version. */
3212 /* Fixed size portion of the DWARF compilation unit header. */
3213 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3214 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE \
3215 + (dwarf_version >= 5 ? 4 : 3))
3217 /* Fixed size portion of the DWARF comdat type unit header. */
3218 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
3219 (DWARF_COMPILE_UNIT_HEADER_SIZE \
3220 + DWARF_TYPE_SIGNATURE_SIZE + DWARF_OFFSET_SIZE)
3222 /* Fixed size portion of the DWARF skeleton compilation unit header. */
3223 #define DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE \
3224 (DWARF_COMPILE_UNIT_HEADER_SIZE + (dwarf_version >= 5 ? 8 : 0))
3226 /* Fixed size portion of public names info. */
3227 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3229 /* Fixed size portion of the address range info. */
3230 #define DWARF_ARANGES_HEADER_SIZE \
3231 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3232 DWARF2_ADDR_SIZE * 2) \
3233 - DWARF_INITIAL_LENGTH_SIZE)
3235 /* Size of padding portion in the address range info. It must be
3236 aligned to twice the pointer size. */
3237 #define DWARF_ARANGES_PAD_SIZE \
3238 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3239 DWARF2_ADDR_SIZE * 2) \
3240 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3242 /* Use assembler line directives if available. */
3243 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3244 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3245 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3247 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3251 /* Use assembler views in line directives if available. */
3252 #ifndef DWARF2_ASM_VIEW_DEBUG_INFO
3253 #ifdef HAVE_AS_DWARF2_DEBUG_VIEW
3254 #define DWARF2_ASM_VIEW_DEBUG_INFO 1
3256 #define DWARF2_ASM_VIEW_DEBUG_INFO 0
3260 /* Return true if GCC configure detected assembler support for .loc. */
3263 dwarf2out_default_as_loc_support (void)
3265 return DWARF2_ASM_LINE_DEBUG_INFO
;
3266 #if (GCC_VERSION >= 3000)
3267 # undef DWARF2_ASM_LINE_DEBUG_INFO
3268 # pragma GCC poison DWARF2_ASM_LINE_DEBUG_INFO
3272 /* Return true if GCC configure detected assembler support for views
3273 in .loc directives. */
3276 dwarf2out_default_as_locview_support (void)
3278 return DWARF2_ASM_VIEW_DEBUG_INFO
;
3279 #if (GCC_VERSION >= 3000)
3280 # undef DWARF2_ASM_VIEW_DEBUG_INFO
3281 # pragma GCC poison DWARF2_ASM_VIEW_DEBUG_INFO
3285 /* A bit is set in ZERO_VIEW_P if we are using the assembler-supported
3286 view computation, and it refers to a view identifier for which we
3287 will not emit a label because it is known to map to a view number
3288 zero. We won't allocate the bitmap if we're not using assembler
3289 support for location views, but we have to make the variable
3290 visible for GGC and for code that will be optimized out for lack of
3291 support but that's still parsed and compiled. We could abstract it
3292 out with macros, but it's not worth it. */
3293 static GTY(()) bitmap zero_view_p
;
3295 /* Evaluate to TRUE iff N is known to identify the first location view
3296 at its PC. When not using assembler location view computation,
3297 that must be view number zero. Otherwise, ZERO_VIEW_P is allocated
3298 and views label numbers recorded in it are the ones known to be
3300 #define ZERO_VIEW_P(N) ((N) == (var_loc_view)0 \
3301 || (N) == (var_loc_view)-1 \
3303 && bitmap_bit_p (zero_view_p, (N))))
3305 /* Return true iff we're to emit .loc directives for the assembler to
3306 generate line number sections.
3308 When we're not emitting views, all we need from the assembler is
3309 support for .loc directives.
3311 If we are emitting views, we can only use the assembler's .loc
3312 support if it also supports views.
3314 When the compiler is emitting the line number programs and
3315 computing view numbers itself, it resets view numbers at known PC
3316 changes and counts from that, and then it emits view numbers as
3317 literal constants in locviewlists. There are cases in which the
3318 compiler is not sure about PC changes, e.g. when extra alignment is
3319 requested for a label. In these cases, the compiler may not reset
3320 the view counter, and the potential PC advance in the line number
3321 program will use an opcode that does not reset the view counter
3322 even if the PC actually changes, so that compiler and debug info
3323 consumer can keep view numbers in sync.
3325 When the compiler defers view computation to the assembler, it
3326 emits symbolic view numbers in locviewlists, with the exception of
3327 views known to be zero (forced resets, or reset after
3328 compiler-visible PC changes): instead of emitting symbols for
3329 these, we emit literal zero and assert the assembler agrees with
3330 the compiler's assessment. We could use symbolic views everywhere,
3331 instead of special-casing zero views, but then we'd be unable to
3332 optimize out locviewlists that contain only zeros. */
3335 output_asm_line_debug_info (void)
3337 return (dwarf2out_as_loc_support
3338 && (dwarf2out_as_locview_support
3339 || !debug_variable_location_views
));
3342 /* Minimum line offset in a special line info. opcode.
3343 This value was chosen to give a reasonable range of values. */
3344 #define DWARF_LINE_BASE -10
3346 /* First special line opcode - leave room for the standard opcodes. */
3347 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
3349 /* Range of line offsets in a special line info. opcode. */
3350 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3352 /* Flag that indicates the initial value of the is_stmt_start flag.
3353 In the present implementation, we do not mark any lines as
3354 the beginning of a source statement, because that information
3355 is not made available by the GCC front-end. */
3356 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3358 /* Maximum number of operations per instruction bundle. */
3359 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
3360 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
3363 /* This location is used by calc_die_sizes() to keep track
3364 the offset of each DIE within the .debug_info section. */
3365 static unsigned long next_die_offset
;
3367 /* Record the root of the DIE's built for the current compilation unit. */
3368 static GTY(()) dw_die_ref single_comp_unit_die
;
3370 /* A list of type DIEs that have been separated into comdat sections. */
3371 static GTY(()) comdat_type_node
*comdat_type_list
;
3373 /* A list of CU DIEs that have been separated. */
3374 static GTY(()) limbo_die_node
*cu_die_list
;
3376 /* A list of DIEs with a NULL parent waiting to be relocated. */
3377 static GTY(()) limbo_die_node
*limbo_die_list
;
3379 /* A list of DIEs for which we may have to generate
3380 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
3381 static GTY(()) limbo_die_node
*deferred_asm_name
;
3383 struct dwarf_file_hasher
: ggc_ptr_hash
<dwarf_file_data
>
3385 typedef const char *compare_type
;
3387 static hashval_t
hash (dwarf_file_data
*);
3388 static bool equal (dwarf_file_data
*, const char *);
3391 /* Filenames referenced by this compilation unit. */
3392 static GTY(()) hash_table
<dwarf_file_hasher
> *file_table
;
3394 struct decl_die_hasher
: ggc_ptr_hash
<die_node
>
3396 typedef tree compare_type
;
3398 static hashval_t
hash (die_node
*);
3399 static bool equal (die_node
*, tree
);
3401 /* A hash table of references to DIE's that describe declarations.
3402 The key is a DECL_UID() which is a unique number identifying each decl. */
3403 static GTY (()) hash_table
<decl_die_hasher
> *decl_die_table
;
3405 struct GTY ((for_user
)) variable_value_struct
{
3406 unsigned int decl_id
;
3407 vec
<dw_die_ref
, va_gc
> *dies
;
3410 struct variable_value_hasher
: ggc_ptr_hash
<variable_value_struct
>
3412 typedef tree compare_type
;
3414 static hashval_t
hash (variable_value_struct
*);
3415 static bool equal (variable_value_struct
*, tree
);
3417 /* A hash table of DIEs that contain DW_OP_GNU_variable_value with
3418 dw_val_class_decl_ref class, indexed by FUNCTION_DECLs which is
3419 DECL_CONTEXT of the referenced VAR_DECLs. */
3420 static GTY (()) hash_table
<variable_value_hasher
> *variable_value_hash
;
3422 struct block_die_hasher
: ggc_ptr_hash
<die_struct
>
3424 static hashval_t
hash (die_struct
*);
3425 static bool equal (die_struct
*, die_struct
*);
3428 /* A hash table of references to DIE's that describe COMMON blocks.
3429 The key is DECL_UID() ^ die_parent. */
3430 static GTY (()) hash_table
<block_die_hasher
> *common_block_die_table
;
3432 typedef struct GTY(()) die_arg_entry_struct
{
3438 /* Node of the variable location list. */
3439 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
3440 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
3441 EXPR_LIST chain. For small bitsizes, bitsize is encoded
3442 in mode of the EXPR_LIST node and first EXPR_LIST operand
3443 is either NOTE_INSN_VAR_LOCATION for a piece with a known
3444 location or NULL for padding. For larger bitsizes,
3445 mode is 0 and first operand is a CONCAT with bitsize
3446 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
3447 NULL as second operand. */
3449 const char * GTY (()) label
;
3450 struct var_loc_node
* GTY (()) next
;
3454 /* Variable location list. */
3455 struct GTY ((for_user
)) var_loc_list_def
{
3456 struct var_loc_node
* GTY (()) first
;
3458 /* Pointer to the last but one or last element of the
3459 chained list. If the list is empty, both first and
3460 last are NULL, if the list contains just one node
3461 or the last node certainly is not redundant, it points
3462 to the last node, otherwise points to the last but one.
3463 Do not mark it for GC because it is marked through the chain. */
3464 struct var_loc_node
* GTY ((skip ("%h"))) last
;
3466 /* Pointer to the last element before section switch,
3467 if NULL, either sections weren't switched or first
3468 is after section switch. */
3469 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
3471 /* DECL_UID of the variable decl. */
3472 unsigned int decl_id
;
3474 typedef struct var_loc_list_def var_loc_list
;
3476 /* Call argument location list. */
3477 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
3478 rtx
GTY (()) call_arg_loc_note
;
3479 const char * GTY (()) label
;
3480 tree
GTY (()) block
;
3482 rtx
GTY (()) symbol_ref
;
3483 struct call_arg_loc_node
* GTY (()) next
;
3487 struct decl_loc_hasher
: ggc_ptr_hash
<var_loc_list
>
3489 typedef const_tree compare_type
;
3491 static hashval_t
hash (var_loc_list
*);
3492 static bool equal (var_loc_list
*, const_tree
);
3495 /* Table of decl location linked lists. */
3496 static GTY (()) hash_table
<decl_loc_hasher
> *decl_loc_table
;
3498 /* Head and tail of call_arg_loc chain. */
3499 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
3500 static struct call_arg_loc_node
*call_arg_loc_last
;
3502 /* Number of call sites in the current function. */
3503 static int call_site_count
= -1;
3504 /* Number of tail call sites in the current function. */
3505 static int tail_call_site_count
= -1;
3507 /* A cached location list. */
3508 struct GTY ((for_user
)) cached_dw_loc_list_def
{
3509 /* The DECL_UID of the decl that this entry describes. */
3510 unsigned int decl_id
;
3512 /* The cached location list. */
3513 dw_loc_list_ref loc_list
;
3515 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
3517 struct dw_loc_list_hasher
: ggc_ptr_hash
<cached_dw_loc_list
>
3520 typedef const_tree compare_type
;
3522 static hashval_t
hash (cached_dw_loc_list
*);
3523 static bool equal (cached_dw_loc_list
*, const_tree
);
3526 /* Table of cached location lists. */
3527 static GTY (()) hash_table
<dw_loc_list_hasher
> *cached_dw_loc_list_table
;
3529 /* A vector of references to DIE's that are uniquely identified by their tag,
3530 presence/absence of children DIE's, and list of attribute/value pairs. */
3531 static GTY(()) vec
<dw_die_ref
, va_gc
> *abbrev_die_table
;
3533 /* A hash map to remember the stack usage for DWARF procedures. The value
3534 stored is the stack size difference between before the DWARF procedure
3535 invokation and after it returned. In other words, for a DWARF procedure
3536 that consumes N stack slots and that pushes M ones, this stores M - N. */
3537 static hash_map
<dw_die_ref
, int> *dwarf_proc_stack_usage_map
;
3539 /* A global counter for generating labels for line number data. */
3540 static unsigned int line_info_label_num
;
3542 /* The current table to which we should emit line number information
3543 for the current function. This will be set up at the beginning of
3544 assembly for the function. */
3545 static GTY(()) dw_line_info_table
*cur_line_info_table
;
3547 /* The two default tables of line number info. */
3548 static GTY(()) dw_line_info_table
*text_section_line_info
;
3549 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
3551 /* The set of all non-default tables of line number info. */
3552 static GTY(()) vec
<dw_line_info_table
*, va_gc
> *separate_line_info
;
3554 /* A flag to tell pubnames/types export if there is an info section to
3556 static bool info_section_emitted
;
3558 /* A pointer to the base of a table that contains a list of publicly
3559 accessible names. */
3560 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
3562 /* A pointer to the base of a table that contains a list of publicly
3563 accessible types. */
3564 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
3566 /* A pointer to the base of a table that contains a list of macro
3567 defines/undefines (and file start/end markers). */
3568 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
3570 /* True if .debug_macinfo or .debug_macros section is going to be
3572 #define have_macinfo \
3573 ((!XCOFF_DEBUGGING_INFO || HAVE_XCOFF_DWARF_EXTRAS) \
3574 && debug_info_level >= DINFO_LEVEL_VERBOSE \
3575 && !macinfo_table->is_empty ())
3577 /* Vector of dies for which we should generate .debug_ranges info. */
3578 static GTY (()) vec
<dw_ranges
, va_gc
> *ranges_table
;
3580 /* Vector of pairs of labels referenced in ranges_table. */
3581 static GTY (()) vec
<dw_ranges_by_label
, va_gc
> *ranges_by_label
;
3583 /* Whether we have location lists that need outputting */
3584 static GTY(()) bool have_location_lists
;
3586 /* Unique label counter. */
3587 static GTY(()) unsigned int loclabel_num
;
3589 /* Unique label counter for point-of-call tables. */
3590 static GTY(()) unsigned int poc_label_num
;
3592 /* The last file entry emitted by maybe_emit_file(). */
3593 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
3595 /* Number of internal labels generated by gen_internal_sym(). */
3596 static GTY(()) int label_num
;
3598 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
3600 /* Instances of generic types for which we need to generate debug
3601 info that describe their generic parameters and arguments. That
3602 generation needs to happen once all types are properly laid out so
3603 we do it at the end of compilation. */
3604 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
3606 /* Offset from the "steady-state frame pointer" to the frame base,
3607 within the current function. */
3608 static poly_int64 frame_pointer_fb_offset
;
3609 static bool frame_pointer_fb_offset_valid
;
3611 static vec
<dw_die_ref
> base_types
;
3613 /* Flags to represent a set of attribute classes for attributes that represent
3614 a scalar value (bounds, pointers, ...). */
3617 dw_scalar_form_constant
= 0x01,
3618 dw_scalar_form_exprloc
= 0x02,
3619 dw_scalar_form_reference
= 0x04
3622 /* Forward declarations for functions defined in this file. */
3624 static int is_pseudo_reg (const_rtx
);
3625 static tree
type_main_variant (tree
);
3626 static int is_tagged_type (const_tree
);
3627 static const char *dwarf_tag_name (unsigned);
3628 static const char *dwarf_attr_name (unsigned);
3629 static const char *dwarf_form_name (unsigned);
3630 static tree
decl_ultimate_origin (const_tree
);
3631 static tree
decl_class_context (tree
);
3632 static void add_dwarf_attr (dw_die_ref
, dw_attr_node
*);
3633 static inline enum dw_val_class
AT_class (dw_attr_node
*);
3634 static inline unsigned int AT_index (dw_attr_node
*);
3635 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3636 static inline unsigned AT_flag (dw_attr_node
*);
3637 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3638 static inline HOST_WIDE_INT
AT_int (dw_attr_node
*);
3639 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3640 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_node
*);
3641 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
3642 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
3643 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3644 unsigned int, unsigned char *);
3645 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
3646 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3647 static inline const char *AT_string (dw_attr_node
*);
3648 static enum dwarf_form
AT_string_form (dw_attr_node
*);
3649 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3650 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3651 static inline dw_die_ref
AT_ref (dw_attr_node
*);
3652 static inline int AT_ref_external (dw_attr_node
*);
3653 static inline void set_AT_ref_external (dw_attr_node
*, int);
3654 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3655 static inline dw_loc_descr_ref
AT_loc (dw_attr_node
*);
3656 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3658 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3659 static void add_AT_view_list (dw_die_ref
, enum dwarf_attribute
);
3660 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3661 static addr_table_entry
*add_addr_table_entry (void *, enum ate_kind
);
3662 static void remove_addr_table_entry (addr_table_entry
*);
3663 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
, bool);
3664 static inline rtx
AT_addr (dw_attr_node
*);
3665 static void add_AT_symview (dw_die_ref
, enum dwarf_attribute
, const char *);
3666 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3667 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3668 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3669 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3670 unsigned long, bool);
3671 static inline const char *AT_lbl (dw_attr_node
*);
3672 static dw_attr_node
*get_AT (dw_die_ref
, enum dwarf_attribute
);
3673 static const char *get_AT_low_pc (dw_die_ref
);
3674 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
3675 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
3676 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
3677 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
3678 static bool is_c (void);
3679 static bool is_cxx (void);
3680 static bool is_cxx (const_tree
);
3681 static bool is_fortran (void);
3682 static bool is_ada (void);
3683 static bool remove_AT (dw_die_ref
, enum dwarf_attribute
);
3684 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3685 static void add_child_die (dw_die_ref
, dw_die_ref
);
3686 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3687 static dw_die_ref
lookup_type_die (tree
);
3688 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3689 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3690 static void equate_type_number_to_die (tree
, dw_die_ref
);
3691 static dw_die_ref
lookup_decl_die (tree
);
3692 static var_loc_list
*lookup_decl_loc (const_tree
);
3693 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3694 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *, var_loc_view
);
3695 static void print_spaces (FILE *);
3696 static void print_die (dw_die_ref
, FILE *);
3697 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3698 static void attr_checksum (dw_attr_node
*, struct md5_ctx
*, int *);
3699 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3700 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3701 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3702 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3703 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_node
*,
3704 struct md5_ctx
*, int *);
3705 struct checksum_attributes
;
3706 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3707 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3708 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3709 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3710 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3711 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3712 static int same_attr_p (dw_attr_node
*, dw_attr_node
*, int *);
3713 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3714 static int is_type_die (dw_die_ref
);
3715 static inline bool is_template_instantiation (dw_die_ref
);
3716 static int is_declaration_die (dw_die_ref
);
3717 static int should_move_die_to_comdat (dw_die_ref
);
3718 static dw_die_ref
clone_as_declaration (dw_die_ref
);
3719 static dw_die_ref
clone_die (dw_die_ref
);
3720 static dw_die_ref
clone_tree (dw_die_ref
);
3721 static dw_die_ref
copy_declaration_context (dw_die_ref
, dw_die_ref
);
3722 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
3723 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
3724 static dw_die_ref
generate_skeleton (dw_die_ref
);
3725 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
3728 static void break_out_comdat_types (dw_die_ref
);
3729 static void copy_decls_for_unworthy_types (dw_die_ref
);
3731 static void add_sibling_attributes (dw_die_ref
);
3732 static void output_location_lists (dw_die_ref
);
3733 static int constant_size (unsigned HOST_WIDE_INT
);
3734 static unsigned long size_of_die (dw_die_ref
);
3735 static void calc_die_sizes (dw_die_ref
);
3736 static void calc_base_type_die_sizes (void);
3737 static void mark_dies (dw_die_ref
);
3738 static void unmark_dies (dw_die_ref
);
3739 static void unmark_all_dies (dw_die_ref
);
3740 static unsigned long size_of_pubnames (vec
<pubname_entry
, va_gc
> *);
3741 static unsigned long size_of_aranges (void);
3742 static enum dwarf_form
value_format (dw_attr_node
*);
3743 static void output_value_format (dw_attr_node
*);
3744 static void output_abbrev_section (void);
3745 static void output_die_abbrevs (unsigned long, dw_die_ref
);
3746 static void output_die (dw_die_ref
);
3747 static void output_compilation_unit_header (enum dwarf_unit_type
);
3748 static void output_comp_unit (dw_die_ref
, int, const unsigned char *);
3749 static void output_comdat_type_unit (comdat_type_node
*);
3750 static const char *dwarf2_name (tree
, int);
3751 static void add_pubname (tree
, dw_die_ref
);
3752 static void add_enumerator_pubname (const char *, dw_die_ref
);
3753 static void add_pubname_string (const char *, dw_die_ref
);
3754 static void add_pubtype (tree
, dw_die_ref
);
3755 static void output_pubnames (vec
<pubname_entry
, va_gc
> *);
3756 static void output_aranges (void);
3757 static unsigned int add_ranges (const_tree
, bool = false);
3758 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
3760 static void output_ranges (void);
3761 static dw_line_info_table
*new_line_info_table (void);
3762 static void output_line_info (bool);
3763 static void output_file_names (void);
3764 static dw_die_ref
base_type_die (tree
, bool);
3765 static int is_base_type (tree
);
3766 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, tree
, dw_die_ref
);
3767 static int decl_quals (const_tree
);
3768 static dw_die_ref
modified_type_die (tree
, int, bool, dw_die_ref
);
3769 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
3770 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
3771 static unsigned int dbx_reg_number (const_rtx
);
3772 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3773 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3774 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3775 enum var_init_status
);
3776 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3777 enum var_init_status
);
3778 static dw_loc_descr_ref
based_loc_descr (rtx
, poly_int64
,
3779 enum var_init_status
);
3780 static int is_based_loc (const_rtx
);
3781 static bool resolve_one_addr (rtx
*);
3782 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3783 enum var_init_status
);
3784 static dw_loc_descr_ref
loc_descriptor (rtx
, machine_mode mode
,
3785 enum var_init_status
);
3786 struct loc_descr_context
;
3787 static void add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
);
3788 static void add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
);
3789 static dw_loc_list_ref
loc_list_from_tree (tree
, int,
3790 struct loc_descr_context
*);
3791 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int,
3792 struct loc_descr_context
*);
3793 static tree
field_type (const_tree
);
3794 static unsigned int simple_type_align_in_bits (const_tree
);
3795 static unsigned int simple_decl_align_in_bits (const_tree
);
3796 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3798 static dw_loc_descr_ref
field_byte_offset (const_tree
, struct vlr_context
*,
3800 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3802 static void add_data_member_location_attribute (dw_die_ref
, tree
,
3803 struct vlr_context
*);
3804 static bool add_const_value_attribute (dw_die_ref
, rtx
);
3805 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3806 static void insert_wide_int (const wide_int
&, unsigned char *, int);
3807 static void insert_float (const_rtx
, unsigned char *);
3808 static rtx
rtl_for_decl_location (tree
);
3809 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool);
3810 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3811 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3812 static void add_name_attribute (dw_die_ref
, const char *);
3813 static void add_desc_attribute (dw_die_ref
, tree
);
3814 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3815 static void add_comp_dir_attribute (dw_die_ref
);
3816 static void add_scalar_info (dw_die_ref
, enum dwarf_attribute
, tree
, int,
3817 struct loc_descr_context
*);
3818 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
,
3819 struct loc_descr_context
*);
3820 static void add_subscript_info (dw_die_ref
, tree
, bool);
3821 static void add_byte_size_attribute (dw_die_ref
, tree
);
3822 static void add_alignment_attribute (dw_die_ref
, tree
);
3823 static inline void add_bit_offset_attribute (dw_die_ref
, tree
,
3824 struct vlr_context
*);
3825 static void add_bit_size_attribute (dw_die_ref
, tree
);
3826 static void add_prototyped_attribute (dw_die_ref
, tree
);
3827 static void add_abstract_origin_attribute (dw_die_ref
, tree
);
3828 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3829 static void add_src_coords_attributes (dw_die_ref
, tree
);
3830 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
, bool = false);
3831 static void add_discr_value (dw_die_ref
, dw_discr_value
*);
3832 static void add_discr_list (dw_die_ref
, dw_discr_list_ref
);
3833 static inline dw_discr_list_ref
AT_discr_list (dw_attr_node
*);
3834 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3835 static inline int local_scope_p (dw_die_ref
);
3836 static inline int class_scope_p (dw_die_ref
);
3837 static inline int class_or_namespace_scope_p (dw_die_ref
);
3838 static void add_type_attribute (dw_die_ref
, tree
, int, bool, dw_die_ref
);
3839 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3840 static const char *type_tag (const_tree
);
3841 static tree
member_declared_type (const_tree
);
3843 static const char *decl_start_label (tree
);
3845 static void gen_array_type_die (tree
, dw_die_ref
);
3846 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3848 static void gen_entry_point_die (tree
, dw_die_ref
);
3850 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3851 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3852 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3853 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3854 static void gen_formal_types_die (tree
, dw_die_ref
);
3855 static void gen_subprogram_die (tree
, dw_die_ref
);
3856 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3857 static void gen_const_die (tree
, dw_die_ref
);
3858 static void gen_label_die (tree
, dw_die_ref
);
3859 static void gen_lexical_block_die (tree
, dw_die_ref
);
3860 static void gen_inlined_subroutine_die (tree
, dw_die_ref
);
3861 static void gen_field_die (tree
, struct vlr_context
*, dw_die_ref
);
3862 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3863 static dw_die_ref
gen_compile_unit_die (const char *);
3864 static void gen_inheritance_die (tree
, tree
, tree
, dw_die_ref
);
3865 static void gen_member_die (tree
, dw_die_ref
);
3866 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3867 enum debug_info_usage
);
3868 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3869 static void gen_typedef_die (tree
, dw_die_ref
);
3870 static void gen_type_die (tree
, dw_die_ref
);
3871 static void gen_block_die (tree
, dw_die_ref
);
3872 static void decls_for_scope (tree
, dw_die_ref
, bool = true);
3873 static bool is_naming_typedef_decl (const_tree
);
3874 static inline dw_die_ref
get_context_die (tree
);
3875 static void gen_namespace_die (tree
, dw_die_ref
);
3876 static dw_die_ref
gen_namelist_decl (tree
, dw_die_ref
, tree
);
3877 static dw_die_ref
gen_decl_die (tree
, tree
, struct vlr_context
*, dw_die_ref
);
3878 static dw_die_ref
force_decl_die (tree
);
3879 static dw_die_ref
force_type_die (tree
);
3880 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3881 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3882 static struct dwarf_file_data
* lookup_filename (const char *);
3883 static void retry_incomplete_types (void);
3884 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3885 static void gen_generic_params_dies (tree
);
3886 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3887 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3888 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3889 static int file_info_cmp (const void *, const void *);
3890 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *, var_loc_view
,
3891 const char *, var_loc_view
, const char *);
3892 static void output_loc_list (dw_loc_list_ref
);
3893 static char *gen_internal_sym (const char *);
3894 static bool want_pubnames (void);
3896 static void prune_unmark_dies (dw_die_ref
);
3897 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3898 static void prune_unused_types_mark (dw_die_ref
, int);
3899 static void prune_unused_types_walk (dw_die_ref
);
3900 static void prune_unused_types_walk_attribs (dw_die_ref
);
3901 static void prune_unused_types_prune (dw_die_ref
);
3902 static void prune_unused_types (void);
3903 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3904 static inline const char *AT_vms_delta1 (dw_attr_node
*);
3905 static inline const char *AT_vms_delta2 (dw_attr_node
*);
3906 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
3907 static void gen_remaining_tmpl_value_param_die_attribute (void);
3908 static bool generic_type_p (tree
);
3909 static void schedule_generic_params_dies_gen (tree t
);
3910 static void gen_scheduled_generic_parms_dies (void);
3911 static void resolve_variable_values (void);
3913 static const char *comp_dir_string (void);
3915 static void hash_loc_operands (dw_loc_descr_ref
, inchash::hash
&);
3917 /* enum for tracking thread-local variables whose address is really an offset
3918 relative to the TLS pointer, which will need link-time relocation, but will
3919 not need relocation by the DWARF consumer. */
3927 /* Return the operator to use for an address of a variable. For dtprel_true, we
3928 use DW_OP_const*. For regular variables, which need both link-time
3929 relocation and consumer-level relocation (e.g., to account for shared objects
3930 loaded at a random address), we use DW_OP_addr*. */
3932 static inline enum dwarf_location_atom
3933 dw_addr_op (enum dtprel_bool dtprel
)
3935 if (dtprel
== dtprel_true
)
3936 return (dwarf_split_debug_info
? dwarf_OP (DW_OP_constx
)
3937 : (DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
));
3939 return dwarf_split_debug_info
? dwarf_OP (DW_OP_addrx
) : DW_OP_addr
;
3942 /* Return a pointer to a newly allocated address location description. If
3943 dwarf_split_debug_info is true, then record the address with the appropriate
3945 static inline dw_loc_descr_ref
3946 new_addr_loc_descr (rtx addr
, enum dtprel_bool dtprel
)
3948 dw_loc_descr_ref ref
= new_loc_descr (dw_addr_op (dtprel
), 0, 0);
3950 ref
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
3951 ref
->dw_loc_oprnd1
.v
.val_addr
= addr
;
3952 ref
->dtprel
= dtprel
;
3953 if (dwarf_split_debug_info
)
3954 ref
->dw_loc_oprnd1
.val_entry
3955 = add_addr_table_entry (addr
,
3956 dtprel
? ate_kind_rtx_dtprel
: ate_kind_rtx
);
3958 ref
->dw_loc_oprnd1
.val_entry
= NULL
;
3963 /* Section names used to hold DWARF debugging information. */
3965 #ifndef DEBUG_INFO_SECTION
3966 #define DEBUG_INFO_SECTION ".debug_info"
3968 #ifndef DEBUG_DWO_INFO_SECTION
3969 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3971 #ifndef DEBUG_LTO_INFO_SECTION
3972 #define DEBUG_LTO_INFO_SECTION ".gnu.debuglto_.debug_info"
3974 #ifndef DEBUG_LTO_DWO_INFO_SECTION
3975 #define DEBUG_LTO_DWO_INFO_SECTION ".gnu.debuglto_.debug_info.dwo"
3977 #ifndef DEBUG_ABBREV_SECTION
3978 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3980 #ifndef DEBUG_LTO_ABBREV_SECTION
3981 #define DEBUG_LTO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev"
3983 #ifndef DEBUG_DWO_ABBREV_SECTION
3984 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3986 #ifndef DEBUG_LTO_DWO_ABBREV_SECTION
3987 #define DEBUG_LTO_DWO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev.dwo"
3989 #ifndef DEBUG_ARANGES_SECTION
3990 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3992 #ifndef DEBUG_ADDR_SECTION
3993 #define DEBUG_ADDR_SECTION ".debug_addr"
3995 #ifndef DEBUG_MACINFO_SECTION
3996 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
3998 #ifndef DEBUG_LTO_MACINFO_SECTION
3999 #define DEBUG_LTO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo"
4001 #ifndef DEBUG_DWO_MACINFO_SECTION
4002 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
4004 #ifndef DEBUG_LTO_DWO_MACINFO_SECTION
4005 #define DEBUG_LTO_DWO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo.dwo"
4007 #ifndef DEBUG_MACRO_SECTION
4008 #define DEBUG_MACRO_SECTION ".debug_macro"
4010 #ifndef DEBUG_LTO_MACRO_SECTION
4011 #define DEBUG_LTO_MACRO_SECTION ".gnu.debuglto_.debug_macro"
4013 #ifndef DEBUG_DWO_MACRO_SECTION
4014 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
4016 #ifndef DEBUG_LTO_DWO_MACRO_SECTION
4017 #define DEBUG_LTO_DWO_MACRO_SECTION ".gnu.debuglto_.debug_macro.dwo"
4019 #ifndef DEBUG_LINE_SECTION
4020 #define DEBUG_LINE_SECTION ".debug_line"
4022 #ifndef DEBUG_LTO_LINE_SECTION
4023 #define DEBUG_LTO_LINE_SECTION ".gnu.debuglto_.debug_line"
4025 #ifndef DEBUG_DWO_LINE_SECTION
4026 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
4028 #ifndef DEBUG_LTO_DWO_LINE_SECTION
4029 #define DEBUG_LTO_DWO_LINE_SECTION ".gnu.debuglto_.debug_line.dwo"
4031 #ifndef DEBUG_LOC_SECTION
4032 #define DEBUG_LOC_SECTION ".debug_loc"
4034 #ifndef DEBUG_DWO_LOC_SECTION
4035 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
4037 #ifndef DEBUG_LOCLISTS_SECTION
4038 #define DEBUG_LOCLISTS_SECTION ".debug_loclists"
4040 #ifndef DEBUG_DWO_LOCLISTS_SECTION
4041 #define DEBUG_DWO_LOCLISTS_SECTION ".debug_loclists.dwo"
4043 #ifndef DEBUG_PUBNAMES_SECTION
4044 #define DEBUG_PUBNAMES_SECTION \
4045 ((debug_generate_pub_sections == 2) \
4046 ? ".debug_gnu_pubnames" : ".debug_pubnames")
4048 #ifndef DEBUG_PUBTYPES_SECTION
4049 #define DEBUG_PUBTYPES_SECTION \
4050 ((debug_generate_pub_sections == 2) \
4051 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
4053 #ifndef DEBUG_STR_OFFSETS_SECTION
4054 #define DEBUG_STR_OFFSETS_SECTION ".debug_str_offsets"
4056 #ifndef DEBUG_DWO_STR_OFFSETS_SECTION
4057 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
4059 #ifndef DEBUG_LTO_DWO_STR_OFFSETS_SECTION
4060 #define DEBUG_LTO_DWO_STR_OFFSETS_SECTION ".gnu.debuglto_.debug_str_offsets.dwo"
4062 #ifndef DEBUG_STR_SECTION
4063 #define DEBUG_STR_SECTION ".debug_str"
4065 #ifndef DEBUG_LTO_STR_SECTION
4066 #define DEBUG_LTO_STR_SECTION ".gnu.debuglto_.debug_str"
4068 #ifndef DEBUG_STR_DWO_SECTION
4069 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
4071 #ifndef DEBUG_LTO_STR_DWO_SECTION
4072 #define DEBUG_LTO_STR_DWO_SECTION ".gnu.debuglto_.debug_str.dwo"
4074 #ifndef DEBUG_RANGES_SECTION
4075 #define DEBUG_RANGES_SECTION ".debug_ranges"
4077 #ifndef DEBUG_RNGLISTS_SECTION
4078 #define DEBUG_RNGLISTS_SECTION ".debug_rnglists"
4080 #ifndef DEBUG_LINE_STR_SECTION
4081 #define DEBUG_LINE_STR_SECTION ".debug_line_str"
4083 #ifndef DEBUG_LTO_LINE_STR_SECTION
4084 #define DEBUG_LTO_LINE_STR_SECTION ".gnu.debuglto_.debug_line_str"
4087 /* Standard ELF section names for compiled code and data. */
4088 #ifndef TEXT_SECTION_NAME
4089 #define TEXT_SECTION_NAME ".text"
4092 /* Section flags for .debug_str section. */
4093 #define DEBUG_STR_SECTION_FLAGS \
4094 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
4095 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4098 /* Section flags for .debug_str.dwo section. */
4099 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
4101 /* Attribute used to refer to the macro section. */
4102 #define DEBUG_MACRO_ATTRIBUTE (dwarf_version >= 5 ? DW_AT_macros \
4103 : dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros)
4105 /* Labels we insert at beginning sections we can reference instead of
4106 the section names themselves. */
4108 #ifndef TEXT_SECTION_LABEL
4109 #define TEXT_SECTION_LABEL "Ltext"
4111 #ifndef COLD_TEXT_SECTION_LABEL
4112 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
4114 #ifndef DEBUG_LINE_SECTION_LABEL
4115 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4117 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
4118 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
4120 #ifndef DEBUG_INFO_SECTION_LABEL
4121 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4123 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
4124 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
4126 #ifndef DEBUG_ABBREV_SECTION_LABEL
4127 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4129 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
4130 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
4132 #ifndef DEBUG_ADDR_SECTION_LABEL
4133 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
4135 #ifndef DEBUG_LOC_SECTION_LABEL
4136 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4138 #ifndef DEBUG_RANGES_SECTION_LABEL
4139 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4141 #ifndef DEBUG_MACINFO_SECTION_LABEL
4142 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4144 #ifndef DEBUG_MACRO_SECTION_LABEL
4145 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
4147 #define SKELETON_COMP_DIE_ABBREV 1
4148 #define SKELETON_TYPE_DIE_ABBREV 2
4150 /* Definitions of defaults for formats and names of various special
4151 (artificial) labels which may be generated within this file (when the -g
4152 options is used and DWARF2_DEBUGGING_INFO is in effect.
4153 If necessary, these may be overridden from within the tm.h file, but
4154 typically, overriding these defaults is unnecessary. */
4156 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4157 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4158 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4159 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4160 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4161 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4162 static char debug_skeleton_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4163 static char debug_skeleton_abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4164 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4165 static char debug_addr_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4166 static char debug_skeleton_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4167 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4168 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4169 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4170 static char ranges_base_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4172 #ifndef TEXT_END_LABEL
4173 #define TEXT_END_LABEL "Letext"
4175 #ifndef COLD_END_LABEL
4176 #define COLD_END_LABEL "Letext_cold"
4178 #ifndef BLOCK_BEGIN_LABEL
4179 #define BLOCK_BEGIN_LABEL "LBB"
4181 #ifndef BLOCK_INLINE_ENTRY_LABEL
4182 #define BLOCK_INLINE_ENTRY_LABEL "LBI"
4184 #ifndef BLOCK_END_LABEL
4185 #define BLOCK_END_LABEL "LBE"
4187 #ifndef LINE_CODE_LABEL
4188 #define LINE_CODE_LABEL "LM"
4192 /* Return the root of the DIE's built for the current compilation unit. */
4194 comp_unit_die (void)
4196 if (!single_comp_unit_die
)
4197 single_comp_unit_die
= gen_compile_unit_die (NULL
);
4198 return single_comp_unit_die
;
4201 /* We allow a language front-end to designate a function that is to be
4202 called to "demangle" any name before it is put into a DIE. */
4204 static const char *(*demangle_name_func
) (const char *);
4207 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
4209 demangle_name_func
= func
;
4212 /* Test if rtl node points to a pseudo register. */
4215 is_pseudo_reg (const_rtx rtl
)
4217 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
4218 || (GET_CODE (rtl
) == SUBREG
4219 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
4222 /* Return a reference to a type, with its const and volatile qualifiers
4226 type_main_variant (tree type
)
4228 type
= TYPE_MAIN_VARIANT (type
);
4230 /* ??? There really should be only one main variant among any group of
4231 variants of a given type (and all of the MAIN_VARIANT values for all
4232 members of the group should point to that one type) but sometimes the C
4233 front-end messes this up for array types, so we work around that bug
4235 if (TREE_CODE (type
) == ARRAY_TYPE
)
4236 while (type
!= TYPE_MAIN_VARIANT (type
))
4237 type
= TYPE_MAIN_VARIANT (type
);
4242 /* Return nonzero if the given type node represents a tagged type. */
4245 is_tagged_type (const_tree type
)
4247 enum tree_code code
= TREE_CODE (type
);
4249 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
4250 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
4253 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
4256 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
4258 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
4261 /* Return die_offset of a DIE reference to a base type. */
4263 static unsigned long int
4264 get_base_type_offset (dw_die_ref ref
)
4266 if (ref
->die_offset
)
4267 return ref
->die_offset
;
4268 if (comp_unit_die ()->die_abbrev
)
4270 calc_base_type_die_sizes ();
4271 gcc_assert (ref
->die_offset
);
4273 return ref
->die_offset
;
4276 /* Return die_offset of a DIE reference other than base type. */
4278 static unsigned long int
4279 get_ref_die_offset (dw_die_ref ref
)
4281 gcc_assert (ref
->die_offset
);
4282 return ref
->die_offset
;
4285 /* Convert a DIE tag into its string name. */
4288 dwarf_tag_name (unsigned int tag
)
4290 const char *name
= get_DW_TAG_name (tag
);
4295 return "DW_TAG_<unknown>";
4298 /* Convert a DWARF attribute code into its string name. */
4301 dwarf_attr_name (unsigned int attr
)
4307 #if VMS_DEBUGGING_INFO
4308 case DW_AT_HP_prologue
:
4309 return "DW_AT_HP_prologue";
4311 case DW_AT_MIPS_loop_unroll_factor
:
4312 return "DW_AT_MIPS_loop_unroll_factor";
4315 #if VMS_DEBUGGING_INFO
4316 case DW_AT_HP_epilogue
:
4317 return "DW_AT_HP_epilogue";
4319 case DW_AT_MIPS_stride
:
4320 return "DW_AT_MIPS_stride";
4324 name
= get_DW_AT_name (attr
);
4329 return "DW_AT_<unknown>";
4332 /* Convert a DWARF value form code into its string name. */
4335 dwarf_form_name (unsigned int form
)
4337 const char *name
= get_DW_FORM_name (form
);
4342 return "DW_FORM_<unknown>";
4345 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4346 instance of an inlined instance of a decl which is local to an inline
4347 function, so we have to trace all of the way back through the origin chain
4348 to find out what sort of node actually served as the original seed for the
4352 decl_ultimate_origin (const_tree decl
)
4354 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
4357 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
4358 we're trying to output the abstract instance of this function. */
4359 if (DECL_ABSTRACT_P (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
4362 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4363 most distant ancestor, this should never happen. */
4364 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
4366 return DECL_ABSTRACT_ORIGIN (decl
);
4369 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4370 of a virtual function may refer to a base class, so we check the 'this'
4374 decl_class_context (tree decl
)
4376 tree context
= NULL_TREE
;
4378 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
4379 context
= DECL_CONTEXT (decl
);
4381 context
= TYPE_MAIN_VARIANT
4382 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
4384 if (context
&& !TYPE_P (context
))
4385 context
= NULL_TREE
;
4390 /* Add an attribute/value pair to a DIE. */
4393 add_dwarf_attr (dw_die_ref die
, dw_attr_node
*attr
)
4395 /* Maybe this should be an assert? */
4401 /* Check we do not add duplicate attrs. Can't use get_AT here
4402 because that recurses to the specification/abstract origin DIE. */
4405 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4406 gcc_assert (a
->dw_attr
!= attr
->dw_attr
);
4409 vec_safe_reserve (die
->die_attr
, 1);
4410 vec_safe_push (die
->die_attr
, *attr
);
4413 static inline enum dw_val_class
4414 AT_class (dw_attr_node
*a
)
4416 return a
->dw_attr_val
.val_class
;
4419 /* Return the index for any attribute that will be referenced with a
4420 DW_FORM_addrx/GNU_addr_index or DW_FORM_strx/GNU_str_index. String
4421 indices are stored in dw_attr_val.v.val_str for reference counting
4424 static inline unsigned int
4425 AT_index (dw_attr_node
*a
)
4427 if (AT_class (a
) == dw_val_class_str
)
4428 return a
->dw_attr_val
.v
.val_str
->index
;
4429 else if (a
->dw_attr_val
.val_entry
!= NULL
)
4430 return a
->dw_attr_val
.val_entry
->index
;
4434 /* Add a flag value attribute to a DIE. */
4437 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
4441 attr
.dw_attr
= attr_kind
;
4442 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
4443 attr
.dw_attr_val
.val_entry
= NULL
;
4444 attr
.dw_attr_val
.v
.val_flag
= flag
;
4445 add_dwarf_attr (die
, &attr
);
4448 static inline unsigned
4449 AT_flag (dw_attr_node
*a
)
4451 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
4452 return a
->dw_attr_val
.v
.val_flag
;
4455 /* Add a signed integer attribute value to a DIE. */
4458 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
4462 attr
.dw_attr
= attr_kind
;
4463 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
4464 attr
.dw_attr_val
.val_entry
= NULL
;
4465 attr
.dw_attr_val
.v
.val_int
= int_val
;
4466 add_dwarf_attr (die
, &attr
);
4469 static inline HOST_WIDE_INT
4470 AT_int (dw_attr_node
*a
)
4472 gcc_assert (a
&& (AT_class (a
) == dw_val_class_const
4473 || AT_class (a
) == dw_val_class_const_implicit
));
4474 return a
->dw_attr_val
.v
.val_int
;
4477 /* Add an unsigned integer attribute value to a DIE. */
4480 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4481 unsigned HOST_WIDE_INT unsigned_val
)
4485 attr
.dw_attr
= attr_kind
;
4486 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
4487 attr
.dw_attr_val
.val_entry
= NULL
;
4488 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
4489 add_dwarf_attr (die
, &attr
);
4492 static inline unsigned HOST_WIDE_INT
4493 AT_unsigned (dw_attr_node
*a
)
4495 gcc_assert (a
&& (AT_class (a
) == dw_val_class_unsigned_const
4496 || AT_class (a
) == dw_val_class_unsigned_const_implicit
));
4497 return a
->dw_attr_val
.v
.val_unsigned
;
4500 /* Add an unsigned wide integer attribute value to a DIE. */
4503 add_AT_wide (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4508 attr
.dw_attr
= attr_kind
;
4509 attr
.dw_attr_val
.val_class
= dw_val_class_wide_int
;
4510 attr
.dw_attr_val
.val_entry
= NULL
;
4511 attr
.dw_attr_val
.v
.val_wide
= ggc_alloc
<wide_int
> ();
4512 *attr
.dw_attr_val
.v
.val_wide
= w
;
4513 add_dwarf_attr (die
, &attr
);
4516 /* Add an unsigned double integer attribute value to a DIE. */
4519 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4520 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
4524 attr
.dw_attr
= attr_kind
;
4525 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
4526 attr
.dw_attr_val
.val_entry
= NULL
;
4527 attr
.dw_attr_val
.v
.val_double
.high
= high
;
4528 attr
.dw_attr_val
.v
.val_double
.low
= low
;
4529 add_dwarf_attr (die
, &attr
);
4532 /* Add a floating point attribute value to a DIE and return it. */
4535 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4536 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
4540 attr
.dw_attr
= attr_kind
;
4541 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
4542 attr
.dw_attr_val
.val_entry
= NULL
;
4543 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
4544 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
4545 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
4546 add_dwarf_attr (die
, &attr
);
4549 /* Add an 8-byte data attribute value to a DIE. */
4552 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4553 unsigned char data8
[8])
4557 attr
.dw_attr
= attr_kind
;
4558 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
4559 attr
.dw_attr_val
.val_entry
= NULL
;
4560 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
4561 add_dwarf_attr (die
, &attr
);
4564 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
4565 dwarf_split_debug_info, address attributes in dies destined for the
4566 final executable have force_direct set to avoid using indexed
4570 add_AT_low_high_pc (dw_die_ref die
, const char *lbl_low
, const char *lbl_high
,
4576 lbl_id
= xstrdup (lbl_low
);
4577 attr
.dw_attr
= DW_AT_low_pc
;
4578 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4579 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4580 if (dwarf_split_debug_info
&& !force_direct
)
4581 attr
.dw_attr_val
.val_entry
4582 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4584 attr
.dw_attr_val
.val_entry
= NULL
;
4585 add_dwarf_attr (die
, &attr
);
4587 attr
.dw_attr
= DW_AT_high_pc
;
4588 if (dwarf_version
< 4)
4589 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4591 attr
.dw_attr_val
.val_class
= dw_val_class_high_pc
;
4592 lbl_id
= xstrdup (lbl_high
);
4593 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4594 if (attr
.dw_attr_val
.val_class
== dw_val_class_lbl_id
4595 && dwarf_split_debug_info
&& !force_direct
)
4596 attr
.dw_attr_val
.val_entry
4597 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4599 attr
.dw_attr_val
.val_entry
= NULL
;
4600 add_dwarf_attr (die
, &attr
);
4603 /* Hash and equality functions for debug_str_hash. */
4606 indirect_string_hasher::hash (indirect_string_node
*x
)
4608 return htab_hash_string (x
->str
);
4612 indirect_string_hasher::equal (indirect_string_node
*x1
, const char *x2
)
4614 return strcmp (x1
->str
, x2
) == 0;
4617 /* Add STR to the given string hash table. */
4619 static struct indirect_string_node
*
4620 find_AT_string_in_table (const char *str
,
4621 hash_table
<indirect_string_hasher
> *table
)
4623 struct indirect_string_node
*node
;
4625 indirect_string_node
**slot
4626 = table
->find_slot_with_hash (str
, htab_hash_string (str
), INSERT
);
4629 node
= ggc_cleared_alloc
<indirect_string_node
> ();
4630 node
->str
= ggc_strdup (str
);
4640 /* Add STR to the indirect string hash table. */
4642 static struct indirect_string_node
*
4643 find_AT_string (const char *str
)
4645 if (! debug_str_hash
)
4646 debug_str_hash
= hash_table
<indirect_string_hasher
>::create_ggc (10);
4648 return find_AT_string_in_table (str
, debug_str_hash
);
4651 /* Add a string attribute value to a DIE. */
4654 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
4657 struct indirect_string_node
*node
;
4659 node
= find_AT_string (str
);
4661 attr
.dw_attr
= attr_kind
;
4662 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
4663 attr
.dw_attr_val
.val_entry
= NULL
;
4664 attr
.dw_attr_val
.v
.val_str
= node
;
4665 add_dwarf_attr (die
, &attr
);
4668 static inline const char *
4669 AT_string (dw_attr_node
*a
)
4671 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4672 return a
->dw_attr_val
.v
.val_str
->str
;
4675 /* Call this function directly to bypass AT_string_form's logic to put
4676 the string inline in the die. */
4679 set_indirect_string (struct indirect_string_node
*node
)
4681 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4682 /* Already indirect is a no op. */
4683 if (node
->form
== DW_FORM_strp
4684 || node
->form
== DW_FORM_line_strp
4685 || node
->form
== dwarf_FORM (DW_FORM_strx
))
4687 gcc_assert (node
->label
);
4690 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4691 ++dw2_string_counter
;
4692 node
->label
= xstrdup (label
);
4694 if (!dwarf_split_debug_info
)
4696 node
->form
= DW_FORM_strp
;
4697 node
->index
= NOT_INDEXED
;
4701 node
->form
= dwarf_FORM (DW_FORM_strx
);
4702 node
->index
= NO_INDEX_ASSIGNED
;
4706 /* A helper function for dwarf2out_finish, called to reset indirect
4707 string decisions done for early LTO dwarf output before fat object
4711 reset_indirect_string (indirect_string_node
**h
, void *)
4713 struct indirect_string_node
*node
= *h
;
4714 if (node
->form
== DW_FORM_strp
|| node
->form
== dwarf_FORM (DW_FORM_strx
))
4718 node
->form
= (dwarf_form
) 0;
4724 /* Find out whether a string should be output inline in DIE
4725 or out-of-line in .debug_str section. */
4727 static enum dwarf_form
4728 find_string_form (struct indirect_string_node
*node
)
4735 len
= strlen (node
->str
) + 1;
4737 /* If the string is shorter or equal to the size of the reference, it is
4738 always better to put it inline. */
4739 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
4740 return node
->form
= DW_FORM_string
;
4742 /* If we cannot expect the linker to merge strings in .debug_str
4743 section, only put it into .debug_str if it is worth even in this
4745 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4746 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
4747 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
))
4748 return node
->form
= DW_FORM_string
;
4750 set_indirect_string (node
);
4755 /* Find out whether the string referenced from the attribute should be
4756 output inline in DIE or out-of-line in .debug_str section. */
4758 static enum dwarf_form
4759 AT_string_form (dw_attr_node
*a
)
4761 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4762 return find_string_form (a
->dw_attr_val
.v
.val_str
);
4765 /* Add a DIE reference attribute value to a DIE. */
4768 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4771 gcc_checking_assert (targ_die
!= NULL
);
4773 /* With LTO we can end up trying to reference something we didn't create
4774 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4775 if (targ_die
== NULL
)
4778 attr
.dw_attr
= attr_kind
;
4779 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
4780 attr
.dw_attr_val
.val_entry
= NULL
;
4781 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4782 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
4783 add_dwarf_attr (die
, &attr
);
4786 /* Change DIE reference REF to point to NEW_DIE instead. */
4789 change_AT_die_ref (dw_attr_node
*ref
, dw_die_ref new_die
)
4791 gcc_assert (ref
->dw_attr_val
.val_class
== dw_val_class_die_ref
);
4792 ref
->dw_attr_val
.v
.val_die_ref
.die
= new_die
;
4793 ref
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4796 /* Add an AT_specification attribute to a DIE, and also make the back
4797 pointer from the specification to the definition. */
4800 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4802 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4803 gcc_assert (!targ_die
->die_definition
);
4804 targ_die
->die_definition
= die
;
4807 static inline dw_die_ref
4808 AT_ref (dw_attr_node
*a
)
4810 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4811 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4815 AT_ref_external (dw_attr_node
*a
)
4817 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4818 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4824 set_AT_ref_external (dw_attr_node
*a
, int i
)
4826 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4827 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4830 /* Add a location description attribute value to a DIE. */
4833 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4837 attr
.dw_attr
= attr_kind
;
4838 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4839 attr
.dw_attr_val
.val_entry
= NULL
;
4840 attr
.dw_attr_val
.v
.val_loc
= loc
;
4841 add_dwarf_attr (die
, &attr
);
4844 static inline dw_loc_descr_ref
4845 AT_loc (dw_attr_node
*a
)
4847 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4848 return a
->dw_attr_val
.v
.val_loc
;
4852 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4856 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4859 attr
.dw_attr
= attr_kind
;
4860 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
4861 attr
.dw_attr_val
.val_entry
= NULL
;
4862 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
4863 add_dwarf_attr (die
, &attr
);
4864 have_location_lists
= true;
4867 static inline dw_loc_list_ref
4868 AT_loc_list (dw_attr_node
*a
)
4870 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4871 return a
->dw_attr_val
.v
.val_loc_list
;
4874 /* Add a view list attribute to DIE. It must have a DW_AT_location
4875 attribute, because the view list complements the location list. */
4878 add_AT_view_list (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4882 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4885 attr
.dw_attr
= attr_kind
;
4886 attr
.dw_attr_val
.val_class
= dw_val_class_view_list
;
4887 attr
.dw_attr_val
.val_entry
= NULL
;
4888 attr
.dw_attr_val
.v
.val_view_list
= die
;
4889 add_dwarf_attr (die
, &attr
);
4890 gcc_checking_assert (get_AT (die
, DW_AT_location
));
4891 gcc_assert (have_location_lists
);
4894 /* Return a pointer to the location list referenced by the attribute.
4895 If the named attribute is a view list, look up the corresponding
4896 DW_AT_location attribute and return its location list. */
4898 static inline dw_loc_list_ref
*
4899 AT_loc_list_ptr (dw_attr_node
*a
)
4902 switch (AT_class (a
))
4904 case dw_val_class_loc_list
:
4905 return &a
->dw_attr_val
.v
.val_loc_list
;
4906 case dw_val_class_view_list
:
4909 l
= get_AT (a
->dw_attr_val
.v
.val_view_list
, DW_AT_location
);
4912 gcc_checking_assert (l
+ 1 == a
);
4913 return AT_loc_list_ptr (l
);
4920 /* Return the location attribute value associated with a view list
4923 static inline dw_val_node
*
4924 view_list_to_loc_list_val_node (dw_val_node
*val
)
4926 gcc_assert (val
->val_class
== dw_val_class_view_list
);
4927 dw_attr_node
*loc
= get_AT (val
->v
.val_view_list
, DW_AT_location
);
4930 gcc_checking_assert (&(loc
+ 1)->dw_attr_val
== val
);
4931 gcc_assert (AT_class (loc
) == dw_val_class_loc_list
);
4932 return &loc
->dw_attr_val
;
4935 struct addr_hasher
: ggc_ptr_hash
<addr_table_entry
>
4937 static hashval_t
hash (addr_table_entry
*);
4938 static bool equal (addr_table_entry
*, addr_table_entry
*);
4941 /* Table of entries into the .debug_addr section. */
4943 static GTY (()) hash_table
<addr_hasher
> *addr_index_table
;
4945 /* Hash an address_table_entry. */
4948 addr_hasher::hash (addr_table_entry
*a
)
4950 inchash::hash hstate
;
4956 case ate_kind_rtx_dtprel
:
4959 case ate_kind_label
:
4960 return htab_hash_string (a
->addr
.label
);
4964 inchash::add_rtx (a
->addr
.rtl
, hstate
);
4965 return hstate
.end ();
4968 /* Determine equality for two address_table_entries. */
4971 addr_hasher::equal (addr_table_entry
*a1
, addr_table_entry
*a2
)
4973 if (a1
->kind
!= a2
->kind
)
4978 case ate_kind_rtx_dtprel
:
4979 return rtx_equal_p (a1
->addr
.rtl
, a2
->addr
.rtl
);
4980 case ate_kind_label
:
4981 return strcmp (a1
->addr
.label
, a2
->addr
.label
) == 0;
4987 /* Initialize an addr_table_entry. */
4990 init_addr_table_entry (addr_table_entry
*e
, enum ate_kind kind
, void *addr
)
4996 case ate_kind_rtx_dtprel
:
4997 e
->addr
.rtl
= (rtx
) addr
;
4999 case ate_kind_label
:
5000 e
->addr
.label
= (char *) addr
;
5004 e
->index
= NO_INDEX_ASSIGNED
;
5007 /* Add attr to the address table entry to the table. Defer setting an
5008 index until output time. */
5010 static addr_table_entry
*
5011 add_addr_table_entry (void *addr
, enum ate_kind kind
)
5013 addr_table_entry
*node
;
5014 addr_table_entry finder
;
5016 gcc_assert (dwarf_split_debug_info
);
5017 if (! addr_index_table
)
5018 addr_index_table
= hash_table
<addr_hasher
>::create_ggc (10);
5019 init_addr_table_entry (&finder
, kind
, addr
);
5020 addr_table_entry
**slot
= addr_index_table
->find_slot (&finder
, INSERT
);
5022 if (*slot
== HTAB_EMPTY_ENTRY
)
5024 node
= ggc_cleared_alloc
<addr_table_entry
> ();
5025 init_addr_table_entry (node
, kind
, addr
);
5035 /* Remove an entry from the addr table by decrementing its refcount.
5036 Strictly, decrementing the refcount would be enough, but the
5037 assertion that the entry is actually in the table has found
5041 remove_addr_table_entry (addr_table_entry
*entry
)
5043 gcc_assert (dwarf_split_debug_info
&& addr_index_table
);
5044 /* After an index is assigned, the table is frozen. */
5045 gcc_assert (entry
->refcount
> 0 && entry
->index
== NO_INDEX_ASSIGNED
);
5049 /* Given a location list, remove all addresses it refers to from the
5053 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr
)
5055 for (; descr
; descr
= descr
->dw_loc_next
)
5056 if (descr
->dw_loc_oprnd1
.val_entry
!= NULL
)
5058 gcc_assert (descr
->dw_loc_oprnd1
.val_entry
->index
== NO_INDEX_ASSIGNED
);
5059 remove_addr_table_entry (descr
->dw_loc_oprnd1
.val_entry
);
5063 /* A helper function for dwarf2out_finish called through
5064 htab_traverse. Assign an addr_table_entry its index. All entries
5065 must be collected into the table when this function is called,
5066 because the indexing code relies on htab_traverse to traverse nodes
5067 in the same order for each run. */
5070 index_addr_table_entry (addr_table_entry
**h
, unsigned int *index
)
5072 addr_table_entry
*node
= *h
;
5074 /* Don't index unreferenced nodes. */
5075 if (node
->refcount
== 0)
5078 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
5079 node
->index
= *index
;
5085 /* Add an address constant attribute value to a DIE. When using
5086 dwarf_split_debug_info, address attributes in dies destined for the
5087 final executable should be direct references--setting the parameter
5088 force_direct ensures this behavior. */
5091 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
,
5096 attr
.dw_attr
= attr_kind
;
5097 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
5098 attr
.dw_attr_val
.v
.val_addr
= addr
;
5099 if (dwarf_split_debug_info
&& !force_direct
)
5100 attr
.dw_attr_val
.val_entry
= add_addr_table_entry (addr
, ate_kind_rtx
);
5102 attr
.dw_attr_val
.val_entry
= NULL
;
5103 add_dwarf_attr (die
, &attr
);
5106 /* Get the RTX from to an address DIE attribute. */
5109 AT_addr (dw_attr_node
*a
)
5111 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
5112 return a
->dw_attr_val
.v
.val_addr
;
5115 /* Add a file attribute value to a DIE. */
5118 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5119 struct dwarf_file_data
*fd
)
5123 attr
.dw_attr
= attr_kind
;
5124 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
5125 attr
.dw_attr_val
.val_entry
= NULL
;
5126 attr
.dw_attr_val
.v
.val_file
= fd
;
5127 add_dwarf_attr (die
, &attr
);
5130 /* Get the dwarf_file_data from a file DIE attribute. */
5132 static inline struct dwarf_file_data
*
5133 AT_file (dw_attr_node
*a
)
5135 gcc_assert (a
&& (AT_class (a
) == dw_val_class_file
5136 || AT_class (a
) == dw_val_class_file_implicit
));
5137 return a
->dw_attr_val
.v
.val_file
;
5140 /* Add a symbolic view identifier attribute value to a DIE. */
5143 add_AT_symview (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5144 const char *view_label
)
5148 attr
.dw_attr
= attr_kind
;
5149 attr
.dw_attr_val
.val_class
= dw_val_class_symview
;
5150 attr
.dw_attr_val
.val_entry
= NULL
;
5151 attr
.dw_attr_val
.v
.val_symbolic_view
= xstrdup (view_label
);
5152 add_dwarf_attr (die
, &attr
);
5155 /* Add a label identifier attribute value to a DIE. */
5158 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5163 attr
.dw_attr
= attr_kind
;
5164 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
5165 attr
.dw_attr_val
.val_entry
= NULL
;
5166 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
5167 if (dwarf_split_debug_info
)
5168 attr
.dw_attr_val
.val_entry
5169 = add_addr_table_entry (attr
.dw_attr_val
.v
.val_lbl_id
,
5171 add_dwarf_attr (die
, &attr
);
5174 /* Add a section offset attribute value to a DIE, an offset into the
5175 debug_line section. */
5178 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5183 attr
.dw_attr
= attr_kind
;
5184 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
5185 attr
.dw_attr_val
.val_entry
= NULL
;
5186 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5187 add_dwarf_attr (die
, &attr
);
5190 /* Add a section offset attribute value to a DIE, an offset into the
5191 debug_macinfo section. */
5194 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5199 attr
.dw_attr
= attr_kind
;
5200 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
5201 attr
.dw_attr_val
.val_entry
= NULL
;
5202 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5203 add_dwarf_attr (die
, &attr
);
5206 /* Add a range_list attribute value to a DIE. When using
5207 dwarf_split_debug_info, address attributes in dies destined for the
5208 final executable should be direct references--setting the parameter
5209 force_direct ensures this behavior. */
5211 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
5212 #define RELOCATED_OFFSET (NULL)
5215 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5216 long unsigned int offset
, bool force_direct
)
5220 attr
.dw_attr
= attr_kind
;
5221 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
5222 /* For the range_list attribute, use val_entry to store whether the
5223 offset should follow split-debug-info or normal semantics. This
5224 value is read in output_range_list_offset. */
5225 if (dwarf_split_debug_info
&& !force_direct
)
5226 attr
.dw_attr_val
.val_entry
= UNRELOCATED_OFFSET
;
5228 attr
.dw_attr_val
.val_entry
= RELOCATED_OFFSET
;
5229 attr
.dw_attr_val
.v
.val_offset
= offset
;
5230 add_dwarf_attr (die
, &attr
);
5233 /* Return the start label of a delta attribute. */
5235 static inline const char *
5236 AT_vms_delta1 (dw_attr_node
*a
)
5238 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5239 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
5242 /* Return the end label of a delta attribute. */
5244 static inline const char *
5245 AT_vms_delta2 (dw_attr_node
*a
)
5247 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5248 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
5251 static inline const char *
5252 AT_lbl (dw_attr_node
*a
)
5254 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
5255 || AT_class (a
) == dw_val_class_lineptr
5256 || AT_class (a
) == dw_val_class_macptr
5257 || AT_class (a
) == dw_val_class_loclistsptr
5258 || AT_class (a
) == dw_val_class_high_pc
));
5259 return a
->dw_attr_val
.v
.val_lbl_id
;
5262 /* Get the attribute of type attr_kind. */
5264 static dw_attr_node
*
5265 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5269 dw_die_ref spec
= NULL
;
5274 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5275 if (a
->dw_attr
== attr_kind
)
5277 else if (a
->dw_attr
== DW_AT_specification
5278 || a
->dw_attr
== DW_AT_abstract_origin
)
5282 return get_AT (spec
, attr_kind
);
5287 /* Returns the parent of the declaration of DIE. */
5290 get_die_parent (dw_die_ref die
)
5297 if ((t
= get_AT_ref (die
, DW_AT_abstract_origin
))
5298 || (t
= get_AT_ref (die
, DW_AT_specification
)))
5301 return die
->die_parent
;
5304 /* Return the "low pc" attribute value, typically associated with a subprogram
5305 DIE. Return null if the "low pc" attribute is either not present, or if it
5306 cannot be represented as an assembler label identifier. */
5308 static inline const char *
5309 get_AT_low_pc (dw_die_ref die
)
5311 dw_attr_node
*a
= get_AT (die
, DW_AT_low_pc
);
5313 return a
? AT_lbl (a
) : NULL
;
5316 /* Return the value of the string attribute designated by ATTR_KIND, or
5317 NULL if it is not present. */
5319 static inline const char *
5320 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5322 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5324 return a
? AT_string (a
) : NULL
;
5327 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5328 if it is not present. */
5331 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5333 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5335 return a
? AT_flag (a
) : 0;
5338 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5339 if it is not present. */
5341 static inline unsigned
5342 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5344 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5346 return a
? AT_unsigned (a
) : 0;
5349 static inline dw_die_ref
5350 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5352 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5354 return a
? AT_ref (a
) : NULL
;
5357 static inline struct dwarf_file_data
*
5358 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5360 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5362 return a
? AT_file (a
) : NULL
;
5365 /* Return TRUE if the language is C. */
5370 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5372 return (lang
== DW_LANG_C
|| lang
== DW_LANG_C89
|| lang
== DW_LANG_C99
5373 || lang
== DW_LANG_C11
|| lang
== DW_LANG_ObjC
);
5378 /* Return TRUE if the language is C++. */
5383 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5385 return (lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
5386 || lang
== DW_LANG_C_plus_plus_11
|| lang
== DW_LANG_C_plus_plus_14
);
5389 /* Return TRUE if DECL was created by the C++ frontend. */
5392 is_cxx (const_tree decl
)
5396 const_tree context
= get_ultimate_context (decl
);
5397 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5398 return strncmp (TRANSLATION_UNIT_LANGUAGE (context
), "GNU C++", 7) == 0;
5403 /* Return TRUE if the language is Fortran. */
5408 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5410 return (lang
== DW_LANG_Fortran77
5411 || lang
== DW_LANG_Fortran90
5412 || lang
== DW_LANG_Fortran95
5413 || lang
== DW_LANG_Fortran03
5414 || lang
== DW_LANG_Fortran08
);
5418 is_fortran (const_tree decl
)
5422 const_tree context
= get_ultimate_context (decl
);
5423 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5424 return (strncmp (TRANSLATION_UNIT_LANGUAGE (context
),
5425 "GNU Fortran", 11) == 0
5426 || strcmp (TRANSLATION_UNIT_LANGUAGE (context
),
5429 return is_fortran ();
5432 /* Return TRUE if the language is Ada. */
5437 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5439 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
5442 /* Return TRUE if the language is D. */
5447 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5449 return lang
== DW_LANG_D
;
5452 /* Remove the specified attribute if present. Return TRUE if removal
5456 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5464 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5465 if (a
->dw_attr
== attr_kind
)
5467 if (AT_class (a
) == dw_val_class_str
)
5468 if (a
->dw_attr_val
.v
.val_str
->refcount
)
5469 a
->dw_attr_val
.v
.val_str
->refcount
--;
5471 /* vec::ordered_remove should help reduce the number of abbrevs
5473 die
->die_attr
->ordered_remove (ix
);
5479 /* Remove CHILD from its parent. PREV must have the property that
5480 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
5483 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
5485 gcc_assert (child
->die_parent
== prev
->die_parent
);
5486 gcc_assert (prev
->die_sib
== child
);
5489 gcc_assert (child
->die_parent
->die_child
== child
);
5493 prev
->die_sib
= child
->die_sib
;
5494 if (child
->die_parent
->die_child
== child
)
5495 child
->die_parent
->die_child
= prev
;
5496 child
->die_sib
= NULL
;
5499 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
5500 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
5503 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
5505 dw_die_ref parent
= old_child
->die_parent
;
5507 gcc_assert (parent
== prev
->die_parent
);
5508 gcc_assert (prev
->die_sib
== old_child
);
5510 new_child
->die_parent
= parent
;
5511 if (prev
== old_child
)
5513 gcc_assert (parent
->die_child
== old_child
);
5514 new_child
->die_sib
= new_child
;
5518 prev
->die_sib
= new_child
;
5519 new_child
->die_sib
= old_child
->die_sib
;
5521 if (old_child
->die_parent
->die_child
== old_child
)
5522 old_child
->die_parent
->die_child
= new_child
;
5523 old_child
->die_sib
= NULL
;
5526 /* Move all children from OLD_PARENT to NEW_PARENT. */
5529 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
5532 new_parent
->die_child
= old_parent
->die_child
;
5533 old_parent
->die_child
= NULL
;
5534 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
5537 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
5541 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
5547 dw_die_ref prev
= c
;
5549 while (c
->die_tag
== tag
)
5551 remove_child_with_prev (c
, prev
);
5552 c
->die_parent
= NULL
;
5553 /* Might have removed every child. */
5554 if (die
->die_child
== NULL
)
5558 } while (c
!= die
->die_child
);
5561 /* Add a CHILD_DIE as the last child of DIE. */
5564 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
5566 /* FIXME this should probably be an assert. */
5567 if (! die
|| ! child_die
)
5569 gcc_assert (die
!= child_die
);
5571 child_die
->die_parent
= die
;
5574 child_die
->die_sib
= die
->die_child
->die_sib
;
5575 die
->die_child
->die_sib
= child_die
;
5578 child_die
->die_sib
= child_die
;
5579 die
->die_child
= child_die
;
5582 /* Like add_child_die, but put CHILD_DIE after AFTER_DIE. */
5585 add_child_die_after (dw_die_ref die
, dw_die_ref child_die
,
5586 dw_die_ref after_die
)
5592 && die
!= child_die
);
5594 child_die
->die_parent
= die
;
5595 child_die
->die_sib
= after_die
->die_sib
;
5596 after_die
->die_sib
= child_die
;
5597 if (die
->die_child
== after_die
)
5598 die
->die_child
= child_die
;
5601 /* Unassociate CHILD from its parent, and make its parent be
5605 reparent_child (dw_die_ref child
, dw_die_ref new_parent
)
5607 for (dw_die_ref p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
5608 if (p
->die_sib
== child
)
5610 remove_child_with_prev (child
, p
);
5613 add_child_die (new_parent
, child
);
5616 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5617 is the specification, to the end of PARENT's list of children.
5618 This is done by removing and re-adding it. */
5621 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
5623 /* We want the declaration DIE from inside the class, not the
5624 specification DIE at toplevel. */
5625 if (child
->die_parent
!= parent
)
5627 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5633 gcc_assert (child
->die_parent
== parent
5634 || (child
->die_parent
5635 == get_AT_ref (parent
, DW_AT_specification
)));
5637 reparent_child (child
, parent
);
5640 /* Create and return a new die with TAG_VALUE as tag. */
5642 static inline dw_die_ref
5643 new_die_raw (enum dwarf_tag tag_value
)
5645 dw_die_ref die
= ggc_cleared_alloc
<die_node
> ();
5646 die
->die_tag
= tag_value
;
5650 /* Create and return a new die with a parent of PARENT_DIE. If
5651 PARENT_DIE is NULL, the new DIE is placed in limbo and an
5652 associated tree T must be supplied to determine parenthood
5655 static inline dw_die_ref
5656 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5658 dw_die_ref die
= new_die_raw (tag_value
);
5660 if (parent_die
!= NULL
)
5661 add_child_die (parent_die
, die
);
5664 limbo_die_node
*limbo_node
;
5666 /* No DIEs created after early dwarf should end up in limbo,
5667 because the limbo list should not persist past LTO
5669 if (tag_value
!= DW_TAG_compile_unit
5670 /* These are allowed because they're generated while
5671 breaking out COMDAT units late. */
5672 && tag_value
!= DW_TAG_type_unit
5673 && tag_value
!= DW_TAG_skeleton_unit
5675 /* Allow nested functions to live in limbo because they will
5676 only temporarily live there, as decls_for_scope will fix
5678 && (TREE_CODE (t
) != FUNCTION_DECL
5679 || !decl_function_context (t
))
5680 /* Same as nested functions above but for types. Types that
5681 are local to a function will be fixed in
5683 && (!RECORD_OR_UNION_TYPE_P (t
)
5684 || !TYPE_CONTEXT (t
)
5685 || TREE_CODE (TYPE_CONTEXT (t
)) != FUNCTION_DECL
)
5686 /* FIXME debug-early: Allow late limbo DIE creation for LTO,
5687 especially in the ltrans stage, but once we implement LTO
5688 dwarf streaming, we should remove this exception. */
5691 fprintf (stderr
, "symbol ended up in limbo too late:");
5692 debug_generic_stmt (t
);
5696 limbo_node
= ggc_cleared_alloc
<limbo_die_node
> ();
5697 limbo_node
->die
= die
;
5698 limbo_node
->created_for
= t
;
5699 limbo_node
->next
= limbo_die_list
;
5700 limbo_die_list
= limbo_node
;
5706 /* Return the DIE associated with the given type specifier. */
5708 static inline dw_die_ref
5709 lookup_type_die (tree type
)
5711 dw_die_ref die
= TYPE_SYMTAB_DIE (type
);
5712 if (die
&& die
->removed
)
5714 TYPE_SYMTAB_DIE (type
) = NULL
;
5720 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
5721 anonymous type named by the typedef TYPE_DIE, return the DIE of the
5722 anonymous type instead the one of the naming typedef. */
5724 static inline dw_die_ref
5725 strip_naming_typedef (tree type
, dw_die_ref type_die
)
5728 && TREE_CODE (type
) == RECORD_TYPE
5730 && type_die
->die_tag
== DW_TAG_typedef
5731 && is_naming_typedef_decl (TYPE_NAME (type
)))
5732 type_die
= get_AT_ref (type_die
, DW_AT_type
);
5736 /* Like lookup_type_die, but if type is an anonymous type named by a
5737 typedef[1], return the DIE of the anonymous type instead the one of
5738 the naming typedef. This is because in gen_typedef_die, we did
5739 equate the anonymous struct named by the typedef with the DIE of
5740 the naming typedef. So by default, lookup_type_die on an anonymous
5741 struct yields the DIE of the naming typedef.
5743 [1]: Read the comment of is_naming_typedef_decl to learn about what
5744 a naming typedef is. */
5746 static inline dw_die_ref
5747 lookup_type_die_strip_naming_typedef (tree type
)
5749 dw_die_ref die
= lookup_type_die (type
);
5750 return strip_naming_typedef (type
, die
);
5753 /* Equate a DIE to a given type specifier. */
5756 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5758 TYPE_SYMTAB_DIE (type
) = type_die
;
5761 static dw_die_ref
maybe_create_die_with_external_ref (tree
);
5762 struct GTY(()) sym_off_pair
5764 const char * GTY((skip
)) sym
;
5765 unsigned HOST_WIDE_INT off
;
5767 static GTY(()) hash_map
<tree
, sym_off_pair
> *external_die_map
;
5769 /* Returns a hash value for X (which really is a die_struct). */
5772 decl_die_hasher::hash (die_node
*x
)
5774 return (hashval_t
) x
->decl_id
;
5777 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5780 decl_die_hasher::equal (die_node
*x
, tree y
)
5782 return (x
->decl_id
== DECL_UID (y
));
5785 /* Return the DIE associated with a given declaration. */
5787 static inline dw_die_ref
5788 lookup_decl_die (tree decl
)
5790 dw_die_ref
*die
= decl_die_table
->find_slot_with_hash (decl
, DECL_UID (decl
),
5795 return maybe_create_die_with_external_ref (decl
);
5798 if ((*die
)->removed
)
5800 decl_die_table
->clear_slot (die
);
5807 /* Return the DIE associated with BLOCK. */
5809 static inline dw_die_ref
5810 lookup_block_die (tree block
)
5812 dw_die_ref die
= BLOCK_DIE (block
);
5813 if (!die
&& in_lto_p
)
5814 return maybe_create_die_with_external_ref (block
);
5818 /* Associate DIE with BLOCK. */
5821 equate_block_to_die (tree block
, dw_die_ref die
)
5823 BLOCK_DIE (block
) = die
;
5828 /* For DECL which might have early dwarf output query a SYMBOL + OFFSET
5829 style reference. Return true if we found one refering to a DIE for
5830 DECL, otherwise return false. */
5833 dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
5834 unsigned HOST_WIDE_INT
*off
)
5840 /* During WPA stage and incremental linking we use a hash-map
5841 to store the decl <-> label + offset map. */
5842 if (!external_die_map
)
5844 sym_off_pair
*desc
= external_die_map
->get (decl
);
5852 if (TREE_CODE (decl
) == BLOCK
)
5853 die
= lookup_block_die (decl
);
5855 die
= lookup_decl_die (decl
);
5859 /* Similar to get_ref_die_offset_label, but using the "correct"
5861 *off
= die
->die_offset
;
5862 while (die
->die_parent
)
5863 die
= die
->die_parent
;
5864 /* For the containing CU DIE we compute a die_symbol in
5865 compute_comp_unit_symbol. */
5866 gcc_assert (die
->die_tag
== DW_TAG_compile_unit
5867 && die
->die_id
.die_symbol
!= NULL
);
5868 *sym
= die
->die_id
.die_symbol
;
5872 /* Add a reference of kind ATTR_KIND to a DIE at SYMBOL + OFFSET to DIE. */
5875 add_AT_external_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5876 const char *symbol
, HOST_WIDE_INT offset
)
5878 /* Create a fake DIE that contains the reference. Don't use
5879 new_die because we don't want to end up in the limbo list. */
5880 /* ??? We probably want to share these, thus put a ref to the DIE
5881 we create here to the external_die_map entry. */
5882 dw_die_ref ref
= new_die_raw (die
->die_tag
);
5883 ref
->die_id
.die_symbol
= symbol
;
5884 ref
->die_offset
= offset
;
5885 ref
->with_offset
= 1;
5886 add_AT_die_ref (die
, attr_kind
, ref
);
5889 /* Create a DIE for DECL if required and add a reference to a DIE
5890 at SYMBOL + OFFSET which contains attributes dumped early. */
5893 dwarf2out_register_external_die (tree decl
, const char *sym
,
5894 unsigned HOST_WIDE_INT off
)
5896 if (debug_info_level
== DINFO_LEVEL_NONE
)
5899 if (!external_die_map
)
5900 external_die_map
= hash_map
<tree
, sym_off_pair
>::create_ggc (1000);
5901 gcc_checking_assert (!external_die_map
->get (decl
));
5902 sym_off_pair p
= { IDENTIFIER_POINTER (get_identifier (sym
)), off
};
5903 external_die_map
->put (decl
, p
);
5906 /* If we have a registered external DIE for DECL return a new DIE for
5907 the concrete instance with an appropriate abstract origin. */
5910 maybe_create_die_with_external_ref (tree decl
)
5912 if (!external_die_map
)
5914 sym_off_pair
*desc
= external_die_map
->get (decl
);
5918 const char *sym
= desc
->sym
;
5919 unsigned HOST_WIDE_INT off
= desc
->off
;
5922 dw_die_ref die
= (TREE_CODE (decl
) == BLOCK
5923 ? lookup_block_die (decl
) : lookup_decl_die (decl
));
5928 dw_die_ref parent
= NULL
;
5929 /* Need to lookup a DIE for the decls context - the containing
5930 function or translation unit. */
5931 if (TREE_CODE (decl
) == BLOCK
)
5933 ctx
= BLOCK_SUPERCONTEXT (decl
);
5934 /* ??? We do not output DIEs for all scopes thus skip as
5935 many DIEs as needed. */
5936 while (TREE_CODE (ctx
) == BLOCK
5937 && !lookup_block_die (ctx
))
5938 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5941 ctx
= DECL_CONTEXT (decl
);
5942 /* Peel types in the context stack. */
5943 while (ctx
&& TYPE_P (ctx
))
5944 ctx
= TYPE_CONTEXT (ctx
);
5945 /* Likewise namespaces in case we do not want to emit DIEs for them. */
5946 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
5947 while (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5948 ctx
= DECL_CONTEXT (ctx
);
5951 if (TREE_CODE (ctx
) == BLOCK
)
5952 parent
= lookup_block_die (ctx
);
5953 else if (TREE_CODE (ctx
) == TRANSLATION_UNIT_DECL
5954 /* Keep the 1:1 association during WPA. */
5956 && flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
5957 /* Otherwise all late annotations go to the main CU which
5958 imports the original CUs. */
5959 parent
= comp_unit_die ();
5960 else if (TREE_CODE (ctx
) == FUNCTION_DECL
5961 && TREE_CODE (decl
) != FUNCTION_DECL
5962 && TREE_CODE (decl
) != PARM_DECL
5963 && TREE_CODE (decl
) != RESULT_DECL
5964 && TREE_CODE (decl
) != BLOCK
)
5965 /* Leave function local entities parent determination to when
5966 we process scope vars. */
5969 parent
= lookup_decl_die (ctx
);
5972 /* In some cases the FEs fail to set DECL_CONTEXT properly.
5973 Handle this case gracefully by globalizing stuff. */
5974 parent
= comp_unit_die ();
5975 /* Create a DIE "stub". */
5976 switch (TREE_CODE (decl
))
5978 case TRANSLATION_UNIT_DECL
:
5980 die
= comp_unit_die ();
5981 /* We re-target all CU decls to the LTRANS CU DIE, so no need
5982 to create a DIE for the original CUs. */
5985 case NAMESPACE_DECL
:
5986 if (is_fortran (decl
))
5987 die
= new_die (DW_TAG_module
, parent
, decl
);
5989 die
= new_die (DW_TAG_namespace
, parent
, decl
);
5992 die
= new_die (DW_TAG_subprogram
, parent
, decl
);
5995 die
= new_die (DW_TAG_variable
, parent
, decl
);
5998 die
= new_die (DW_TAG_variable
, parent
, decl
);
6001 die
= new_die (DW_TAG_formal_parameter
, parent
, decl
);
6004 die
= new_die (DW_TAG_constant
, parent
, decl
);
6007 die
= new_die (DW_TAG_label
, parent
, decl
);
6010 die
= new_die (DW_TAG_lexical_block
, parent
, decl
);
6015 if (TREE_CODE (decl
) == BLOCK
)
6016 equate_block_to_die (decl
, die
);
6018 equate_decl_number_to_die (decl
, die
);
6020 add_desc_attribute (die
, decl
);
6022 /* Add a reference to the DIE providing early debug at $sym + off. */
6023 add_AT_external_die_ref (die
, DW_AT_abstract_origin
, sym
, off
);
6028 /* Returns a hash value for X (which really is a var_loc_list). */
6031 decl_loc_hasher::hash (var_loc_list
*x
)
6033 return (hashval_t
) x
->decl_id
;
6036 /* Return nonzero if decl_id of var_loc_list X is the same as
6040 decl_loc_hasher::equal (var_loc_list
*x
, const_tree y
)
6042 return (x
->decl_id
== DECL_UID (y
));
6045 /* Return the var_loc list associated with a given declaration. */
6047 static inline var_loc_list
*
6048 lookup_decl_loc (const_tree decl
)
6050 if (!decl_loc_table
)
6052 return decl_loc_table
->find_with_hash (decl
, DECL_UID (decl
));
6055 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
6058 dw_loc_list_hasher::hash (cached_dw_loc_list
*x
)
6060 return (hashval_t
) x
->decl_id
;
6063 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
6067 dw_loc_list_hasher::equal (cached_dw_loc_list
*x
, const_tree y
)
6069 return (x
->decl_id
== DECL_UID (y
));
6072 /* Equate a DIE to a particular declaration. */
6075 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
6077 unsigned int decl_id
= DECL_UID (decl
);
6079 *decl_die_table
->find_slot_with_hash (decl
, decl_id
, INSERT
) = decl_die
;
6080 decl_die
->decl_id
= decl_id
;
6083 /* Return how many bits covers PIECE EXPR_LIST. */
6085 static HOST_WIDE_INT
6086 decl_piece_bitsize (rtx piece
)
6088 int ret
= (int) GET_MODE (piece
);
6091 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
6092 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
6093 return INTVAL (XEXP (XEXP (piece
, 0), 0));
6096 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
6099 decl_piece_varloc_ptr (rtx piece
)
6101 if ((int) GET_MODE (piece
))
6102 return &XEXP (piece
, 0);
6104 return &XEXP (XEXP (piece
, 0), 1);
6107 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
6108 Next is the chain of following piece nodes. */
6110 static rtx_expr_list
*
6111 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
6113 if (bitsize
> 0 && bitsize
<= (int) MAX_MACHINE_MODE
)
6114 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
6116 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
6121 /* Return rtx that should be stored into loc field for
6122 LOC_NOTE and BITPOS/BITSIZE. */
6125 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
6126 HOST_WIDE_INT bitsize
)
6130 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
6132 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
6137 /* This function either modifies location piece list *DEST in
6138 place (if SRC and INNER is NULL), or copies location piece list
6139 *SRC to *DEST while modifying it. Location BITPOS is modified
6140 to contain LOC_NOTE, any pieces overlapping it are removed resp.
6141 not copied and if needed some padding around it is added.
6142 When modifying in place, DEST should point to EXPR_LIST where
6143 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
6144 to the start of the whole list and INNER points to the EXPR_LIST
6145 where earlier pieces cover PIECE_BITPOS bits. */
6148 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
6149 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
6150 HOST_WIDE_INT bitsize
, rtx loc_note
)
6153 bool copy
= inner
!= NULL
;
6157 /* First copy all nodes preceding the current bitpos. */
6158 while (src
!= inner
)
6160 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
6161 decl_piece_bitsize (*src
), NULL_RTX
);
6162 dest
= &XEXP (*dest
, 1);
6163 src
= &XEXP (*src
, 1);
6166 /* Add padding if needed. */
6167 if (bitpos
!= piece_bitpos
)
6169 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
6170 copy
? NULL_RTX
: *dest
);
6171 dest
= &XEXP (*dest
, 1);
6173 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
6176 /* A piece with correct bitpos and bitsize already exist,
6177 just update the location for it and return. */
6178 *decl_piece_varloc_ptr (*dest
) = loc_note
;
6181 /* Add the piece that changed. */
6182 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
6183 dest
= &XEXP (*dest
, 1);
6184 /* Skip over pieces that overlap it. */
6185 diff
= bitpos
- piece_bitpos
+ bitsize
;
6188 while (diff
> 0 && *src
)
6191 diff
-= decl_piece_bitsize (piece
);
6193 src
= &XEXP (piece
, 1);
6196 *src
= XEXP (piece
, 1);
6197 free_EXPR_LIST_node (piece
);
6200 /* Add padding if needed. */
6201 if (diff
< 0 && *src
)
6205 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
6206 dest
= &XEXP (*dest
, 1);
6210 /* Finally copy all nodes following it. */
6213 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
6214 decl_piece_bitsize (*src
), NULL_RTX
);
6215 dest
= &XEXP (*dest
, 1);
6216 src
= &XEXP (*src
, 1);
6220 /* Add a variable location node to the linked list for DECL. */
6222 static struct var_loc_node
*
6223 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
, var_loc_view view
)
6225 unsigned int decl_id
;
6227 struct var_loc_node
*loc
= NULL
;
6228 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
6230 if (VAR_P (decl
) && DECL_HAS_DEBUG_EXPR_P (decl
))
6232 tree realdecl
= DECL_DEBUG_EXPR (decl
);
6233 if (handled_component_p (realdecl
)
6234 || (TREE_CODE (realdecl
) == MEM_REF
6235 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
6238 tree innerdecl
= get_ref_base_and_extent_hwi (realdecl
, &bitpos
,
6239 &bitsize
, &reverse
);
6241 || !DECL_P (innerdecl
)
6242 || DECL_IGNORED_P (innerdecl
)
6243 || TREE_STATIC (innerdecl
)
6245 || bitpos
+ bitsize
> 256)
6251 decl_id
= DECL_UID (decl
);
6253 = decl_loc_table
->find_slot_with_hash (decl
, decl_id
, INSERT
);
6256 temp
= ggc_cleared_alloc
<var_loc_list
> ();
6257 temp
->decl_id
= decl_id
;
6263 /* For PARM_DECLs try to keep around the original incoming value,
6264 even if that means we'll emit a zero-range .debug_loc entry. */
6266 && temp
->first
== temp
->last
6267 && TREE_CODE (decl
) == PARM_DECL
6268 && NOTE_P (temp
->first
->loc
)
6269 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
6270 && DECL_INCOMING_RTL (decl
)
6271 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
6272 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
6273 == GET_CODE (DECL_INCOMING_RTL (decl
))
6274 && prev_real_insn (as_a
<rtx_insn
*> (temp
->first
->loc
)) == NULL_RTX
6276 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
6277 NOTE_VAR_LOCATION_LOC (loc_note
))
6278 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
6279 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
6281 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6282 temp
->first
->next
= loc
;
6284 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6286 else if (temp
->last
)
6288 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
6289 rtx
*piece_loc
= NULL
, last_loc_note
;
6290 HOST_WIDE_INT piece_bitpos
= 0;
6294 gcc_assert (last
->next
== NULL
);
6296 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
6298 piece_loc
= &last
->loc
;
6301 HOST_WIDE_INT cur_bitsize
= decl_piece_bitsize (*piece_loc
);
6302 if (piece_bitpos
+ cur_bitsize
> bitpos
)
6304 piece_bitpos
+= cur_bitsize
;
6305 piece_loc
= &XEXP (*piece_loc
, 1);
6309 /* TEMP->LAST here is either pointer to the last but one or
6310 last element in the chained list, LAST is pointer to the
6312 if (label
&& strcmp (last
->label
, label
) == 0 && last
->view
== view
)
6314 /* For SRA optimized variables if there weren't any real
6315 insns since last note, just modify the last node. */
6316 if (piece_loc
!= NULL
)
6318 adjust_piece_list (piece_loc
, NULL
, NULL
,
6319 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6322 /* If the last note doesn't cover any instructions, remove it. */
6323 if (temp
->last
!= last
)
6325 temp
->last
->next
= NULL
;
6328 gcc_assert (strcmp (last
->label
, label
) != 0 || last
->view
!= view
);
6332 gcc_assert (temp
->first
== temp
->last
6333 || (temp
->first
->next
== temp
->last
6334 && TREE_CODE (decl
) == PARM_DECL
));
6335 memset (temp
->last
, '\0', sizeof (*temp
->last
));
6336 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6340 if (bitsize
== -1 && NOTE_P (last
->loc
))
6341 last_loc_note
= last
->loc
;
6342 else if (piece_loc
!= NULL
6343 && *piece_loc
!= NULL_RTX
6344 && piece_bitpos
== bitpos
6345 && decl_piece_bitsize (*piece_loc
) == bitsize
)
6346 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
6348 last_loc_note
= NULL_RTX
;
6349 /* If the current location is the same as the end of the list,
6350 and either both or neither of the locations is uninitialized,
6351 we have nothing to do. */
6352 if (last_loc_note
== NULL_RTX
6353 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
6354 NOTE_VAR_LOCATION_LOC (loc_note
)))
6355 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6356 != NOTE_VAR_LOCATION_STATUS (loc_note
))
6357 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6358 == VAR_INIT_STATUS_UNINITIALIZED
)
6359 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
6360 == VAR_INIT_STATUS_UNINITIALIZED
))))
6362 /* Add LOC to the end of list and update LAST. If the last
6363 element of the list has been removed above, reuse its
6364 memory for the new node, otherwise allocate a new one. */
6368 memset (loc
, '\0', sizeof (*loc
));
6371 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6372 if (bitsize
== -1 || piece_loc
== NULL
)
6373 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6375 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
6376 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6378 /* Ensure TEMP->LAST will point either to the new last but one
6379 element of the chain, or to the last element in it. */
6380 if (last
!= temp
->last
)
6388 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6391 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6396 /* Keep track of the number of spaces used to indent the
6397 output of the debugging routines that print the structure of
6398 the DIE internal representation. */
6399 static int print_indent
;
6401 /* Indent the line the number of spaces given by print_indent. */
6404 print_spaces (FILE *outfile
)
6406 fprintf (outfile
, "%*s", print_indent
, "");
6409 /* Print a type signature in hex. */
6412 print_signature (FILE *outfile
, char *sig
)
6416 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
6417 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
6421 print_discr_value (FILE *outfile
, dw_discr_value
*discr_value
)
6423 if (discr_value
->pos
)
6424 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, discr_value
->v
.sval
);
6426 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, discr_value
->v
.uval
);
6429 static void print_loc_descr (dw_loc_descr_ref
, FILE *);
6431 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
6432 RECURSE, output location descriptor operations. */
6435 print_dw_val (dw_val_node
*val
, bool recurse
, FILE *outfile
)
6437 switch (val
->val_class
)
6439 case dw_val_class_addr
:
6440 fprintf (outfile
, "address");
6442 case dw_val_class_offset
:
6443 fprintf (outfile
, "offset");
6445 case dw_val_class_loc
:
6446 fprintf (outfile
, "location descriptor");
6447 if (val
->v
.val_loc
== NULL
)
6448 fprintf (outfile
, " -> <null>\n");
6451 fprintf (outfile
, ":\n");
6453 print_loc_descr (val
->v
.val_loc
, outfile
);
6458 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6459 fprintf (outfile
, " #\n");
6461 fprintf (outfile
, " (%p)\n", (void *) val
->v
.val_loc
);
6464 case dw_val_class_loc_list
:
6465 fprintf (outfile
, "location list -> label:%s",
6466 val
->v
.val_loc_list
->ll_symbol
);
6468 case dw_val_class_view_list
:
6469 val
= view_list_to_loc_list_val_node (val
);
6470 fprintf (outfile
, "location list with views -> labels:%s and %s",
6471 val
->v
.val_loc_list
->ll_symbol
,
6472 val
->v
.val_loc_list
->vl_symbol
);
6474 case dw_val_class_range_list
:
6475 fprintf (outfile
, "range list");
6477 case dw_val_class_const
:
6478 case dw_val_class_const_implicit
:
6479 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, val
->v
.val_int
);
6481 case dw_val_class_unsigned_const
:
6482 case dw_val_class_unsigned_const_implicit
:
6483 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, val
->v
.val_unsigned
);
6485 case dw_val_class_const_double
:
6486 fprintf (outfile
, "constant (" HOST_WIDE_INT_PRINT_DEC
","\
6487 HOST_WIDE_INT_PRINT_UNSIGNED
")",
6488 val
->v
.val_double
.high
,
6489 val
->v
.val_double
.low
);
6491 case dw_val_class_wide_int
:
6493 int i
= val
->v
.val_wide
->get_len ();
6494 fprintf (outfile
, "constant (");
6496 if (val
->v
.val_wide
->elt (i
- 1) == 0)
6497 fprintf (outfile
, "0x");
6498 fprintf (outfile
, HOST_WIDE_INT_PRINT_HEX
,
6499 val
->v
.val_wide
->elt (--i
));
6501 fprintf (outfile
, HOST_WIDE_INT_PRINT_PADDED_HEX
,
6502 val
->v
.val_wide
->elt (i
));
6503 fprintf (outfile
, ")");
6506 case dw_val_class_vec
:
6507 fprintf (outfile
, "floating-point or vector constant");
6509 case dw_val_class_flag
:
6510 fprintf (outfile
, "%u", val
->v
.val_flag
);
6512 case dw_val_class_die_ref
:
6513 if (val
->v
.val_die_ref
.die
!= NULL
)
6515 dw_die_ref die
= val
->v
.val_die_ref
.die
;
6517 if (die
->comdat_type_p
)
6519 fprintf (outfile
, "die -> signature: ");
6520 print_signature (outfile
,
6521 die
->die_id
.die_type_node
->signature
);
6523 else if (die
->die_id
.die_symbol
)
6525 fprintf (outfile
, "die -> label: %s", die
->die_id
.die_symbol
);
6526 if (die
->with_offset
)
6527 fprintf (outfile
, " + %ld", die
->die_offset
);
6530 fprintf (outfile
, "die -> %ld", die
->die_offset
);
6531 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6532 fprintf (outfile
, " #");
6534 fprintf (outfile
, " (%p)", (void *) die
);
6537 fprintf (outfile
, "die -> <null>");
6539 case dw_val_class_vms_delta
:
6540 fprintf (outfile
, "delta: @slotcount(%s-%s)",
6541 val
->v
.val_vms_delta
.lbl2
, val
->v
.val_vms_delta
.lbl1
);
6543 case dw_val_class_symview
:
6544 fprintf (outfile
, "view: %s", val
->v
.val_symbolic_view
);
6546 case dw_val_class_lbl_id
:
6547 case dw_val_class_lineptr
:
6548 case dw_val_class_macptr
:
6549 case dw_val_class_loclistsptr
:
6550 case dw_val_class_high_pc
:
6551 fprintf (outfile
, "label: %s", val
->v
.val_lbl_id
);
6553 case dw_val_class_str
:
6554 if (val
->v
.val_str
->str
!= NULL
)
6555 fprintf (outfile
, "\"%s\"", val
->v
.val_str
->str
);
6557 fprintf (outfile
, "<null>");
6559 case dw_val_class_file
:
6560 case dw_val_class_file_implicit
:
6561 fprintf (outfile
, "\"%s\" (%d)", val
->v
.val_file
->filename
,
6562 val
->v
.val_file
->emitted_number
);
6564 case dw_val_class_data8
:
6568 for (i
= 0; i
< 8; i
++)
6569 fprintf (outfile
, "%02x", val
->v
.val_data8
[i
]);
6572 case dw_val_class_discr_value
:
6573 print_discr_value (outfile
, &val
->v
.val_discr_value
);
6575 case dw_val_class_discr_list
:
6576 for (dw_discr_list_ref node
= val
->v
.val_discr_list
;
6578 node
= node
->dw_discr_next
)
6580 if (node
->dw_discr_range
)
6582 fprintf (outfile
, " .. ");
6583 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6584 print_discr_value (outfile
, &node
->dw_discr_upper_bound
);
6587 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6589 if (node
->dw_discr_next
!= NULL
)
6590 fprintf (outfile
, " | ");
6597 /* Likewise, for a DIE attribute. */
6600 print_attribute (dw_attr_node
*a
, bool recurse
, FILE *outfile
)
6602 print_dw_val (&a
->dw_attr_val
, recurse
, outfile
);
6606 /* Print the list of operands in the LOC location description to OUTFILE. This
6607 routine is a debugging aid only. */
6610 print_loc_descr (dw_loc_descr_ref loc
, FILE *outfile
)
6612 dw_loc_descr_ref l
= loc
;
6616 print_spaces (outfile
);
6617 fprintf (outfile
, "<null>\n");
6621 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
6623 print_spaces (outfile
);
6624 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6625 fprintf (outfile
, "#");
6627 fprintf (outfile
, "(%p)", (void *) l
);
6628 fprintf (outfile
, " %s",
6629 dwarf_stack_op_name (l
->dw_loc_opc
));
6630 if (l
->dw_loc_oprnd1
.val_class
!= dw_val_class_none
)
6632 fprintf (outfile
, " ");
6633 print_dw_val (&l
->dw_loc_oprnd1
, false, outfile
);
6635 if (l
->dw_loc_oprnd2
.val_class
!= dw_val_class_none
)
6637 fprintf (outfile
, ", ");
6638 print_dw_val (&l
->dw_loc_oprnd2
, false, outfile
);
6640 fprintf (outfile
, "\n");
6644 /* Print the information associated with a given DIE, and its children.
6645 This routine is a debugging aid only. */
6648 print_die (dw_die_ref die
, FILE *outfile
)
6654 print_spaces (outfile
);
6655 fprintf (outfile
, "DIE %4ld: %s ",
6656 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
6657 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6658 fprintf (outfile
, "#\n");
6660 fprintf (outfile
, "(%p)\n", (void*) die
);
6661 print_spaces (outfile
);
6662 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
6663 fprintf (outfile
, " offset: %ld", die
->die_offset
);
6664 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
6666 if (die
->comdat_type_p
)
6668 print_spaces (outfile
);
6669 fprintf (outfile
, " signature: ");
6670 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
6671 fprintf (outfile
, "\n");
6674 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6676 print_spaces (outfile
);
6677 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
6679 print_attribute (a
, true, outfile
);
6680 fprintf (outfile
, "\n");
6683 if (die
->die_child
!= NULL
)
6686 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
6689 if (print_indent
== 0)
6690 fprintf (outfile
, "\n");
6693 /* Print the list of operations in the LOC location description. */
6696 debug_dwarf_loc_descr (dw_loc_descr_ref loc
)
6698 print_loc_descr (loc
, stderr
);
6701 /* Print the information collected for a given DIE. */
6704 debug_dwarf_die (dw_die_ref die
)
6706 print_die (die
, stderr
);
6710 debug (die_struct
&ref
)
6712 print_die (&ref
, stderr
);
6716 debug (die_struct
*ptr
)
6721 fprintf (stderr
, "<nil>\n");
6725 /* Print all DWARF information collected for the compilation unit.
6726 This routine is a debugging aid only. */
6732 print_die (comp_unit_die (), stderr
);
6735 /* Verify the DIE tree structure. */
6738 verify_die (dw_die_ref die
)
6740 gcc_assert (!die
->die_mark
);
6741 if (die
->die_parent
== NULL
6742 && die
->die_sib
== NULL
)
6744 /* Verify the die_sib list is cyclic. */
6751 while (x
&& !x
->die_mark
);
6752 gcc_assert (x
== die
);
6756 /* Verify all dies have the same parent. */
6757 gcc_assert (x
->die_parent
== die
->die_parent
);
6760 /* Verify the child has the proper parent and recurse. */
6761 gcc_assert (x
->die_child
->die_parent
== x
);
6762 verify_die (x
->die_child
);
6767 while (x
&& x
->die_mark
);
6770 /* Sanity checks on DIEs. */
6773 check_die (dw_die_ref die
)
6777 bool inline_found
= false;
6778 int n_location
= 0, n_low_pc
= 0, n_high_pc
= 0, n_artificial
= 0;
6779 int n_decl_line
= 0, n_decl_column
= 0, n_decl_file
= 0;
6780 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6785 if (a
->dw_attr_val
.v
.val_unsigned
)
6786 inline_found
= true;
6788 case DW_AT_location
:
6797 case DW_AT_artificial
:
6800 case DW_AT_decl_column
:
6803 case DW_AT_decl_line
:
6806 case DW_AT_decl_file
:
6813 if (n_location
> 1 || n_low_pc
> 1 || n_high_pc
> 1 || n_artificial
> 1
6814 || n_decl_column
> 1 || n_decl_line
> 1 || n_decl_file
> 1)
6816 fprintf (stderr
, "Duplicate attributes in DIE:\n");
6817 debug_dwarf_die (die
);
6822 /* A debugging information entry that is a member of an abstract
6823 instance tree [that has DW_AT_inline] should not contain any
6824 attributes which describe aspects of the subroutine which vary
6825 between distinct inlined expansions or distinct out-of-line
6827 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6828 gcc_assert (a
->dw_attr
!= DW_AT_low_pc
6829 && a
->dw_attr
!= DW_AT_high_pc
6830 && a
->dw_attr
!= DW_AT_location
6831 && a
->dw_attr
!= DW_AT_frame_base
6832 && a
->dw_attr
!= DW_AT_call_all_calls
6833 && a
->dw_attr
!= DW_AT_GNU_all_call_sites
);
6837 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6838 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6839 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
6841 /* Calculate the checksum of a location expression. */
6844 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
6847 inchash::hash hstate
;
6850 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
6852 hash_loc_operands (loc
, hstate
);
6853 hash
= hstate
.end();
6857 /* Calculate the checksum of an attribute. */
6860 attr_checksum (dw_attr_node
*at
, struct md5_ctx
*ctx
, int *mark
)
6862 dw_loc_descr_ref loc
;
6865 CHECKSUM (at
->dw_attr
);
6867 /* We don't care that this was compiled with a different compiler
6868 snapshot; if the output is the same, that's what matters. */
6869 if (at
->dw_attr
== DW_AT_producer
)
6872 switch (AT_class (at
))
6874 case dw_val_class_const
:
6875 case dw_val_class_const_implicit
:
6876 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
6878 case dw_val_class_unsigned_const
:
6879 case dw_val_class_unsigned_const_implicit
:
6880 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
6882 case dw_val_class_const_double
:
6883 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
6885 case dw_val_class_wide_int
:
6886 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
6887 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
6888 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
6890 case dw_val_class_vec
:
6891 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
6892 (at
->dw_attr_val
.v
.val_vec
.length
6893 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
6895 case dw_val_class_flag
:
6896 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
6898 case dw_val_class_str
:
6899 CHECKSUM_STRING (AT_string (at
));
6902 case dw_val_class_addr
:
6904 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
6905 CHECKSUM_STRING (XSTR (r
, 0));
6908 case dw_val_class_offset
:
6909 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
6912 case dw_val_class_loc
:
6913 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
6914 loc_checksum (loc
, ctx
);
6917 case dw_val_class_die_ref
:
6918 die_checksum (AT_ref (at
), ctx
, mark
);
6921 case dw_val_class_fde_ref
:
6922 case dw_val_class_vms_delta
:
6923 case dw_val_class_symview
:
6924 case dw_val_class_lbl_id
:
6925 case dw_val_class_lineptr
:
6926 case dw_val_class_macptr
:
6927 case dw_val_class_loclistsptr
:
6928 case dw_val_class_high_pc
:
6931 case dw_val_class_file
:
6932 case dw_val_class_file_implicit
:
6933 CHECKSUM_STRING (AT_file (at
)->filename
);
6936 case dw_val_class_data8
:
6937 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
6945 /* Calculate the checksum of a DIE. */
6948 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6954 /* To avoid infinite recursion. */
6957 CHECKSUM (die
->die_mark
);
6960 die
->die_mark
= ++(*mark
);
6962 CHECKSUM (die
->die_tag
);
6964 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6965 attr_checksum (a
, ctx
, mark
);
6967 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
6971 #undef CHECKSUM_BLOCK
6972 #undef CHECKSUM_STRING
6974 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
6975 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6976 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6977 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
6978 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
6979 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
6980 #define CHECKSUM_ATTR(FOO) \
6981 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
6983 /* Calculate the checksum of a number in signed LEB128 format. */
6986 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
6993 byte
= (value
& 0x7f);
6995 more
= !((value
== 0 && (byte
& 0x40) == 0)
6996 || (value
== -1 && (byte
& 0x40) != 0));
7005 /* Calculate the checksum of a number in unsigned LEB128 format. */
7008 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
7012 unsigned char byte
= (value
& 0x7f);
7015 /* More bytes to follow. */
7023 /* Checksum the context of the DIE. This adds the names of any
7024 surrounding namespaces or structures to the checksum. */
7027 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
7031 int tag
= die
->die_tag
;
7033 if (tag
!= DW_TAG_namespace
7034 && tag
!= DW_TAG_structure_type
7035 && tag
!= DW_TAG_class_type
)
7038 name
= get_AT_string (die
, DW_AT_name
);
7040 spec
= get_AT_ref (die
, DW_AT_specification
);
7044 if (die
->die_parent
!= NULL
)
7045 checksum_die_context (die
->die_parent
, ctx
);
7047 CHECKSUM_ULEB128 ('C');
7048 CHECKSUM_ULEB128 (tag
);
7050 CHECKSUM_STRING (name
);
7053 /* Calculate the checksum of a location expression. */
7056 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
7058 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
7059 were emitted as a DW_FORM_sdata instead of a location expression. */
7060 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
7062 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7063 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
7067 /* Otherwise, just checksum the raw location expression. */
7070 inchash::hash hstate
;
7073 CHECKSUM_ULEB128 (loc
->dtprel
);
7074 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
7075 hash_loc_operands (loc
, hstate
);
7076 hash
= hstate
.end ();
7078 loc
= loc
->dw_loc_next
;
7082 /* Calculate the checksum of an attribute. */
7085 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_node
*at
,
7086 struct md5_ctx
*ctx
, int *mark
)
7088 dw_loc_descr_ref loc
;
7091 if (AT_class (at
) == dw_val_class_die_ref
)
7093 dw_die_ref target_die
= AT_ref (at
);
7095 /* For pointer and reference types, we checksum only the (qualified)
7096 name of the target type (if there is a name). For friend entries,
7097 we checksum only the (qualified) name of the target type or function.
7098 This allows the checksum to remain the same whether the target type
7099 is complete or not. */
7100 if ((at
->dw_attr
== DW_AT_type
7101 && (tag
== DW_TAG_pointer_type
7102 || tag
== DW_TAG_reference_type
7103 || tag
== DW_TAG_rvalue_reference_type
7104 || tag
== DW_TAG_ptr_to_member_type
))
7105 || (at
->dw_attr
== DW_AT_friend
7106 && tag
== DW_TAG_friend
))
7108 dw_attr_node
*name_attr
= get_AT (target_die
, DW_AT_name
);
7110 if (name_attr
!= NULL
)
7112 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
7116 CHECKSUM_ULEB128 ('N');
7117 CHECKSUM_ULEB128 (at
->dw_attr
);
7118 if (decl
->die_parent
!= NULL
)
7119 checksum_die_context (decl
->die_parent
, ctx
);
7120 CHECKSUM_ULEB128 ('E');
7121 CHECKSUM_STRING (AT_string (name_attr
));
7126 /* For all other references to another DIE, we check to see if the
7127 target DIE has already been visited. If it has, we emit a
7128 backward reference; if not, we descend recursively. */
7129 if (target_die
->die_mark
> 0)
7131 CHECKSUM_ULEB128 ('R');
7132 CHECKSUM_ULEB128 (at
->dw_attr
);
7133 CHECKSUM_ULEB128 (target_die
->die_mark
);
7137 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
7141 target_die
->die_mark
= ++(*mark
);
7142 CHECKSUM_ULEB128 ('T');
7143 CHECKSUM_ULEB128 (at
->dw_attr
);
7144 if (decl
->die_parent
!= NULL
)
7145 checksum_die_context (decl
->die_parent
, ctx
);
7146 die_checksum_ordered (target_die
, ctx
, mark
);
7151 CHECKSUM_ULEB128 ('A');
7152 CHECKSUM_ULEB128 (at
->dw_attr
);
7154 switch (AT_class (at
))
7156 case dw_val_class_const
:
7157 case dw_val_class_const_implicit
:
7158 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7159 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
7162 case dw_val_class_unsigned_const
:
7163 case dw_val_class_unsigned_const_implicit
:
7164 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7165 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
7168 case dw_val_class_const_double
:
7169 CHECKSUM_ULEB128 (DW_FORM_block
);
7170 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
7171 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
7174 case dw_val_class_wide_int
:
7175 CHECKSUM_ULEB128 (DW_FORM_block
);
7176 CHECKSUM_ULEB128 (get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7177 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
7178 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
7179 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7180 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
7183 case dw_val_class_vec
:
7184 CHECKSUM_ULEB128 (DW_FORM_block
);
7185 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_vec
.length
7186 * at
->dw_attr_val
.v
.val_vec
.elt_size
);
7187 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
7188 (at
->dw_attr_val
.v
.val_vec
.length
7189 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
7192 case dw_val_class_flag
:
7193 CHECKSUM_ULEB128 (DW_FORM_flag
);
7194 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
7197 case dw_val_class_str
:
7198 CHECKSUM_ULEB128 (DW_FORM_string
);
7199 CHECKSUM_STRING (AT_string (at
));
7202 case dw_val_class_addr
:
7204 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
7205 CHECKSUM_ULEB128 (DW_FORM_string
);
7206 CHECKSUM_STRING (XSTR (r
, 0));
7209 case dw_val_class_offset
:
7210 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7211 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
7214 case dw_val_class_loc
:
7215 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
7216 loc_checksum_ordered (loc
, ctx
);
7219 case dw_val_class_fde_ref
:
7220 case dw_val_class_symview
:
7221 case dw_val_class_lbl_id
:
7222 case dw_val_class_lineptr
:
7223 case dw_val_class_macptr
:
7224 case dw_val_class_loclistsptr
:
7225 case dw_val_class_high_pc
:
7228 case dw_val_class_file
:
7229 case dw_val_class_file_implicit
:
7230 CHECKSUM_ULEB128 (DW_FORM_string
);
7231 CHECKSUM_STRING (AT_file (at
)->filename
);
7234 case dw_val_class_data8
:
7235 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
7243 struct checksum_attributes
7245 dw_attr_node
*at_name
;
7246 dw_attr_node
*at_type
;
7247 dw_attr_node
*at_friend
;
7248 dw_attr_node
*at_accessibility
;
7249 dw_attr_node
*at_address_class
;
7250 dw_attr_node
*at_alignment
;
7251 dw_attr_node
*at_allocated
;
7252 dw_attr_node
*at_artificial
;
7253 dw_attr_node
*at_associated
;
7254 dw_attr_node
*at_binary_scale
;
7255 dw_attr_node
*at_bit_offset
;
7256 dw_attr_node
*at_bit_size
;
7257 dw_attr_node
*at_bit_stride
;
7258 dw_attr_node
*at_byte_size
;
7259 dw_attr_node
*at_byte_stride
;
7260 dw_attr_node
*at_const_value
;
7261 dw_attr_node
*at_containing_type
;
7262 dw_attr_node
*at_count
;
7263 dw_attr_node
*at_data_location
;
7264 dw_attr_node
*at_data_member_location
;
7265 dw_attr_node
*at_decimal_scale
;
7266 dw_attr_node
*at_decimal_sign
;
7267 dw_attr_node
*at_default_value
;
7268 dw_attr_node
*at_digit_count
;
7269 dw_attr_node
*at_discr
;
7270 dw_attr_node
*at_discr_list
;
7271 dw_attr_node
*at_discr_value
;
7272 dw_attr_node
*at_encoding
;
7273 dw_attr_node
*at_endianity
;
7274 dw_attr_node
*at_explicit
;
7275 dw_attr_node
*at_is_optional
;
7276 dw_attr_node
*at_location
;
7277 dw_attr_node
*at_lower_bound
;
7278 dw_attr_node
*at_mutable
;
7279 dw_attr_node
*at_ordering
;
7280 dw_attr_node
*at_picture_string
;
7281 dw_attr_node
*at_prototyped
;
7282 dw_attr_node
*at_small
;
7283 dw_attr_node
*at_segment
;
7284 dw_attr_node
*at_string_length
;
7285 dw_attr_node
*at_string_length_bit_size
;
7286 dw_attr_node
*at_string_length_byte_size
;
7287 dw_attr_node
*at_threads_scaled
;
7288 dw_attr_node
*at_upper_bound
;
7289 dw_attr_node
*at_use_location
;
7290 dw_attr_node
*at_use_UTF8
;
7291 dw_attr_node
*at_variable_parameter
;
7292 dw_attr_node
*at_virtuality
;
7293 dw_attr_node
*at_visibility
;
7294 dw_attr_node
*at_vtable_elem_location
;
7297 /* Collect the attributes that we will want to use for the checksum. */
7300 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
7305 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7316 attrs
->at_friend
= a
;
7318 case DW_AT_accessibility
:
7319 attrs
->at_accessibility
= a
;
7321 case DW_AT_address_class
:
7322 attrs
->at_address_class
= a
;
7324 case DW_AT_alignment
:
7325 attrs
->at_alignment
= a
;
7327 case DW_AT_allocated
:
7328 attrs
->at_allocated
= a
;
7330 case DW_AT_artificial
:
7331 attrs
->at_artificial
= a
;
7333 case DW_AT_associated
:
7334 attrs
->at_associated
= a
;
7336 case DW_AT_binary_scale
:
7337 attrs
->at_binary_scale
= a
;
7339 case DW_AT_bit_offset
:
7340 attrs
->at_bit_offset
= a
;
7342 case DW_AT_bit_size
:
7343 attrs
->at_bit_size
= a
;
7345 case DW_AT_bit_stride
:
7346 attrs
->at_bit_stride
= a
;
7348 case DW_AT_byte_size
:
7349 attrs
->at_byte_size
= a
;
7351 case DW_AT_byte_stride
:
7352 attrs
->at_byte_stride
= a
;
7354 case DW_AT_const_value
:
7355 attrs
->at_const_value
= a
;
7357 case DW_AT_containing_type
:
7358 attrs
->at_containing_type
= a
;
7361 attrs
->at_count
= a
;
7363 case DW_AT_data_location
:
7364 attrs
->at_data_location
= a
;
7366 case DW_AT_data_member_location
:
7367 attrs
->at_data_member_location
= a
;
7369 case DW_AT_decimal_scale
:
7370 attrs
->at_decimal_scale
= a
;
7372 case DW_AT_decimal_sign
:
7373 attrs
->at_decimal_sign
= a
;
7375 case DW_AT_default_value
:
7376 attrs
->at_default_value
= a
;
7378 case DW_AT_digit_count
:
7379 attrs
->at_digit_count
= a
;
7382 attrs
->at_discr
= a
;
7384 case DW_AT_discr_list
:
7385 attrs
->at_discr_list
= a
;
7387 case DW_AT_discr_value
:
7388 attrs
->at_discr_value
= a
;
7390 case DW_AT_encoding
:
7391 attrs
->at_encoding
= a
;
7393 case DW_AT_endianity
:
7394 attrs
->at_endianity
= a
;
7396 case DW_AT_explicit
:
7397 attrs
->at_explicit
= a
;
7399 case DW_AT_is_optional
:
7400 attrs
->at_is_optional
= a
;
7402 case DW_AT_location
:
7403 attrs
->at_location
= a
;
7405 case DW_AT_lower_bound
:
7406 attrs
->at_lower_bound
= a
;
7409 attrs
->at_mutable
= a
;
7411 case DW_AT_ordering
:
7412 attrs
->at_ordering
= a
;
7414 case DW_AT_picture_string
:
7415 attrs
->at_picture_string
= a
;
7417 case DW_AT_prototyped
:
7418 attrs
->at_prototyped
= a
;
7421 attrs
->at_small
= a
;
7424 attrs
->at_segment
= a
;
7426 case DW_AT_string_length
:
7427 attrs
->at_string_length
= a
;
7429 case DW_AT_string_length_bit_size
:
7430 attrs
->at_string_length_bit_size
= a
;
7432 case DW_AT_string_length_byte_size
:
7433 attrs
->at_string_length_byte_size
= a
;
7435 case DW_AT_threads_scaled
:
7436 attrs
->at_threads_scaled
= a
;
7438 case DW_AT_upper_bound
:
7439 attrs
->at_upper_bound
= a
;
7441 case DW_AT_use_location
:
7442 attrs
->at_use_location
= a
;
7444 case DW_AT_use_UTF8
:
7445 attrs
->at_use_UTF8
= a
;
7447 case DW_AT_variable_parameter
:
7448 attrs
->at_variable_parameter
= a
;
7450 case DW_AT_virtuality
:
7451 attrs
->at_virtuality
= a
;
7453 case DW_AT_visibility
:
7454 attrs
->at_visibility
= a
;
7456 case DW_AT_vtable_elem_location
:
7457 attrs
->at_vtable_elem_location
= a
;
7465 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
7468 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
7472 struct checksum_attributes attrs
;
7474 CHECKSUM_ULEB128 ('D');
7475 CHECKSUM_ULEB128 (die
->die_tag
);
7477 memset (&attrs
, 0, sizeof (attrs
));
7479 decl
= get_AT_ref (die
, DW_AT_specification
);
7481 collect_checksum_attributes (&attrs
, decl
);
7482 collect_checksum_attributes (&attrs
, die
);
7484 CHECKSUM_ATTR (attrs
.at_name
);
7485 CHECKSUM_ATTR (attrs
.at_accessibility
);
7486 CHECKSUM_ATTR (attrs
.at_address_class
);
7487 CHECKSUM_ATTR (attrs
.at_allocated
);
7488 CHECKSUM_ATTR (attrs
.at_artificial
);
7489 CHECKSUM_ATTR (attrs
.at_associated
);
7490 CHECKSUM_ATTR (attrs
.at_binary_scale
);
7491 CHECKSUM_ATTR (attrs
.at_bit_offset
);
7492 CHECKSUM_ATTR (attrs
.at_bit_size
);
7493 CHECKSUM_ATTR (attrs
.at_bit_stride
);
7494 CHECKSUM_ATTR (attrs
.at_byte_size
);
7495 CHECKSUM_ATTR (attrs
.at_byte_stride
);
7496 CHECKSUM_ATTR (attrs
.at_const_value
);
7497 CHECKSUM_ATTR (attrs
.at_containing_type
);
7498 CHECKSUM_ATTR (attrs
.at_count
);
7499 CHECKSUM_ATTR (attrs
.at_data_location
);
7500 CHECKSUM_ATTR (attrs
.at_data_member_location
);
7501 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
7502 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
7503 CHECKSUM_ATTR (attrs
.at_default_value
);
7504 CHECKSUM_ATTR (attrs
.at_digit_count
);
7505 CHECKSUM_ATTR (attrs
.at_discr
);
7506 CHECKSUM_ATTR (attrs
.at_discr_list
);
7507 CHECKSUM_ATTR (attrs
.at_discr_value
);
7508 CHECKSUM_ATTR (attrs
.at_encoding
);
7509 CHECKSUM_ATTR (attrs
.at_endianity
);
7510 CHECKSUM_ATTR (attrs
.at_explicit
);
7511 CHECKSUM_ATTR (attrs
.at_is_optional
);
7512 CHECKSUM_ATTR (attrs
.at_location
);
7513 CHECKSUM_ATTR (attrs
.at_lower_bound
);
7514 CHECKSUM_ATTR (attrs
.at_mutable
);
7515 CHECKSUM_ATTR (attrs
.at_ordering
);
7516 CHECKSUM_ATTR (attrs
.at_picture_string
);
7517 CHECKSUM_ATTR (attrs
.at_prototyped
);
7518 CHECKSUM_ATTR (attrs
.at_small
);
7519 CHECKSUM_ATTR (attrs
.at_segment
);
7520 CHECKSUM_ATTR (attrs
.at_string_length
);
7521 CHECKSUM_ATTR (attrs
.at_string_length_bit_size
);
7522 CHECKSUM_ATTR (attrs
.at_string_length_byte_size
);
7523 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
7524 CHECKSUM_ATTR (attrs
.at_upper_bound
);
7525 CHECKSUM_ATTR (attrs
.at_use_location
);
7526 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
7527 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
7528 CHECKSUM_ATTR (attrs
.at_virtuality
);
7529 CHECKSUM_ATTR (attrs
.at_visibility
);
7530 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
7531 CHECKSUM_ATTR (attrs
.at_type
);
7532 CHECKSUM_ATTR (attrs
.at_friend
);
7533 CHECKSUM_ATTR (attrs
.at_alignment
);
7535 /* Checksum the child DIEs. */
7538 dw_attr_node
*name_attr
;
7541 name_attr
= get_AT (c
, DW_AT_name
);
7542 if (is_template_instantiation (c
))
7544 /* Ignore instantiations of member type and function templates. */
7546 else if (name_attr
!= NULL
7547 && (is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
))
7549 /* Use a shallow checksum for named nested types and member
7551 CHECKSUM_ULEB128 ('S');
7552 CHECKSUM_ULEB128 (c
->die_tag
);
7553 CHECKSUM_STRING (AT_string (name_attr
));
7557 /* Use a deep checksum for other children. */
7558 /* Mark this DIE so it gets processed when unmarking. */
7559 if (c
->die_mark
== 0)
7561 die_checksum_ordered (c
, ctx
, mark
);
7563 } while (c
!= die
->die_child
);
7565 CHECKSUM_ULEB128 (0);
7568 /* Add a type name and tag to a hash. */
7570 die_odr_checksum (int tag
, const char *name
, md5_ctx
*ctx
)
7572 CHECKSUM_ULEB128 (tag
);
7573 CHECKSUM_STRING (name
);
7577 #undef CHECKSUM_STRING
7578 #undef CHECKSUM_ATTR
7579 #undef CHECKSUM_LEB128
7580 #undef CHECKSUM_ULEB128
7582 /* Generate the type signature for DIE. This is computed by generating an
7583 MD5 checksum over the DIE's tag, its relevant attributes, and its
7584 children. Attributes that are references to other DIEs are processed
7585 by recursion, using the MARK field to prevent infinite recursion.
7586 If the DIE is nested inside a namespace or another type, we also
7587 need to include that context in the signature. The lower 64 bits
7588 of the resulting MD5 checksum comprise the signature. */
7591 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
7595 unsigned char checksum
[16];
7600 name
= get_AT_string (die
, DW_AT_name
);
7601 decl
= get_AT_ref (die
, DW_AT_specification
);
7602 parent
= get_die_parent (die
);
7604 /* First, compute a signature for just the type name (and its surrounding
7605 context, if any. This is stored in the type unit DIE for link-time
7606 ODR (one-definition rule) checking. */
7608 if (is_cxx () && name
!= NULL
)
7610 md5_init_ctx (&ctx
);
7612 /* Checksum the names of surrounding namespaces and structures. */
7614 checksum_die_context (parent
, &ctx
);
7616 /* Checksum the current DIE. */
7617 die_odr_checksum (die
->die_tag
, name
, &ctx
);
7618 md5_finish_ctx (&ctx
, checksum
);
7620 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
7623 /* Next, compute the complete type signature. */
7625 md5_init_ctx (&ctx
);
7627 die
->die_mark
= mark
;
7629 /* Checksum the names of surrounding namespaces and structures. */
7631 checksum_die_context (parent
, &ctx
);
7633 /* Checksum the DIE and its children. */
7634 die_checksum_ordered (die
, &ctx
, &mark
);
7635 unmark_all_dies (die
);
7636 md5_finish_ctx (&ctx
, checksum
);
7638 /* Store the signature in the type node and link the type DIE and the
7639 type node together. */
7640 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
7641 DWARF_TYPE_SIGNATURE_SIZE
);
7642 die
->comdat_type_p
= true;
7643 die
->die_id
.die_type_node
= type_node
;
7644 type_node
->type_die
= die
;
7646 /* If the DIE is a specification, link its declaration to the type node
7650 decl
->comdat_type_p
= true;
7651 decl
->die_id
.die_type_node
= type_node
;
7655 /* Do the location expressions look same? */
7657 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
7659 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
7660 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
7661 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
7664 /* Do the values look the same? */
7666 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
7668 dw_loc_descr_ref loc1
, loc2
;
7671 if (v1
->val_class
!= v2
->val_class
)
7674 switch (v1
->val_class
)
7676 case dw_val_class_const
:
7677 case dw_val_class_const_implicit
:
7678 return v1
->v
.val_int
== v2
->v
.val_int
;
7679 case dw_val_class_unsigned_const
:
7680 case dw_val_class_unsigned_const_implicit
:
7681 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
7682 case dw_val_class_const_double
:
7683 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
7684 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
7685 case dw_val_class_wide_int
:
7686 return *v1
->v
.val_wide
== *v2
->v
.val_wide
;
7687 case dw_val_class_vec
:
7688 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
7689 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
7691 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
7692 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
7695 case dw_val_class_flag
:
7696 return v1
->v
.val_flag
== v2
->v
.val_flag
;
7697 case dw_val_class_str
:
7698 return !strcmp (v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
7700 case dw_val_class_addr
:
7701 r1
= v1
->v
.val_addr
;
7702 r2
= v2
->v
.val_addr
;
7703 if (GET_CODE (r1
) != GET_CODE (r2
))
7705 return !rtx_equal_p (r1
, r2
);
7707 case dw_val_class_offset
:
7708 return v1
->v
.val_offset
== v2
->v
.val_offset
;
7710 case dw_val_class_loc
:
7711 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
7713 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
7714 if (!same_loc_p (loc1
, loc2
, mark
))
7716 return !loc1
&& !loc2
;
7718 case dw_val_class_die_ref
:
7719 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
7721 case dw_val_class_symview
:
7722 return strcmp (v1
->v
.val_symbolic_view
, v2
->v
.val_symbolic_view
) == 0;
7724 case dw_val_class_fde_ref
:
7725 case dw_val_class_vms_delta
:
7726 case dw_val_class_lbl_id
:
7727 case dw_val_class_lineptr
:
7728 case dw_val_class_macptr
:
7729 case dw_val_class_loclistsptr
:
7730 case dw_val_class_high_pc
:
7733 case dw_val_class_file
:
7734 case dw_val_class_file_implicit
:
7735 return v1
->v
.val_file
== v2
->v
.val_file
;
7737 case dw_val_class_data8
:
7738 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
7745 /* Do the attributes look the same? */
7748 same_attr_p (dw_attr_node
*at1
, dw_attr_node
*at2
, int *mark
)
7750 if (at1
->dw_attr
!= at2
->dw_attr
)
7753 /* We don't care that this was compiled with a different compiler
7754 snapshot; if the output is the same, that's what matters. */
7755 if (at1
->dw_attr
== DW_AT_producer
)
7758 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
7761 /* Do the dies look the same? */
7764 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
7770 /* To avoid infinite recursion. */
7772 return die1
->die_mark
== die2
->die_mark
;
7773 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
7775 if (die1
->die_tag
!= die2
->die_tag
)
7778 if (vec_safe_length (die1
->die_attr
) != vec_safe_length (die2
->die_attr
))
7781 FOR_EACH_VEC_SAFE_ELT (die1
->die_attr
, ix
, a1
)
7782 if (!same_attr_p (a1
, &(*die2
->die_attr
)[ix
], mark
))
7785 c1
= die1
->die_child
;
7786 c2
= die2
->die_child
;
7795 if (!same_die_p (c1
, c2
, mark
))
7799 if (c1
== die1
->die_child
)
7801 if (c2
== die2
->die_child
)
7811 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7812 children, and set die_symbol. */
7815 compute_comp_unit_symbol (dw_die_ref unit_die
)
7817 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
7818 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
7819 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
7822 unsigned char checksum
[16];
7825 /* Compute the checksum of the DIE, then append part of it as hex digits to
7826 the name filename of the unit. */
7828 md5_init_ctx (&ctx
);
7830 die_checksum (unit_die
, &ctx
, &mark
);
7831 unmark_all_dies (unit_die
);
7832 md5_finish_ctx (&ctx
, checksum
);
7834 /* When we this for comp_unit_die () we have a DW_AT_name that might
7835 not start with a letter but with anything valid for filenames and
7836 clean_symbol_name doesn't fix that up. Prepend 'g' if the first
7837 character is not a letter. */
7838 sprintf (name
, "%s%s.", ISALPHA (*base
) ? "" : "g", base
);
7839 clean_symbol_name (name
);
7841 p
= name
+ strlen (name
);
7842 for (i
= 0; i
< 4; i
++)
7844 sprintf (p
, "%.2x", checksum
[i
]);
7848 unit_die
->die_id
.die_symbol
= xstrdup (name
);
7851 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7854 is_type_die (dw_die_ref die
)
7856 switch (die
->die_tag
)
7858 case DW_TAG_array_type
:
7859 case DW_TAG_class_type
:
7860 case DW_TAG_interface_type
:
7861 case DW_TAG_enumeration_type
:
7862 case DW_TAG_pointer_type
:
7863 case DW_TAG_reference_type
:
7864 case DW_TAG_rvalue_reference_type
:
7865 case DW_TAG_string_type
:
7866 case DW_TAG_structure_type
:
7867 case DW_TAG_subroutine_type
:
7868 case DW_TAG_union_type
:
7869 case DW_TAG_ptr_to_member_type
:
7870 case DW_TAG_set_type
:
7871 case DW_TAG_subrange_type
:
7872 case DW_TAG_base_type
:
7873 case DW_TAG_const_type
:
7874 case DW_TAG_file_type
:
7875 case DW_TAG_packed_type
:
7876 case DW_TAG_volatile_type
:
7877 case DW_TAG_typedef
:
7884 /* Returns true iff C is a compile-unit DIE. */
7887 is_cu_die (dw_die_ref c
)
7889 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7890 || c
->die_tag
== DW_TAG_skeleton_unit
);
7893 /* Returns true iff C is a unit DIE of some sort. */
7896 is_unit_die (dw_die_ref c
)
7898 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7899 || c
->die_tag
== DW_TAG_partial_unit
7900 || c
->die_tag
== DW_TAG_type_unit
7901 || c
->die_tag
== DW_TAG_skeleton_unit
);
7904 /* Returns true iff C is a namespace DIE. */
7907 is_namespace_die (dw_die_ref c
)
7909 return c
&& c
->die_tag
== DW_TAG_namespace
;
7912 /* Return non-zero if this DIE is a template parameter. */
7915 is_template_parameter (dw_die_ref die
)
7917 switch (die
->die_tag
)
7919 case DW_TAG_template_type_param
:
7920 case DW_TAG_template_value_param
:
7921 case DW_TAG_GNU_template_template_param
:
7922 case DW_TAG_GNU_template_parameter_pack
:
7929 /* Return non-zero if this DIE represents a template instantiation. */
7932 is_template_instantiation (dw_die_ref die
)
7936 if (!is_type_die (die
) && die
->die_tag
!= DW_TAG_subprogram
)
7938 FOR_EACH_CHILD (die
, c
, if (is_template_parameter (c
)) return true);
7943 gen_internal_sym (const char *prefix
)
7945 char buf
[MAX_ARTIFICIAL_LABEL_BYTES
];
7947 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
7948 return xstrdup (buf
);
7951 /* Return non-zero if this DIE is a declaration. */
7954 is_declaration_die (dw_die_ref die
)
7959 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7960 if (a
->dw_attr
== DW_AT_declaration
)
7966 /* Return non-zero if this DIE is nested inside a subprogram. */
7969 is_nested_in_subprogram (dw_die_ref die
)
7971 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
7975 return local_scope_p (decl
);
7978 /* Return non-zero if this DIE contains a defining declaration of a
7982 contains_subprogram_definition (dw_die_ref die
)
7986 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
7988 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
7992 /* Return non-zero if this is a type DIE that should be moved to a
7993 COMDAT .debug_types section or .debug_info section with DW_UT_*type
7997 should_move_die_to_comdat (dw_die_ref die
)
7999 switch (die
->die_tag
)
8001 case DW_TAG_class_type
:
8002 case DW_TAG_structure_type
:
8003 case DW_TAG_enumeration_type
:
8004 case DW_TAG_union_type
:
8005 /* Don't move declarations, inlined instances, types nested in a
8006 subprogram, or types that contain subprogram definitions. */
8007 if (is_declaration_die (die
)
8008 || get_AT (die
, DW_AT_abstract_origin
)
8009 || is_nested_in_subprogram (die
)
8010 || contains_subprogram_definition (die
))
8013 case DW_TAG_array_type
:
8014 case DW_TAG_interface_type
:
8015 case DW_TAG_pointer_type
:
8016 case DW_TAG_reference_type
:
8017 case DW_TAG_rvalue_reference_type
:
8018 case DW_TAG_string_type
:
8019 case DW_TAG_subroutine_type
:
8020 case DW_TAG_ptr_to_member_type
:
8021 case DW_TAG_set_type
:
8022 case DW_TAG_subrange_type
:
8023 case DW_TAG_base_type
:
8024 case DW_TAG_const_type
:
8025 case DW_TAG_file_type
:
8026 case DW_TAG_packed_type
:
8027 case DW_TAG_volatile_type
:
8028 case DW_TAG_typedef
:
8034 /* Make a clone of DIE. */
8037 clone_die (dw_die_ref die
)
8039 dw_die_ref clone
= new_die_raw (die
->die_tag
);
8043 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8044 add_dwarf_attr (clone
, a
);
8049 /* Make a clone of the tree rooted at DIE. */
8052 clone_tree (dw_die_ref die
)
8055 dw_die_ref clone
= clone_die (die
);
8057 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
8062 /* Make a clone of DIE as a declaration. */
8065 clone_as_declaration (dw_die_ref die
)
8072 /* If the DIE is already a declaration, just clone it. */
8073 if (is_declaration_die (die
))
8074 return clone_die (die
);
8076 /* If the DIE is a specification, just clone its declaration DIE. */
8077 decl
= get_AT_ref (die
, DW_AT_specification
);
8080 clone
= clone_die (decl
);
8081 if (die
->comdat_type_p
)
8082 add_AT_die_ref (clone
, DW_AT_signature
, die
);
8086 clone
= new_die_raw (die
->die_tag
);
8088 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8090 /* We don't want to copy over all attributes.
8091 For example we don't want DW_AT_byte_size because otherwise we will no
8092 longer have a declaration and GDB will treat it as a definition. */
8096 case DW_AT_abstract_origin
:
8097 case DW_AT_artificial
:
8098 case DW_AT_containing_type
:
8099 case DW_AT_external
:
8102 case DW_AT_virtuality
:
8103 case DW_AT_linkage_name
:
8104 case DW_AT_MIPS_linkage_name
:
8105 add_dwarf_attr (clone
, a
);
8107 case DW_AT_byte_size
:
8108 case DW_AT_alignment
:
8114 if (die
->comdat_type_p
)
8115 add_AT_die_ref (clone
, DW_AT_signature
, die
);
8117 add_AT_flag (clone
, DW_AT_declaration
, 1);
8122 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
8124 struct decl_table_entry
8130 /* Helpers to manipulate hash table of copied declarations. */
8132 /* Hashtable helpers. */
8134 struct decl_table_entry_hasher
: free_ptr_hash
<decl_table_entry
>
8136 typedef die_struct
*compare_type
;
8137 static inline hashval_t
hash (const decl_table_entry
*);
8138 static inline bool equal (const decl_table_entry
*, const die_struct
*);
8142 decl_table_entry_hasher::hash (const decl_table_entry
*entry
)
8144 return htab_hash_pointer (entry
->orig
);
8148 decl_table_entry_hasher::equal (const decl_table_entry
*entry1
,
8149 const die_struct
*entry2
)
8151 return entry1
->orig
== entry2
;
8154 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
8156 /* Copy DIE and its ancestors, up to, but not including, the compile unit
8157 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
8158 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
8159 to check if the ancestor has already been copied into UNIT. */
8162 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
,
8163 decl_hash_type
*decl_table
)
8165 dw_die_ref parent
= die
->die_parent
;
8166 dw_die_ref new_parent
= unit
;
8168 decl_table_entry
**slot
= NULL
;
8169 struct decl_table_entry
*entry
= NULL
;
8173 /* Check if the entry has already been copied to UNIT. */
8174 slot
= decl_table
->find_slot_with_hash (die
, htab_hash_pointer (die
),
8176 if (*slot
!= HTAB_EMPTY_ENTRY
)
8182 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
8183 entry
= XCNEW (struct decl_table_entry
);
8191 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
8194 if (!is_unit_die (parent
))
8195 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
8198 copy
= clone_as_declaration (die
);
8199 add_child_die (new_parent
, copy
);
8203 /* Record the pointer to the copy. */
8209 /* Copy the declaration context to the new type unit DIE. This includes
8210 any surrounding namespace or type declarations. If the DIE has an
8211 AT_specification attribute, it also includes attributes and children
8212 attached to the specification, and returns a pointer to the original
8213 parent of the declaration DIE. Returns NULL otherwise. */
8216 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
8219 dw_die_ref new_decl
;
8220 dw_die_ref orig_parent
= NULL
;
8222 decl
= get_AT_ref (die
, DW_AT_specification
);
8231 /* The original DIE will be changed to a declaration, and must
8232 be moved to be a child of the original declaration DIE. */
8233 orig_parent
= decl
->die_parent
;
8235 /* Copy the type node pointer from the new DIE to the original
8236 declaration DIE so we can forward references later. */
8237 decl
->comdat_type_p
= true;
8238 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
8240 remove_AT (die
, DW_AT_specification
);
8242 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
8244 if (a
->dw_attr
!= DW_AT_name
8245 && a
->dw_attr
!= DW_AT_declaration
8246 && a
->dw_attr
!= DW_AT_external
)
8247 add_dwarf_attr (die
, a
);
8250 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
8253 if (decl
->die_parent
!= NULL
8254 && !is_unit_die (decl
->die_parent
))
8256 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
8257 if (new_decl
!= NULL
)
8259 remove_AT (new_decl
, DW_AT_signature
);
8260 add_AT_specification (die
, new_decl
);
8267 /* Generate the skeleton ancestor tree for the given NODE, then clone
8268 the DIE and add the clone into the tree. */
8271 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
8273 if (node
->new_die
!= NULL
)
8276 node
->new_die
= clone_as_declaration (node
->old_die
);
8278 if (node
->parent
!= NULL
)
8280 generate_skeleton_ancestor_tree (node
->parent
);
8281 add_child_die (node
->parent
->new_die
, node
->new_die
);
8285 /* Generate a skeleton tree of DIEs containing any declarations that are
8286 found in the original tree. We traverse the tree looking for declaration
8287 DIEs, and construct the skeleton from the bottom up whenever we find one. */
8290 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
8292 skeleton_chain_node node
;
8295 dw_die_ref prev
= NULL
;
8296 dw_die_ref next
= NULL
;
8298 node
.parent
= parent
;
8300 first
= c
= parent
->old_die
->die_child
;
8304 if (prev
== NULL
|| prev
->die_sib
== c
)
8307 next
= (c
== first
? NULL
: c
->die_sib
);
8309 node
.new_die
= NULL
;
8310 if (is_declaration_die (c
))
8312 if (is_template_instantiation (c
))
8314 /* Instantiated templates do not need to be cloned into the
8315 type unit. Just move the DIE and its children back to
8316 the skeleton tree (in the main CU). */
8317 remove_child_with_prev (c
, prev
);
8318 add_child_die (parent
->new_die
, c
);
8321 else if (c
->comdat_type_p
)
8323 /* This is the skeleton of earlier break_out_comdat_types
8324 type. Clone the existing DIE, but keep the children
8325 under the original (which is in the main CU). */
8326 dw_die_ref clone
= clone_die (c
);
8328 replace_child (c
, clone
, prev
);
8329 generate_skeleton_ancestor_tree (parent
);
8330 add_child_die (parent
->new_die
, c
);
8336 /* Clone the existing DIE, move the original to the skeleton
8337 tree (which is in the main CU), and put the clone, with
8338 all the original's children, where the original came from
8339 (which is about to be moved to the type unit). */
8340 dw_die_ref clone
= clone_die (c
);
8341 move_all_children (c
, clone
);
8343 /* If the original has a DW_AT_object_pointer attribute,
8344 it would now point to a child DIE just moved to the
8345 cloned tree, so we need to remove that attribute from
8347 remove_AT (c
, DW_AT_object_pointer
);
8349 replace_child (c
, clone
, prev
);
8350 generate_skeleton_ancestor_tree (parent
);
8351 add_child_die (parent
->new_die
, c
);
8352 node
.old_die
= clone
;
8357 generate_skeleton_bottom_up (&node
);
8358 } while (next
!= NULL
);
8361 /* Wrapper function for generate_skeleton_bottom_up. */
8364 generate_skeleton (dw_die_ref die
)
8366 skeleton_chain_node node
;
8369 node
.new_die
= NULL
;
8372 /* If this type definition is nested inside another type,
8373 and is not an instantiation of a template, always leave
8374 at least a declaration in its place. */
8375 if (die
->die_parent
!= NULL
8376 && is_type_die (die
->die_parent
)
8377 && !is_template_instantiation (die
))
8378 node
.new_die
= clone_as_declaration (die
);
8380 generate_skeleton_bottom_up (&node
);
8381 return node
.new_die
;
8384 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
8385 declaration. The original DIE is moved to a new compile unit so that
8386 existing references to it follow it to the new location. If any of the
8387 original DIE's descendants is a declaration, we need to replace the
8388 original DIE with a skeleton tree and move the declarations back into the
8392 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
8395 dw_die_ref skeleton
, orig_parent
;
8397 /* Copy the declaration context to the type unit DIE. If the returned
8398 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
8400 orig_parent
= copy_declaration_context (unit
, child
);
8402 skeleton
= generate_skeleton (child
);
8403 if (skeleton
== NULL
)
8404 remove_child_with_prev (child
, prev
);
8407 skeleton
->comdat_type_p
= true;
8408 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
8410 /* If the original DIE was a specification, we need to put
8411 the skeleton under the parent DIE of the declaration.
8412 This leaves the original declaration in the tree, but
8413 it will be pruned later since there are no longer any
8414 references to it. */
8415 if (orig_parent
!= NULL
)
8417 remove_child_with_prev (child
, prev
);
8418 add_child_die (orig_parent
, skeleton
);
8421 replace_child (child
, skeleton
, prev
);
8428 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8429 comdat_type_node
*type_node
,
8430 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
);
8432 /* Helper for copy_dwarf_procs_ref_in_dies. Make a copy of the DIE DWARF
8433 procedure, put it under TYPE_NODE and return the copy. Continue looking for
8434 DWARF procedure references in the DW_AT_location attribute. */
8437 copy_dwarf_procedure (dw_die_ref die
,
8438 comdat_type_node
*type_node
,
8439 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8441 gcc_assert (die
->die_tag
== DW_TAG_dwarf_procedure
);
8443 /* DWARF procedures are not supposed to have children... */
8444 gcc_assert (die
->die_child
== NULL
);
8446 /* ... and they are supposed to have only one attribute: DW_AT_location. */
8447 gcc_assert (vec_safe_length (die
->die_attr
) == 1
8448 && ((*die
->die_attr
)[0].dw_attr
== DW_AT_location
));
8450 /* Do not copy more than once DWARF procedures. */
8452 dw_die_ref
&die_copy
= copied_dwarf_procs
.get_or_insert (die
, &existed
);
8456 die_copy
= clone_die (die
);
8457 add_child_die (type_node
->root_die
, die_copy
);
8458 copy_dwarf_procs_ref_in_attrs (die_copy
, type_node
, copied_dwarf_procs
);
8462 /* Helper for copy_dwarf_procs_ref_in_dies. Look for references to DWARF
8463 procedures in DIE's attributes. */
8466 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8467 comdat_type_node
*type_node
,
8468 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8473 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, i
, a
)
8475 dw_loc_descr_ref loc
;
8477 if (a
->dw_attr_val
.val_class
!= dw_val_class_loc
)
8480 for (loc
= a
->dw_attr_val
.v
.val_loc
; loc
!= NULL
; loc
= loc
->dw_loc_next
)
8482 switch (loc
->dw_loc_opc
)
8486 case DW_OP_call_ref
:
8487 gcc_assert (loc
->dw_loc_oprnd1
.val_class
8488 == dw_val_class_die_ref
);
8489 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
8490 = copy_dwarf_procedure (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
,
8492 copied_dwarf_procs
);
8501 /* Copy DWARF procedures that are referenced by the DIE tree to TREE_NODE and
8502 rewrite references to point to the copies.
8504 References are looked for in DIE's attributes and recursively in all its
8505 children attributes that are location descriptions. COPIED_DWARF_PROCS is a
8506 mapping from old DWARF procedures to their copy. It is used not to copy
8507 twice the same DWARF procedure under TYPE_NODE. */
8510 copy_dwarf_procs_ref_in_dies (dw_die_ref die
,
8511 comdat_type_node
*type_node
,
8512 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8516 copy_dwarf_procs_ref_in_attrs (die
, type_node
, copied_dwarf_procs
);
8517 FOR_EACH_CHILD (die
, c
, copy_dwarf_procs_ref_in_dies (c
,
8519 copied_dwarf_procs
));
8522 /* Traverse the DIE and set up additional .debug_types or .debug_info
8523 DW_UT_*type sections for each type worthy of being placed in a COMDAT
8527 break_out_comdat_types (dw_die_ref die
)
8531 dw_die_ref prev
= NULL
;
8532 dw_die_ref next
= NULL
;
8533 dw_die_ref unit
= NULL
;
8535 first
= c
= die
->die_child
;
8539 if (prev
== NULL
|| prev
->die_sib
== c
)
8542 next
= (c
== first
? NULL
: c
->die_sib
);
8543 if (should_move_die_to_comdat (c
))
8545 dw_die_ref replacement
;
8546 comdat_type_node
*type_node
;
8548 /* Break out nested types into their own type units. */
8549 break_out_comdat_types (c
);
8551 /* Create a new type unit DIE as the root for the new tree, and
8552 add it to the list of comdat types. */
8553 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
8554 add_AT_unsigned (unit
, DW_AT_language
,
8555 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
8556 type_node
= ggc_cleared_alloc
<comdat_type_node
> ();
8557 type_node
->root_die
= unit
;
8558 type_node
->next
= comdat_type_list
;
8559 comdat_type_list
= type_node
;
8561 /* Generate the type signature. */
8562 generate_type_signature (c
, type_node
);
8564 /* Copy the declaration context, attributes, and children of the
8565 declaration into the new type unit DIE, then remove this DIE
8566 from the main CU (or replace it with a skeleton if necessary). */
8567 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
8568 type_node
->skeleton_die
= replacement
;
8570 /* Add the DIE to the new compunit. */
8571 add_child_die (unit
, c
);
8573 /* Types can reference DWARF procedures for type size or data location
8574 expressions. Calls in DWARF expressions cannot target procedures
8575 that are not in the same section. So we must copy DWARF procedures
8576 along with this type and then rewrite references to them. */
8577 hash_map
<dw_die_ref
, dw_die_ref
> copied_dwarf_procs
;
8578 copy_dwarf_procs_ref_in_dies (c
, type_node
, copied_dwarf_procs
);
8580 if (replacement
!= NULL
)
8583 else if (c
->die_tag
== DW_TAG_namespace
8584 || c
->die_tag
== DW_TAG_class_type
8585 || c
->die_tag
== DW_TAG_structure_type
8586 || c
->die_tag
== DW_TAG_union_type
)
8588 /* Look for nested types that can be broken out. */
8589 break_out_comdat_types (c
);
8591 } while (next
!= NULL
);
8594 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
8595 Enter all the cloned children into the hash table decl_table. */
8598 clone_tree_partial (dw_die_ref die
, decl_hash_type
*decl_table
)
8602 struct decl_table_entry
*entry
;
8603 decl_table_entry
**slot
;
8605 if (die
->die_tag
== DW_TAG_subprogram
)
8606 clone
= clone_as_declaration (die
);
8608 clone
= clone_die (die
);
8610 slot
= decl_table
->find_slot_with_hash (die
,
8611 htab_hash_pointer (die
), INSERT
);
8613 /* Assert that DIE isn't in the hash table yet. If it would be there
8614 before, the ancestors would be necessarily there as well, therefore
8615 clone_tree_partial wouldn't be called. */
8616 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
8618 entry
= XCNEW (struct decl_table_entry
);
8620 entry
->copy
= clone
;
8623 if (die
->die_tag
!= DW_TAG_subprogram
)
8624 FOR_EACH_CHILD (die
, c
,
8625 add_child_die (clone
, clone_tree_partial (c
, decl_table
)));
8630 /* Walk the DIE and its children, looking for references to incomplete
8631 or trivial types that are unmarked (i.e., that are not in the current
8635 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type
*decl_table
)
8641 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8643 if (AT_class (a
) == dw_val_class_die_ref
)
8645 dw_die_ref targ
= AT_ref (a
);
8646 decl_table_entry
**slot
;
8647 struct decl_table_entry
*entry
;
8649 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
8652 slot
= decl_table
->find_slot_with_hash (targ
,
8653 htab_hash_pointer (targ
),
8656 if (*slot
!= HTAB_EMPTY_ENTRY
)
8658 /* TARG has already been copied, so we just need to
8659 modify the reference to point to the copy. */
8661 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
8665 dw_die_ref parent
= unit
;
8666 dw_die_ref copy
= clone_die (targ
);
8668 /* Record in DECL_TABLE that TARG has been copied.
8669 Need to do this now, before the recursive call,
8670 because DECL_TABLE may be expanded and SLOT
8671 would no longer be a valid pointer. */
8672 entry
= XCNEW (struct decl_table_entry
);
8677 /* If TARG is not a declaration DIE, we need to copy its
8679 if (!is_declaration_die (targ
))
8683 add_child_die (copy
,
8684 clone_tree_partial (c
, decl_table
)));
8687 /* Make sure the cloned tree is marked as part of the
8691 /* If TARG has surrounding context, copy its ancestor tree
8692 into the new type unit. */
8693 if (targ
->die_parent
!= NULL
8694 && !is_unit_die (targ
->die_parent
))
8695 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
8698 add_child_die (parent
, copy
);
8699 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
8701 /* Make sure the newly-copied DIE is walked. If it was
8702 installed in a previously-added context, it won't
8703 get visited otherwise. */
8706 /* Find the highest point of the newly-added tree,
8707 mark each node along the way, and walk from there. */
8708 parent
->die_mark
= 1;
8709 while (parent
->die_parent
8710 && parent
->die_parent
->die_mark
== 0)
8712 parent
= parent
->die_parent
;
8713 parent
->die_mark
= 1;
8715 copy_decls_walk (unit
, parent
, decl_table
);
8721 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
8724 /* Copy declarations for "unworthy" types into the new comdat section.
8725 Incomplete types, modified types, and certain other types aren't broken
8726 out into comdat sections of their own, so they don't have a signature,
8727 and we need to copy the declaration into the same section so that we
8728 don't have an external reference. */
8731 copy_decls_for_unworthy_types (dw_die_ref unit
)
8734 decl_hash_type
decl_table (10);
8735 copy_decls_walk (unit
, unit
, &decl_table
);
8739 /* Traverse the DIE and add a sibling attribute if it may have the
8740 effect of speeding up access to siblings. To save some space,
8741 avoid generating sibling attributes for DIE's without children. */
8744 add_sibling_attributes (dw_die_ref die
)
8748 if (! die
->die_child
)
8751 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
8752 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
8754 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
8757 /* Output all location lists for the DIE and its children. */
8760 output_location_lists (dw_die_ref die
)
8766 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8767 if (AT_class (a
) == dw_val_class_loc_list
)
8768 output_loc_list (AT_loc_list (a
));
8770 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
8773 /* During assign_location_list_indexes and output_loclists_offset the
8774 current index, after it the number of assigned indexes (i.e. how
8775 large the .debug_loclists* offset table should be). */
8776 static unsigned int loc_list_idx
;
8778 /* Output all location list offsets for the DIE and its children. */
8781 output_loclists_offsets (dw_die_ref die
)
8787 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8788 if (AT_class (a
) == dw_val_class_loc_list
)
8790 dw_loc_list_ref l
= AT_loc_list (a
);
8791 if (l
->offset_emitted
)
8793 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l
->ll_symbol
,
8794 loc_section_label
, NULL
);
8795 gcc_assert (l
->hash
== loc_list_idx
);
8797 l
->offset_emitted
= true;
8800 FOR_EACH_CHILD (die
, c
, output_loclists_offsets (c
));
8803 /* Recursively set indexes of location lists. */
8806 assign_location_list_indexes (dw_die_ref die
)
8812 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8813 if (AT_class (a
) == dw_val_class_loc_list
)
8815 dw_loc_list_ref list
= AT_loc_list (a
);
8816 if (!list
->num_assigned
)
8818 list
->num_assigned
= true;
8819 list
->hash
= loc_list_idx
++;
8823 FOR_EACH_CHILD (die
, c
, assign_location_list_indexes (c
));
8826 /* We want to limit the number of external references, because they are
8827 larger than local references: a relocation takes multiple words, and
8828 even a sig8 reference is always eight bytes, whereas a local reference
8829 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
8830 So if we encounter multiple external references to the same type DIE, we
8831 make a local typedef stub for it and redirect all references there.
8833 This is the element of the hash table for keeping track of these
8843 /* Hashtable helpers. */
8845 struct external_ref_hasher
: free_ptr_hash
<external_ref
>
8847 static inline hashval_t
hash (const external_ref
*);
8848 static inline bool equal (const external_ref
*, const external_ref
*);
8852 external_ref_hasher::hash (const external_ref
*r
)
8854 dw_die_ref die
= r
->type
;
8857 /* We can't use the address of the DIE for hashing, because
8858 that will make the order of the stub DIEs non-deterministic. */
8859 if (! die
->comdat_type_p
)
8860 /* We have a symbol; use it to compute a hash. */
8861 h
= htab_hash_string (die
->die_id
.die_symbol
);
8864 /* We have a type signature; use a subset of the bits as the hash.
8865 The 8-byte signature is at least as large as hashval_t. */
8866 comdat_type_node
*type_node
= die
->die_id
.die_type_node
;
8867 memcpy (&h
, type_node
->signature
, sizeof (h
));
8873 external_ref_hasher::equal (const external_ref
*r1
, const external_ref
*r2
)
8875 return r1
->type
== r2
->type
;
8878 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
8880 /* Return a pointer to the external_ref for references to DIE. */
8882 static struct external_ref
*
8883 lookup_external_ref (external_ref_hash_type
*map
, dw_die_ref die
)
8885 struct external_ref ref
, *ref_p
;
8886 external_ref
**slot
;
8889 slot
= map
->find_slot (&ref
, INSERT
);
8890 if (*slot
!= HTAB_EMPTY_ENTRY
)
8893 ref_p
= XCNEW (struct external_ref
);
8899 /* Subroutine of optimize_external_refs, below.
8901 If we see a type skeleton, record it as our stub. If we see external
8902 references, remember how many we've seen. */
8905 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type
*map
)
8910 struct external_ref
*ref_p
;
8912 if (is_type_die (die
)
8913 && (c
= get_AT_ref (die
, DW_AT_signature
)))
8915 /* This is a local skeleton; use it for local references. */
8916 ref_p
= lookup_external_ref (map
, c
);
8920 /* Scan the DIE references, and remember any that refer to DIEs from
8921 other CUs (i.e. those which are not marked). */
8922 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8923 if (AT_class (a
) == dw_val_class_die_ref
8924 && (c
= AT_ref (a
))->die_mark
== 0
8927 ref_p
= lookup_external_ref (map
, c
);
8931 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
8934 /* htab_traverse callback function for optimize_external_refs, below. SLOT
8935 points to an external_ref, DATA is the CU we're processing. If we don't
8936 already have a local stub, and we have multiple refs, build a stub. */
8939 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
8941 struct external_ref
*ref_p
= *slot
;
8943 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
8945 /* We have multiple references to this type, so build a small stub.
8946 Both of these forms are a bit dodgy from the perspective of the
8947 DWARF standard, since technically they should have names. */
8948 dw_die_ref cu
= data
;
8949 dw_die_ref type
= ref_p
->type
;
8950 dw_die_ref stub
= NULL
;
8952 if (type
->comdat_type_p
)
8954 /* If we refer to this type via sig8, use AT_signature. */
8955 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
8956 add_AT_die_ref (stub
, DW_AT_signature
, type
);
8960 /* Otherwise, use a typedef with no name. */
8961 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
8962 add_AT_die_ref (stub
, DW_AT_type
, type
);
8971 /* DIE is a unit; look through all the DIE references to see if there are
8972 any external references to types, and if so, create local stubs for
8973 them which will be applied in build_abbrev_table. This is useful because
8974 references to local DIEs are smaller. */
8976 static external_ref_hash_type
*
8977 optimize_external_refs (dw_die_ref die
)
8979 external_ref_hash_type
*map
= new external_ref_hash_type (10);
8980 optimize_external_refs_1 (die
, map
);
8981 map
->traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
8985 /* The following 3 variables are temporaries that are computed only during the
8986 build_abbrev_table call and used and released during the following
8987 optimize_abbrev_table call. */
8989 /* First abbrev_id that can be optimized based on usage. */
8990 static unsigned int abbrev_opt_start
;
8992 /* Maximum abbrev_id of a base type plus one (we can't optimize DIEs with
8993 abbrev_id smaller than this, because they must be already sized
8994 during build_abbrev_table). */
8995 static unsigned int abbrev_opt_base_type_end
;
8997 /* Vector of usage counts during build_abbrev_table. Indexed by
8998 abbrev_id - abbrev_opt_start. */
8999 static vec
<unsigned int> abbrev_usage_count
;
9001 /* Vector of all DIEs added with die_abbrev >= abbrev_opt_start. */
9002 static vec
<dw_die_ref
> sorted_abbrev_dies
;
9004 /* The format of each DIE (and its attribute value pairs) is encoded in an
9005 abbreviation table. This routine builds the abbreviation table and assigns
9006 a unique abbreviation id for each abbreviation entry. The children of each
9007 die are visited recursively. */
9010 build_abbrev_table (dw_die_ref die
, external_ref_hash_type
*extern_map
)
9012 unsigned int abbrev_id
= 0;
9018 /* Scan the DIE references, and replace any that refer to
9019 DIEs from other CUs (i.e. those which are not marked) with
9020 the local stubs we built in optimize_external_refs. */
9021 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9022 if (AT_class (a
) == dw_val_class_die_ref
9023 && (c
= AT_ref (a
))->die_mark
== 0)
9025 struct external_ref
*ref_p
;
9026 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
9029 && (ref_p
= lookup_external_ref (extern_map
, c
))
9030 && ref_p
->stub
&& ref_p
->stub
!= die
)
9031 change_AT_die_ref (a
, ref_p
->stub
);
9033 /* We aren't changing this reference, so mark it external. */
9034 set_AT_ref_external (a
, 1);
9037 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
9039 dw_attr_node
*die_a
, *abbrev_a
;
9045 if (abbrev
->die_tag
!= die
->die_tag
)
9047 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
9050 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
9053 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
9055 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
9056 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
9057 || (value_format (abbrev_a
) != value_format (die_a
)))
9067 if (abbrev_id
>= vec_safe_length (abbrev_die_table
))
9069 vec_safe_push (abbrev_die_table
, die
);
9070 if (abbrev_opt_start
)
9071 abbrev_usage_count
.safe_push (0);
9073 if (abbrev_opt_start
&& abbrev_id
>= abbrev_opt_start
)
9075 abbrev_usage_count
[abbrev_id
- abbrev_opt_start
]++;
9076 sorted_abbrev_dies
.safe_push (die
);
9079 die
->die_abbrev
= abbrev_id
;
9080 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
9083 /* Callback function for sorted_abbrev_dies vector sorting. We sort
9084 by die_abbrev's usage count, from the most commonly used
9085 abbreviation to the least. */
9088 die_abbrev_cmp (const void *p1
, const void *p2
)
9090 dw_die_ref die1
= *(const dw_die_ref
*) p1
;
9091 dw_die_ref die2
= *(const dw_die_ref
*) p2
;
9093 gcc_checking_assert (die1
->die_abbrev
>= abbrev_opt_start
);
9094 gcc_checking_assert (die2
->die_abbrev
>= abbrev_opt_start
);
9096 if (die1
->die_abbrev
>= abbrev_opt_base_type_end
9097 && die2
->die_abbrev
>= abbrev_opt_base_type_end
)
9099 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
9100 > abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
9102 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
9103 < abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
9107 /* Stabilize the sort. */
9108 if (die1
->die_abbrev
< die2
->die_abbrev
)
9110 if (die1
->die_abbrev
> die2
->die_abbrev
)
9116 /* Convert dw_val_class_const and dw_val_class_unsigned_const class attributes
9117 of DIEs in between sorted_abbrev_dies[first_id] and abbrev_dies[end_id - 1]
9118 into dw_val_class_const_implicit or
9119 dw_val_class_unsigned_const_implicit. */
9122 optimize_implicit_const (unsigned int first_id
, unsigned int end
,
9123 vec
<bool> &implicit_consts
)
9125 /* It never makes sense if there is just one DIE using the abbreviation. */
9126 if (end
< first_id
+ 2)
9131 dw_die_ref die
= sorted_abbrev_dies
[first_id
];
9132 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9133 if (implicit_consts
[ix
])
9135 enum dw_val_class new_class
= dw_val_class_none
;
9136 switch (AT_class (a
))
9138 case dw_val_class_unsigned_const
:
9139 if ((HOST_WIDE_INT
) AT_unsigned (a
) < 0)
9142 /* The .debug_abbrev section will grow by
9143 size_of_sleb128 (AT_unsigned (a)) and we avoid the constants
9144 in all the DIEs using that abbreviation. */
9145 if (constant_size (AT_unsigned (a
)) * (end
- first_id
)
9146 <= (unsigned) size_of_sleb128 (AT_unsigned (a
)))
9149 new_class
= dw_val_class_unsigned_const_implicit
;
9152 case dw_val_class_const
:
9153 new_class
= dw_val_class_const_implicit
;
9156 case dw_val_class_file
:
9157 new_class
= dw_val_class_file_implicit
;
9163 for (i
= first_id
; i
< end
; i
++)
9164 (*sorted_abbrev_dies
[i
]->die_attr
)[ix
].dw_attr_val
.val_class
9169 /* Attempt to optimize abbreviation table from abbrev_opt_start
9170 abbreviation above. */
9173 optimize_abbrev_table (void)
9175 if (abbrev_opt_start
9176 && vec_safe_length (abbrev_die_table
) > abbrev_opt_start
9177 && (dwarf_version
>= 5 || vec_safe_length (abbrev_die_table
) > 127))
9179 auto_vec
<bool, 32> implicit_consts
;
9180 sorted_abbrev_dies
.qsort (die_abbrev_cmp
);
9182 unsigned int abbrev_id
= abbrev_opt_start
- 1;
9183 unsigned int first_id
= ~0U;
9184 unsigned int last_abbrev_id
= 0;
9187 if (abbrev_opt_base_type_end
> abbrev_opt_start
)
9188 abbrev_id
= abbrev_opt_base_type_end
- 1;
9189 /* Reassign abbreviation ids from abbrev_opt_start above, so that
9190 most commonly used abbreviations come first. */
9191 FOR_EACH_VEC_ELT (sorted_abbrev_dies
, i
, die
)
9196 /* If calc_base_type_die_sizes has been called, the CU and
9197 base types after it can't be optimized, because we've already
9198 calculated their DIE offsets. We've sorted them first. */
9199 if (die
->die_abbrev
< abbrev_opt_base_type_end
)
9201 if (die
->die_abbrev
!= last_abbrev_id
)
9203 last_abbrev_id
= die
->die_abbrev
;
9204 if (dwarf_version
>= 5 && first_id
!= ~0U)
9205 optimize_implicit_const (first_id
, i
, implicit_consts
);
9207 (*abbrev_die_table
)[abbrev_id
] = die
;
9208 if (dwarf_version
>= 5)
9211 implicit_consts
.truncate (0);
9213 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9214 switch (AT_class (a
))
9216 case dw_val_class_const
:
9217 case dw_val_class_unsigned_const
:
9218 case dw_val_class_file
:
9219 implicit_consts
.safe_push (true);
9222 implicit_consts
.safe_push (false);
9227 else if (dwarf_version
>= 5)
9229 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9230 if (!implicit_consts
[ix
])
9234 dw_attr_node
*other_a
9235 = &(*(*abbrev_die_table
)[abbrev_id
]->die_attr
)[ix
];
9236 if (!dw_val_equal_p (&a
->dw_attr_val
,
9237 &other_a
->dw_attr_val
))
9238 implicit_consts
[ix
] = false;
9241 die
->die_abbrev
= abbrev_id
;
9243 gcc_assert (abbrev_id
== vec_safe_length (abbrev_die_table
) - 1);
9244 if (dwarf_version
>= 5 && first_id
!= ~0U)
9245 optimize_implicit_const (first_id
, i
, implicit_consts
);
9248 abbrev_opt_start
= 0;
9249 abbrev_opt_base_type_end
= 0;
9250 abbrev_usage_count
.release ();
9251 sorted_abbrev_dies
.release ();
9254 /* Return the power-of-two number of bytes necessary to represent VALUE. */
9257 constant_size (unsigned HOST_WIDE_INT value
)
9264 log
= floor_log2 (value
);
9267 log
= 1 << (floor_log2 (log
) + 1);
9272 /* Return the size of a DIE as it is represented in the
9273 .debug_info section. */
9275 static unsigned long
9276 size_of_die (dw_die_ref die
)
9278 unsigned long size
= 0;
9281 enum dwarf_form form
;
9283 size
+= size_of_uleb128 (die
->die_abbrev
);
9284 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9286 switch (AT_class (a
))
9288 case dw_val_class_addr
:
9289 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9291 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9292 size
+= size_of_uleb128 (AT_index (a
));
9295 size
+= DWARF2_ADDR_SIZE
;
9297 case dw_val_class_offset
:
9298 size
+= DWARF_OFFSET_SIZE
;
9300 case dw_val_class_loc
:
9302 unsigned long lsize
= size_of_locs (AT_loc (a
));
9305 if (dwarf_version
>= 4)
9306 size
+= size_of_uleb128 (lsize
);
9308 size
+= constant_size (lsize
);
9312 case dw_val_class_loc_list
:
9313 case dw_val_class_view_list
:
9314 if (dwarf_split_debug_info
&& dwarf_version
>= 5)
9316 gcc_assert (AT_loc_list (a
)->num_assigned
);
9317 size
+= size_of_uleb128 (AT_loc_list (a
)->hash
);
9320 size
+= DWARF_OFFSET_SIZE
;
9322 case dw_val_class_range_list
:
9323 if (value_format (a
) == DW_FORM_rnglistx
)
9325 gcc_assert (rnglist_idx
);
9326 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
9327 size
+= size_of_uleb128 (r
->idx
);
9330 size
+= DWARF_OFFSET_SIZE
;
9332 case dw_val_class_const
:
9333 size
+= size_of_sleb128 (AT_int (a
));
9335 case dw_val_class_unsigned_const
:
9337 int csize
= constant_size (AT_unsigned (a
));
9338 if (dwarf_version
== 3
9339 && a
->dw_attr
== DW_AT_data_member_location
9341 size
+= size_of_uleb128 (AT_unsigned (a
));
9346 case dw_val_class_symview
:
9347 if (symview_upper_bound
<= 0xff)
9349 else if (symview_upper_bound
<= 0xffff)
9351 else if (symview_upper_bound
<= 0xffffffff)
9356 case dw_val_class_const_implicit
:
9357 case dw_val_class_unsigned_const_implicit
:
9358 case dw_val_class_file_implicit
:
9359 /* These occupy no size in the DIE, just an extra sleb128 in
9362 case dw_val_class_const_double
:
9363 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
9364 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
9367 case dw_val_class_wide_int
:
9368 size
+= (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9369 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
9370 if (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9371 * HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
9374 case dw_val_class_vec
:
9375 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
9376 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
9377 + a
->dw_attr_val
.v
.val_vec
.length
9378 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
9380 case dw_val_class_flag
:
9381 if (dwarf_version
>= 4)
9382 /* Currently all add_AT_flag calls pass in 1 as last argument,
9383 so DW_FORM_flag_present can be used. If that ever changes,
9384 we'll need to use DW_FORM_flag and have some optimization
9385 in build_abbrev_table that will change those to
9386 DW_FORM_flag_present if it is set to 1 in all DIEs using
9387 the same abbrev entry. */
9388 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9392 case dw_val_class_die_ref
:
9393 if (AT_ref_external (a
))
9395 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
9396 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
9397 is sized by target address length, whereas in DWARF3
9398 it's always sized as an offset. */
9399 if (use_debug_types
)
9400 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
9401 else if (dwarf_version
== 2)
9402 size
+= DWARF2_ADDR_SIZE
;
9404 size
+= DWARF_OFFSET_SIZE
;
9407 size
+= DWARF_OFFSET_SIZE
;
9409 case dw_val_class_fde_ref
:
9410 size
+= DWARF_OFFSET_SIZE
;
9412 case dw_val_class_lbl_id
:
9413 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9415 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9416 size
+= size_of_uleb128 (AT_index (a
));
9419 size
+= DWARF2_ADDR_SIZE
;
9421 case dw_val_class_lineptr
:
9422 case dw_val_class_macptr
:
9423 case dw_val_class_loclistsptr
:
9424 size
+= DWARF_OFFSET_SIZE
;
9426 case dw_val_class_str
:
9427 form
= AT_string_form (a
);
9428 if (form
== DW_FORM_strp
|| form
== DW_FORM_line_strp
)
9429 size
+= DWARF_OFFSET_SIZE
;
9430 else if (form
== dwarf_FORM (DW_FORM_strx
))
9431 size
+= size_of_uleb128 (AT_index (a
));
9433 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
9435 case dw_val_class_file
:
9436 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
9438 case dw_val_class_data8
:
9441 case dw_val_class_vms_delta
:
9442 size
+= DWARF_OFFSET_SIZE
;
9444 case dw_val_class_high_pc
:
9445 size
+= DWARF2_ADDR_SIZE
;
9447 case dw_val_class_discr_value
:
9448 size
+= size_of_discr_value (&a
->dw_attr_val
.v
.val_discr_value
);
9450 case dw_val_class_discr_list
:
9452 unsigned block_size
= size_of_discr_list (AT_discr_list (a
));
9454 /* This is a block, so we have the block length and then its
9456 size
+= constant_size (block_size
) + block_size
;
9467 /* Size the debugging information associated with a given DIE. Visits the
9468 DIE's children recursively. Updates the global variable next_die_offset, on
9469 each time through. Uses the current value of next_die_offset to update the
9470 die_offset field in each DIE. */
9473 calc_die_sizes (dw_die_ref die
)
9477 gcc_assert (die
->die_offset
== 0
9478 || (unsigned long int) die
->die_offset
== next_die_offset
);
9479 die
->die_offset
= next_die_offset
;
9480 next_die_offset
+= size_of_die (die
);
9482 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
9484 if (die
->die_child
!= NULL
)
9485 /* Count the null byte used to terminate sibling lists. */
9486 next_die_offset
+= 1;
9489 /* Size just the base type children at the start of the CU.
9490 This is needed because build_abbrev needs to size locs
9491 and sizing of type based stack ops needs to know die_offset
9492 values for the base types. */
9495 calc_base_type_die_sizes (void)
9497 unsigned long die_offset
= (dwarf_split_debug_info
9498 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
9499 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
9501 dw_die_ref base_type
;
9502 #if ENABLE_ASSERT_CHECKING
9503 dw_die_ref prev
= comp_unit_die ()->die_child
;
9506 die_offset
+= size_of_die (comp_unit_die ());
9507 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
9509 #if ENABLE_ASSERT_CHECKING
9510 gcc_assert (base_type
->die_offset
== 0
9511 && prev
->die_sib
== base_type
9512 && base_type
->die_child
== NULL
9513 && base_type
->die_abbrev
);
9516 if (abbrev_opt_start
9517 && base_type
->die_abbrev
>= abbrev_opt_base_type_end
)
9518 abbrev_opt_base_type_end
= base_type
->die_abbrev
+ 1;
9519 base_type
->die_offset
= die_offset
;
9520 die_offset
+= size_of_die (base_type
);
9524 /* Set the marks for a die and its children. We do this so
9525 that we know whether or not a reference needs to use FORM_ref_addr; only
9526 DIEs in the same CU will be marked. We used to clear out the offset
9527 and use that as the flag, but ran into ordering problems. */
9530 mark_dies (dw_die_ref die
)
9534 gcc_assert (!die
->die_mark
);
9537 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
9540 /* Clear the marks for a die and its children. */
9543 unmark_dies (dw_die_ref die
)
9547 if (! use_debug_types
)
9548 gcc_assert (die
->die_mark
);
9551 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
9554 /* Clear the marks for a die, its children and referred dies. */
9557 unmark_all_dies (dw_die_ref die
)
9567 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
9569 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9570 if (AT_class (a
) == dw_val_class_die_ref
)
9571 unmark_all_dies (AT_ref (a
));
9574 /* Calculate if the entry should appear in the final output file. It may be
9575 from a pruned a type. */
9578 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
9580 /* By limiting gnu pubnames to definitions only, gold can generate a
9581 gdb index without entries for declarations, which don't include
9582 enough information to be useful. */
9583 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
9586 if (table
== pubname_table
)
9588 /* Enumerator names are part of the pubname table, but the
9589 parent DW_TAG_enumeration_type die may have been pruned.
9590 Don't output them if that is the case. */
9591 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
9592 (p
->die
->die_parent
== NULL
9593 || !p
->die
->die_parent
->die_perennial_p
))
9596 /* Everything else in the pubname table is included. */
9600 /* The pubtypes table shouldn't include types that have been
9602 return (p
->die
->die_offset
!= 0
9603 || !flag_eliminate_unused_debug_types
);
9606 /* Return the size of the .debug_pubnames or .debug_pubtypes table
9607 generated for the compilation unit. */
9609 static unsigned long
9610 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9615 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
9617 size
= DWARF_PUBNAMES_HEADER_SIZE
;
9618 FOR_EACH_VEC_ELT (*names
, i
, p
)
9619 if (include_pubname_in_output (names
, p
))
9620 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1 + space_for_flags
;
9622 size
+= DWARF_OFFSET_SIZE
;
9626 /* Return the size of the information in the .debug_aranges section. */
9628 static unsigned long
9629 size_of_aranges (void)
9633 size
= DWARF_ARANGES_HEADER_SIZE
;
9635 /* Count the address/length pair for this compilation unit. */
9636 if (text_section_used
)
9637 size
+= 2 * DWARF2_ADDR_SIZE
;
9638 if (cold_text_section_used
)
9639 size
+= 2 * DWARF2_ADDR_SIZE
;
9640 if (have_multiple_function_sections
)
9645 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
9647 if (DECL_IGNORED_P (fde
->decl
))
9649 if (!fde
->in_std_section
)
9650 size
+= 2 * DWARF2_ADDR_SIZE
;
9651 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
9652 size
+= 2 * DWARF2_ADDR_SIZE
;
9656 /* Count the two zero words used to terminated the address range table. */
9657 size
+= 2 * DWARF2_ADDR_SIZE
;
9661 /* Select the encoding of an attribute value. */
9663 static enum dwarf_form
9664 value_format (dw_attr_node
*a
)
9666 switch (AT_class (a
))
9668 case dw_val_class_addr
:
9669 /* Only very few attributes allow DW_FORM_addr. */
9674 case DW_AT_entry_pc
:
9675 case DW_AT_trampoline
:
9676 return (AT_index (a
) == NOT_INDEXED
9677 ? DW_FORM_addr
: dwarf_FORM (DW_FORM_addrx
));
9681 switch (DWARF2_ADDR_SIZE
)
9684 return DW_FORM_data1
;
9686 return DW_FORM_data2
;
9688 return DW_FORM_data4
;
9690 return DW_FORM_data8
;
9694 case dw_val_class_loc_list
:
9695 case dw_val_class_view_list
:
9696 if (dwarf_split_debug_info
9697 && dwarf_version
>= 5
9698 && AT_loc_list (a
)->num_assigned
)
9699 return DW_FORM_loclistx
;
9701 case dw_val_class_range_list
:
9702 /* For range lists in DWARF 5, use DW_FORM_rnglistx from .debug_info.dwo
9703 but in .debug_info use DW_FORM_sec_offset, which is shorter if we
9704 care about sizes of .debug* sections in shared libraries and
9705 executables and don't take into account relocations that affect just
9706 relocatable objects - for DW_FORM_rnglistx we'd have to emit offset
9707 table in the .debug_rnglists section. */
9708 if (dwarf_split_debug_info
9709 && dwarf_version
>= 5
9710 && AT_class (a
) == dw_val_class_range_list
9712 && a
->dw_attr_val
.val_entry
!= RELOCATED_OFFSET
)
9713 return DW_FORM_rnglistx
;
9714 if (dwarf_version
>= 4)
9715 return DW_FORM_sec_offset
;
9717 case dw_val_class_vms_delta
:
9718 case dw_val_class_offset
:
9719 switch (DWARF_OFFSET_SIZE
)
9722 return DW_FORM_data4
;
9724 return DW_FORM_data8
;
9728 case dw_val_class_loc
:
9729 if (dwarf_version
>= 4)
9730 return DW_FORM_exprloc
;
9731 switch (constant_size (size_of_locs (AT_loc (a
))))
9734 return DW_FORM_block1
;
9736 return DW_FORM_block2
;
9738 return DW_FORM_block4
;
9742 case dw_val_class_const
:
9743 return DW_FORM_sdata
;
9744 case dw_val_class_unsigned_const
:
9745 switch (constant_size (AT_unsigned (a
)))
9748 return DW_FORM_data1
;
9750 return DW_FORM_data2
;
9752 /* In DWARF3 DW_AT_data_member_location with
9753 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
9754 constant, so we need to use DW_FORM_udata if we need
9755 a large constant. */
9756 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9757 return DW_FORM_udata
;
9758 return DW_FORM_data4
;
9760 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9761 return DW_FORM_udata
;
9762 return DW_FORM_data8
;
9766 case dw_val_class_const_implicit
:
9767 case dw_val_class_unsigned_const_implicit
:
9768 case dw_val_class_file_implicit
:
9769 return DW_FORM_implicit_const
;
9770 case dw_val_class_const_double
:
9771 switch (HOST_BITS_PER_WIDE_INT
)
9774 return DW_FORM_data2
;
9776 return DW_FORM_data4
;
9778 return DW_FORM_data8
;
9780 if (dwarf_version
>= 5)
9781 return DW_FORM_data16
;
9784 return DW_FORM_block1
;
9786 case dw_val_class_wide_int
:
9787 switch (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
)
9790 return DW_FORM_data1
;
9792 return DW_FORM_data2
;
9794 return DW_FORM_data4
;
9796 return DW_FORM_data8
;
9798 if (dwarf_version
>= 5)
9799 return DW_FORM_data16
;
9802 return DW_FORM_block1
;
9804 case dw_val_class_symview
:
9805 /* ??? We might use uleb128, but then we'd have to compute
9806 .debug_info offsets in the assembler. */
9807 if (symview_upper_bound
<= 0xff)
9808 return DW_FORM_data1
;
9809 else if (symview_upper_bound
<= 0xffff)
9810 return DW_FORM_data2
;
9811 else if (symview_upper_bound
<= 0xffffffff)
9812 return DW_FORM_data4
;
9814 return DW_FORM_data8
;
9815 case dw_val_class_vec
:
9816 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
9817 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
9820 return DW_FORM_block1
;
9822 return DW_FORM_block2
;
9824 return DW_FORM_block4
;
9828 case dw_val_class_flag
:
9829 if (dwarf_version
>= 4)
9831 /* Currently all add_AT_flag calls pass in 1 as last argument,
9832 so DW_FORM_flag_present can be used. If that ever changes,
9833 we'll need to use DW_FORM_flag and have some optimization
9834 in build_abbrev_table that will change those to
9835 DW_FORM_flag_present if it is set to 1 in all DIEs using
9836 the same abbrev entry. */
9837 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9838 return DW_FORM_flag_present
;
9840 return DW_FORM_flag
;
9841 case dw_val_class_die_ref
:
9842 if (AT_ref_external (a
))
9843 return use_debug_types
? DW_FORM_ref_sig8
: DW_FORM_ref_addr
;
9846 case dw_val_class_fde_ref
:
9847 return DW_FORM_data
;
9848 case dw_val_class_lbl_id
:
9849 return (AT_index (a
) == NOT_INDEXED
9850 ? DW_FORM_addr
: dwarf_FORM (DW_FORM_addrx
));
9851 case dw_val_class_lineptr
:
9852 case dw_val_class_macptr
:
9853 case dw_val_class_loclistsptr
:
9854 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
9855 case dw_val_class_str
:
9856 return AT_string_form (a
);
9857 case dw_val_class_file
:
9858 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
9861 return DW_FORM_data1
;
9863 return DW_FORM_data2
;
9865 return DW_FORM_data4
;
9870 case dw_val_class_data8
:
9871 return DW_FORM_data8
;
9873 case dw_val_class_high_pc
:
9874 switch (DWARF2_ADDR_SIZE
)
9877 return DW_FORM_data1
;
9879 return DW_FORM_data2
;
9881 return DW_FORM_data4
;
9883 return DW_FORM_data8
;
9888 case dw_val_class_discr_value
:
9889 return (a
->dw_attr_val
.v
.val_discr_value
.pos
9892 case dw_val_class_discr_list
:
9893 switch (constant_size (size_of_discr_list (AT_discr_list (a
))))
9896 return DW_FORM_block1
;
9898 return DW_FORM_block2
;
9900 return DW_FORM_block4
;
9910 /* Output the encoding of an attribute value. */
9913 output_value_format (dw_attr_node
*a
)
9915 enum dwarf_form form
= value_format (a
);
9917 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
9920 /* Given a die and id, produce the appropriate abbreviations. */
9923 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
9926 dw_attr_node
*a_attr
;
9928 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
9929 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
9930 dwarf_tag_name (abbrev
->die_tag
));
9932 if (abbrev
->die_child
!= NULL
)
9933 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
9935 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
9937 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
9939 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
9940 dwarf_attr_name (a_attr
->dw_attr
));
9941 output_value_format (a_attr
);
9942 if (value_format (a_attr
) == DW_FORM_implicit_const
)
9944 if (AT_class (a_attr
) == dw_val_class_file_implicit
)
9946 int f
= maybe_emit_file (a_attr
->dw_attr_val
.v
.val_file
);
9947 const char *filename
= a_attr
->dw_attr_val
.v
.val_file
->filename
;
9948 dw2_asm_output_data_sleb128 (f
, "(%s)", filename
);
9951 dw2_asm_output_data_sleb128 (a_attr
->dw_attr_val
.v
.val_int
, NULL
);
9955 dw2_asm_output_data (1, 0, NULL
);
9956 dw2_asm_output_data (1, 0, NULL
);
9960 /* Output the .debug_abbrev section which defines the DIE abbreviation
9964 output_abbrev_section (void)
9966 unsigned int abbrev_id
;
9969 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
9971 output_die_abbrevs (abbrev_id
, abbrev
);
9973 /* Terminate the table. */
9974 dw2_asm_output_data (1, 0, NULL
);
9977 /* Return a new location list, given the begin and end range, and the
9980 static inline dw_loc_list_ref
9981 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, var_loc_view vbegin
,
9982 const char *end
, var_loc_view vend
,
9983 const char *section
)
9985 dw_loc_list_ref retlist
= ggc_cleared_alloc
<dw_loc_list_node
> ();
9987 retlist
->begin
= begin
;
9988 retlist
->begin_entry
= NULL
;
9990 retlist
->expr
= expr
;
9991 retlist
->section
= section
;
9992 retlist
->vbegin
= vbegin
;
9993 retlist
->vend
= vend
;
9998 /* Return true iff there's any nonzero view number in the loc list.
10000 ??? When views are not enabled, we'll often extend a single range
10001 to the entire function, so that we emit a single location
10002 expression rather than a location list. With views, even with a
10003 single range, we'll output a list if start or end have a nonzero
10004 view. If we change this, we may want to stop splitting a single
10005 range in dw_loc_list just because of a nonzero view, even if it
10006 straddles across hot/cold partitions. */
10009 loc_list_has_views (dw_loc_list_ref list
)
10011 if (!debug_variable_location_views
)
10014 for (dw_loc_list_ref loc
= list
;
10015 loc
!= NULL
; loc
= loc
->dw_loc_next
)
10016 if (!ZERO_VIEW_P (loc
->vbegin
) || !ZERO_VIEW_P (loc
->vend
))
10022 /* Generate a new internal symbol for this location list node, if it
10023 hasn't got one yet. */
10026 gen_llsym (dw_loc_list_ref list
)
10028 gcc_assert (!list
->ll_symbol
);
10029 list
->ll_symbol
= gen_internal_sym ("LLST");
10031 if (!loc_list_has_views (list
))
10034 if (dwarf2out_locviews_in_attribute ())
10036 /* Use the same label_num for the view list. */
10038 list
->vl_symbol
= gen_internal_sym ("LVUS");
10041 list
->vl_symbol
= list
->ll_symbol
;
10044 /* Generate a symbol for the list, but only if we really want to emit
10048 maybe_gen_llsym (dw_loc_list_ref list
)
10050 if (!list
|| (!list
->dw_loc_next
&& !loc_list_has_views (list
)))
10056 /* Determine whether or not to skip loc_list entry CURR. If SIZEP is
10057 NULL, don't consider size of the location expression. If we're not
10058 to skip it, and SIZEP is non-null, store the size of CURR->expr's
10059 representation in *SIZEP. */
10062 skip_loc_list_entry (dw_loc_list_ref curr
, unsigned long *sizep
= NULL
)
10064 /* Don't output an entry that starts and ends at the same address. */
10065 if (strcmp (curr
->begin
, curr
->end
) == 0
10066 && curr
->vbegin
== curr
->vend
&& !curr
->force
)
10072 unsigned long size
= size_of_locs (curr
->expr
);
10074 /* If the expression is too large, drop it on the floor. We could
10075 perhaps put it into DW_TAG_dwarf_procedure and refer to that
10076 in the expression, but >= 64KB expressions for a single value
10077 in a single range are unlikely very useful. */
10078 if (dwarf_version
< 5 && size
> 0xffff)
10086 /* Output a view pair loclist entry for CURR, if it requires one. */
10089 dwarf2out_maybe_output_loclist_view_pair (dw_loc_list_ref curr
)
10091 if (!dwarf2out_locviews_in_loclist ())
10094 if (ZERO_VIEW_P (curr
->vbegin
) && ZERO_VIEW_P (curr
->vend
))
10097 #ifdef DW_LLE_view_pair
10098 dw2_asm_output_data (1, DW_LLE_view_pair
, "DW_LLE_view_pair");
10100 if (dwarf2out_as_locview_support
)
10102 if (ZERO_VIEW_P (curr
->vbegin
))
10103 dw2_asm_output_data_uleb128 (0, "Location view begin");
10106 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10107 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vbegin
);
10108 dw2_asm_output_symname_uleb128 (label
, "Location view begin");
10111 if (ZERO_VIEW_P (curr
->vend
))
10112 dw2_asm_output_data_uleb128 (0, "Location view end");
10115 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10116 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vend
);
10117 dw2_asm_output_symname_uleb128 (label
, "Location view end");
10122 dw2_asm_output_data_uleb128 (curr
->vbegin
, "Location view begin");
10123 dw2_asm_output_data_uleb128 (curr
->vend
, "Location view end");
10125 #endif /* DW_LLE_view_pair */
10130 /* Output the location list given to us. */
10133 output_loc_list (dw_loc_list_ref list_head
)
10135 int vcount
= 0, lcount
= 0;
10137 if (list_head
->emitted
)
10139 list_head
->emitted
= true;
10141 if (list_head
->vl_symbol
&& dwarf2out_locviews_in_attribute ())
10143 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->vl_symbol
);
10145 for (dw_loc_list_ref curr
= list_head
; curr
!= NULL
;
10146 curr
= curr
->dw_loc_next
)
10148 unsigned long size
;
10150 if (skip_loc_list_entry (curr
, &size
))
10155 /* ?? dwarf_split_debug_info? */
10156 if (dwarf2out_as_locview_support
)
10158 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10160 if (!ZERO_VIEW_P (curr
->vbegin
))
10162 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vbegin
);
10163 dw2_asm_output_symname_uleb128 (label
,
10164 "View list begin (%s)",
10165 list_head
->vl_symbol
);
10168 dw2_asm_output_data_uleb128 (0,
10169 "View list begin (%s)",
10170 list_head
->vl_symbol
);
10172 if (!ZERO_VIEW_P (curr
->vend
))
10174 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vend
);
10175 dw2_asm_output_symname_uleb128 (label
,
10176 "View list end (%s)",
10177 list_head
->vl_symbol
);
10180 dw2_asm_output_data_uleb128 (0,
10181 "View list end (%s)",
10182 list_head
->vl_symbol
);
10186 dw2_asm_output_data_uleb128 (curr
->vbegin
,
10187 "View list begin (%s)",
10188 list_head
->vl_symbol
);
10189 dw2_asm_output_data_uleb128 (curr
->vend
,
10190 "View list end (%s)",
10191 list_head
->vl_symbol
);
10196 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
10198 const char *last_section
= NULL
;
10199 const char *base_label
= NULL
;
10201 /* Walk the location list, and output each range + expression. */
10202 for (dw_loc_list_ref curr
= list_head
; curr
!= NULL
;
10203 curr
= curr
->dw_loc_next
)
10205 unsigned long size
;
10207 /* Skip this entry? If we skip it here, we must skip it in the
10208 view list above as well. */
10209 if (skip_loc_list_entry (curr
, &size
))
10214 if (dwarf_version
>= 5)
10216 if (dwarf_split_debug_info
)
10218 dwarf2out_maybe_output_loclist_view_pair (curr
);
10219 /* For -gsplit-dwarf, emit DW_LLE_starx_length, which has
10220 uleb128 index into .debug_addr and uleb128 length. */
10221 dw2_asm_output_data (1, DW_LLE_startx_length
,
10222 "DW_LLE_startx_length (%s)",
10223 list_head
->ll_symbol
);
10224 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10225 "Location list range start index "
10226 "(%s)", curr
->begin
);
10227 /* FIXME: This will ICE ifndef HAVE_AS_LEB128.
10228 For that case we probably need to emit DW_LLE_startx_endx,
10229 but we'd need 2 .debug_addr entries rather than just one. */
10230 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
10231 "Location list length (%s)",
10232 list_head
->ll_symbol
);
10234 else if (!have_multiple_function_sections
&& HAVE_AS_LEB128
)
10236 dwarf2out_maybe_output_loclist_view_pair (curr
);
10237 /* If all code is in .text section, the base address is
10238 already provided by the CU attributes. Use
10239 DW_LLE_offset_pair where both addresses are uleb128 encoded
10240 offsets against that base. */
10241 dw2_asm_output_data (1, DW_LLE_offset_pair
,
10242 "DW_LLE_offset_pair (%s)",
10243 list_head
->ll_symbol
);
10244 dw2_asm_output_delta_uleb128 (curr
->begin
, curr
->section
,
10245 "Location list begin address (%s)",
10246 list_head
->ll_symbol
);
10247 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->section
,
10248 "Location list end address (%s)",
10249 list_head
->ll_symbol
);
10251 else if (HAVE_AS_LEB128
)
10253 /* Otherwise, find out how many consecutive entries could share
10254 the same base entry. If just one, emit DW_LLE_start_length,
10255 otherwise emit DW_LLE_base_address for the base address
10256 followed by a series of DW_LLE_offset_pair. */
10257 if (last_section
== NULL
|| curr
->section
!= last_section
)
10259 dw_loc_list_ref curr2
;
10260 for (curr2
= curr
->dw_loc_next
; curr2
!= NULL
;
10261 curr2
= curr2
->dw_loc_next
)
10263 if (strcmp (curr2
->begin
, curr2
->end
) == 0
10268 if (curr2
== NULL
|| curr
->section
!= curr2
->section
)
10269 last_section
= NULL
;
10272 last_section
= curr
->section
;
10273 base_label
= curr
->begin
;
10274 dw2_asm_output_data (1, DW_LLE_base_address
,
10275 "DW_LLE_base_address (%s)",
10276 list_head
->ll_symbol
);
10277 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, base_label
,
10278 "Base address (%s)",
10279 list_head
->ll_symbol
);
10282 /* Only one entry with the same base address. Use
10283 DW_LLE_start_length with absolute address and uleb128
10285 if (last_section
== NULL
)
10287 dwarf2out_maybe_output_loclist_view_pair (curr
);
10288 dw2_asm_output_data (1, DW_LLE_start_length
,
10289 "DW_LLE_start_length (%s)",
10290 list_head
->ll_symbol
);
10291 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10292 "Location list begin address (%s)",
10293 list_head
->ll_symbol
);
10294 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
10295 "Location list length "
10296 "(%s)", list_head
->ll_symbol
);
10298 /* Otherwise emit DW_LLE_offset_pair, relative to above emitted
10299 DW_LLE_base_address. */
10302 dwarf2out_maybe_output_loclist_view_pair (curr
);
10303 dw2_asm_output_data (1, DW_LLE_offset_pair
,
10304 "DW_LLE_offset_pair (%s)",
10305 list_head
->ll_symbol
);
10306 dw2_asm_output_delta_uleb128 (curr
->begin
, base_label
,
10307 "Location list begin address "
10308 "(%s)", list_head
->ll_symbol
);
10309 dw2_asm_output_delta_uleb128 (curr
->end
, base_label
,
10310 "Location list end address "
10311 "(%s)", list_head
->ll_symbol
);
10314 /* The assembler does not support .uleb128 directive. Emit
10315 DW_LLE_start_end with a pair of absolute addresses. */
10318 dwarf2out_maybe_output_loclist_view_pair (curr
);
10319 dw2_asm_output_data (1, DW_LLE_start_end
,
10320 "DW_LLE_start_end (%s)",
10321 list_head
->ll_symbol
);
10322 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10323 "Location list begin address (%s)",
10324 list_head
->ll_symbol
);
10325 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10326 "Location list end address (%s)",
10327 list_head
->ll_symbol
);
10330 else if (dwarf_split_debug_info
)
10332 /* For -gsplit-dwarf -gdwarf-{2,3,4} emit index into .debug_addr
10333 and 4 byte length. */
10334 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
10335 "Location list start/length entry (%s)",
10336 list_head
->ll_symbol
);
10337 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10338 "Location list range start index (%s)",
10340 /* The length field is 4 bytes. If we ever need to support
10341 an 8-byte length, we can add a new DW_LLE code or fall back
10342 to DW_LLE_GNU_start_end_entry. */
10343 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
10344 "Location list range length (%s)",
10345 list_head
->ll_symbol
);
10347 else if (!have_multiple_function_sections
)
10349 /* Pair of relative addresses against start of text section. */
10350 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
10351 "Location list begin address (%s)",
10352 list_head
->ll_symbol
);
10353 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
10354 "Location list end address (%s)",
10355 list_head
->ll_symbol
);
10359 /* Pair of absolute addresses. */
10360 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10361 "Location list begin address (%s)",
10362 list_head
->ll_symbol
);
10363 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10364 "Location list end address (%s)",
10365 list_head
->ll_symbol
);
10368 /* Output the block length for this list of location operations. */
10369 if (dwarf_version
>= 5)
10370 dw2_asm_output_data_uleb128 (size
, "Location expression size");
10373 gcc_assert (size
<= 0xffff);
10374 dw2_asm_output_data (2, size
, "Location expression size");
10377 output_loc_sequence (curr
->expr
, -1);
10380 /* And finally list termination. */
10381 if (dwarf_version
>= 5)
10382 dw2_asm_output_data (1, DW_LLE_end_of_list
,
10383 "DW_LLE_end_of_list (%s)", list_head
->ll_symbol
);
10384 else if (dwarf_split_debug_info
)
10385 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
10386 "Location list terminator (%s)",
10387 list_head
->ll_symbol
);
10390 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10391 "Location list terminator begin (%s)",
10392 list_head
->ll_symbol
);
10393 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10394 "Location list terminator end (%s)",
10395 list_head
->ll_symbol
);
10398 gcc_assert (!list_head
->vl_symbol
10399 || vcount
== lcount
* (dwarf2out_locviews_in_attribute () ? 1 : 0));
10402 /* Output a range_list offset into the .debug_ranges or .debug_rnglists
10403 section. Emit a relocated reference if val_entry is NULL, otherwise,
10404 emit an indirect reference. */
10407 output_range_list_offset (dw_attr_node
*a
)
10409 const char *name
= dwarf_attr_name (a
->dw_attr
);
10411 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
10413 if (dwarf_version
>= 5)
10415 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
10416 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, r
->label
,
10417 debug_ranges_section
, "%s", name
);
10421 char *p
= strchr (ranges_section_label
, '\0');
10422 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
10423 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
);
10424 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
10425 debug_ranges_section
, "%s", name
);
10429 else if (dwarf_version
>= 5)
10431 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
10432 gcc_assert (rnglist_idx
);
10433 dw2_asm_output_data_uleb128 (r
->idx
, "%s", name
);
10436 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
10437 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
,
10438 "%s (offset from %s)", name
, ranges_section_label
);
10441 /* Output the offset into the debug_loc section. */
10444 output_loc_list_offset (dw_attr_node
*a
)
10446 char *sym
= AT_loc_list (a
)->ll_symbol
;
10449 if (!dwarf_split_debug_info
)
10450 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
10451 "%s", dwarf_attr_name (a
->dw_attr
));
10452 else if (dwarf_version
>= 5)
10454 gcc_assert (AT_loc_list (a
)->num_assigned
);
10455 dw2_asm_output_data_uleb128 (AT_loc_list (a
)->hash
, "%s (%s)",
10456 dwarf_attr_name (a
->dw_attr
),
10460 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
10461 "%s", dwarf_attr_name (a
->dw_attr
));
10464 /* Output the offset into the debug_loc section. */
10467 output_view_list_offset (dw_attr_node
*a
)
10469 char *sym
= (*AT_loc_list_ptr (a
))->vl_symbol
;
10472 if (dwarf_split_debug_info
)
10473 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
10474 "%s", dwarf_attr_name (a
->dw_attr
));
10476 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
10477 "%s", dwarf_attr_name (a
->dw_attr
));
10480 /* Output an attribute's index or value appropriately. */
10483 output_attr_index_or_value (dw_attr_node
*a
)
10485 const char *name
= dwarf_attr_name (a
->dw_attr
);
10487 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
10489 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
10492 switch (AT_class (a
))
10494 case dw_val_class_addr
:
10495 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
10497 case dw_val_class_high_pc
:
10498 case dw_val_class_lbl_id
:
10499 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
10502 gcc_unreachable ();
10506 /* Output a type signature. */
10509 output_signature (const char *sig
, const char *name
)
10513 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
10514 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
10517 /* Output a discriminant value. */
10520 output_discr_value (dw_discr_value
*discr_value
, const char *name
)
10522 if (discr_value
->pos
)
10523 dw2_asm_output_data_uleb128 (discr_value
->v
.uval
, "%s", name
);
10525 dw2_asm_output_data_sleb128 (discr_value
->v
.sval
, "%s", name
);
10528 /* Output the DIE and its attributes. Called recursively to generate
10529 the definitions of each child DIE. */
10532 output_die (dw_die_ref die
)
10536 unsigned long size
;
10539 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
10540 (unsigned long)die
->die_offset
,
10541 dwarf_tag_name (die
->die_tag
));
10543 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
10545 const char *name
= dwarf_attr_name (a
->dw_attr
);
10547 switch (AT_class (a
))
10549 case dw_val_class_addr
:
10550 output_attr_index_or_value (a
);
10553 case dw_val_class_offset
:
10554 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
10558 case dw_val_class_range_list
:
10559 output_range_list_offset (a
);
10562 case dw_val_class_loc
:
10563 size
= size_of_locs (AT_loc (a
));
10565 /* Output the block length for this list of location operations. */
10566 if (dwarf_version
>= 4)
10567 dw2_asm_output_data_uleb128 (size
, "%s", name
);
10569 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
10571 output_loc_sequence (AT_loc (a
), -1);
10574 case dw_val_class_const
:
10575 /* ??? It would be slightly more efficient to use a scheme like is
10576 used for unsigned constants below, but gdb 4.x does not sign
10577 extend. Gdb 5.x does sign extend. */
10578 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
10581 case dw_val_class_unsigned_const
:
10583 int csize
= constant_size (AT_unsigned (a
));
10584 if (dwarf_version
== 3
10585 && a
->dw_attr
== DW_AT_data_member_location
10587 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
10589 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
10593 case dw_val_class_symview
:
10596 if (symview_upper_bound
<= 0xff)
10598 else if (symview_upper_bound
<= 0xffff)
10600 else if (symview_upper_bound
<= 0xffffffff)
10604 dw2_asm_output_addr (vsize
, a
->dw_attr_val
.v
.val_symbolic_view
,
10609 case dw_val_class_const_implicit
:
10610 if (flag_debug_asm
)
10611 fprintf (asm_out_file
, "\t\t\t%s %s ("
10612 HOST_WIDE_INT_PRINT_DEC
")\n",
10613 ASM_COMMENT_START
, name
, AT_int (a
));
10616 case dw_val_class_unsigned_const_implicit
:
10617 if (flag_debug_asm
)
10618 fprintf (asm_out_file
, "\t\t\t%s %s ("
10619 HOST_WIDE_INT_PRINT_HEX
")\n",
10620 ASM_COMMENT_START
, name
, AT_unsigned (a
));
10623 case dw_val_class_const_double
:
10625 unsigned HOST_WIDE_INT first
, second
;
10627 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
10628 dw2_asm_output_data (1,
10629 HOST_BITS_PER_DOUBLE_INT
10630 / HOST_BITS_PER_CHAR
,
10633 if (WORDS_BIG_ENDIAN
)
10635 first
= a
->dw_attr_val
.v
.val_double
.high
;
10636 second
= a
->dw_attr_val
.v
.val_double
.low
;
10640 first
= a
->dw_attr_val
.v
.val_double
.low
;
10641 second
= a
->dw_attr_val
.v
.val_double
.high
;
10644 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10645 first
, "%s", name
);
10646 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10651 case dw_val_class_wide_int
:
10654 int len
= get_full_len (*a
->dw_attr_val
.v
.val_wide
);
10655 int l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
10656 if (len
* HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
10657 dw2_asm_output_data (1, get_full_len (*a
->dw_attr_val
.v
.val_wide
)
10660 if (WORDS_BIG_ENDIAN
)
10661 for (i
= len
- 1; i
>= 0; --i
)
10663 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10668 for (i
= 0; i
< len
; ++i
)
10670 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10677 case dw_val_class_vec
:
10679 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
10680 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
10684 dw2_asm_output_data (constant_size (len
* elt_size
),
10685 len
* elt_size
, "%s", name
);
10686 if (elt_size
> sizeof (HOST_WIDE_INT
))
10691 for (i
= 0, p
= (unsigned char *) a
->dw_attr_val
.v
.val_vec
.array
;
10693 i
++, p
+= elt_size
)
10694 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
10695 "fp or vector constant word %u", i
);
10699 case dw_val_class_flag
:
10700 if (dwarf_version
>= 4)
10702 /* Currently all add_AT_flag calls pass in 1 as last argument,
10703 so DW_FORM_flag_present can be used. If that ever changes,
10704 we'll need to use DW_FORM_flag and have some optimization
10705 in build_abbrev_table that will change those to
10706 DW_FORM_flag_present if it is set to 1 in all DIEs using
10707 the same abbrev entry. */
10708 gcc_assert (AT_flag (a
) == 1);
10709 if (flag_debug_asm
)
10710 fprintf (asm_out_file
, "\t\t\t%s %s\n",
10711 ASM_COMMENT_START
, name
);
10714 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
10717 case dw_val_class_loc_list
:
10718 output_loc_list_offset (a
);
10721 case dw_val_class_view_list
:
10722 output_view_list_offset (a
);
10725 case dw_val_class_die_ref
:
10726 if (AT_ref_external (a
))
10728 if (AT_ref (a
)->comdat_type_p
)
10730 comdat_type_node
*type_node
10731 = AT_ref (a
)->die_id
.die_type_node
;
10733 gcc_assert (type_node
);
10734 output_signature (type_node
->signature
, name
);
10738 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
10742 /* In DWARF2, DW_FORM_ref_addr is sized by target address
10743 length, whereas in DWARF3 it's always sized as an
10745 if (dwarf_version
== 2)
10746 size
= DWARF2_ADDR_SIZE
;
10748 size
= DWARF_OFFSET_SIZE
;
10749 /* ??? We cannot unconditionally output die_offset if
10750 non-zero - others might create references to those
10752 And we do not clear its DIE offset after outputting it
10753 (and the label refers to the actual DIEs, not the
10754 DWARF CU unit header which is when using label + offset
10755 would be the correct thing to do).
10756 ??? This is the reason for the with_offset flag. */
10757 if (AT_ref (a
)->with_offset
)
10758 dw2_asm_output_offset (size
, sym
, AT_ref (a
)->die_offset
,
10759 debug_info_section
, "%s", name
);
10761 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
10767 gcc_assert (AT_ref (a
)->die_offset
);
10768 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
10773 case dw_val_class_fde_ref
:
10775 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
10777 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
10778 a
->dw_attr_val
.v
.val_fde_index
* 2);
10779 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
10784 case dw_val_class_vms_delta
:
10785 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
10786 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
10787 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
10790 dw2_asm_output_delta (DWARF_OFFSET_SIZE
,
10791 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
10796 case dw_val_class_lbl_id
:
10797 output_attr_index_or_value (a
);
10800 case dw_val_class_lineptr
:
10801 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10802 debug_line_section
, "%s", name
);
10805 case dw_val_class_macptr
:
10806 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10807 debug_macinfo_section
, "%s", name
);
10810 case dw_val_class_loclistsptr
:
10811 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10812 debug_loc_section
, "%s", name
);
10815 case dw_val_class_str
:
10816 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
10817 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
10818 a
->dw_attr_val
.v
.val_str
->label
,
10820 "%s: \"%s\"", name
, AT_string (a
));
10821 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_line_strp
)
10822 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
10823 a
->dw_attr_val
.v
.val_str
->label
,
10824 debug_line_str_section
,
10825 "%s: \"%s\"", name
, AT_string (a
));
10826 else if (a
->dw_attr_val
.v
.val_str
->form
== dwarf_FORM (DW_FORM_strx
))
10827 dw2_asm_output_data_uleb128 (AT_index (a
),
10828 "%s: \"%s\"", name
, AT_string (a
));
10830 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
10833 case dw_val_class_file
:
10835 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
10837 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
10838 a
->dw_attr_val
.v
.val_file
->filename
);
10842 case dw_val_class_file_implicit
:
10843 if (flag_debug_asm
)
10844 fprintf (asm_out_file
, "\t\t\t%s %s (%d, %s)\n",
10845 ASM_COMMENT_START
, name
,
10846 maybe_emit_file (a
->dw_attr_val
.v
.val_file
),
10847 a
->dw_attr_val
.v
.val_file
->filename
);
10850 case dw_val_class_data8
:
10854 for (i
= 0; i
< 8; i
++)
10855 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
10856 i
== 0 ? "%s" : NULL
, name
);
10860 case dw_val_class_high_pc
:
10861 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
10862 get_AT_low_pc (die
), "DW_AT_high_pc");
10865 case dw_val_class_discr_value
:
10866 output_discr_value (&a
->dw_attr_val
.v
.val_discr_value
, name
);
10869 case dw_val_class_discr_list
:
10871 dw_discr_list_ref list
= AT_discr_list (a
);
10872 const int size
= size_of_discr_list (list
);
10874 /* This is a block, so output its length first. */
10875 dw2_asm_output_data (constant_size (size
), size
,
10876 "%s: block size", name
);
10878 for (; list
!= NULL
; list
= list
->dw_discr_next
)
10880 /* One byte for the discriminant value descriptor, and then as
10881 many LEB128 numbers as required. */
10882 if (list
->dw_discr_range
)
10883 dw2_asm_output_data (1, DW_DSC_range
,
10884 "%s: DW_DSC_range", name
);
10886 dw2_asm_output_data (1, DW_DSC_label
,
10887 "%s: DW_DSC_label", name
);
10889 output_discr_value (&list
->dw_discr_lower_bound
, name
);
10890 if (list
->dw_discr_range
)
10891 output_discr_value (&list
->dw_discr_upper_bound
, name
);
10897 gcc_unreachable ();
10901 FOR_EACH_CHILD (die
, c
, output_die (c
));
10903 /* Add null byte to terminate sibling list. */
10904 if (die
->die_child
!= NULL
)
10905 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
10906 (unsigned long) die
->die_offset
);
10909 /* Output the dwarf version number. */
10912 output_dwarf_version ()
10914 /* ??? For now, if -gdwarf-6 is specified, we output version 5 with
10915 views in loclist. That will change eventually. */
10916 if (dwarf_version
== 6)
10922 "-gdwarf-6 is output as version 5 with incompatibilities");
10925 dw2_asm_output_data (2, 5, "DWARF version number");
10928 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
10931 /* Output the compilation unit that appears at the beginning of the
10932 .debug_info section, and precedes the DIE descriptions. */
10935 output_compilation_unit_header (enum dwarf_unit_type ut
)
10937 if (!XCOFF_DEBUGGING_INFO
)
10939 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10940 dw2_asm_output_data (4, 0xffffffff,
10941 "Initial length escape value indicating 64-bit DWARF extension");
10942 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
10943 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
10944 "Length of Compilation Unit Info");
10947 output_dwarf_version ();
10948 if (dwarf_version
>= 5)
10953 case DW_UT_compile
: name
= "DW_UT_compile"; break;
10954 case DW_UT_type
: name
= "DW_UT_type"; break;
10955 case DW_UT_split_compile
: name
= "DW_UT_split_compile"; break;
10956 case DW_UT_split_type
: name
= "DW_UT_split_type"; break;
10957 default: gcc_unreachable ();
10959 dw2_asm_output_data (1, ut
, "%s", name
);
10960 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
10962 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
10963 debug_abbrev_section
,
10964 "Offset Into Abbrev. Section");
10965 if (dwarf_version
< 5)
10966 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
10969 /* Output the compilation unit DIE and its children. */
10972 output_comp_unit (dw_die_ref die
, int output_if_empty
,
10973 const unsigned char *dwo_id
)
10975 const char *secname
, *oldsym
;
10978 /* Unless we are outputting main CU, we may throw away empty ones. */
10979 if (!output_if_empty
&& die
->die_child
== NULL
)
10982 /* Even if there are no children of this DIE, we must output the information
10983 about the compilation unit. Otherwise, on an empty translation unit, we
10984 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
10985 will then complain when examining the file. First mark all the DIEs in
10986 this CU so we know which get local refs. */
10989 external_ref_hash_type
*extern_map
= optimize_external_refs (die
);
10991 /* For now, optimize only the main CU, in order to optimize the rest
10992 we'd need to see all of them earlier. Leave the rest for post-linking
10994 if (die
== comp_unit_die ())
10995 abbrev_opt_start
= vec_safe_length (abbrev_die_table
);
10997 build_abbrev_table (die
, extern_map
);
10999 optimize_abbrev_table ();
11003 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11004 next_die_offset
= (dwo_id
11005 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11006 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
11007 calc_die_sizes (die
);
11009 oldsym
= die
->die_id
.die_symbol
;
11010 if (oldsym
&& die
->comdat_type_p
)
11012 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
11014 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
11016 die
->die_id
.die_symbol
= NULL
;
11017 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11021 switch_to_section (debug_info_section
);
11022 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
11023 info_section_emitted
= true;
11026 /* For LTO cross unit DIE refs we want a symbol on the start of the
11027 debuginfo section, not on the CU DIE. */
11028 if ((flag_generate_lto
|| flag_generate_offload
) && oldsym
)
11030 /* ??? No way to get visibility assembled without a decl. */
11031 tree decl
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
11032 get_identifier (oldsym
), char_type_node
);
11033 TREE_PUBLIC (decl
) = true;
11034 TREE_STATIC (decl
) = true;
11035 DECL_ARTIFICIAL (decl
) = true;
11036 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
11037 DECL_VISIBILITY_SPECIFIED (decl
) = true;
11038 targetm
.asm_out
.assemble_visibility (decl
, VISIBILITY_HIDDEN
);
11039 #ifdef ASM_WEAKEN_LABEL
11040 /* We prefer a .weak because that handles duplicates from duplicate
11041 archive members in a graceful way. */
11042 ASM_WEAKEN_LABEL (asm_out_file
, oldsym
);
11044 targetm
.asm_out
.globalize_label (asm_out_file
, oldsym
);
11046 ASM_OUTPUT_LABEL (asm_out_file
, oldsym
);
11049 /* Output debugging information. */
11050 output_compilation_unit_header (dwo_id
11051 ? DW_UT_split_compile
: DW_UT_compile
);
11052 if (dwarf_version
>= 5)
11054 if (dwo_id
!= NULL
)
11055 for (int i
= 0; i
< 8; i
++)
11056 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
11060 /* Leave the marks on the main CU, so we can check them in
11061 output_pubnames. */
11065 die
->die_id
.die_symbol
= oldsym
;
11069 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
11070 and .debug_pubtypes. This is configured per-target, but can be
11071 overridden by the -gpubnames or -gno-pubnames options. */
11074 want_pubnames (void)
11076 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
11078 if (debug_generate_pub_sections
!= -1)
11079 return debug_generate_pub_sections
;
11080 return targetm
.want_debug_pub_sections
;
11083 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
11086 add_AT_pubnames (dw_die_ref die
)
11088 if (want_pubnames ())
11089 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
11092 /* Add a string attribute value to a skeleton DIE. */
11095 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
11099 struct indirect_string_node
*node
;
11101 if (! skeleton_debug_str_hash
)
11102 skeleton_debug_str_hash
11103 = hash_table
<indirect_string_hasher
>::create_ggc (10);
11105 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
11106 find_string_form (node
);
11107 if (node
->form
== dwarf_FORM (DW_FORM_strx
))
11108 node
->form
= DW_FORM_strp
;
11110 attr
.dw_attr
= attr_kind
;
11111 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
11112 attr
.dw_attr_val
.val_entry
= NULL
;
11113 attr
.dw_attr_val
.v
.val_str
= node
;
11114 add_dwarf_attr (die
, &attr
);
11117 /* Helper function to generate top-level dies for skeleton debug_info and
11121 add_top_level_skeleton_die_attrs (dw_die_ref die
)
11123 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
11124 const char *comp_dir
= comp_dir_string ();
11126 add_skeleton_AT_string (die
, dwarf_AT (DW_AT_dwo_name
), dwo_file_name
);
11127 if (comp_dir
!= NULL
)
11128 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
11129 add_AT_pubnames (die
);
11130 add_AT_lineptr (die
, dwarf_AT (DW_AT_addr_base
), debug_addr_section_label
);
11133 /* Output skeleton debug sections that point to the dwo file. */
11136 output_skeleton_debug_sections (dw_die_ref comp_unit
,
11137 const unsigned char *dwo_id
)
11139 /* These attributes will be found in the full debug_info section. */
11140 remove_AT (comp_unit
, DW_AT_producer
);
11141 remove_AT (comp_unit
, DW_AT_language
);
11143 switch_to_section (debug_skeleton_info_section
);
11144 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
11146 /* Produce the skeleton compilation-unit header. This one differs enough from
11147 a normal CU header that it's better not to call output_compilation_unit
11149 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11150 dw2_asm_output_data (4, 0xffffffff,
11151 "Initial length escape value indicating 64-bit "
11152 "DWARF extension");
11154 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
11155 DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11156 - DWARF_INITIAL_LENGTH_SIZE
11157 + size_of_die (comp_unit
),
11158 "Length of Compilation Unit Info");
11159 output_dwarf_version ();
11160 if (dwarf_version
>= 5)
11162 dw2_asm_output_data (1, DW_UT_skeleton
, "DW_UT_skeleton");
11163 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11165 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_abbrev_section_label
,
11166 debug_skeleton_abbrev_section
,
11167 "Offset Into Abbrev. Section");
11168 if (dwarf_version
< 5)
11169 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11171 for (int i
= 0; i
< 8; i
++)
11172 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
11174 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
11175 output_die (comp_unit
);
11177 /* Build the skeleton debug_abbrev section. */
11178 switch_to_section (debug_skeleton_abbrev_section
);
11179 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
11181 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
11183 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
11186 /* Output a comdat type unit DIE and its children. */
11189 output_comdat_type_unit (comdat_type_node
*node
)
11191 const char *secname
;
11194 #if defined (OBJECT_FORMAT_ELF)
11198 /* First mark all the DIEs in this CU so we know which get local refs. */
11199 mark_dies (node
->root_die
);
11201 external_ref_hash_type
*extern_map
= optimize_external_refs (node
->root_die
);
11203 build_abbrev_table (node
->root_die
, extern_map
);
11208 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11209 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
11210 calc_die_sizes (node
->root_die
);
11212 #if defined (OBJECT_FORMAT_ELF)
11213 if (dwarf_version
>= 5)
11215 if (!dwarf_split_debug_info
)
11216 secname
= ".debug_info";
11218 secname
= ".debug_info.dwo";
11220 else if (!dwarf_split_debug_info
)
11221 secname
= ".debug_types";
11223 secname
= ".debug_types.dwo";
11225 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11226 sprintf (tmp
, dwarf_version
>= 5 ? "wi." : "wt.");
11227 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11228 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11229 comdat_key
= get_identifier (tmp
);
11230 targetm
.asm_out
.named_section (secname
,
11231 SECTION_DEBUG
| SECTION_LINKONCE
,
11234 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11235 sprintf (tmp
, (dwarf_version
>= 5
11236 ? ".gnu.linkonce.wi." : ".gnu.linkonce.wt."));
11237 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11238 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11240 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11243 /* Output debugging information. */
11244 output_compilation_unit_header (dwarf_split_debug_info
11245 ? DW_UT_split_type
: DW_UT_type
);
11246 output_signature (node
->signature
, "Type Signature");
11247 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
11248 "Offset to Type DIE");
11249 output_die (node
->root_die
);
11251 unmark_dies (node
->root_die
);
11254 /* Return the DWARF2/3 pubname associated with a decl. */
11256 static const char *
11257 dwarf2_name (tree decl
, int scope
)
11259 if (DECL_NAMELESS (decl
))
11261 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
11264 /* Add a new entry to .debug_pubnames if appropriate. */
11267 add_pubname_string (const char *str
, dw_die_ref die
)
11272 e
.name
= xstrdup (str
);
11273 vec_safe_push (pubname_table
, e
);
11277 add_pubname (tree decl
, dw_die_ref die
)
11279 if (!want_pubnames ())
11282 /* Don't add items to the table when we expect that the consumer will have
11283 just read the enclosing die. For example, if the consumer is looking at a
11284 class_member, it will either be inside the class already, or will have just
11285 looked up the class to find the member. Either way, searching the class is
11286 faster than searching the index. */
11287 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
11288 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
11290 const char *name
= dwarf2_name (decl
, 1);
11293 add_pubname_string (name
, die
);
11297 /* Add an enumerator to the pubnames section. */
11300 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
11304 gcc_assert (scope_name
);
11305 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
11307 vec_safe_push (pubname_table
, e
);
11310 /* Add a new entry to .debug_pubtypes if appropriate. */
11313 add_pubtype (tree decl
, dw_die_ref die
)
11317 if (!want_pubnames ())
11320 if ((TREE_PUBLIC (decl
)
11321 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
11322 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
11325 const char *scope_name
= "";
11326 const char *sep
= is_cxx () ? "::" : ".";
11329 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
11330 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
11332 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
11333 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
11334 scope_name
= concat (scope_name
, sep
, NULL
);
11340 name
= type_tag (decl
);
11342 name
= lang_hooks
.dwarf_name (decl
, 1);
11344 /* If we don't have a name for the type, there's no point in adding
11345 it to the table. */
11346 if (name
!= NULL
&& name
[0] != '\0')
11349 e
.name
= concat (scope_name
, name
, NULL
);
11350 vec_safe_push (pubtype_table
, e
);
11353 /* Although it might be more consistent to add the pubinfo for the
11354 enumerators as their dies are created, they should only be added if the
11355 enum type meets the criteria above. So rather than re-check the parent
11356 enum type whenever an enumerator die is created, just output them all
11357 here. This isn't protected by the name conditional because anonymous
11358 enums don't have names. */
11359 if (die
->die_tag
== DW_TAG_enumeration_type
)
11363 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
11368 /* Output a single entry in the pubnames table. */
11371 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
11373 dw_die_ref die
= entry
->die
;
11374 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
11376 dw2_asm_output_data (DWARF_OFFSET_SIZE
, die_offset
, "DIE offset");
11378 if (debug_generate_pub_sections
== 2)
11380 /* This logic follows gdb's method for determining the value of the flag
11382 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
11383 switch (die
->die_tag
)
11385 case DW_TAG_typedef
:
11386 case DW_TAG_base_type
:
11387 case DW_TAG_subrange_type
:
11388 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11389 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11391 case DW_TAG_enumerator
:
11392 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11393 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11395 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11397 case DW_TAG_subprogram
:
11398 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11399 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
11401 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11403 case DW_TAG_constant
:
11404 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11405 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11406 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11408 case DW_TAG_variable
:
11409 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11410 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11411 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11413 case DW_TAG_namespace
:
11414 case DW_TAG_imported_declaration
:
11415 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11417 case DW_TAG_class_type
:
11418 case DW_TAG_interface_type
:
11419 case DW_TAG_structure_type
:
11420 case DW_TAG_union_type
:
11421 case DW_TAG_enumeration_type
:
11422 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11424 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11427 /* An unusual tag. Leave the flag-byte empty. */
11430 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
11431 "GDB-index flags");
11434 dw2_asm_output_nstring (entry
->name
, -1, "external name");
11438 /* Output the public names table used to speed up access to externally
11439 visible names; or the public types table used to find type definitions. */
11442 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
11445 unsigned long pubnames_length
= size_of_pubnames (names
);
11446 pubname_entry
*pub
;
11448 if (!XCOFF_DEBUGGING_INFO
)
11450 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11451 dw2_asm_output_data (4, 0xffffffff,
11452 "Initial length escape value indicating 64-bit DWARF extension");
11453 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
11454 "Pub Info Length");
11457 /* Version number for pubnames/pubtypes is independent of dwarf version. */
11458 dw2_asm_output_data (2, 2, "DWARF pubnames/pubtypes version");
11460 if (dwarf_split_debug_info
)
11461 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
11462 debug_skeleton_info_section
,
11463 "Offset of Compilation Unit Info");
11465 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
11466 debug_info_section
,
11467 "Offset of Compilation Unit Info");
11468 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
11469 "Compilation Unit Length");
11471 FOR_EACH_VEC_ELT (*names
, i
, pub
)
11473 if (include_pubname_in_output (names
, pub
))
11475 dw_offset die_offset
= pub
->die
->die_offset
;
11477 /* We shouldn't see pubnames for DIEs outside of the main CU. */
11478 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
11479 gcc_assert (pub
->die
->die_mark
);
11481 /* If we're putting types in their own .debug_types sections,
11482 the .debug_pubtypes table will still point to the compile
11483 unit (not the type unit), so we want to use the offset of
11484 the skeleton DIE (if there is one). */
11485 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
11487 comdat_type_node
*type_node
= pub
->die
->die_id
.die_type_node
;
11489 if (type_node
!= NULL
)
11490 die_offset
= (type_node
->skeleton_die
!= NULL
11491 ? type_node
->skeleton_die
->die_offset
11492 : comp_unit_die ()->die_offset
);
11495 output_pubname (die_offset
, pub
);
11499 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
11502 /* Output public names and types tables if necessary. */
11505 output_pubtables (void)
11507 if (!want_pubnames () || !info_section_emitted
)
11510 switch_to_section (debug_pubnames_section
);
11511 output_pubnames (pubname_table
);
11512 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
11513 It shouldn't hurt to emit it always, since pure DWARF2 consumers
11514 simply won't look for the section. */
11515 switch_to_section (debug_pubtypes_section
);
11516 output_pubnames (pubtype_table
);
11520 /* Output the information that goes into the .debug_aranges table.
11521 Namely, define the beginning and ending address range of the
11522 text section generated for this compilation unit. */
11525 output_aranges (void)
11528 unsigned long aranges_length
= size_of_aranges ();
11530 if (!XCOFF_DEBUGGING_INFO
)
11532 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11533 dw2_asm_output_data (4, 0xffffffff,
11534 "Initial length escape value indicating 64-bit DWARF extension");
11535 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
11536 "Length of Address Ranges Info");
11539 /* Version number for aranges is still 2, even up to DWARF5. */
11540 dw2_asm_output_data (2, 2, "DWARF aranges version");
11541 if (dwarf_split_debug_info
)
11542 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
11543 debug_skeleton_info_section
,
11544 "Offset of Compilation Unit Info");
11546 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
11547 debug_info_section
,
11548 "Offset of Compilation Unit Info");
11549 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
11550 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
11552 /* We need to align to twice the pointer size here. */
11553 if (DWARF_ARANGES_PAD_SIZE
)
11555 /* Pad using a 2 byte words so that padding is correct for any
11557 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
11558 2 * DWARF2_ADDR_SIZE
);
11559 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
11560 dw2_asm_output_data (2, 0, NULL
);
11563 /* It is necessary not to output these entries if the sections were
11564 not used; if the sections were not used, the length will be 0 and
11565 the address may end up as 0 if the section is discarded by ld
11566 --gc-sections, leaving an invalid (0, 0) entry that can be
11567 confused with the terminator. */
11568 if (text_section_used
)
11570 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
11571 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
11572 text_section_label
, "Length");
11574 if (cold_text_section_used
)
11576 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
11578 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
11579 cold_text_section_label
, "Length");
11582 if (have_multiple_function_sections
)
11587 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
11589 if (DECL_IGNORED_P (fde
->decl
))
11591 if (!fde
->in_std_section
)
11593 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
11595 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
11596 fde
->dw_fde_begin
, "Length");
11598 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
11600 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
11602 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
11603 fde
->dw_fde_second_begin
, "Length");
11608 /* Output the terminator words. */
11609 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11610 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11613 /* Add a new entry to .debug_ranges. Return its index into
11614 ranges_table vector. */
11616 static unsigned int
11617 add_ranges_num (int num
, bool maybe_new_sec
)
11619 dw_ranges r
= { NULL
, num
, 0, maybe_new_sec
};
11620 vec_safe_push (ranges_table
, r
);
11621 return vec_safe_length (ranges_table
) - 1;
11624 /* Add a new entry to .debug_ranges corresponding to a block, or a
11625 range terminator if BLOCK is NULL. MAYBE_NEW_SEC is true if
11626 this entry might be in a different section from previous range. */
11628 static unsigned int
11629 add_ranges (const_tree block
, bool maybe_new_sec
)
11631 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0, maybe_new_sec
);
11634 /* Note that (*rnglist_table)[offset] is either a head of a rnglist
11635 chain, or middle entry of a chain that will be directly referred to. */
11638 note_rnglist_head (unsigned int offset
)
11640 if (dwarf_version
< 5 || (*ranges_table
)[offset
].label
)
11642 (*ranges_table
)[offset
].label
= gen_internal_sym ("LLRL");
11645 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
11646 When using dwarf_split_debug_info, address attributes in dies destined
11647 for the final executable should be direct references--setting the
11648 parameter force_direct ensures this behavior. */
11651 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
11652 bool *added
, bool force_direct
)
11654 unsigned int in_use
= vec_safe_length (ranges_by_label
);
11655 unsigned int offset
;
11656 dw_ranges_by_label rbl
= { begin
, end
};
11657 vec_safe_push (ranges_by_label
, rbl
);
11658 offset
= add_ranges_num (-(int)in_use
- 1, true);
11661 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
11663 note_rnglist_head (offset
);
11667 /* Emit .debug_ranges section. */
11670 output_ranges (void)
11673 static const char *const start_fmt
= "Offset %#x";
11674 const char *fmt
= start_fmt
;
11677 switch_to_section (debug_ranges_section
);
11678 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11679 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11681 int block_num
= r
->num
;
11685 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11686 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11688 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11689 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11691 /* If all code is in the text section, then the compilation
11692 unit base address defaults to DW_AT_low_pc, which is the
11693 base of the text section. */
11694 if (!have_multiple_function_sections
)
11696 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
11697 text_section_label
,
11698 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11699 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
11700 text_section_label
, NULL
);
11703 /* Otherwise, the compilation unit base address is zero,
11704 which allows us to use absolute addresses, and not worry
11705 about whether the target supports cross-section
11709 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11710 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11711 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
11717 /* Negative block_num stands for an index into ranges_by_label. */
11718 else if (block_num
< 0)
11720 int lab_idx
= - block_num
- 1;
11722 if (!have_multiple_function_sections
)
11724 gcc_unreachable ();
11726 /* If we ever use add_ranges_by_labels () for a single
11727 function section, all we have to do is to take out
11728 the #if 0 above. */
11729 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11730 (*ranges_by_label
)[lab_idx
].begin
,
11731 text_section_label
,
11732 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11733 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11734 (*ranges_by_label
)[lab_idx
].end
,
11735 text_section_label
, NULL
);
11740 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11741 (*ranges_by_label
)[lab_idx
].begin
,
11742 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11743 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11744 (*ranges_by_label
)[lab_idx
].end
,
11750 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11751 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11757 /* Non-zero if .debug_line_str should be used for .debug_line section
11758 strings or strings that are likely shareable with those. */
11759 #define DWARF5_USE_DEBUG_LINE_STR \
11760 (!DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET \
11761 && (DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) != 0 \
11762 /* FIXME: there is no .debug_line_str.dwo section, \
11763 for -gsplit-dwarf we should use DW_FORM_strx instead. */ \
11764 && !dwarf_split_debug_info)
11766 /* Assign .debug_rnglists indexes. */
11769 index_rnglists (void)
11774 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11776 r
->idx
= rnglist_idx
++;
11779 /* Emit .debug_rnglists section. */
11782 output_rnglists (unsigned generation
)
11786 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
11787 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
11788 char basebuf
[MAX_ARTIFICIAL_LABEL_BYTES
];
11790 switch_to_section (debug_ranges_section
);
11791 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11792 /* There are up to 4 unique ranges labels per generation.
11793 See also init_sections_and_labels. */
11794 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_RANGES_SECTION_LABEL
,
11795 2 + generation
* 4);
11796 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_RANGES_SECTION_LABEL
,
11797 3 + generation
* 4);
11798 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11799 dw2_asm_output_data (4, 0xffffffff,
11800 "Initial length escape value indicating "
11801 "64-bit DWARF extension");
11802 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
11803 "Length of Range Lists");
11804 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
11805 output_dwarf_version ();
11806 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
11807 dw2_asm_output_data (1, 0, "Segment Size");
11808 /* Emit the offset table only for -gsplit-dwarf. If we don't care
11809 about relocation sizes and primarily care about the size of .debug*
11810 sections in linked shared libraries and executables, then
11811 the offset table plus corresponding DW_FORM_rnglistx uleb128 indexes
11812 into it are usually larger than just DW_FORM_sec_offset offsets
11813 into the .debug_rnglists section. */
11814 dw2_asm_output_data (4, dwarf_split_debug_info
? rnglist_idx
: 0,
11815 "Offset Entry Count");
11816 if (dwarf_split_debug_info
)
11818 ASM_OUTPUT_LABEL (asm_out_file
, ranges_base_label
);
11819 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11821 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, r
->label
,
11822 ranges_base_label
, NULL
);
11825 const char *lab
= "";
11826 unsigned int len
= vec_safe_length (ranges_table
);
11827 const char *base
= NULL
;
11828 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11830 int block_num
= r
->num
;
11834 ASM_OUTPUT_LABEL (asm_out_file
, r
->label
);
11837 if (HAVE_AS_LEB128
&& (r
->label
|| r
->maybe_new_sec
))
11841 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11842 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11844 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11845 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11847 if (HAVE_AS_LEB128
)
11849 /* If all code is in the text section, then the compilation
11850 unit base address defaults to DW_AT_low_pc, which is the
11851 base of the text section. */
11852 if (!have_multiple_function_sections
)
11854 dw2_asm_output_data (1, DW_RLE_offset_pair
,
11855 "DW_RLE_offset_pair (%s)", lab
);
11856 dw2_asm_output_delta_uleb128 (blabel
, text_section_label
,
11857 "Range begin address (%s)", lab
);
11858 dw2_asm_output_delta_uleb128 (elabel
, text_section_label
,
11859 "Range end address (%s)", lab
);
11864 dw_ranges
*r2
= NULL
;
11866 r2
= &(*ranges_table
)[i
+ 1];
11869 && r2
->label
== NULL
11870 && !r2
->maybe_new_sec
)
11872 dw2_asm_output_data (1, DW_RLE_base_address
,
11873 "DW_RLE_base_address (%s)", lab
);
11874 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11875 "Base address (%s)", lab
);
11876 strcpy (basebuf
, blabel
);
11882 dw2_asm_output_data (1, DW_RLE_offset_pair
,
11883 "DW_RLE_offset_pair (%s)", lab
);
11884 dw2_asm_output_delta_uleb128 (blabel
, base
,
11885 "Range begin address (%s)", lab
);
11886 dw2_asm_output_delta_uleb128 (elabel
, base
,
11887 "Range end address (%s)", lab
);
11890 dw2_asm_output_data (1, DW_RLE_start_length
,
11891 "DW_RLE_start_length (%s)", lab
);
11892 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11893 "Range begin address (%s)", lab
);
11894 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
11895 "Range length (%s)", lab
);
11899 dw2_asm_output_data (1, DW_RLE_start_end
,
11900 "DW_RLE_start_end (%s)", lab
);
11901 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11902 "Range begin address (%s)", lab
);
11903 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
11904 "Range end address (%s)", lab
);
11908 /* Negative block_num stands for an index into ranges_by_label. */
11909 else if (block_num
< 0)
11911 int lab_idx
= - block_num
- 1;
11912 const char *blabel
= (*ranges_by_label
)[lab_idx
].begin
;
11913 const char *elabel
= (*ranges_by_label
)[lab_idx
].end
;
11915 if (!have_multiple_function_sections
)
11916 gcc_unreachable ();
11917 if (HAVE_AS_LEB128
)
11919 dw2_asm_output_data (1, DW_RLE_start_length
,
11920 "DW_RLE_start_length (%s)", lab
);
11921 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11922 "Range begin address (%s)", lab
);
11923 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
11924 "Range length (%s)", lab
);
11928 dw2_asm_output_data (1, DW_RLE_start_end
,
11929 "DW_RLE_start_end (%s)", lab
);
11930 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11931 "Range begin address (%s)", lab
);
11932 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
11933 "Range end address (%s)", lab
);
11937 dw2_asm_output_data (1, DW_RLE_end_of_list
,
11938 "DW_RLE_end_of_list (%s)", lab
);
11940 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
11943 /* Data structure containing information about input files. */
11946 const char *path
; /* Complete file name. */
11947 const char *fname
; /* File name part. */
11948 int length
; /* Length of entire string. */
11949 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
11950 int dir_idx
; /* Index in directory table. */
11953 /* Data structure containing information about directories with source
11957 const char *path
; /* Path including directory name. */
11958 int length
; /* Path length. */
11959 int prefix
; /* Index of directory entry which is a prefix. */
11960 int count
; /* Number of files in this directory. */
11961 int dir_idx
; /* Index of directory used as base. */
11964 /* Callback function for file_info comparison. We sort by looking at
11965 the directories in the path. */
11968 file_info_cmp (const void *p1
, const void *p2
)
11970 const struct file_info
*const s1
= (const struct file_info
*) p1
;
11971 const struct file_info
*const s2
= (const struct file_info
*) p2
;
11972 const unsigned char *cp1
;
11973 const unsigned char *cp2
;
11975 /* Take care of file names without directories. We need to make sure that
11976 we return consistent values to qsort since some will get confused if
11977 we return the same value when identical operands are passed in opposite
11978 orders. So if neither has a directory, return 0 and otherwise return
11979 1 or -1 depending on which one has the directory. We want the one with
11980 the directory to sort after the one without, so all no directory files
11981 are at the start (normally only the compilation unit file). */
11982 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
11983 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
11985 cp1
= (const unsigned char *) s1
->path
;
11986 cp2
= (const unsigned char *) s2
->path
;
11992 /* Reached the end of the first path? If so, handle like above,
11993 but now we want longer directory prefixes before shorter ones. */
11994 if ((cp1
== (const unsigned char *) s1
->fname
)
11995 || (cp2
== (const unsigned char *) s2
->fname
))
11996 return ((cp1
== (const unsigned char *) s1
->fname
)
11997 - (cp2
== (const unsigned char *) s2
->fname
));
11999 /* Character of current path component the same? */
12000 else if (*cp1
!= *cp2
)
12001 return *cp1
- *cp2
;
12005 struct file_name_acquire_data
12007 struct file_info
*files
;
12012 /* Traversal function for the hash table. */
12015 file_name_acquire (dwarf_file_data
**slot
, file_name_acquire_data
*fnad
)
12017 struct dwarf_file_data
*d
= *slot
;
12018 struct file_info
*fi
;
12021 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
12023 if (! d
->emitted_number
)
12026 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
12028 fi
= fnad
->files
+ fnad
->used_files
++;
12030 /* Skip all leading "./". */
12032 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
12035 /* Create a new array entry. */
12037 fi
->length
= strlen (f
);
12040 /* Search for the file name part. */
12041 f
= strrchr (f
, DIR_SEPARATOR
);
12042 #if defined (DIR_SEPARATOR_2)
12044 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
12048 if (f
== NULL
|| f
< g
)
12054 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
12058 /* Helper function for output_file_names. Emit a FORM encoded
12059 string STR, with assembly comment start ENTRY_KIND and
12063 output_line_string (enum dwarf_form form
, const char *str
,
12064 const char *entry_kind
, unsigned int idx
)
12068 case DW_FORM_string
:
12069 dw2_asm_output_nstring (str
, -1, "%s: %#x", entry_kind
, idx
);
12071 case DW_FORM_line_strp
:
12072 if (!debug_line_str_hash
)
12073 debug_line_str_hash
12074 = hash_table
<indirect_string_hasher
>::create_ggc (10);
12076 struct indirect_string_node
*node
;
12077 node
= find_AT_string_in_table (str
, debug_line_str_hash
);
12078 set_indirect_string (node
);
12080 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
12081 debug_line_str_section
, "%s: %#x: \"%s\"",
12082 entry_kind
, 0, node
->str
);
12085 gcc_unreachable ();
12089 /* Output the directory table and the file name table. We try to minimize
12090 the total amount of memory needed. A heuristic is used to avoid large
12091 slowdowns with many input files. */
12094 output_file_names (void)
12096 struct file_name_acquire_data fnad
;
12098 struct file_info
*files
;
12099 struct dir_info
*dirs
;
12107 if (!last_emitted_file
)
12109 if (dwarf_version
>= 5)
12111 dw2_asm_output_data (1, 0, "Directory entry format count");
12112 dw2_asm_output_data_uleb128 (0, "Directories count");
12113 dw2_asm_output_data (1, 0, "File name entry format count");
12114 dw2_asm_output_data_uleb128 (0, "File names count");
12118 dw2_asm_output_data (1, 0, "End directory table");
12119 dw2_asm_output_data (1, 0, "End file name table");
12124 numfiles
= last_emitted_file
->emitted_number
;
12126 /* Allocate the various arrays we need. */
12127 files
= XALLOCAVEC (struct file_info
, numfiles
);
12128 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
12130 fnad
.files
= files
;
12131 fnad
.used_files
= 0;
12132 fnad
.max_files
= numfiles
;
12133 file_table
->traverse
<file_name_acquire_data
*, file_name_acquire
> (&fnad
);
12134 gcc_assert (fnad
.used_files
== fnad
.max_files
);
12136 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
12138 /* Find all the different directories used. */
12139 dirs
[0].path
= files
[0].path
;
12140 dirs
[0].length
= files
[0].fname
- files
[0].path
;
12141 dirs
[0].prefix
= -1;
12143 dirs
[0].dir_idx
= 0;
12144 files
[0].dir_idx
= 0;
12147 for (i
= 1; i
< numfiles
; i
++)
12148 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
12149 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
12150 dirs
[ndirs
- 1].length
) == 0)
12152 /* Same directory as last entry. */
12153 files
[i
].dir_idx
= ndirs
- 1;
12154 ++dirs
[ndirs
- 1].count
;
12160 /* This is a new directory. */
12161 dirs
[ndirs
].path
= files
[i
].path
;
12162 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
12163 dirs
[ndirs
].count
= 1;
12164 dirs
[ndirs
].dir_idx
= ndirs
;
12165 files
[i
].dir_idx
= ndirs
;
12167 /* Search for a prefix. */
12168 dirs
[ndirs
].prefix
= -1;
12169 for (j
= 0; j
< ndirs
; j
++)
12170 if (dirs
[j
].length
< dirs
[ndirs
].length
12171 && dirs
[j
].length
> 1
12172 && (dirs
[ndirs
].prefix
== -1
12173 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
12174 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
12175 dirs
[ndirs
].prefix
= j
;
12180 /* Now to the actual work. We have to find a subset of the directories which
12181 allow expressing the file name using references to the directory table
12182 with the least amount of characters. We do not do an exhaustive search
12183 where we would have to check out every combination of every single
12184 possible prefix. Instead we use a heuristic which provides nearly optimal
12185 results in most cases and never is much off. */
12186 saved
= XALLOCAVEC (int, ndirs
);
12187 savehere
= XALLOCAVEC (int, ndirs
);
12189 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
12190 for (i
= 0; i
< ndirs
; i
++)
12195 /* We can always save some space for the current directory. But this
12196 does not mean it will be enough to justify adding the directory. */
12197 savehere
[i
] = dirs
[i
].length
;
12198 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
12200 for (j
= i
+ 1; j
< ndirs
; j
++)
12203 if (saved
[j
] < dirs
[i
].length
)
12205 /* Determine whether the dirs[i] path is a prefix of the
12209 k
= dirs
[j
].prefix
;
12210 while (k
!= -1 && k
!= (int) i
)
12211 k
= dirs
[k
].prefix
;
12215 /* Yes it is. We can possibly save some memory by
12216 writing the filenames in dirs[j] relative to
12218 savehere
[j
] = dirs
[i
].length
;
12219 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
12224 /* Check whether we can save enough to justify adding the dirs[i]
12226 if (total
> dirs
[i
].length
+ 1)
12228 /* It's worthwhile adding. */
12229 for (j
= i
; j
< ndirs
; j
++)
12230 if (savehere
[j
] > 0)
12232 /* Remember how much we saved for this directory so far. */
12233 saved
[j
] = savehere
[j
];
12235 /* Remember the prefix directory. */
12236 dirs
[j
].dir_idx
= i
;
12241 /* Emit the directory name table. */
12242 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
12243 enum dwarf_form str_form
= DW_FORM_string
;
12244 enum dwarf_form idx_form
= DW_FORM_udata
;
12245 if (dwarf_version
>= 5)
12247 const char *comp_dir
= comp_dir_string ();
12248 if (comp_dir
== NULL
)
12250 dw2_asm_output_data (1, 1, "Directory entry format count");
12251 if (DWARF5_USE_DEBUG_LINE_STR
)
12252 str_form
= DW_FORM_line_strp
;
12253 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12254 dw2_asm_output_data_uleb128 (str_form
, "%s",
12255 get_DW_FORM_name (str_form
));
12256 dw2_asm_output_data_uleb128 (ndirs
+ idx_offset
, "Directories count");
12257 if (str_form
== DW_FORM_string
)
12259 dw2_asm_output_nstring (comp_dir
, -1, "Directory Entry: %#x", 0);
12260 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12261 dw2_asm_output_nstring (dirs
[i
].path
,
12263 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
12264 "Directory Entry: %#x", i
+ idx_offset
);
12268 output_line_string (str_form
, comp_dir
, "Directory Entry", 0);
12269 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12272 = ggc_alloc_string (dirs
[i
].path
,
12274 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
);
12275 output_line_string (str_form
, str
, "Directory Entry",
12276 (unsigned) i
+ idx_offset
);
12282 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12283 dw2_asm_output_nstring (dirs
[i
].path
,
12285 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
12286 "Directory Entry: %#x", i
+ idx_offset
);
12288 dw2_asm_output_data (1, 0, "End directory table");
12291 /* We have to emit them in the order of emitted_number since that's
12292 used in the debug info generation. To do this efficiently we
12293 generate a back-mapping of the indices first. */
12294 backmap
= XALLOCAVEC (int, numfiles
);
12295 for (i
= 0; i
< numfiles
; i
++)
12296 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
12298 if (dwarf_version
>= 5)
12300 const char *filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
12301 if (filename0
== NULL
)
12303 /* DW_LNCT_directory_index can use DW_FORM_udata, DW_FORM_data1 and
12304 DW_FORM_data2. Choose one based on the number of directories
12305 and how much space would they occupy in each encoding.
12306 If we have at most 256 directories, all indexes fit into
12307 a single byte, so DW_FORM_data1 is most compact (if there
12308 are at most 128 directories, DW_FORM_udata would be as
12309 compact as that, but not shorter and slower to decode). */
12310 if (ndirs
+ idx_offset
<= 256)
12311 idx_form
= DW_FORM_data1
;
12312 /* If there are more than 65536 directories, we have to use
12313 DW_FORM_udata, DW_FORM_data2 can't refer to them.
12314 Otherwise, compute what space would occupy if all the indexes
12315 used DW_FORM_udata - sum - and compare that to how large would
12316 be DW_FORM_data2 encoding, and pick the more efficient one. */
12317 else if (ndirs
+ idx_offset
<= 65536)
12319 unsigned HOST_WIDE_INT sum
= 1;
12320 for (i
= 0; i
< numfiles
; i
++)
12322 int file_idx
= backmap
[i
];
12323 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
12324 sum
+= size_of_uleb128 (dir_idx
);
12326 if (sum
>= HOST_WIDE_INT_UC (2) * (numfiles
+ 1))
12327 idx_form
= DW_FORM_data2
;
12329 #ifdef VMS_DEBUGGING_INFO
12330 dw2_asm_output_data (1, 4, "File name entry format count");
12332 dw2_asm_output_data (1, 2, "File name entry format count");
12334 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12335 dw2_asm_output_data_uleb128 (str_form
, "%s",
12336 get_DW_FORM_name (str_form
));
12337 dw2_asm_output_data_uleb128 (DW_LNCT_directory_index
,
12338 "DW_LNCT_directory_index");
12339 dw2_asm_output_data_uleb128 (idx_form
, "%s",
12340 get_DW_FORM_name (idx_form
));
12341 #ifdef VMS_DEBUGGING_INFO
12342 dw2_asm_output_data_uleb128 (DW_LNCT_timestamp
, "DW_LNCT_timestamp");
12343 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12344 dw2_asm_output_data_uleb128 (DW_LNCT_size
, "DW_LNCT_size");
12345 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12347 dw2_asm_output_data_uleb128 (numfiles
+ 1, "File names count");
12349 output_line_string (str_form
, filename0
, "File Entry", 0);
12351 /* Include directory index. */
12352 if (idx_form
!= DW_FORM_udata
)
12353 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12356 dw2_asm_output_data_uleb128 (0, NULL
);
12358 #ifdef VMS_DEBUGGING_INFO
12359 dw2_asm_output_data_uleb128 (0, NULL
);
12360 dw2_asm_output_data_uleb128 (0, NULL
);
12364 /* Now write all the file names. */
12365 for (i
= 0; i
< numfiles
; i
++)
12367 int file_idx
= backmap
[i
];
12368 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
12370 #ifdef VMS_DEBUGGING_INFO
12371 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
12373 /* Setting these fields can lead to debugger miscomparisons,
12374 but VMS Debug requires them to be set correctly. */
12379 int maxfilelen
= (strlen (files
[file_idx
].path
)
12380 + dirs
[dir_idx
].length
12381 + MAX_VMS_VERSION_LEN
+ 1);
12382 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
12384 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
12385 snprintf (filebuf
, maxfilelen
, "%s;%d",
12386 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
12388 output_line_string (str_form
, filebuf
, "File Entry", (unsigned) i
+ 1);
12390 /* Include directory index. */
12391 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
12392 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12393 dir_idx
+ idx_offset
, NULL
);
12395 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
12397 /* Modification time. */
12398 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
12399 &cdt
, 0, 0, 0) == 0)
12402 /* File length in bytes. */
12403 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
12404 0, &siz
, 0, 0) == 0)
12407 output_line_string (str_form
,
12408 files
[file_idx
].path
+ dirs
[dir_idx
].length
,
12409 "File Entry", (unsigned) i
+ 1);
12411 /* Include directory index. */
12412 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
12413 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12414 dir_idx
+ idx_offset
, NULL
);
12416 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
12418 if (dwarf_version
>= 5)
12421 /* Modification time. */
12422 dw2_asm_output_data_uleb128 (0, NULL
);
12424 /* File length in bytes. */
12425 dw2_asm_output_data_uleb128 (0, NULL
);
12426 #endif /* VMS_DEBUGGING_INFO */
12429 if (dwarf_version
< 5)
12430 dw2_asm_output_data (1, 0, "End file name table");
12434 /* Output one line number table into the .debug_line section. */
12437 output_one_line_info_table (dw_line_info_table
*table
)
12439 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12440 unsigned int current_line
= 1;
12441 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
12442 dw_line_info_entry
*ent
, *prev_addr
;
12448 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
12450 switch (ent
->opcode
)
12452 case LI_set_address
:
12453 /* ??? Unfortunately, we have little choice here currently, and
12454 must always use the most general form. GCC does not know the
12455 address delta itself, so we can't use DW_LNS_advance_pc. Many
12456 ports do have length attributes which will give an upper bound
12457 on the address range. We could perhaps use length attributes
12458 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
12459 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
12463 /* This can handle any delta. This takes
12464 4+DWARF2_ADDR_SIZE bytes. */
12465 dw2_asm_output_data (1, 0, "set address %s%s", line_label
,
12466 debug_variable_location_views
12467 ? ", reset view to 0" : "");
12468 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12469 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12470 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
12475 case LI_adv_address
:
12477 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
12478 char prev_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12479 ASM_GENERATE_INTERNAL_LABEL (prev_label
, LINE_CODE_LABEL
, prev_addr
->val
);
12483 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
, "fixed advance PC, increment view to %i", view
);
12484 dw2_asm_output_delta (2, line_label
, prev_label
,
12485 "from %s to %s", prev_label
, line_label
);
12492 if (ent
->val
== current_line
)
12494 /* We still need to start a new row, so output a copy insn. */
12495 dw2_asm_output_data (1, DW_LNS_copy
,
12496 "copy line %u", current_line
);
12500 int line_offset
= ent
->val
- current_line
;
12501 int line_delta
= line_offset
- DWARF_LINE_BASE
;
12503 current_line
= ent
->val
;
12504 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
12506 /* This can handle deltas from -10 to 234, using the current
12507 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
12508 This takes 1 byte. */
12509 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
12510 "line %u", current_line
);
12514 /* This can handle any delta. This takes at least 4 bytes,
12515 depending on the value being encoded. */
12516 dw2_asm_output_data (1, DW_LNS_advance_line
,
12517 "advance to line %u", current_line
);
12518 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
12519 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
12525 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
12526 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
12529 case LI_set_column
:
12530 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
12531 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
12534 case LI_negate_stmt
:
12535 current_is_stmt
= !current_is_stmt
;
12536 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
12537 "is_stmt %d", current_is_stmt
);
12540 case LI_set_prologue_end
:
12541 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
12542 "set prologue end");
12545 case LI_set_epilogue_begin
:
12546 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
12547 "set epilogue begin");
12550 case LI_set_discriminator
:
12551 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
12552 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
12553 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
12554 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
12559 /* Emit debug info for the address of the end of the table. */
12560 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
12561 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12562 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12563 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
12565 dw2_asm_output_data (1, 0, "end sequence");
12566 dw2_asm_output_data_uleb128 (1, NULL
);
12567 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
12570 /* Output the source line number correspondence information. This
12571 information goes into the .debug_line section. */
12574 output_line_info (bool prologue_only
)
12576 static unsigned int generation
;
12577 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
12578 char p1
[MAX_ARTIFICIAL_LABEL_BYTES
], p2
[MAX_ARTIFICIAL_LABEL_BYTES
];
12579 bool saw_one
= false;
12582 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, generation
);
12583 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, generation
);
12584 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, generation
);
12585 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, generation
++);
12587 if (!XCOFF_DEBUGGING_INFO
)
12589 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
12590 dw2_asm_output_data (4, 0xffffffff,
12591 "Initial length escape value indicating 64-bit DWARF extension");
12592 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
12593 "Length of Source Line Info");
12596 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
12598 output_dwarf_version ();
12599 if (dwarf_version
>= 5)
12601 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
12602 dw2_asm_output_data (1, 0, "Segment Size");
12604 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
12605 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
12607 /* Define the architecture-dependent minimum instruction length (in bytes).
12608 In this implementation of DWARF, this field is used for information
12609 purposes only. Since GCC generates assembly language, we have no
12610 a priori knowledge of how many instruction bytes are generated for each
12611 source line, and therefore can use only the DW_LNE_set_address and
12612 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
12613 this as '1', which is "correct enough" for all architectures,
12614 and don't let the target override. */
12615 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
12617 if (dwarf_version
>= 4)
12618 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
12619 "Maximum Operations Per Instruction");
12620 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
12621 "Default is_stmt_start flag");
12622 dw2_asm_output_data (1, DWARF_LINE_BASE
,
12623 "Line Base Value (Special Opcodes)");
12624 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
12625 "Line Range Value (Special Opcodes)");
12626 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
12627 "Special Opcode Base");
12629 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
12634 case DW_LNS_advance_pc
:
12635 case DW_LNS_advance_line
:
12636 case DW_LNS_set_file
:
12637 case DW_LNS_set_column
:
12638 case DW_LNS_fixed_advance_pc
:
12639 case DW_LNS_set_isa
:
12647 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
12651 /* Write out the information about the files we use. */
12652 output_file_names ();
12653 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
12656 /* Output the marker for the end of the line number info. */
12657 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12661 if (separate_line_info
)
12663 dw_line_info_table
*table
;
12666 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
12669 output_one_line_info_table (table
);
12673 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
12675 output_one_line_info_table (cold_text_section_line_info
);
12679 /* ??? Some Darwin linkers crash on a .debug_line section with no
12680 sequences. Further, merely a DW_LNE_end_sequence entry is not
12681 sufficient -- the address column must also be initialized.
12682 Make sure to output at least one set_address/end_sequence pair,
12683 choosing .text since that section is always present. */
12684 if (text_section_line_info
->in_use
|| !saw_one
)
12685 output_one_line_info_table (text_section_line_info
);
12687 /* Output the marker for the end of the line number info. */
12688 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12691 /* Return true if DW_AT_endianity should be emitted according to REVERSE. */
12694 need_endianity_attribute_p (bool reverse
)
12696 return reverse
&& (dwarf_version
>= 3 || !dwarf_strict
);
12699 /* Given a pointer to a tree node for some base type, return a pointer to
12700 a DIE that describes the given type. REVERSE is true if the type is
12701 to be interpreted in the reverse storage order wrt the target order.
12703 This routine must only be called for GCC type nodes that correspond to
12704 Dwarf base (fundamental) types. */
12707 base_type_die (tree type
, bool reverse
)
12709 dw_die_ref base_type_result
;
12710 enum dwarf_type encoding
;
12711 bool fpt_used
= false;
12712 struct fixed_point_type_info fpt_info
;
12713 tree type_bias
= NULL_TREE
;
12715 /* If this is a subtype that should not be emitted as a subrange type,
12716 use the base type. See subrange_type_for_debug_p. */
12717 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
12718 type
= TREE_TYPE (type
);
12720 switch (TREE_CODE (type
))
12723 if ((dwarf_version
>= 4 || !dwarf_strict
)
12724 && TYPE_NAME (type
)
12725 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
12726 && DECL_IS_BUILTIN (TYPE_NAME (type
))
12727 && DECL_NAME (TYPE_NAME (type
)))
12729 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
12730 if (strcmp (name
, "char16_t") == 0
12731 || strcmp (name
, "char32_t") == 0)
12733 encoding
= DW_ATE_UTF
;
12737 if ((dwarf_version
>= 3 || !dwarf_strict
)
12738 && lang_hooks
.types
.get_fixed_point_type_info
)
12740 memset (&fpt_info
, 0, sizeof (fpt_info
));
12741 if (lang_hooks
.types
.get_fixed_point_type_info (type
, &fpt_info
))
12744 encoding
= ((TYPE_UNSIGNED (type
))
12745 ? DW_ATE_unsigned_fixed
12746 : DW_ATE_signed_fixed
);
12750 if (TYPE_STRING_FLAG (type
))
12752 if (TYPE_UNSIGNED (type
))
12753 encoding
= DW_ATE_unsigned_char
;
12755 encoding
= DW_ATE_signed_char
;
12757 else if (TYPE_UNSIGNED (type
))
12758 encoding
= DW_ATE_unsigned
;
12760 encoding
= DW_ATE_signed
;
12763 && lang_hooks
.types
.get_type_bias
)
12764 type_bias
= lang_hooks
.types
.get_type_bias (type
);
12768 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
12770 if (dwarf_version
>= 3 || !dwarf_strict
)
12771 encoding
= DW_ATE_decimal_float
;
12773 encoding
= DW_ATE_lo_user
;
12776 encoding
= DW_ATE_float
;
12779 case FIXED_POINT_TYPE
:
12780 if (!(dwarf_version
>= 3 || !dwarf_strict
))
12781 encoding
= DW_ATE_lo_user
;
12782 else if (TYPE_UNSIGNED (type
))
12783 encoding
= DW_ATE_unsigned_fixed
;
12785 encoding
= DW_ATE_signed_fixed
;
12788 /* Dwarf2 doesn't know anything about complex ints, so use
12789 a user defined type for it. */
12791 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
12792 encoding
= DW_ATE_complex_float
;
12794 encoding
= DW_ATE_lo_user
;
12798 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
12799 encoding
= DW_ATE_boolean
;
12803 /* No other TREE_CODEs are Dwarf fundamental types. */
12804 gcc_unreachable ();
12807 base_type_result
= new_die_raw (DW_TAG_base_type
);
12809 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
12810 int_size_in_bytes (type
));
12811 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
12813 if (need_endianity_attribute_p (reverse
))
12814 add_AT_unsigned (base_type_result
, DW_AT_endianity
,
12815 BYTES_BIG_ENDIAN
? DW_END_little
: DW_END_big
);
12817 add_alignment_attribute (base_type_result
, type
);
12821 switch (fpt_info
.scale_factor_kind
)
12823 case fixed_point_scale_factor_binary
:
12824 add_AT_int (base_type_result
, DW_AT_binary_scale
,
12825 fpt_info
.scale_factor
.binary
);
12828 case fixed_point_scale_factor_decimal
:
12829 add_AT_int (base_type_result
, DW_AT_decimal_scale
,
12830 fpt_info
.scale_factor
.decimal
);
12833 case fixed_point_scale_factor_arbitrary
:
12834 /* Arbitrary scale factors cannot be described in standard DWARF,
12838 /* Describe the scale factor as a rational constant. */
12839 const dw_die_ref scale_factor
12840 = new_die (DW_TAG_constant
, comp_unit_die (), type
);
12842 add_AT_unsigned (scale_factor
, DW_AT_GNU_numerator
,
12843 fpt_info
.scale_factor
.arbitrary
.numerator
);
12844 add_AT_int (scale_factor
, DW_AT_GNU_denominator
,
12845 fpt_info
.scale_factor
.arbitrary
.denominator
);
12847 add_AT_die_ref (base_type_result
, DW_AT_small
, scale_factor
);
12852 gcc_unreachable ();
12857 add_scalar_info (base_type_result
, DW_AT_GNU_bias
, type_bias
,
12858 dw_scalar_form_constant
12859 | dw_scalar_form_exprloc
12860 | dw_scalar_form_reference
,
12863 return base_type_result
;
12866 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
12867 named 'auto' in its type: return true for it, false otherwise. */
12870 is_cxx_auto (tree type
)
12874 tree name
= TYPE_IDENTIFIER (type
);
12875 if (name
== get_identifier ("auto")
12876 || name
== get_identifier ("decltype(auto)"))
12882 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
12883 given input type is a Dwarf "fundamental" type. Otherwise return null. */
12886 is_base_type (tree type
)
12888 switch (TREE_CODE (type
))
12892 case FIXED_POINT_TYPE
:
12901 case QUAL_UNION_TYPE
:
12902 case ENUMERAL_TYPE
:
12903 case FUNCTION_TYPE
:
12906 case REFERENCE_TYPE
:
12914 if (is_cxx_auto (type
))
12916 gcc_unreachable ();
12922 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
12923 node, return the size in bits for the type if it is a constant, or else
12924 return the alignment for the type if the type's size is not constant, or
12925 else return BITS_PER_WORD if the type actually turns out to be an
12926 ERROR_MARK node. */
12928 static inline unsigned HOST_WIDE_INT
12929 simple_type_size_in_bits (const_tree type
)
12931 if (TREE_CODE (type
) == ERROR_MARK
)
12932 return BITS_PER_WORD
;
12933 else if (TYPE_SIZE (type
) == NULL_TREE
)
12935 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
12936 return tree_to_uhwi (TYPE_SIZE (type
));
12938 return TYPE_ALIGN (type
);
12941 /* Similarly, but return an offset_int instead of UHWI. */
12943 static inline offset_int
12944 offset_int_type_size_in_bits (const_tree type
)
12946 if (TREE_CODE (type
) == ERROR_MARK
)
12947 return BITS_PER_WORD
;
12948 else if (TYPE_SIZE (type
) == NULL_TREE
)
12950 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
12951 return wi::to_offset (TYPE_SIZE (type
));
12953 return TYPE_ALIGN (type
);
12956 /* Given a pointer to a tree node for a subrange type, return a pointer
12957 to a DIE that describes the given type. */
12960 subrange_type_die (tree type
, tree low
, tree high
, tree bias
,
12961 dw_die_ref context_die
)
12963 dw_die_ref subrange_die
;
12964 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
12966 if (context_die
== NULL
)
12967 context_die
= comp_unit_die ();
12969 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
12971 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
12973 /* The size of the subrange type and its base type do not match,
12974 so we need to generate a size attribute for the subrange type. */
12975 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
12978 add_alignment_attribute (subrange_die
, type
);
12981 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
, NULL
);
12983 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
, NULL
);
12984 if (bias
&& !dwarf_strict
)
12985 add_scalar_info (subrange_die
, DW_AT_GNU_bias
, bias
,
12986 dw_scalar_form_constant
12987 | dw_scalar_form_exprloc
12988 | dw_scalar_form_reference
,
12991 return subrange_die
;
12994 /* Returns the (const and/or volatile) cv_qualifiers associated with
12995 the decl node. This will normally be augmented with the
12996 cv_qualifiers of the underlying type in add_type_attribute. */
12999 decl_quals (const_tree decl
)
13001 return ((TREE_READONLY (decl
)
13002 /* The C++ front-end correctly marks reference-typed
13003 variables as readonly, but from a language (and debug
13004 info) standpoint they are not const-qualified. */
13005 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
13006 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
)
13007 | (TREE_THIS_VOLATILE (decl
)
13008 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
));
13011 /* Determine the TYPE whose qualifiers match the largest strict subset
13012 of the given TYPE_QUALS, and return its qualifiers. Ignore all
13013 qualifiers outside QUAL_MASK. */
13016 get_nearest_type_subqualifiers (tree type
, int type_quals
, int qual_mask
)
13019 int best_rank
= 0, best_qual
= 0, max_rank
;
13021 type_quals
&= qual_mask
;
13022 max_rank
= popcount_hwi (type_quals
) - 1;
13024 for (t
= TYPE_MAIN_VARIANT (type
); t
&& best_rank
< max_rank
;
13025 t
= TYPE_NEXT_VARIANT (t
))
13027 int q
= TYPE_QUALS (t
) & qual_mask
;
13029 if ((q
& type_quals
) == q
&& q
!= type_quals
13030 && check_base_type (t
, type
))
13032 int rank
= popcount_hwi (q
);
13034 if (rank
> best_rank
)
13045 struct dwarf_qual_info_t
{ int q
; enum dwarf_tag t
; };
13046 static const dwarf_qual_info_t dwarf_qual_info
[] =
13048 { TYPE_QUAL_CONST
, DW_TAG_const_type
},
13049 { TYPE_QUAL_VOLATILE
, DW_TAG_volatile_type
},
13050 { TYPE_QUAL_RESTRICT
, DW_TAG_restrict_type
},
13051 { TYPE_QUAL_ATOMIC
, DW_TAG_atomic_type
}
13053 static const unsigned int dwarf_qual_info_size
13054 = sizeof (dwarf_qual_info
) / sizeof (dwarf_qual_info
[0]);
13056 /* If DIE is a qualified DIE of some base DIE with the same parent,
13057 return the base DIE, otherwise return NULL. Set MASK to the
13058 qualifiers added compared to the returned DIE. */
13061 qualified_die_p (dw_die_ref die
, int *mask
, unsigned int depth
)
13064 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13065 if (die
->die_tag
== dwarf_qual_info
[i
].t
)
13067 if (i
== dwarf_qual_info_size
)
13069 if (vec_safe_length (die
->die_attr
) != 1)
13071 dw_die_ref type
= get_AT_ref (die
, DW_AT_type
);
13072 if (type
== NULL
|| type
->die_parent
!= die
->die_parent
)
13074 *mask
|= dwarf_qual_info
[i
].q
;
13077 dw_die_ref ret
= qualified_die_p (type
, mask
, depth
- 1);
13084 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
13085 entry that chains the modifiers specified by CV_QUALS in front of the
13086 given type. REVERSE is true if the type is to be interpreted in the
13087 reverse storage order wrt the target order. */
13090 modified_type_die (tree type
, int cv_quals
, bool reverse
,
13091 dw_die_ref context_die
)
13093 enum tree_code code
= TREE_CODE (type
);
13094 dw_die_ref mod_type_die
;
13095 dw_die_ref sub_die
= NULL
;
13096 tree item_type
= NULL
;
13097 tree qualified_type
;
13098 tree name
, low
, high
;
13099 dw_die_ref mod_scope
;
13100 /* Only these cv-qualifiers are currently handled. */
13101 const int cv_qual_mask
= (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
13102 | TYPE_QUAL_RESTRICT
| TYPE_QUAL_ATOMIC
|
13103 ENCODE_QUAL_ADDR_SPACE(~0U));
13104 const bool reverse_base_type
13105 = need_endianity_attribute_p (reverse
) && is_base_type (type
);
13107 if (code
== ERROR_MARK
)
13110 if (lang_hooks
.types
.get_debug_type
)
13112 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
13114 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
13115 return modified_type_die (debug_type
, cv_quals
, reverse
, context_die
);
13118 cv_quals
&= cv_qual_mask
;
13120 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
13121 tag modifier (and not an attribute) old consumers won't be able
13123 if (dwarf_version
< 3)
13124 cv_quals
&= ~TYPE_QUAL_RESTRICT
;
13126 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
13127 if (dwarf_version
< 5)
13128 cv_quals
&= ~TYPE_QUAL_ATOMIC
;
13130 /* See if we already have the appropriately qualified variant of
13132 qualified_type
= get_qualified_type (type
, cv_quals
);
13134 if (qualified_type
== sizetype
)
13136 /* Try not to expose the internal sizetype type's name. */
13137 if (TYPE_NAME (qualified_type
)
13138 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
13140 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
13142 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
13143 && (TYPE_PRECISION (t
)
13144 == TYPE_PRECISION (qualified_type
))
13145 && (TYPE_UNSIGNED (t
)
13146 == TYPE_UNSIGNED (qualified_type
)));
13147 qualified_type
= t
;
13149 else if (qualified_type
== sizetype
13150 && TREE_CODE (sizetype
) == TREE_CODE (size_type_node
)
13151 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (size_type_node
)
13152 && TYPE_UNSIGNED (sizetype
) == TYPE_UNSIGNED (size_type_node
))
13153 qualified_type
= size_type_node
;
13156 /* If we do, then we can just use its DIE, if it exists. */
13157 if (qualified_type
)
13159 mod_type_die
= lookup_type_die (qualified_type
);
13161 /* DW_AT_endianity doesn't come from a qualifier on the type, so it is
13162 dealt with specially: the DIE with the attribute, if it exists, is
13163 placed immediately after the regular DIE for the same base type. */
13165 && (!reverse_base_type
13166 || ((mod_type_die
= mod_type_die
->die_sib
) != NULL
13167 && get_AT_unsigned (mod_type_die
, DW_AT_endianity
))))
13168 return mod_type_die
;
13171 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
13173 /* Handle C typedef types. */
13175 && TREE_CODE (name
) == TYPE_DECL
13176 && DECL_ORIGINAL_TYPE (name
)
13177 && !DECL_ARTIFICIAL (name
))
13179 tree dtype
= TREE_TYPE (name
);
13181 /* Skip the typedef for base types with DW_AT_endianity, no big deal. */
13182 if (qualified_type
== dtype
&& !reverse_base_type
)
13184 tree origin
= decl_ultimate_origin (name
);
13186 /* Typedef variants that have an abstract origin don't get their own
13187 type DIE (see gen_typedef_die), so fall back on the ultimate
13188 abstract origin instead. */
13189 if (origin
!= NULL
&& origin
!= name
)
13190 return modified_type_die (TREE_TYPE (origin
), cv_quals
, reverse
,
13193 /* For a named type, use the typedef. */
13194 gen_type_die (qualified_type
, context_die
);
13195 return lookup_type_die (qualified_type
);
13199 int dquals
= TYPE_QUALS_NO_ADDR_SPACE (dtype
);
13200 dquals
&= cv_qual_mask
;
13201 if ((dquals
& ~cv_quals
) != TYPE_UNQUALIFIED
13202 || (cv_quals
== dquals
&& DECL_ORIGINAL_TYPE (name
) != type
))
13203 /* cv-unqualified version of named type. Just use
13204 the unnamed type to which it refers. */
13205 return modified_type_die (DECL_ORIGINAL_TYPE (name
), cv_quals
,
13206 reverse
, context_die
);
13207 /* Else cv-qualified version of named type; fall through. */
13211 mod_scope
= scope_die_for (type
, context_die
);
13215 int sub_quals
= 0, first_quals
= 0;
13217 dw_die_ref first
= NULL
, last
= NULL
;
13219 /* Determine a lesser qualified type that most closely matches
13220 this one. Then generate DW_TAG_* entries for the remaining
13222 sub_quals
= get_nearest_type_subqualifiers (type
, cv_quals
,
13224 if (sub_quals
&& use_debug_types
)
13226 bool needed
= false;
13227 /* If emitting type units, make sure the order of qualifiers
13228 is canonical. Thus, start from unqualified type if
13229 an earlier qualifier is missing in sub_quals, but some later
13230 one is present there. */
13231 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13232 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
13234 else if (needed
&& (dwarf_qual_info
[i
].q
& cv_quals
))
13240 mod_type_die
= modified_type_die (type
, sub_quals
, reverse
, context_die
);
13241 if (mod_scope
&& mod_type_die
&& mod_type_die
->die_parent
== mod_scope
)
13243 /* As not all intermediate qualified DIEs have corresponding
13244 tree types, ensure that qualified DIEs in the same scope
13245 as their DW_AT_type are emitted after their DW_AT_type,
13246 only with other qualified DIEs for the same type possibly
13247 in between them. Determine the range of such qualified
13248 DIEs now (first being the base type, last being corresponding
13249 last qualified DIE for it). */
13250 unsigned int count
= 0;
13251 first
= qualified_die_p (mod_type_die
, &first_quals
,
13252 dwarf_qual_info_size
);
13254 first
= mod_type_die
;
13255 gcc_assert ((first_quals
& ~sub_quals
) == 0);
13256 for (count
= 0, last
= first
;
13257 count
< (1U << dwarf_qual_info_size
);
13258 count
++, last
= last
->die_sib
)
13261 if (last
== mod_scope
->die_child
)
13263 if (qualified_die_p (last
->die_sib
, &quals
, dwarf_qual_info_size
)
13269 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13270 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
13273 if (first
&& first
!= last
)
13275 for (d
= first
->die_sib
; ; d
= d
->die_sib
)
13278 qualified_die_p (d
, &quals
, dwarf_qual_info_size
);
13279 if (quals
== (first_quals
| dwarf_qual_info
[i
].q
))
13295 d
= new_die_raw (dwarf_qual_info
[i
].t
);
13296 add_child_die_after (mod_scope
, d
, last
);
13300 d
= new_die (dwarf_qual_info
[i
].t
, mod_scope
, type
);
13302 add_AT_die_ref (d
, DW_AT_type
, mod_type_die
);
13304 first_quals
|= dwarf_qual_info
[i
].q
;
13307 else if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
)
13309 dwarf_tag tag
= DW_TAG_pointer_type
;
13310 if (code
== REFERENCE_TYPE
)
13312 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
13313 tag
= DW_TAG_rvalue_reference_type
;
13315 tag
= DW_TAG_reference_type
;
13317 mod_type_die
= new_die (tag
, mod_scope
, type
);
13319 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
13320 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
13321 add_alignment_attribute (mod_type_die
, type
);
13322 item_type
= TREE_TYPE (type
);
13324 addr_space_t as
= TYPE_ADDR_SPACE (item_type
);
13325 if (!ADDR_SPACE_GENERIC_P (as
))
13327 int action
= targetm
.addr_space
.debug (as
);
13330 /* Positive values indicate an address_class. */
13331 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, action
);
13335 /* Negative values indicate an (inverted) segment base reg. */
13337 = one_reg_loc_descriptor (~action
, VAR_INIT_STATUS_INITIALIZED
);
13338 add_AT_loc (mod_type_die
, DW_AT_segment
, d
);
13342 else if (code
== INTEGER_TYPE
13343 && TREE_TYPE (type
) != NULL_TREE
13344 && subrange_type_for_debug_p (type
, &low
, &high
))
13346 tree bias
= NULL_TREE
;
13347 if (lang_hooks
.types
.get_type_bias
)
13348 bias
= lang_hooks
.types
.get_type_bias (type
);
13349 mod_type_die
= subrange_type_die (type
, low
, high
, bias
, context_die
);
13350 item_type
= TREE_TYPE (type
);
13352 else if (is_base_type (type
))
13354 mod_type_die
= base_type_die (type
, reverse
);
13356 /* The DIE with DW_AT_endianity is placed right after the naked DIE. */
13357 if (reverse_base_type
)
13359 dw_die_ref after_die
13360 = modified_type_die (type
, cv_quals
, false, context_die
);
13361 add_child_die_after (comp_unit_die (), mod_type_die
, after_die
);
13364 add_child_die (comp_unit_die (), mod_type_die
);
13366 add_pubtype (type
, mod_type_die
);
13370 gen_type_die (type
, context_die
);
13372 /* We have to get the type_main_variant here (and pass that to the
13373 `lookup_type_die' routine) because the ..._TYPE node we have
13374 might simply be a *copy* of some original type node (where the
13375 copy was created to help us keep track of typedef names) and
13376 that copy might have a different TYPE_UID from the original
13378 if (TREE_CODE (type
) == FUNCTION_TYPE
13379 || TREE_CODE (type
) == METHOD_TYPE
)
13381 /* For function/method types, can't just use type_main_variant here,
13382 because that can have different ref-qualifiers for C++,
13383 but try to canonicalize. */
13384 tree main
= TYPE_MAIN_VARIANT (type
);
13385 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
13386 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
13387 && check_base_type (t
, main
)
13388 && check_lang_type (t
, type
))
13389 return lookup_type_die (t
);
13390 return lookup_type_die (type
);
13392 else if (TREE_CODE (type
) != VECTOR_TYPE
13393 && TREE_CODE (type
) != ARRAY_TYPE
)
13394 return lookup_type_die (type_main_variant (type
));
13396 /* Vectors have the debugging information in the type,
13397 not the main variant. */
13398 return lookup_type_die (type
);
13401 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
13402 don't output a DW_TAG_typedef, since there isn't one in the
13403 user's program; just attach a DW_AT_name to the type.
13404 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
13405 if the base type already has the same name. */
13407 && ((TREE_CODE (name
) != TYPE_DECL
13408 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
13409 || (cv_quals
== TYPE_UNQUALIFIED
)))
13410 || (TREE_CODE (name
) == TYPE_DECL
13411 && TREE_TYPE (name
) == qualified_type
13412 && DECL_NAME (name
))))
13414 if (TREE_CODE (name
) == TYPE_DECL
)
13415 /* Could just call add_name_and_src_coords_attributes here,
13416 but since this is a builtin type it doesn't have any
13417 useful source coordinates anyway. */
13418 name
= DECL_NAME (name
);
13419 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
13421 /* This probably indicates a bug. */
13422 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
13424 name
= TYPE_IDENTIFIER (type
);
13425 add_name_attribute (mod_type_die
,
13426 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
13429 if (qualified_type
&& !reverse_base_type
)
13430 equate_type_number_to_die (qualified_type
, mod_type_die
);
13433 /* We must do this after the equate_type_number_to_die call, in case
13434 this is a recursive type. This ensures that the modified_type_die
13435 recursion will terminate even if the type is recursive. Recursive
13436 types are possible in Ada. */
13437 sub_die
= modified_type_die (item_type
,
13438 TYPE_QUALS_NO_ADDR_SPACE (item_type
),
13442 if (sub_die
!= NULL
)
13443 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
13445 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
13446 if (TYPE_ARTIFICIAL (type
))
13447 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
13449 return mod_type_die
;
13452 /* Generate DIEs for the generic parameters of T.
13453 T must be either a generic type or a generic function.
13454 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
13457 gen_generic_params_dies (tree t
)
13461 dw_die_ref die
= NULL
;
13464 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
13468 die
= lookup_type_die (t
);
13469 else if (DECL_P (t
))
13470 die
= lookup_decl_die (t
);
13474 parms
= lang_hooks
.get_innermost_generic_parms (t
);
13476 /* T has no generic parameter. It means T is neither a generic type
13477 or function. End of story. */
13480 parms_num
= TREE_VEC_LENGTH (parms
);
13481 args
= lang_hooks
.get_innermost_generic_args (t
);
13482 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
13483 non_default
= int_cst_value (TREE_CHAIN (args
));
13485 non_default
= TREE_VEC_LENGTH (args
);
13486 for (i
= 0; i
< parms_num
; i
++)
13488 tree parm
, arg
, arg_pack_elems
;
13489 dw_die_ref parm_die
;
13491 parm
= TREE_VEC_ELT (parms
, i
);
13492 arg
= TREE_VEC_ELT (args
, i
);
13493 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
13494 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
13496 if (parm
&& TREE_VALUE (parm
) && arg
)
13498 /* If PARM represents a template parameter pack,
13499 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
13500 by DW_TAG_template_*_parameter DIEs for the argument
13501 pack elements of ARG. Note that ARG would then be
13502 an argument pack. */
13503 if (arg_pack_elems
)
13504 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
13508 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
13509 true /* emit name */, die
);
13510 if (i
>= non_default
)
13511 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
13516 /* Create and return a DIE for PARM which should be
13517 the representation of a generic type parameter.
13518 For instance, in the C++ front end, PARM would be a template parameter.
13519 ARG is the argument to PARM.
13520 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
13522 PARENT_DIE is the parent DIE which the new created DIE should be added to,
13523 as a child node. */
13526 generic_parameter_die (tree parm
, tree arg
,
13528 dw_die_ref parent_die
)
13530 dw_die_ref tmpl_die
= NULL
;
13531 const char *name
= NULL
;
13533 if (!parm
|| !DECL_NAME (parm
) || !arg
)
13536 /* We support non-type generic parameters and arguments,
13537 type generic parameters and arguments, as well as
13538 generic generic parameters (a.k.a. template template parameters in C++)
13540 if (TREE_CODE (parm
) == PARM_DECL
)
13541 /* PARM is a nontype generic parameter */
13542 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
13543 else if (TREE_CODE (parm
) == TYPE_DECL
)
13544 /* PARM is a type generic parameter. */
13545 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
13546 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
13547 /* PARM is a generic generic parameter.
13548 Its DIE is a GNU extension. It shall have a
13549 DW_AT_name attribute to represent the name of the template template
13550 parameter, and a DW_AT_GNU_template_name attribute to represent the
13551 name of the template template argument. */
13552 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
13555 gcc_unreachable ();
13561 /* If PARM is a generic parameter pack, it means we are
13562 emitting debug info for a template argument pack element.
13563 In other terms, ARG is a template argument pack element.
13564 In that case, we don't emit any DW_AT_name attribute for
13568 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
13570 add_AT_string (tmpl_die
, DW_AT_name
, name
);
13573 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
13575 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
13576 TMPL_DIE should have a child DW_AT_type attribute that is set
13577 to the type of the argument to PARM, which is ARG.
13578 If PARM is a type generic parameter, TMPL_DIE should have a
13579 child DW_AT_type that is set to ARG. */
13580 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
13581 add_type_attribute (tmpl_die
, tmpl_type
,
13582 (TREE_THIS_VOLATILE (tmpl_type
)
13583 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
),
13584 false, parent_die
);
13588 /* So TMPL_DIE is a DIE representing a
13589 a generic generic template parameter, a.k.a template template
13590 parameter in C++ and arg is a template. */
13592 /* The DW_AT_GNU_template_name attribute of the DIE must be set
13593 to the name of the argument. */
13594 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
13596 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
13599 if (TREE_CODE (parm
) == PARM_DECL
)
13600 /* So PARM is a non-type generic parameter.
13601 DWARF3 5.6.8 says we must set a DW_AT_const_value child
13602 attribute of TMPL_DIE which value represents the value
13604 We must be careful here:
13605 The value of ARG might reference some function decls.
13606 We might currently be emitting debug info for a generic
13607 type and types are emitted before function decls, we don't
13608 know if the function decls referenced by ARG will actually be
13609 emitted after cgraph computations.
13610 So must defer the generation of the DW_AT_const_value to
13611 after cgraph is ready. */
13612 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
13618 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
13619 PARM_PACK must be a template parameter pack. The returned DIE
13620 will be child DIE of PARENT_DIE. */
13623 template_parameter_pack_die (tree parm_pack
,
13624 tree parm_pack_args
,
13625 dw_die_ref parent_die
)
13630 gcc_assert (parent_die
&& parm_pack
);
13632 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
13633 add_name_and_src_coords_attributes (die
, parm_pack
);
13634 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
13635 generic_parameter_die (parm_pack
,
13636 TREE_VEC_ELT (parm_pack_args
, j
),
13637 false /* Don't emit DW_AT_name */,
13642 /* Return the DBX register number described by a given RTL node. */
13644 static unsigned int
13645 dbx_reg_number (const_rtx rtl
)
13647 unsigned regno
= REGNO (rtl
);
13649 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
13651 #ifdef LEAF_REG_REMAP
13652 if (crtl
->uses_only_leaf_regs
)
13654 int leaf_reg
= LEAF_REG_REMAP (regno
);
13655 if (leaf_reg
!= -1)
13656 regno
= (unsigned) leaf_reg
;
13660 regno
= DBX_REGISTER_NUMBER (regno
);
13661 gcc_assert (regno
!= INVALID_REGNUM
);
13665 /* Optionally add a DW_OP_piece term to a location description expression.
13666 DW_OP_piece is only added if the location description expression already
13667 doesn't end with DW_OP_piece. */
13670 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
13672 dw_loc_descr_ref loc
;
13674 if (*list_head
!= NULL
)
13676 /* Find the end of the chain. */
13677 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
13680 if (loc
->dw_loc_opc
!= DW_OP_piece
)
13681 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
13685 /* Return a location descriptor that designates a machine register or
13686 zero if there is none. */
13688 static dw_loc_descr_ref
13689 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
13693 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
13696 /* We only use "frame base" when we're sure we're talking about the
13697 post-prologue local stack frame. We do this by *not* running
13698 register elimination until this point, and recognizing the special
13699 argument pointer and soft frame pointer rtx's.
13700 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
13701 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
13702 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
13704 dw_loc_descr_ref result
= NULL
;
13706 if (dwarf_version
>= 4 || !dwarf_strict
)
13708 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
13711 add_loc_descr (&result
,
13712 new_loc_descr (DW_OP_stack_value
, 0, 0));
13717 regs
= targetm
.dwarf_register_span (rtl
);
13719 if (REG_NREGS (rtl
) > 1 || regs
)
13720 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
13723 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
13724 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
13726 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
13730 /* Return a location descriptor that designates a machine register for
13731 a given hard register number. */
13733 static dw_loc_descr_ref
13734 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
13736 dw_loc_descr_ref reg_loc_descr
;
13740 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
13742 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
13744 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13745 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13747 return reg_loc_descr
;
13750 /* Given an RTL of a register, return a location descriptor that
13751 designates a value that spans more than one register. */
13753 static dw_loc_descr_ref
13754 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
13755 enum var_init_status initialized
)
13758 dw_loc_descr_ref loc_result
= NULL
;
13760 /* Simple, contiguous registers. */
13761 if (regs
== NULL_RTX
)
13763 unsigned reg
= REGNO (rtl
);
13766 #ifdef LEAF_REG_REMAP
13767 if (crtl
->uses_only_leaf_regs
)
13769 int leaf_reg
= LEAF_REG_REMAP (reg
);
13770 if (leaf_reg
!= -1)
13771 reg
= (unsigned) leaf_reg
;
13775 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
13776 nregs
= REG_NREGS (rtl
);
13778 /* At present we only track constant-sized pieces. */
13779 if (!GET_MODE_SIZE (GET_MODE (rtl
)).is_constant (&size
))
13786 dw_loc_descr_ref t
;
13788 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
13789 VAR_INIT_STATUS_INITIALIZED
);
13790 add_loc_descr (&loc_result
, t
);
13791 add_loc_descr_op_piece (&loc_result
, size
);
13797 /* Now onto stupid register sets in non contiguous locations. */
13799 gcc_assert (GET_CODE (regs
) == PARALLEL
);
13801 /* At present we only track constant-sized pieces. */
13802 if (!GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0))).is_constant (&size
))
13806 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
13808 dw_loc_descr_ref t
;
13810 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
13811 VAR_INIT_STATUS_INITIALIZED
);
13812 add_loc_descr (&loc_result
, t
);
13813 add_loc_descr_op_piece (&loc_result
, size
);
13816 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13817 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13821 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
13823 /* Return a location descriptor that designates a constant i,
13824 as a compound operation from constant (i >> shift), constant shift
13827 static dw_loc_descr_ref
13828 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
13830 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
13831 add_loc_descr (&ret
, int_loc_descriptor (shift
));
13832 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
13836 /* Return a location descriptor that designates constant POLY_I. */
13838 static dw_loc_descr_ref
13839 int_loc_descriptor (poly_int64 poly_i
)
13841 enum dwarf_location_atom op
;
13844 if (!poly_i
.is_constant (&i
))
13846 /* Create location descriptions for the non-constant part and
13847 add any constant offset at the end. */
13848 dw_loc_descr_ref ret
= NULL
;
13849 HOST_WIDE_INT constant
= poly_i
.coeffs
[0];
13850 for (unsigned int j
= 1; j
< NUM_POLY_INT_COEFFS
; ++j
)
13852 HOST_WIDE_INT coeff
= poly_i
.coeffs
[j
];
13855 dw_loc_descr_ref start
= ret
;
13856 unsigned int factor
;
13858 unsigned int regno
= targetm
.dwarf_poly_indeterminate_value
13859 (j
, &factor
, &bias
);
13861 /* Add COEFF * ((REGNO / FACTOR) - BIAS) to the value:
13862 add COEFF * (REGNO / FACTOR) now and subtract
13863 COEFF * BIAS from the final constant part. */
13864 constant
-= coeff
* bias
;
13865 add_loc_descr (&ret
, new_reg_loc_descr (regno
, 0));
13866 if (coeff
% factor
== 0)
13870 int amount
= exact_log2 (factor
);
13871 gcc_assert (amount
>= 0);
13872 add_loc_descr (&ret
, int_loc_descriptor (amount
));
13873 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
13877 add_loc_descr (&ret
, int_loc_descriptor (coeff
));
13878 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
13881 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
13884 loc_descr_plus_const (&ret
, constant
);
13888 /* Pick the smallest representation of a constant, rather than just
13889 defaulting to the LEB encoding. */
13892 int clz
= clz_hwi (i
);
13893 int ctz
= ctz_hwi (i
);
13895 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
13896 else if (i
<= 0xff)
13897 op
= DW_OP_const1u
;
13898 else if (i
<= 0xffff)
13899 op
= DW_OP_const2u
;
13900 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
13901 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
13902 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
13903 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
13904 while DW_OP_const4u is 5 bytes. */
13905 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
13906 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13907 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
13908 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
13909 while DW_OP_const4u is 5 bytes. */
13910 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
13912 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
13913 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
13916 /* As i >= 2**31, the double cast above will yield a negative number.
13917 Since wrapping is defined in DWARF expressions we can output big
13918 positive integers as small negative ones, regardless of the size
13921 Here, since the evaluator will handle 32-bit values and since i >=
13922 2**31, we know it's going to be interpreted as a negative literal:
13923 store it this way if we can do better than 5 bytes this way. */
13924 return int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
13926 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
13927 op
= DW_OP_const4u
;
13929 /* Past this point, i >= 0x100000000 and thus DW_OP_constu will take at
13930 least 6 bytes: see if we can do better before falling back to it. */
13931 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13932 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
13933 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes. */
13934 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
13935 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
13936 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
13937 >= HOST_BITS_PER_WIDE_INT
)
13938 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
13939 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes. */
13940 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
13941 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
13942 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
13943 && size_of_uleb128 (i
) > 6)
13944 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
13945 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
13952 op
= DW_OP_const1s
;
13953 else if (i
>= -0x8000)
13954 op
= DW_OP_const2s
;
13955 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
13957 if (size_of_int_loc_descriptor (i
) < 5)
13959 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
13960 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
13963 op
= DW_OP_const4s
;
13967 if (size_of_int_loc_descriptor (i
)
13968 < (unsigned long) 1 + size_of_sleb128 (i
))
13970 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
13971 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
13978 return new_loc_descr (op
, i
, 0);
13981 /* Likewise, for unsigned constants. */
13983 static dw_loc_descr_ref
13984 uint_loc_descriptor (unsigned HOST_WIDE_INT i
)
13986 const unsigned HOST_WIDE_INT max_int
= INTTYPE_MAXIMUM (HOST_WIDE_INT
);
13987 const unsigned HOST_WIDE_INT max_uint
13988 = INTTYPE_MAXIMUM (unsigned HOST_WIDE_INT
);
13990 /* If possible, use the clever signed constants handling. */
13992 return int_loc_descriptor ((HOST_WIDE_INT
) i
);
13994 /* Here, we are left with positive numbers that cannot be represented as
13995 HOST_WIDE_INT, i.e.:
13996 max (HOST_WIDE_INT) < i <= max (unsigned HOST_WIDE_INT)
13998 Using DW_OP_const4/8/./u operation to encode them consumes a lot of bytes
13999 whereas may be better to output a negative integer: thanks to integer
14000 wrapping, we know that:
14001 x = x - 2 ** DWARF2_ADDR_SIZE
14002 = x - 2 * (max (HOST_WIDE_INT) + 1)
14003 So numbers close to max (unsigned HOST_WIDE_INT) could be represented as
14004 small negative integers. Let's try that in cases it will clearly improve
14005 the encoding: there is no gain turning DW_OP_const4u into
14007 if (DWARF2_ADDR_SIZE
* 8 == HOST_BITS_PER_WIDE_INT
14008 && ((DWARF2_ADDR_SIZE
== 4 && i
> max_uint
- 0x8000)
14009 || (DWARF2_ADDR_SIZE
== 8 && i
> max_uint
- 0x80000000)))
14011 const unsigned HOST_WIDE_INT first_shift
= i
- max_int
- 1;
14013 /* Now, -1 < first_shift <= max (HOST_WIDE_INT)
14014 i.e. 0 <= first_shift <= max (HOST_WIDE_INT). */
14015 const HOST_WIDE_INT second_shift
14016 = (HOST_WIDE_INT
) first_shift
- (HOST_WIDE_INT
) max_int
- 1;
14018 /* So we finally have:
14019 -max (HOST_WIDE_INT) - 1 <= second_shift <= -1.
14020 i.e. min (HOST_WIDE_INT) <= second_shift < 0. */
14021 return int_loc_descriptor (second_shift
);
14024 /* Last chance: fallback to a simple constant operation. */
14025 return new_loc_descr
14026 ((HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14032 /* Generate and return a location description that computes the unsigned
14033 comparison of the two stack top entries (a OP b where b is the top-most
14034 entry and a is the second one). The KIND of comparison can be LT_EXPR,
14035 LE_EXPR, GT_EXPR or GE_EXPR. */
14037 static dw_loc_descr_ref
14038 uint_comparison_loc_list (enum tree_code kind
)
14040 enum dwarf_location_atom op
, flip_op
;
14041 dw_loc_descr_ref ret
, bra_node
, jmp_node
, tmp
;
14058 gcc_unreachable ();
14061 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14062 jmp_node
= new_loc_descr (DW_OP_skip
, 0, 0);
14064 /* Until DWARFv4, operations all work on signed integers. It is nevertheless
14065 possible to perform unsigned comparisons: we just have to distinguish
14068 1. when a and b have the same sign (as signed integers); then we should
14069 return: a OP(signed) b;
14071 2. when a is a negative signed integer while b is a positive one, then a
14072 is a greater unsigned integer than b; likewise when a and b's roles
14075 So first, compare the sign of the two operands. */
14076 ret
= new_loc_descr (DW_OP_over
, 0, 0);
14077 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
14078 add_loc_descr (&ret
, new_loc_descr (DW_OP_xor
, 0, 0));
14079 /* If they have different signs (i.e. they have different sign bits), then
14080 the stack top value has now the sign bit set and thus it's smaller than
14082 add_loc_descr (&ret
, new_loc_descr (DW_OP_lit0
, 0, 0));
14083 add_loc_descr (&ret
, new_loc_descr (DW_OP_lt
, 0, 0));
14084 add_loc_descr (&ret
, bra_node
);
14086 /* We are in case 1. At this point, we know both operands have the same
14087 sign, to it's safe to use the built-in signed comparison. */
14088 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14089 add_loc_descr (&ret
, jmp_node
);
14091 /* We are in case 2. Here, we know both operands do not have the same sign,
14092 so we have to flip the signed comparison. */
14093 flip_op
= (kind
== LT_EXPR
|| kind
== LE_EXPR
) ? DW_OP_gt
: DW_OP_lt
;
14094 tmp
= new_loc_descr (flip_op
, 0, 0);
14095 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14096 bra_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14097 add_loc_descr (&ret
, tmp
);
14099 /* This dummy operation is necessary to make the two branches join. */
14100 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
14101 jmp_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14102 jmp_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14103 add_loc_descr (&ret
, tmp
);
14108 /* Likewise, but takes the location description lists (might be destructive on
14109 them). Return NULL if either is NULL or if concatenation fails. */
14111 static dw_loc_list_ref
14112 loc_list_from_uint_comparison (dw_loc_list_ref left
, dw_loc_list_ref right
,
14113 enum tree_code kind
)
14115 if (left
== NULL
|| right
== NULL
)
14118 add_loc_list (&left
, right
);
14122 add_loc_descr_to_each (left
, uint_comparison_loc_list (kind
));
14126 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
14127 without actually allocating it. */
14129 static unsigned long
14130 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
14132 return size_of_int_loc_descriptor (i
>> shift
)
14133 + size_of_int_loc_descriptor (shift
)
14137 /* Return size_of_locs (int_loc_descriptor (i)) without
14138 actually allocating it. */
14140 static unsigned long
14141 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
14150 else if (i
<= 0xff)
14152 else if (i
<= 0xffff)
14156 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
14157 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
14158 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14160 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14161 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
14162 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14164 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
14165 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
14167 return size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
14168 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14170 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
14171 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14172 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
14173 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14175 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
14176 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
14177 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14179 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
14180 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
14182 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14191 else if (i
>= -0x8000)
14193 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
14195 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
14197 s
= size_of_int_loc_descriptor (-i
) + 1;
14205 unsigned long r
= 1 + size_of_sleb128 (i
);
14206 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
14208 s
= size_of_int_loc_descriptor (-i
) + 1;
14217 /* Return loc description representing "address" of integer value.
14218 This can appear only as toplevel expression. */
14220 static dw_loc_descr_ref
14221 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
14224 dw_loc_descr_ref loc_result
= NULL
;
14226 if (!(dwarf_version
>= 4 || !dwarf_strict
))
14229 litsize
= size_of_int_loc_descriptor (i
);
14230 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
14231 is more compact. For DW_OP_stack_value we need:
14232 litsize + 1 (DW_OP_stack_value)
14233 and for DW_OP_implicit_value:
14234 1 (DW_OP_implicit_value) + 1 (length) + size. */
14235 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
14237 loc_result
= int_loc_descriptor (i
);
14238 add_loc_descr (&loc_result
,
14239 new_loc_descr (DW_OP_stack_value
, 0, 0));
14243 loc_result
= new_loc_descr (DW_OP_implicit_value
,
14245 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
14246 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
14250 /* Return a location descriptor that designates a base+offset location. */
14252 static dw_loc_descr_ref
14253 based_loc_descr (rtx reg
, poly_int64 offset
,
14254 enum var_init_status initialized
)
14256 unsigned int regno
;
14257 dw_loc_descr_ref result
;
14258 dw_fde_ref fde
= cfun
->fde
;
14260 /* We only use "frame base" when we're sure we're talking about the
14261 post-prologue local stack frame. We do this by *not* running
14262 register elimination until this point, and recognizing the special
14263 argument pointer and soft frame pointer rtx's. */
14264 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
14266 rtx elim
= (ira_use_lra_p
14267 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
14268 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
14272 /* Allow hard frame pointer here even if frame pointer
14273 isn't used since hard frame pointer is encoded with
14274 DW_OP_fbreg which uses the DW_AT_frame_base attribute,
14275 not hard frame pointer directly. */
14276 elim
= strip_offset_and_add (elim
, &offset
);
14277 gcc_assert (elim
== hard_frame_pointer_rtx
14278 || elim
== stack_pointer_rtx
);
14280 /* If drap register is used to align stack, use frame
14281 pointer + offset to access stack variables. If stack
14282 is aligned without drap, use stack pointer + offset to
14283 access stack variables. */
14284 if (crtl
->stack_realign_tried
14285 && reg
== frame_pointer_rtx
)
14288 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
14289 ? HARD_FRAME_POINTER_REGNUM
14291 return new_reg_loc_descr (base_reg
, offset
);
14294 gcc_assert (frame_pointer_fb_offset_valid
);
14295 offset
+= frame_pointer_fb_offset
;
14296 HOST_WIDE_INT const_offset
;
14297 if (offset
.is_constant (&const_offset
))
14298 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
14301 dw_loc_descr_ref ret
= new_loc_descr (DW_OP_fbreg
, 0, 0);
14302 loc_descr_plus_const (&ret
, offset
);
14308 regno
= REGNO (reg
);
14309 #ifdef LEAF_REG_REMAP
14310 if (crtl
->uses_only_leaf_regs
)
14312 int leaf_reg
= LEAF_REG_REMAP (regno
);
14313 if (leaf_reg
!= -1)
14314 regno
= (unsigned) leaf_reg
;
14317 regno
= DWARF_FRAME_REGNUM (regno
);
14319 HOST_WIDE_INT const_offset
;
14320 if (!optimize
&& fde
14321 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
)
14322 && offset
.is_constant (&const_offset
))
14324 /* Use cfa+offset to represent the location of arguments passed
14325 on the stack when drap is used to align stack.
14326 Only do this when not optimizing, for optimized code var-tracking
14327 is supposed to track where the arguments live and the register
14328 used as vdrap or drap in some spot might be used for something
14329 else in other part of the routine. */
14330 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
14333 result
= new_reg_loc_descr (regno
, offset
);
14335 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14336 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14341 /* Return true if this RTL expression describes a base+offset calculation. */
14344 is_based_loc (const_rtx rtl
)
14346 return (GET_CODE (rtl
) == PLUS
14347 && ((REG_P (XEXP (rtl
, 0))
14348 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
14349 && CONST_INT_P (XEXP (rtl
, 1)))));
14352 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
14355 static dw_loc_descr_ref
14356 tls_mem_loc_descriptor (rtx mem
)
14359 dw_loc_descr_ref loc_result
;
14361 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
14364 base
= get_base_address (MEM_EXPR (mem
));
14367 || !DECL_THREAD_LOCAL_P (base
))
14370 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1, NULL
);
14371 if (loc_result
== NULL
)
14374 if (maybe_ne (MEM_OFFSET (mem
), 0))
14375 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
14380 /* Output debug info about reason why we failed to expand expression as dwarf
14384 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
14386 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
14388 fprintf (dump_file
, "Failed to expand as dwarf: ");
14390 print_generic_expr (dump_file
, expr
, dump_flags
);
14393 fprintf (dump_file
, "\n");
14394 print_rtl (dump_file
, rtl
);
14396 fprintf (dump_file
, "\nReason: %s\n", reason
);
14400 /* Helper function for const_ok_for_output. */
14403 const_ok_for_output_1 (rtx rtl
)
14405 if (targetm
.const_not_ok_for_debug_p (rtl
))
14407 if (GET_CODE (rtl
) != UNSPEC
)
14409 expansion_failed (NULL_TREE
, rtl
,
14410 "Expression rejected for debug by the backend.\n");
14414 /* If delegitimize_address couldn't do anything with the UNSPEC, and
14415 the target hook doesn't explicitly allow it in debug info, assume
14416 we can't express it in the debug info. */
14417 /* Don't complain about TLS UNSPECs, those are just too hard to
14418 delegitimize. Note this could be a non-decl SYMBOL_REF such as
14419 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
14420 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
14422 && (XVECLEN (rtl
, 0) == 0
14423 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
14424 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
))
14425 inform (current_function_decl
14426 ? DECL_SOURCE_LOCATION (current_function_decl
)
14427 : UNKNOWN_LOCATION
,
14428 #if NUM_UNSPEC_VALUES > 0
14429 "non-delegitimized UNSPEC %s (%d) found in variable location",
14430 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
14431 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
14434 "non-delegitimized UNSPEC %d found in variable location",
14437 expansion_failed (NULL_TREE
, rtl
,
14438 "UNSPEC hasn't been delegitimized.\n");
14442 if (CONST_POLY_INT_P (rtl
))
14445 if (targetm
.const_not_ok_for_debug_p (rtl
))
14447 expansion_failed (NULL_TREE
, rtl
,
14448 "Expression rejected for debug by the backend.\n");
14452 /* FIXME: Refer to PR60655. It is possible for simplification
14453 of rtl expressions in var tracking to produce such expressions.
14454 We should really identify / validate expressions
14455 enclosed in CONST that can be handled by assemblers on various
14456 targets and only handle legitimate cases here. */
14457 switch (GET_CODE (rtl
))
14468 if (CONSTANT_POOL_ADDRESS_P (rtl
))
14471 get_pool_constant_mark (rtl
, &marked
);
14472 /* If all references to this pool constant were optimized away,
14473 it was not output and thus we can't represent it. */
14476 expansion_failed (NULL_TREE
, rtl
,
14477 "Constant was removed from constant pool.\n");
14482 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
14485 /* Avoid references to external symbols in debug info, on several targets
14486 the linker might even refuse to link when linking a shared library,
14487 and in many other cases the relocations for .debug_info/.debug_loc are
14488 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
14489 to be defined within the same shared library or executable are fine. */
14490 if (SYMBOL_REF_EXTERNAL_P (rtl
))
14492 tree decl
= SYMBOL_REF_DECL (rtl
);
14494 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
14496 expansion_failed (NULL_TREE
, rtl
,
14497 "Symbol not defined in current TU.\n");
14505 /* Return true if constant RTL can be emitted in DW_OP_addr or
14506 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
14507 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
14510 const_ok_for_output (rtx rtl
)
14512 if (GET_CODE (rtl
) == SYMBOL_REF
)
14513 return const_ok_for_output_1 (rtl
);
14515 if (GET_CODE (rtl
) == CONST
)
14517 subrtx_var_iterator::array_type array
;
14518 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
14519 if (!const_ok_for_output_1 (*iter
))
14527 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
14528 if possible, NULL otherwise. */
14531 base_type_for_mode (machine_mode mode
, bool unsignedp
)
14533 dw_die_ref type_die
;
14534 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
14538 switch (TREE_CODE (type
))
14546 type_die
= lookup_type_die (type
);
14548 type_die
= modified_type_die (type
, TYPE_UNQUALIFIED
, false,
14550 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
14555 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
14556 type matching MODE, or, if MODE is narrower than or as wide as
14557 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
14560 static dw_loc_descr_ref
14561 convert_descriptor_to_mode (scalar_int_mode mode
, dw_loc_descr_ref op
)
14563 machine_mode outer_mode
= mode
;
14564 dw_die_ref type_die
;
14565 dw_loc_descr_ref cvt
;
14567 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
14569 add_loc_descr (&op
, new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0));
14572 type_die
= base_type_for_mode (outer_mode
, 1);
14573 if (type_die
== NULL
)
14575 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14576 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14577 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14578 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14579 add_loc_descr (&op
, cvt
);
14583 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
14585 static dw_loc_descr_ref
14586 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
14587 dw_loc_descr_ref op1
)
14589 dw_loc_descr_ref ret
= op0
;
14590 add_loc_descr (&ret
, op1
);
14591 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14592 if (STORE_FLAG_VALUE
!= 1)
14594 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
14595 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
14600 /* Subroutine of scompare_loc_descriptor for the case in which we're
14601 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
14602 and in which OP_MODE is bigger than DWARF2_ADDR_SIZE. */
14604 static dw_loc_descr_ref
14605 scompare_loc_descriptor_wide (enum dwarf_location_atom op
,
14606 scalar_int_mode op_mode
,
14607 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
14609 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
14610 dw_loc_descr_ref cvt
;
14612 if (type_die
== NULL
)
14614 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14615 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14616 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14617 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14618 add_loc_descr (&op0
, cvt
);
14619 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14620 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14621 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14622 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14623 add_loc_descr (&op1
, cvt
);
14624 return compare_loc_descriptor (op
, op0
, op1
);
14627 /* Subroutine of scompare_loc_descriptor for the case in which we're
14628 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
14629 and in which OP_MODE is smaller than DWARF2_ADDR_SIZE. */
14631 static dw_loc_descr_ref
14632 scompare_loc_descriptor_narrow (enum dwarf_location_atom op
, rtx rtl
,
14633 scalar_int_mode op_mode
,
14634 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
14636 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
14637 /* For eq/ne, if the operands are known to be zero-extended,
14638 there is no need to do the fancy shifting up. */
14639 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
14641 dw_loc_descr_ref last0
, last1
;
14642 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
14644 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
14646 /* deref_size zero extends, and for constants we can check
14647 whether they are zero extended or not. */
14648 if (((last0
->dw_loc_opc
== DW_OP_deref_size
14649 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
14650 || (CONST_INT_P (XEXP (rtl
, 0))
14651 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
14652 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
14653 && ((last1
->dw_loc_opc
== DW_OP_deref_size
14654 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
14655 || (CONST_INT_P (XEXP (rtl
, 1))
14656 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
14657 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
14658 return compare_loc_descriptor (op
, op0
, op1
);
14660 /* EQ/NE comparison against constant in narrower type than
14661 DWARF2_ADDR_SIZE can be performed either as
14662 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
14665 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
14666 DW_OP_{eq,ne}. Pick whatever is shorter. */
14667 if (CONST_INT_P (XEXP (rtl
, 1))
14668 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
14669 && (size_of_int_loc_descriptor (shift
) + 1
14670 + size_of_int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
)
14671 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
14672 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
14673 & GET_MODE_MASK (op_mode
))))
14675 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
14676 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14677 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
14678 & GET_MODE_MASK (op_mode
));
14679 return compare_loc_descriptor (op
, op0
, op1
);
14682 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14683 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14684 if (CONST_INT_P (XEXP (rtl
, 1)))
14685 op1
= int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
);
14688 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14689 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14691 return compare_loc_descriptor (op
, op0
, op1
);
14694 /* Return location descriptor for unsigned comparison OP RTL. */
14696 static dw_loc_descr_ref
14697 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
14698 machine_mode mem_mode
)
14700 machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
14701 dw_loc_descr_ref op0
, op1
;
14703 if (op_mode
== VOIDmode
)
14704 op_mode
= GET_MODE (XEXP (rtl
, 1));
14705 if (op_mode
== VOIDmode
)
14708 scalar_int_mode int_op_mode
;
14710 && dwarf_version
< 5
14711 && (!is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
)
14712 || GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
))
14715 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
14716 VAR_INIT_STATUS_INITIALIZED
);
14717 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
14718 VAR_INIT_STATUS_INITIALIZED
);
14720 if (op0
== NULL
|| op1
== NULL
)
14723 if (is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
))
14725 if (GET_MODE_SIZE (int_op_mode
) < DWARF2_ADDR_SIZE
)
14726 return scompare_loc_descriptor_narrow (op
, rtl
, int_op_mode
, op0
, op1
);
14728 if (GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
)
14729 return scompare_loc_descriptor_wide (op
, int_op_mode
, op0
, op1
);
14731 return compare_loc_descriptor (op
, op0
, op1
);
14734 /* Return location descriptor for unsigned comparison OP RTL. */
14736 static dw_loc_descr_ref
14737 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
14738 machine_mode mem_mode
)
14740 dw_loc_descr_ref op0
, op1
;
14742 machine_mode test_op_mode
= GET_MODE (XEXP (rtl
, 0));
14743 if (test_op_mode
== VOIDmode
)
14744 test_op_mode
= GET_MODE (XEXP (rtl
, 1));
14746 scalar_int_mode op_mode
;
14747 if (!is_a
<scalar_int_mode
> (test_op_mode
, &op_mode
))
14751 && dwarf_version
< 5
14752 && GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
14755 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
14756 VAR_INIT_STATUS_INITIALIZED
);
14757 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
14758 VAR_INIT_STATUS_INITIALIZED
);
14760 if (op0
== NULL
|| op1
== NULL
)
14763 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
14765 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
14766 dw_loc_descr_ref last0
, last1
;
14767 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
14769 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
14771 if (CONST_INT_P (XEXP (rtl
, 0)))
14772 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
14773 /* deref_size zero extends, so no need to mask it again. */
14774 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
14775 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
14777 add_loc_descr (&op0
, int_loc_descriptor (mask
));
14778 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14780 if (CONST_INT_P (XEXP (rtl
, 1)))
14781 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
14782 /* deref_size zero extends, so no need to mask it again. */
14783 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
14784 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
14786 add_loc_descr (&op1
, int_loc_descriptor (mask
));
14787 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
14790 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
14792 HOST_WIDE_INT bias
= 1;
14793 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
14794 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14795 if (CONST_INT_P (XEXP (rtl
, 1)))
14796 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
14797 + INTVAL (XEXP (rtl
, 1)));
14799 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
14802 return compare_loc_descriptor (op
, op0
, op1
);
14805 /* Return location descriptor for {U,S}{MIN,MAX}. */
14807 static dw_loc_descr_ref
14808 minmax_loc_descriptor (rtx rtl
, machine_mode mode
,
14809 machine_mode mem_mode
)
14811 enum dwarf_location_atom op
;
14812 dw_loc_descr_ref op0
, op1
, ret
;
14813 dw_loc_descr_ref bra_node
, drop_node
;
14815 scalar_int_mode int_mode
;
14817 && dwarf_version
< 5
14818 && (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
14819 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
))
14822 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14823 VAR_INIT_STATUS_INITIALIZED
);
14824 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
14825 VAR_INIT_STATUS_INITIALIZED
);
14827 if (op0
== NULL
|| op1
== NULL
)
14830 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
14831 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
14832 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
14833 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
14835 /* Checked by the caller. */
14836 int_mode
= as_a
<scalar_int_mode
> (mode
);
14837 if (GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
14839 HOST_WIDE_INT mask
= GET_MODE_MASK (int_mode
);
14840 add_loc_descr (&op0
, int_loc_descriptor (mask
));
14841 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14842 add_loc_descr (&op1
, int_loc_descriptor (mask
));
14843 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
14845 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
14847 HOST_WIDE_INT bias
= 1;
14848 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
14849 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14850 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14853 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14854 && GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
14856 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (int_mode
)) * BITS_PER_UNIT
;
14857 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14858 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14859 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14860 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14862 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14863 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
14865 dw_die_ref type_die
= base_type_for_mode (int_mode
, 0);
14866 dw_loc_descr_ref cvt
;
14867 if (type_die
== NULL
)
14869 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14870 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14871 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14872 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14873 add_loc_descr (&op0
, cvt
);
14874 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14875 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14876 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14877 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14878 add_loc_descr (&op1
, cvt
);
14881 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
14886 add_loc_descr (&ret
, op1
);
14887 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14888 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14889 add_loc_descr (&ret
, bra_node
);
14890 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14891 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
14892 add_loc_descr (&ret
, drop_node
);
14893 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14894 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
14895 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
14896 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
14897 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
14898 ret
= convert_descriptor_to_mode (int_mode
, ret
);
14902 /* Helper function for mem_loc_descriptor. Perform OP binary op,
14903 but after converting arguments to type_die, afterwards
14904 convert back to unsigned. */
14906 static dw_loc_descr_ref
14907 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
14908 scalar_int_mode mode
, machine_mode mem_mode
)
14910 dw_loc_descr_ref cvt
, op0
, op1
;
14912 if (type_die
== NULL
)
14914 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14915 VAR_INIT_STATUS_INITIALIZED
);
14916 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
14917 VAR_INIT_STATUS_INITIALIZED
);
14918 if (op0
== NULL
|| op1
== NULL
)
14920 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14921 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14922 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14923 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14924 add_loc_descr (&op0
, cvt
);
14925 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14926 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14927 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14928 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14929 add_loc_descr (&op1
, cvt
);
14930 add_loc_descr (&op0
, op1
);
14931 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
14932 return convert_descriptor_to_mode (mode
, op0
);
14935 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
14936 const0 is DW_OP_lit0 or corresponding typed constant,
14937 const1 is DW_OP_lit1 or corresponding typed constant
14938 and constMSB is constant with just the MSB bit set
14940 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
14941 L1: const0 DW_OP_swap
14942 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
14943 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
14948 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
14949 L1: const0 DW_OP_swap
14950 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
14951 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
14956 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
14957 L1: const1 DW_OP_swap
14958 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
14959 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
14963 static dw_loc_descr_ref
14964 clz_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
14965 machine_mode mem_mode
)
14967 dw_loc_descr_ref op0
, ret
, tmp
;
14968 HOST_WIDE_INT valv
;
14969 dw_loc_descr_ref l1jump
, l1label
;
14970 dw_loc_descr_ref l2jump
, l2label
;
14971 dw_loc_descr_ref l3jump
, l3label
;
14972 dw_loc_descr_ref l4jump
, l4label
;
14975 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
14978 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14979 VAR_INIT_STATUS_INITIALIZED
);
14983 if (GET_CODE (rtl
) == CLZ
)
14985 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
14986 valv
= GET_MODE_BITSIZE (mode
);
14988 else if (GET_CODE (rtl
) == FFS
)
14990 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
14991 valv
= GET_MODE_BITSIZE (mode
);
14992 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
14993 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
14994 add_loc_descr (&ret
, l1jump
);
14995 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
14996 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
14997 VAR_INIT_STATUS_INITIALIZED
);
15000 add_loc_descr (&ret
, tmp
);
15001 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15002 add_loc_descr (&ret
, l4jump
);
15003 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
15004 ? const1_rtx
: const0_rtx
,
15006 VAR_INIT_STATUS_INITIALIZED
);
15007 if (l1label
== NULL
)
15009 add_loc_descr (&ret
, l1label
);
15010 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15011 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
15012 add_loc_descr (&ret
, l2label
);
15013 if (GET_CODE (rtl
) != CLZ
)
15015 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
15016 msb
= GEN_INT (HOST_WIDE_INT_1U
15017 << (GET_MODE_BITSIZE (mode
) - 1));
15019 msb
= immed_wide_int_const
15020 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode
) - 1,
15021 GET_MODE_PRECISION (mode
)), mode
);
15022 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
15023 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
15024 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
15025 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
15027 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
15028 VAR_INIT_STATUS_INITIALIZED
);
15031 add_loc_descr (&ret
, tmp
);
15032 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15033 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15034 add_loc_descr (&ret
, l3jump
);
15035 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15036 VAR_INIT_STATUS_INITIALIZED
);
15039 add_loc_descr (&ret
, tmp
);
15040 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
15041 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
15042 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15043 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
15044 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15045 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15046 add_loc_descr (&ret
, l2jump
);
15047 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
15048 add_loc_descr (&ret
, l3label
);
15049 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
15050 add_loc_descr (&ret
, l4label
);
15051 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15052 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15053 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15054 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15055 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15056 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
15057 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15058 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
15062 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
15063 const1 is DW_OP_lit1 or corresponding typed constant):
15065 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15066 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15070 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15071 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15074 static dw_loc_descr_ref
15075 popcount_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15076 machine_mode mem_mode
)
15078 dw_loc_descr_ref op0
, ret
, tmp
;
15079 dw_loc_descr_ref l1jump
, l1label
;
15080 dw_loc_descr_ref l2jump
, l2label
;
15082 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
15085 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15086 VAR_INIT_STATUS_INITIALIZED
);
15090 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15091 VAR_INIT_STATUS_INITIALIZED
);
15094 add_loc_descr (&ret
, tmp
);
15095 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15096 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
15097 add_loc_descr (&ret
, l1label
);
15098 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15099 add_loc_descr (&ret
, l2jump
);
15100 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15101 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
15102 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15103 VAR_INIT_STATUS_INITIALIZED
);
15106 add_loc_descr (&ret
, tmp
);
15107 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15108 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
15109 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
15110 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15111 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15112 VAR_INIT_STATUS_INITIALIZED
);
15113 add_loc_descr (&ret
, tmp
);
15114 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15115 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15116 add_loc_descr (&ret
, l1jump
);
15117 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
15118 add_loc_descr (&ret
, l2label
);
15119 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15120 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15121 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15122 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15126 /* BSWAP (constS is initial shift count, either 56 or 24):
15128 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
15129 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
15130 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
15131 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
15132 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
15134 static dw_loc_descr_ref
15135 bswap_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15136 machine_mode mem_mode
)
15138 dw_loc_descr_ref op0
, ret
, tmp
;
15139 dw_loc_descr_ref l1jump
, l1label
;
15140 dw_loc_descr_ref l2jump
, l2label
;
15142 if (BITS_PER_UNIT
!= 8
15143 || (GET_MODE_BITSIZE (mode
) != 32
15144 && GET_MODE_BITSIZE (mode
) != 64))
15147 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15148 VAR_INIT_STATUS_INITIALIZED
);
15153 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
15155 VAR_INIT_STATUS_INITIALIZED
);
15158 add_loc_descr (&ret
, tmp
);
15159 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15160 VAR_INIT_STATUS_INITIALIZED
);
15163 add_loc_descr (&ret
, tmp
);
15164 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
15165 add_loc_descr (&ret
, l1label
);
15166 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
15168 VAR_INIT_STATUS_INITIALIZED
);
15169 add_loc_descr (&ret
, tmp
);
15170 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
15171 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15172 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15173 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
15174 VAR_INIT_STATUS_INITIALIZED
);
15177 add_loc_descr (&ret
, tmp
);
15178 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15179 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
15180 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
15181 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
15182 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15183 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15184 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15185 VAR_INIT_STATUS_INITIALIZED
);
15186 add_loc_descr (&ret
, tmp
);
15187 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
15188 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15189 add_loc_descr (&ret
, l2jump
);
15190 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
15191 VAR_INIT_STATUS_INITIALIZED
);
15192 add_loc_descr (&ret
, tmp
);
15193 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15194 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15195 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15196 add_loc_descr (&ret
, l1jump
);
15197 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
15198 add_loc_descr (&ret
, l2label
);
15199 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15200 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
15201 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15202 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15203 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15204 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15208 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
15209 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15210 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
15211 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
15213 ROTATERT is similar:
15214 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
15215 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15216 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
15218 static dw_loc_descr_ref
15219 rotate_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15220 machine_mode mem_mode
)
15222 rtx rtlop1
= XEXP (rtl
, 1);
15223 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
15226 if (is_narrower_int_mode (GET_MODE (rtlop1
), mode
))
15227 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
15228 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15229 VAR_INIT_STATUS_INITIALIZED
);
15230 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
15231 VAR_INIT_STATUS_INITIALIZED
);
15232 if (op0
== NULL
|| op1
== NULL
)
15234 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
15235 for (i
= 0; i
< 2; i
++)
15237 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
15238 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
15240 VAR_INIT_STATUS_INITIALIZED
);
15241 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
15242 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
15244 : HOST_BITS_PER_WIDE_INT
== 64
15245 ? DW_OP_const8u
: DW_OP_constu
,
15246 GET_MODE_MASK (mode
), 0);
15249 if (mask
[i
] == NULL
)
15251 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
15254 add_loc_descr (&ret
, op1
);
15255 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
15256 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
15257 if (GET_CODE (rtl
) == ROTATERT
)
15259 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
15260 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
15261 GET_MODE_BITSIZE (mode
), 0));
15263 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
15264 if (mask
[0] != NULL
)
15265 add_loc_descr (&ret
, mask
[0]);
15266 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
15267 if (mask
[1] != NULL
)
15269 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15270 add_loc_descr (&ret
, mask
[1]);
15271 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15273 if (GET_CODE (rtl
) == ROTATE
)
15275 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
15276 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
15277 GET_MODE_BITSIZE (mode
), 0));
15279 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15280 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
15284 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
15285 for DEBUG_PARAMETER_REF RTL. */
15287 static dw_loc_descr_ref
15288 parameter_ref_descriptor (rtx rtl
)
15290 dw_loc_descr_ref ret
;
15295 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
15296 /* With LTO during LTRANS we get the late DIE that refers to the early
15297 DIE, thus we add another indirection here. This seems to confuse
15298 gdb enough to make gcc.dg/guality/pr68860-1.c FAIL with LTO. */
15299 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
15300 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
15303 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15304 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
15305 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15309 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
15310 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
15315 /* The following routine converts the RTL for a variable or parameter
15316 (resident in memory) into an equivalent Dwarf representation of a
15317 mechanism for getting the address of that same variable onto the top of a
15318 hypothetical "address evaluation" stack.
15320 When creating memory location descriptors, we are effectively transforming
15321 the RTL for a memory-resident object into its Dwarf postfix expression
15322 equivalent. This routine recursively descends an RTL tree, turning
15323 it into Dwarf postfix code as it goes.
15325 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
15327 MEM_MODE is the mode of the memory reference, needed to handle some
15328 autoincrement addressing modes.
15330 Return 0 if we can't represent the location. */
15333 mem_loc_descriptor (rtx rtl
, machine_mode mode
,
15334 machine_mode mem_mode
,
15335 enum var_init_status initialized
)
15337 dw_loc_descr_ref mem_loc_result
= NULL
;
15338 enum dwarf_location_atom op
;
15339 dw_loc_descr_ref op0
, op1
;
15340 rtx inner
= NULL_RTX
;
15343 if (mode
== VOIDmode
)
15344 mode
= GET_MODE (rtl
);
15346 /* Note that for a dynamically sized array, the location we will generate a
15347 description of here will be the lowest numbered location which is
15348 actually within the array. That's *not* necessarily the same as the
15349 zeroth element of the array. */
15351 rtl
= targetm
.delegitimize_address (rtl
);
15353 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
15356 scalar_int_mode int_mode
, inner_mode
, op1_mode
;
15357 switch (GET_CODE (rtl
))
15362 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
15365 /* The case of a subreg may arise when we have a local (register)
15366 variable or a formal (register) parameter which doesn't quite fill
15367 up an entire register. For now, just assume that it is
15368 legitimate to make the Dwarf info refer to the whole register which
15369 contains the given subreg. */
15370 if (!subreg_lowpart_p (rtl
))
15372 inner
= SUBREG_REG (rtl
);
15375 if (inner
== NULL_RTX
)
15376 inner
= XEXP (rtl
, 0);
15377 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15378 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
15379 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15380 #ifdef POINTERS_EXTEND_UNSIGNED
15381 || (int_mode
== Pmode
&& mem_mode
!= VOIDmode
)
15384 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
)
15386 mem_loc_result
= mem_loc_descriptor (inner
,
15388 mem_mode
, initialized
);
15391 if (dwarf_strict
&& dwarf_version
< 5)
15393 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15394 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
15395 ? GET_MODE_SIZE (int_mode
) <= GET_MODE_SIZE (inner_mode
)
15396 : known_eq (GET_MODE_SIZE (mode
), GET_MODE_SIZE (GET_MODE (inner
))))
15398 dw_die_ref type_die
;
15399 dw_loc_descr_ref cvt
;
15401 mem_loc_result
= mem_loc_descriptor (inner
,
15403 mem_mode
, initialized
);
15404 if (mem_loc_result
== NULL
)
15406 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15407 if (type_die
== NULL
)
15409 mem_loc_result
= NULL
;
15412 if (maybe_ne (GET_MODE_SIZE (mode
), GET_MODE_SIZE (GET_MODE (inner
))))
15413 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15415 cvt
= new_loc_descr (dwarf_OP (DW_OP_reinterpret
), 0, 0);
15416 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15417 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15418 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15419 add_loc_descr (&mem_loc_result
, cvt
);
15420 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15421 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
15423 /* Convert it to untyped afterwards. */
15424 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15425 add_loc_descr (&mem_loc_result
, cvt
);
15431 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15432 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
15433 && rtl
!= arg_pointer_rtx
15434 && rtl
!= frame_pointer_rtx
15435 #ifdef POINTERS_EXTEND_UNSIGNED
15436 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
15440 dw_die_ref type_die
;
15441 unsigned int dbx_regnum
;
15443 if (dwarf_strict
&& dwarf_version
< 5)
15445 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
15447 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15448 if (type_die
== NULL
)
15451 dbx_regnum
= dbx_reg_number (rtl
);
15452 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
15454 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_regval_type
),
15456 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
15457 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
15458 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
15461 /* Whenever a register number forms a part of the description of the
15462 method for calculating the (dynamic) address of a memory resident
15463 object, DWARF rules require the register number be referred to as
15464 a "base register". This distinction is not based in any way upon
15465 what category of register the hardware believes the given register
15466 belongs to. This is strictly DWARF terminology we're dealing with
15467 here. Note that in cases where the location of a memory-resident
15468 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
15469 OP_CONST (0)) the actual DWARF location descriptor that we generate
15470 may just be OP_BASEREG (basereg). This may look deceptively like
15471 the object in question was allocated to a register (rather than in
15472 memory) so DWARF consumers need to be aware of the subtle
15473 distinction between OP_REG and OP_BASEREG. */
15474 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
15475 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
15476 else if (stack_realign_drap
15478 && crtl
->args
.internal_arg_pointer
== rtl
15479 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
15481 /* If RTL is internal_arg_pointer, which has been optimized
15482 out, use DRAP instead. */
15483 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
15484 VAR_INIT_STATUS_INITIALIZED
);
15490 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15491 || !is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
))
15493 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
15494 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
15497 else if (GET_CODE (rtl
) == ZERO_EXTEND
15498 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15499 && GET_MODE_BITSIZE (inner_mode
) < HOST_BITS_PER_WIDE_INT
15500 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
15501 to expand zero extend as two shifts instead of
15503 && GET_MODE_SIZE (inner_mode
) <= 4)
15505 mem_loc_result
= op0
;
15506 add_loc_descr (&mem_loc_result
,
15507 int_loc_descriptor (GET_MODE_MASK (inner_mode
)));
15508 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
15510 else if (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
15512 int shift
= DWARF2_ADDR_SIZE
- GET_MODE_SIZE (inner_mode
);
15513 shift
*= BITS_PER_UNIT
;
15514 if (GET_CODE (rtl
) == SIGN_EXTEND
)
15518 mem_loc_result
= op0
;
15519 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
15520 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
15521 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
15522 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15524 else if (!dwarf_strict
|| dwarf_version
>= 5)
15526 dw_die_ref type_die1
, type_die2
;
15527 dw_loc_descr_ref cvt
;
15529 type_die1
= base_type_for_mode (inner_mode
,
15530 GET_CODE (rtl
) == ZERO_EXTEND
);
15531 if (type_die1
== NULL
)
15533 type_die2
= base_type_for_mode (int_mode
, 1);
15534 if (type_die2
== NULL
)
15536 mem_loc_result
= op0
;
15537 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15538 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15539 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
15540 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15541 add_loc_descr (&mem_loc_result
, cvt
);
15542 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15543 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15544 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
15545 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15546 add_loc_descr (&mem_loc_result
, cvt
);
15552 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
15553 if (new_rtl
!= rtl
)
15555 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
15557 if (mem_loc_result
!= NULL
)
15558 return mem_loc_result
;
15561 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
15562 get_address_mode (rtl
), mode
,
15563 VAR_INIT_STATUS_INITIALIZED
);
15564 if (mem_loc_result
== NULL
)
15565 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
15566 if (mem_loc_result
!= NULL
)
15568 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15569 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15571 dw_die_ref type_die
;
15572 dw_loc_descr_ref deref
;
15573 HOST_WIDE_INT size
;
15575 if (dwarf_strict
&& dwarf_version
< 5)
15577 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
15580 = base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15581 if (type_die
== NULL
)
15583 deref
= new_loc_descr (dwarf_OP (DW_OP_deref_type
), size
, 0);
15584 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
15585 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
15586 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
15587 add_loc_descr (&mem_loc_result
, deref
);
15589 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
15590 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
15592 add_loc_descr (&mem_loc_result
,
15593 new_loc_descr (DW_OP_deref_size
,
15594 GET_MODE_SIZE (int_mode
), 0));
15599 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
15602 /* Some ports can transform a symbol ref into a label ref, because
15603 the symbol ref is too far away and has to be dumped into a constant
15607 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15608 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
15609 #ifdef POINTERS_EXTEND_UNSIGNED
15610 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
15614 if (GET_CODE (rtl
) == SYMBOL_REF
15615 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
15617 dw_loc_descr_ref temp
;
15619 /* If this is not defined, we have no way to emit the data. */
15620 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
15623 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
15625 /* We check for DWARF 5 here because gdb did not implement
15626 DW_OP_form_tls_address until after 7.12. */
15627 mem_loc_result
= new_loc_descr ((dwarf_version
>= 5
15628 ? DW_OP_form_tls_address
15629 : DW_OP_GNU_push_tls_address
),
15631 add_loc_descr (&mem_loc_result
, temp
);
15636 if (!const_ok_for_output (rtl
))
15638 if (GET_CODE (rtl
) == CONST
)
15639 switch (GET_CODE (XEXP (rtl
, 0)))
15643 goto try_const_unop
;
15646 goto try_const_unop
;
15649 arg
= XEXP (XEXP (rtl
, 0), 0);
15650 if (!CONSTANT_P (arg
))
15651 arg
= gen_rtx_CONST (int_mode
, arg
);
15652 op0
= mem_loc_descriptor (arg
, int_mode
, mem_mode
,
15656 mem_loc_result
= op0
;
15657 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15661 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
,
15662 mem_mode
, initialized
);
15669 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
15670 vec_safe_push (used_rtx_array
, rtl
);
15676 case DEBUG_IMPLICIT_PTR
:
15677 expansion_failed (NULL_TREE
, rtl
,
15678 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
15682 if (dwarf_strict
&& dwarf_version
< 5)
15684 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
15686 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15687 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15688 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
15689 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15692 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
15693 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
15695 op0
= one_reg_loc_descriptor (dbx_regnum
,
15696 VAR_INIT_STATUS_INITIALIZED
);
15699 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
15700 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
15702 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
15703 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15704 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
15708 gcc_unreachable ();
15711 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_entry_value
), 0, 0);
15712 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15713 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
15716 case DEBUG_PARAMETER_REF
:
15717 mem_loc_result
= parameter_ref_descriptor (rtl
);
15721 /* Extract the PLUS expression nested inside and fall into
15722 PLUS code below. */
15723 rtl
= XEXP (rtl
, 1);
15728 /* Turn these into a PLUS expression and fall into the PLUS code
15730 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
15731 gen_int_mode (GET_CODE (rtl
) == PRE_INC
15732 ? GET_MODE_UNIT_SIZE (mem_mode
)
15733 : -GET_MODE_UNIT_SIZE (mem_mode
),
15740 if (is_based_loc (rtl
)
15741 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15742 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15743 || XEXP (rtl
, 0) == arg_pointer_rtx
15744 || XEXP (rtl
, 0) == frame_pointer_rtx
))
15745 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
15746 INTVAL (XEXP (rtl
, 1)),
15747 VAR_INIT_STATUS_INITIALIZED
);
15750 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15751 VAR_INIT_STATUS_INITIALIZED
);
15752 if (mem_loc_result
== 0)
15755 if (CONST_INT_P (XEXP (rtl
, 1))
15756 && (GET_MODE_SIZE (as_a
<scalar_int_mode
> (mode
))
15757 <= DWARF2_ADDR_SIZE
))
15758 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
15761 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15762 VAR_INIT_STATUS_INITIALIZED
);
15765 add_loc_descr (&mem_loc_result
, op1
);
15766 add_loc_descr (&mem_loc_result
,
15767 new_loc_descr (DW_OP_plus
, 0, 0));
15772 /* If a pseudo-reg is optimized away, it is possible for it to
15773 be replaced with a MEM containing a multiply or shift. */
15783 if ((!dwarf_strict
|| dwarf_version
>= 5)
15784 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15785 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15787 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
15788 base_type_for_mode (mode
, 0),
15789 int_mode
, mem_mode
);
15812 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
))
15814 op0
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
, mem_mode
,
15815 VAR_INIT_STATUS_INITIALIZED
);
15817 rtx rtlop1
= XEXP (rtl
, 1);
15818 if (is_a
<scalar_int_mode
> (GET_MODE (rtlop1
), &op1_mode
)
15819 && GET_MODE_BITSIZE (op1_mode
) < GET_MODE_BITSIZE (int_mode
))
15820 rtlop1
= gen_rtx_ZERO_EXTEND (int_mode
, rtlop1
);
15821 op1
= mem_loc_descriptor (rtlop1
, int_mode
, mem_mode
,
15822 VAR_INIT_STATUS_INITIALIZED
);
15825 if (op0
== 0 || op1
== 0)
15828 mem_loc_result
= op0
;
15829 add_loc_descr (&mem_loc_result
, op1
);
15830 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15846 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15847 VAR_INIT_STATUS_INITIALIZED
);
15848 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15849 VAR_INIT_STATUS_INITIALIZED
);
15851 if (op0
== 0 || op1
== 0)
15854 mem_loc_result
= op0
;
15855 add_loc_descr (&mem_loc_result
, op1
);
15856 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15860 if ((!dwarf_strict
|| dwarf_version
>= 5)
15861 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15862 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15864 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
15865 base_type_for_mode (mode
, 0),
15866 int_mode
, mem_mode
);
15870 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15871 VAR_INIT_STATUS_INITIALIZED
);
15872 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15873 VAR_INIT_STATUS_INITIALIZED
);
15875 if (op0
== 0 || op1
== 0)
15878 mem_loc_result
= op0
;
15879 add_loc_descr (&mem_loc_result
, op1
);
15880 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
15881 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
15882 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
15883 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
15884 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
15888 if ((!dwarf_strict
|| dwarf_version
>= 5)
15889 && is_a
<scalar_int_mode
> (mode
, &int_mode
))
15891 if (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15896 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
15897 base_type_for_mode (int_mode
, 1),
15898 int_mode
, mem_mode
);
15915 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15916 VAR_INIT_STATUS_INITIALIZED
);
15921 mem_loc_result
= op0
;
15922 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15926 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15927 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15928 #ifdef POINTERS_EXTEND_UNSIGNED
15929 || (int_mode
== Pmode
15930 && mem_mode
!= VOIDmode
15931 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
15935 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
15938 if ((!dwarf_strict
|| dwarf_version
>= 5)
15939 && (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
15940 || GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_DOUBLE_INT
))
15942 dw_die_ref type_die
= base_type_for_mode (int_mode
, 1);
15943 scalar_int_mode amode
;
15944 if (type_die
== NULL
)
15946 if (INTVAL (rtl
) >= 0
15947 && (int_mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
, 0)
15949 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
15950 /* const DW_OP_convert <XXX> vs.
15951 DW_OP_const_type <XXX, 1, const>. */
15952 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
15953 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (int_mode
))
15955 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
15956 op0
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15957 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15958 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15959 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15960 add_loc_descr (&mem_loc_result
, op0
);
15961 return mem_loc_result
;
15963 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0,
15965 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15966 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15967 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15968 if (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
)
15969 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
15972 mem_loc_result
->dw_loc_oprnd2
.val_class
15973 = dw_val_class_const_double
;
15974 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
15975 = double_int::from_shwi (INTVAL (rtl
));
15981 if (!dwarf_strict
|| dwarf_version
>= 5)
15983 dw_die_ref type_die
;
15985 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
15986 CONST_DOUBLE rtx could represent either a large integer
15987 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
15988 the value is always a floating point constant.
15990 When it is an integer, a CONST_DOUBLE is used whenever
15991 the constant requires 2 HWIs to be adequately represented.
15992 We output CONST_DOUBLEs as blocks. */
15993 if (mode
== VOIDmode
15994 || (GET_MODE (rtl
) == VOIDmode
15995 && maybe_ne (GET_MODE_BITSIZE (mode
),
15996 HOST_BITS_PER_DOUBLE_INT
)))
15998 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15999 if (type_die
== NULL
)
16001 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
16002 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16003 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16004 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16005 #if TARGET_SUPPORTS_WIDE_INT == 0
16006 if (!SCALAR_FLOAT_MODE_P (mode
))
16008 mem_loc_result
->dw_loc_oprnd2
.val_class
16009 = dw_val_class_const_double
;
16010 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
16011 = rtx_to_double_int (rtl
);
16016 scalar_float_mode float_mode
= as_a
<scalar_float_mode
> (mode
);
16017 unsigned int length
= GET_MODE_SIZE (float_mode
);
16018 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
16020 insert_float (rtl
, array
);
16021 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16022 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
16023 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
16024 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16029 case CONST_WIDE_INT
:
16030 if (!dwarf_strict
|| dwarf_version
>= 5)
16032 dw_die_ref type_die
;
16034 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16035 if (type_die
== NULL
)
16037 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
16038 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16039 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16040 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16041 mem_loc_result
->dw_loc_oprnd2
.val_class
16042 = dw_val_class_wide_int
;
16043 mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
16044 *mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, mode
);
16048 case CONST_POLY_INT
:
16049 mem_loc_result
= int_loc_descriptor (rtx_to_poly_int64 (rtl
));
16053 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
16057 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
16061 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
16065 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
16069 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
16073 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
16077 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
16081 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
16085 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
16089 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
16094 if (!SCALAR_INT_MODE_P (mode
))
16099 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
16104 if (CONST_INT_P (XEXP (rtl
, 1))
16105 && CONST_INT_P (XEXP (rtl
, 2))
16106 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16107 && is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
)
16108 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16109 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
16110 && ((unsigned) INTVAL (XEXP (rtl
, 1))
16111 + (unsigned) INTVAL (XEXP (rtl
, 2))
16112 <= GET_MODE_BITSIZE (int_mode
)))
16115 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
16116 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16119 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
16123 mem_loc_result
= op0
;
16124 size
= INTVAL (XEXP (rtl
, 1));
16125 shift
= INTVAL (XEXP (rtl
, 2));
16126 if (BITS_BIG_ENDIAN
)
16127 shift
= GET_MODE_BITSIZE (inner_mode
) - shift
- size
;
16128 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
16130 add_loc_descr (&mem_loc_result
,
16131 int_loc_descriptor (DWARF2_ADDR_SIZE
16133 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
16135 if (size
!= (int) DWARF2_ADDR_SIZE
)
16137 add_loc_descr (&mem_loc_result
,
16138 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
16139 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16146 dw_loc_descr_ref op2
, bra_node
, drop_node
;
16147 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
16148 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
16149 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
16150 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16151 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16152 VAR_INIT_STATUS_INITIALIZED
);
16153 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
16154 VAR_INIT_STATUS_INITIALIZED
);
16155 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
16158 mem_loc_result
= op1
;
16159 add_loc_descr (&mem_loc_result
, op2
);
16160 add_loc_descr (&mem_loc_result
, op0
);
16161 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
16162 add_loc_descr (&mem_loc_result
, bra_node
);
16163 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
16164 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
16165 add_loc_descr (&mem_loc_result
, drop_node
);
16166 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
16167 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
16172 case FLOAT_TRUNCATE
:
16174 case UNSIGNED_FLOAT
:
16177 if (!dwarf_strict
|| dwarf_version
>= 5)
16179 dw_die_ref type_die
;
16180 dw_loc_descr_ref cvt
;
16182 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
16183 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16186 if (is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &int_mode
)
16187 && (GET_CODE (rtl
) == FLOAT
16188 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
))
16190 type_die
= base_type_for_mode (int_mode
,
16191 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
16192 if (type_die
== NULL
)
16194 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16195 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16196 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16197 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16198 add_loc_descr (&op0
, cvt
);
16200 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
16201 if (type_die
== NULL
)
16203 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16204 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16205 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16206 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16207 add_loc_descr (&op0
, cvt
);
16208 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16209 && (GET_CODE (rtl
) == FIX
16210 || GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
))
16212 op0
= convert_descriptor_to_mode (int_mode
, op0
);
16216 mem_loc_result
= op0
;
16223 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16224 mem_loc_result
= clz_loc_descriptor (rtl
, int_mode
, mem_mode
);
16229 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16230 mem_loc_result
= popcount_loc_descriptor (rtl
, int_mode
, mem_mode
);
16234 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16235 mem_loc_result
= bswap_loc_descriptor (rtl
, int_mode
, mem_mode
);
16240 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16241 mem_loc_result
= rotate_loc_descriptor (rtl
, int_mode
, mem_mode
);
16245 /* In theory, we could implement the above. */
16246 /* DWARF cannot represent the unsigned compare operations
16271 case FRACT_CONVERT
:
16272 case UNSIGNED_FRACT_CONVERT
:
16274 case UNSIGNED_SAT_FRACT
:
16280 case VEC_DUPLICATE
:
16285 case STRICT_LOW_PART
:
16291 /* If delegitimize_address couldn't do anything with the UNSPEC, we
16292 can't express it in the debug info. This can happen e.g. with some
16297 resolve_one_addr (&rtl
);
16300 /* RTL sequences inside PARALLEL record a series of DWARF operations for
16301 the expression. An UNSPEC rtx represents a raw DWARF operation,
16302 new_loc_descr is called for it to build the operation directly.
16303 Otherwise mem_loc_descriptor is called recursively. */
16307 dw_loc_descr_ref exp_result
= NULL
;
16309 for (; index
< XVECLEN (rtl
, 0); index
++)
16311 rtx elem
= XVECEXP (rtl
, 0, index
);
16312 if (GET_CODE (elem
) == UNSPEC
)
16314 /* Each DWARF operation UNSPEC contain two operands, if
16315 one operand is not used for the operation, const0_rtx is
16317 gcc_assert (XVECLEN (elem
, 0) == 2);
16319 HOST_WIDE_INT dw_op
= XINT (elem
, 1);
16320 HOST_WIDE_INT oprnd1
= INTVAL (XVECEXP (elem
, 0, 0));
16321 HOST_WIDE_INT oprnd2
= INTVAL (XVECEXP (elem
, 0, 1));
16323 = new_loc_descr ((enum dwarf_location_atom
) dw_op
, oprnd1
,
16328 = mem_loc_descriptor (elem
, mode
, mem_mode
,
16329 VAR_INIT_STATUS_INITIALIZED
);
16331 if (!mem_loc_result
)
16332 mem_loc_result
= exp_result
;
16334 add_loc_descr (&mem_loc_result
, exp_result
);
16343 print_rtl (stderr
, rtl
);
16344 gcc_unreachable ();
16349 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
16350 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
16352 return mem_loc_result
;
16355 /* Return a descriptor that describes the concatenation of two locations.
16356 This is typically a complex variable. */
16358 static dw_loc_descr_ref
16359 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
16361 /* At present we only track constant-sized pieces. */
16362 unsigned int size0
, size1
;
16363 if (!GET_MODE_SIZE (GET_MODE (x0
)).is_constant (&size0
)
16364 || !GET_MODE_SIZE (GET_MODE (x1
)).is_constant (&size1
))
16367 dw_loc_descr_ref cc_loc_result
= NULL
;
16368 dw_loc_descr_ref x0_ref
16369 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16370 dw_loc_descr_ref x1_ref
16371 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16373 if (x0_ref
== 0 || x1_ref
== 0)
16376 cc_loc_result
= x0_ref
;
16377 add_loc_descr_op_piece (&cc_loc_result
, size0
);
16379 add_loc_descr (&cc_loc_result
, x1_ref
);
16380 add_loc_descr_op_piece (&cc_loc_result
, size1
);
16382 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
16383 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
16385 return cc_loc_result
;
16388 /* Return a descriptor that describes the concatenation of N
16391 static dw_loc_descr_ref
16392 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
16395 dw_loc_descr_ref cc_loc_result
= NULL
;
16396 unsigned int n
= XVECLEN (concatn
, 0);
16399 for (i
= 0; i
< n
; ++i
)
16401 dw_loc_descr_ref ref
;
16402 rtx x
= XVECEXP (concatn
, 0, i
);
16404 /* At present we only track constant-sized pieces. */
16405 if (!GET_MODE_SIZE (GET_MODE (x
)).is_constant (&size
))
16408 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16412 add_loc_descr (&cc_loc_result
, ref
);
16413 add_loc_descr_op_piece (&cc_loc_result
, size
);
16416 if (cc_loc_result
&& 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 /* Helper function for loc_descriptor. Return DW_OP_implicit_pointer
16423 for DEBUG_IMPLICIT_PTR RTL. */
16425 static dw_loc_descr_ref
16426 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
16428 dw_loc_descr_ref ret
;
16431 if (dwarf_strict
&& dwarf_version
< 5)
16433 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
16434 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
16435 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
16436 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
16437 ret
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
16438 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
16441 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16442 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
16443 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16447 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
16448 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
16453 /* Output a proper Dwarf location descriptor for a variable or parameter
16454 which is either allocated in a register or in a memory location. For a
16455 register, we just generate an OP_REG and the register number. For a
16456 memory location we provide a Dwarf postfix expression describing how to
16457 generate the (dynamic) address of the object onto the address stack.
16459 MODE is mode of the decl if this loc_descriptor is going to be used in
16460 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
16461 allowed, VOIDmode otherwise.
16463 If we don't know how to describe it, return 0. */
16465 static dw_loc_descr_ref
16466 loc_descriptor (rtx rtl
, machine_mode mode
,
16467 enum var_init_status initialized
)
16469 dw_loc_descr_ref loc_result
= NULL
;
16470 scalar_int_mode int_mode
;
16472 switch (GET_CODE (rtl
))
16475 /* The case of a subreg may arise when we have a local (register)
16476 variable or a formal (register) parameter which doesn't quite fill
16477 up an entire register. For now, just assume that it is
16478 legitimate to make the Dwarf info refer to the whole register which
16479 contains the given subreg. */
16480 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
16481 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
16482 GET_MODE (SUBREG_REG (rtl
)), initialized
);
16488 loc_result
= reg_loc_descriptor (rtl
, initialized
);
16492 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
16493 GET_MODE (rtl
), initialized
);
16494 if (loc_result
== NULL
)
16495 loc_result
= tls_mem_loc_descriptor (rtl
);
16496 if (loc_result
== NULL
)
16498 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
16499 if (new_rtl
!= rtl
)
16500 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
16505 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
16510 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
16515 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
16517 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
16518 if (GET_CODE (loc
) == EXPR_LIST
)
16519 loc
= XEXP (loc
, 0);
16520 loc_result
= loc_descriptor (loc
, mode
, initialized
);
16524 rtl
= XEXP (rtl
, 1);
16529 rtvec par_elems
= XVEC (rtl
, 0);
16530 int num_elem
= GET_NUM_ELEM (par_elems
);
16534 /* Create the first one, so we have something to add to. */
16535 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
16536 VOIDmode
, initialized
);
16537 if (loc_result
== NULL
)
16539 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
16540 /* At present we only track constant-sized pieces. */
16541 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
16543 add_loc_descr_op_piece (&loc_result
, size
);
16544 for (i
= 1; i
< num_elem
; i
++)
16546 dw_loc_descr_ref temp
;
16548 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
16549 VOIDmode
, initialized
);
16552 add_loc_descr (&loc_result
, temp
);
16553 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
16554 /* At present we only track constant-sized pieces. */
16555 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
16557 add_loc_descr_op_piece (&loc_result
, size
);
16563 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
16565 int_mode
= as_a
<scalar_int_mode
> (mode
);
16566 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (int_mode
),
16572 if (mode
== VOIDmode
)
16573 mode
= GET_MODE (rtl
);
16575 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16577 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
16579 /* Note that a CONST_DOUBLE rtx could represent either an integer
16580 or a floating-point constant. A CONST_DOUBLE is used whenever
16581 the constant requires more than one word in order to be
16582 adequately represented. We output CONST_DOUBLEs as blocks. */
16583 scalar_mode smode
= as_a
<scalar_mode
> (mode
);
16584 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16585 GET_MODE_SIZE (smode
), 0);
16586 #if TARGET_SUPPORTS_WIDE_INT == 0
16587 if (!SCALAR_FLOAT_MODE_P (smode
))
16589 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
16590 loc_result
->dw_loc_oprnd2
.v
.val_double
16591 = rtx_to_double_int (rtl
);
16596 unsigned int length
= GET_MODE_SIZE (smode
);
16597 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
16599 insert_float (rtl
, array
);
16600 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16601 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
16602 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
16603 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16608 case CONST_WIDE_INT
:
16609 if (mode
== VOIDmode
)
16610 mode
= GET_MODE (rtl
);
16612 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16614 int_mode
= as_a
<scalar_int_mode
> (mode
);
16615 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16616 GET_MODE_SIZE (int_mode
), 0);
16617 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_wide_int
;
16618 loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
16619 *loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, int_mode
);
16624 if (mode
== VOIDmode
)
16625 mode
= GET_MODE (rtl
);
16627 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16629 unsigned int length
;
16630 if (!CONST_VECTOR_NUNITS (rtl
).is_constant (&length
))
16633 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
16634 unsigned char *array
16635 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
16638 machine_mode imode
= GET_MODE_INNER (mode
);
16640 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
16641 switch (GET_MODE_CLASS (mode
))
16643 case MODE_VECTOR_INT
:
16644 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
16646 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
16647 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
16651 case MODE_VECTOR_FLOAT
:
16652 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
16654 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
16655 insert_float (elt
, p
);
16660 gcc_unreachable ();
16663 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16664 length
* elt_size
, 0);
16665 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16666 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
16667 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
16668 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16673 if (mode
== VOIDmode
16674 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
16675 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
16676 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
16678 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
16683 if (!const_ok_for_output (rtl
))
16687 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16688 && GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
16689 && (dwarf_version
>= 4 || !dwarf_strict
))
16691 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
16692 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16693 vec_safe_push (used_rtx_array
, rtl
);
16697 case DEBUG_IMPLICIT_PTR
:
16698 loc_result
= implicit_ptr_descriptor (rtl
, 0);
16702 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
16703 && CONST_INT_P (XEXP (rtl
, 1)))
16706 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
16712 if ((is_a
<scalar_int_mode
> (mode
, &int_mode
)
16713 && GET_MODE (rtl
) == int_mode
16714 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16715 && dwarf_version
>= 4)
16716 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
16718 /* Value expression. */
16719 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
16721 add_loc_descr (&loc_result
,
16722 new_loc_descr (DW_OP_stack_value
, 0, 0));
16730 /* We need to figure out what section we should use as the base for the
16731 address ranges where a given location is valid.
16732 1. If this particular DECL has a section associated with it, use that.
16733 2. If this function has a section associated with it, use that.
16734 3. Otherwise, use the text section.
16735 XXX: If you split a variable across multiple sections, we won't notice. */
16737 static const char *
16738 secname_for_decl (const_tree decl
)
16740 const char *secname
;
16742 if (VAR_OR_FUNCTION_DECL_P (decl
)
16743 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
) || TREE_STATIC (decl
))
16744 && DECL_SECTION_NAME (decl
))
16745 secname
= DECL_SECTION_NAME (decl
);
16746 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
16748 if (in_cold_section_p
)
16750 section
*sec
= current_function_section ();
16751 if (sec
->common
.flags
& SECTION_NAMED
)
16752 return sec
->named
.name
;
16754 secname
= DECL_SECTION_NAME (current_function_decl
);
16756 else if (cfun
&& in_cold_section_p
)
16757 secname
= crtl
->subsections
.cold_section_label
;
16759 secname
= text_section_label
;
16764 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
16767 decl_by_reference_p (tree decl
)
16769 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
16771 && DECL_BY_REFERENCE (decl
));
16774 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
16777 static dw_loc_descr_ref
16778 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
16779 enum var_init_status initialized
)
16781 int have_address
= 0;
16782 dw_loc_descr_ref descr
;
16785 if (want_address
!= 2)
16787 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
16789 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
16791 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
16792 if (GET_CODE (varloc
) == EXPR_LIST
)
16793 varloc
= XEXP (varloc
, 0);
16794 mode
= GET_MODE (varloc
);
16795 if (MEM_P (varloc
))
16797 rtx addr
= XEXP (varloc
, 0);
16798 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
16799 mode
, initialized
);
16804 rtx x
= avoid_constant_pool_reference (varloc
);
16806 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
16811 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
16818 if (GET_CODE (varloc
) == VAR_LOCATION
)
16819 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
16821 mode
= DECL_MODE (loc
);
16822 descr
= loc_descriptor (varloc
, mode
, initialized
);
16829 if (want_address
== 2 && !have_address
16830 && (dwarf_version
>= 4 || !dwarf_strict
))
16832 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
16834 expansion_failed (loc
, NULL_RTX
,
16835 "DWARF address size mismatch");
16838 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16841 /* Show if we can't fill the request for an address. */
16842 if (want_address
&& !have_address
)
16844 expansion_failed (loc
, NULL_RTX
,
16845 "Want address and only have value");
16849 /* If we've got an address and don't want one, dereference. */
16850 if (!want_address
&& have_address
)
16852 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
16853 enum dwarf_location_atom op
;
16855 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
16857 expansion_failed (loc
, NULL_RTX
,
16858 "DWARF address size mismatch");
16861 else if (size
== DWARF2_ADDR_SIZE
)
16864 op
= DW_OP_deref_size
;
16866 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
16872 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
16873 if it is not possible. */
16875 static dw_loc_descr_ref
16876 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
16878 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
16879 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
16880 else if (dwarf_version
>= 3 || !dwarf_strict
)
16881 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
16886 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
16887 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
16889 static dw_loc_descr_ref
16890 dw_sra_loc_expr (tree decl
, rtx loc
)
16893 unsigned HOST_WIDE_INT padsize
= 0;
16894 dw_loc_descr_ref descr
, *descr_tail
;
16895 unsigned HOST_WIDE_INT decl_size
;
16897 enum var_init_status initialized
;
16899 if (DECL_SIZE (decl
) == NULL
16900 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
16903 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
16905 descr_tail
= &descr
;
16907 for (p
= loc
; p
; p
= XEXP (p
, 1))
16909 unsigned HOST_WIDE_INT bitsize
= decl_piece_bitsize (p
);
16910 rtx loc_note
= *decl_piece_varloc_ptr (p
);
16911 dw_loc_descr_ref cur_descr
;
16912 dw_loc_descr_ref
*tail
, last
= NULL
;
16913 unsigned HOST_WIDE_INT opsize
= 0;
16915 if (loc_note
== NULL_RTX
16916 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
16918 padsize
+= bitsize
;
16921 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
16922 varloc
= NOTE_VAR_LOCATION (loc_note
);
16923 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
16924 if (cur_descr
== NULL
)
16926 padsize
+= bitsize
;
16930 /* Check that cur_descr either doesn't use
16931 DW_OP_*piece operations, or their sum is equal
16932 to bitsize. Otherwise we can't embed it. */
16933 for (tail
= &cur_descr
; *tail
!= NULL
;
16934 tail
= &(*tail
)->dw_loc_next
)
16935 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
16937 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
16941 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
16943 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
16947 if (last
!= NULL
&& opsize
!= bitsize
)
16949 padsize
+= bitsize
;
16950 /* Discard the current piece of the descriptor and release any
16951 addr_table entries it uses. */
16952 remove_loc_list_addr_table_entries (cur_descr
);
16956 /* If there is a hole, add DW_OP_*piece after empty DWARF
16957 expression, which means that those bits are optimized out. */
16960 if (padsize
> decl_size
)
16962 remove_loc_list_addr_table_entries (cur_descr
);
16963 goto discard_descr
;
16965 decl_size
-= padsize
;
16966 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
16967 if (*descr_tail
== NULL
)
16969 remove_loc_list_addr_table_entries (cur_descr
);
16970 goto discard_descr
;
16972 descr_tail
= &(*descr_tail
)->dw_loc_next
;
16975 *descr_tail
= cur_descr
;
16977 if (bitsize
> decl_size
)
16978 goto discard_descr
;
16979 decl_size
-= bitsize
;
16982 HOST_WIDE_INT offset
= 0;
16983 if (GET_CODE (varloc
) == VAR_LOCATION
16984 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
16986 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
16987 if (GET_CODE (varloc
) == EXPR_LIST
)
16988 varloc
= XEXP (varloc
, 0);
16992 if (GET_CODE (varloc
) == CONST
16993 || GET_CODE (varloc
) == SIGN_EXTEND
16994 || GET_CODE (varloc
) == ZERO_EXTEND
)
16995 varloc
= XEXP (varloc
, 0);
16996 else if (GET_CODE (varloc
) == SUBREG
)
16997 varloc
= SUBREG_REG (varloc
);
17002 /* DW_OP_bit_size offset should be zero for register
17003 or implicit location descriptions and empty location
17004 descriptions, but for memory addresses needs big endian
17006 if (MEM_P (varloc
))
17008 unsigned HOST_WIDE_INT memsize
;
17009 if (!poly_uint64 (MEM_SIZE (varloc
)).is_constant (&memsize
))
17010 goto discard_descr
;
17011 memsize
*= BITS_PER_UNIT
;
17012 if (memsize
!= bitsize
)
17014 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
17015 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
17016 goto discard_descr
;
17017 if (memsize
< bitsize
)
17018 goto discard_descr
;
17019 if (BITS_BIG_ENDIAN
)
17020 offset
= memsize
- bitsize
;
17024 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
17025 if (*descr_tail
== NULL
)
17026 goto discard_descr
;
17027 descr_tail
= &(*descr_tail
)->dw_loc_next
;
17031 /* If there were any non-empty expressions, add padding till the end of
17033 if (descr
!= NULL
&& decl_size
!= 0)
17035 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
17036 if (*descr_tail
== NULL
)
17037 goto discard_descr
;
17042 /* Discard the descriptor and release any addr_table entries it uses. */
17043 remove_loc_list_addr_table_entries (descr
);
17047 /* Return the dwarf representation of the location list LOC_LIST of
17048 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
17051 static dw_loc_list_ref
17052 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
17054 const char *endname
, *secname
;
17055 var_loc_view endview
;
17057 enum var_init_status initialized
;
17058 struct var_loc_node
*node
;
17059 dw_loc_descr_ref descr
;
17060 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
17061 dw_loc_list_ref list
= NULL
;
17062 dw_loc_list_ref
*listp
= &list
;
17064 /* Now that we know what section we are using for a base,
17065 actually construct the list of locations.
17066 The first location information is what is passed to the
17067 function that creates the location list, and the remaining
17068 locations just get added on to that list.
17069 Note that we only know the start address for a location
17070 (IE location changes), so to build the range, we use
17071 the range [current location start, next location start].
17072 This means we have to special case the last node, and generate
17073 a range of [last location start, end of function label]. */
17075 if (cfun
&& crtl
->has_bb_partition
)
17077 bool save_in_cold_section_p
= in_cold_section_p
;
17078 in_cold_section_p
= first_function_block_is_cold
;
17079 if (loc_list
->last_before_switch
== NULL
)
17080 in_cold_section_p
= !in_cold_section_p
;
17081 secname
= secname_for_decl (decl
);
17082 in_cold_section_p
= save_in_cold_section_p
;
17085 secname
= secname_for_decl (decl
);
17087 for (node
= loc_list
->first
; node
; node
= node
->next
)
17089 bool range_across_switch
= false;
17090 if (GET_CODE (node
->loc
) == EXPR_LIST
17091 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
17093 if (GET_CODE (node
->loc
) == EXPR_LIST
)
17096 /* This requires DW_OP_{,bit_}piece, which is not usable
17097 inside DWARF expressions. */
17098 if (want_address
== 2)
17099 descr
= dw_sra_loc_expr (decl
, node
->loc
);
17103 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
17104 varloc
= NOTE_VAR_LOCATION (node
->loc
);
17105 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
17109 /* If section switch happens in between node->label
17110 and node->next->label (or end of function) and
17111 we can't emit it as a single entry list,
17112 emit two ranges, first one ending at the end
17113 of first partition and second one starting at the
17114 beginning of second partition. */
17115 if (node
== loc_list
->last_before_switch
17116 && (node
!= loc_list
->first
|| loc_list
->first
->next
17117 /* If we are to emit a view number, we will emit
17118 a loclist rather than a single location
17119 expression for the entire function (see
17120 loc_list_has_views), so we have to split the
17121 range that straddles across partitions. */
17122 || !ZERO_VIEW_P (node
->view
))
17123 && current_function_decl
)
17125 endname
= cfun
->fde
->dw_fde_end
;
17127 range_across_switch
= true;
17129 /* The variable has a location between NODE->LABEL and
17130 NODE->NEXT->LABEL. */
17131 else if (node
->next
)
17132 endname
= node
->next
->label
, endview
= node
->next
->view
;
17133 /* If the variable has a location at the last label
17134 it keeps its location until the end of function. */
17135 else if (!current_function_decl
)
17136 endname
= text_end_label
, endview
= 0;
17139 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
17140 current_function_funcdef_no
);
17141 endname
= ggc_strdup (label_id
);
17145 *listp
= new_loc_list (descr
, node
->label
, node
->view
,
17146 endname
, endview
, secname
);
17147 if (TREE_CODE (decl
) == PARM_DECL
17148 && node
== loc_list
->first
17149 && NOTE_P (node
->loc
)
17150 && strcmp (node
->label
, endname
) == 0)
17151 (*listp
)->force
= true;
17152 listp
= &(*listp
)->dw_loc_next
;
17157 && crtl
->has_bb_partition
17158 && node
== loc_list
->last_before_switch
)
17160 bool save_in_cold_section_p
= in_cold_section_p
;
17161 in_cold_section_p
= !first_function_block_is_cold
;
17162 secname
= secname_for_decl (decl
);
17163 in_cold_section_p
= save_in_cold_section_p
;
17166 if (range_across_switch
)
17168 if (GET_CODE (node
->loc
) == EXPR_LIST
)
17169 descr
= dw_sra_loc_expr (decl
, node
->loc
);
17172 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
17173 varloc
= NOTE_VAR_LOCATION (node
->loc
);
17174 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
17177 gcc_assert (descr
);
17178 /* The variable has a location between NODE->LABEL and
17179 NODE->NEXT->LABEL. */
17181 endname
= node
->next
->label
, endview
= node
->next
->view
;
17183 endname
= cfun
->fde
->dw_fde_second_end
, endview
= 0;
17184 *listp
= new_loc_list (descr
, cfun
->fde
->dw_fde_second_begin
, 0,
17185 endname
, endview
, secname
);
17186 listp
= &(*listp
)->dw_loc_next
;
17190 /* Try to avoid the overhead of a location list emitting a location
17191 expression instead, but only if we didn't have more than one
17192 location entry in the first place. If some entries were not
17193 representable, we don't want to pretend a single entry that was
17194 applies to the entire scope in which the variable is
17196 if (list
&& loc_list
->first
->next
)
17199 maybe_gen_llsym (list
);
17204 /* Return if the loc_list has only single element and thus can be represented
17205 as location description. */
17208 single_element_loc_list_p (dw_loc_list_ref list
)
17210 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
17211 return !list
->ll_symbol
;
17214 /* Duplicate a single element of location list. */
17216 static inline dw_loc_descr_ref
17217 copy_loc_descr (dw_loc_descr_ref ref
)
17219 dw_loc_descr_ref copy
= ggc_alloc
<dw_loc_descr_node
> ();
17220 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
17224 /* To each location in list LIST append loc descr REF. */
17227 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
17229 dw_loc_descr_ref copy
;
17230 add_loc_descr (&list
->expr
, ref
);
17231 list
= list
->dw_loc_next
;
17234 copy
= copy_loc_descr (ref
);
17235 add_loc_descr (&list
->expr
, copy
);
17236 while (copy
->dw_loc_next
)
17237 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
17238 list
= list
->dw_loc_next
;
17242 /* To each location in list LIST prepend loc descr REF. */
17245 prepend_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
17247 dw_loc_descr_ref copy
;
17248 dw_loc_descr_ref ref_end
= list
->expr
;
17249 add_loc_descr (&ref
, list
->expr
);
17251 list
= list
->dw_loc_next
;
17254 dw_loc_descr_ref end
= list
->expr
;
17255 list
->expr
= copy
= copy_loc_descr (ref
);
17256 while (copy
->dw_loc_next
!= ref_end
)
17257 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
17258 copy
->dw_loc_next
= end
;
17259 list
= list
->dw_loc_next
;
17263 /* Given two lists RET and LIST
17264 produce location list that is result of adding expression in LIST
17265 to expression in RET on each position in program.
17266 Might be destructive on both RET and LIST.
17268 TODO: We handle only simple cases of RET or LIST having at most one
17269 element. General case would involve sorting the lists in program order
17270 and merging them that will need some additional work.
17271 Adding that will improve quality of debug info especially for SRA-ed
17275 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
17284 if (!list
->dw_loc_next
)
17286 add_loc_descr_to_each (*ret
, list
->expr
);
17289 if (!(*ret
)->dw_loc_next
)
17291 prepend_loc_descr_to_each (list
, (*ret
)->expr
);
17295 expansion_failed (NULL_TREE
, NULL_RTX
,
17296 "Don't know how to merge two non-trivial"
17297 " location lists.\n");
17302 /* LOC is constant expression. Try a luck, look it up in constant
17303 pool and return its loc_descr of its address. */
17305 static dw_loc_descr_ref
17306 cst_pool_loc_descr (tree loc
)
17308 /* Get an RTL for this, if something has been emitted. */
17309 rtx rtl
= lookup_constant_def (loc
);
17311 if (!rtl
|| !MEM_P (rtl
))
17316 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
17318 /* TODO: We might get more coverage if we was actually delaying expansion
17319 of all expressions till end of compilation when constant pools are fully
17321 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
17323 expansion_failed (loc
, NULL_RTX
,
17324 "CST value in contant pool but not marked.");
17327 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
17328 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
17331 /* Return dw_loc_list representing address of addr_expr LOC
17332 by looking for inner INDIRECT_REF expression and turning
17333 it into simple arithmetics.
17335 See loc_list_from_tree for the meaning of CONTEXT. */
17337 static dw_loc_list_ref
17338 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
,
17339 loc_descr_context
*context
)
17342 poly_int64 bitsize
, bitpos
, bytepos
;
17344 int unsignedp
, reversep
, volatilep
= 0;
17345 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
17347 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
17348 &bitsize
, &bitpos
, &offset
, &mode
,
17349 &unsignedp
, &reversep
, &volatilep
);
17351 if (!multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
))
17353 expansion_failed (loc
, NULL_RTX
, "bitfield access");
17356 if (!INDIRECT_REF_P (obj
))
17358 expansion_failed (obj
,
17359 NULL_RTX
, "no indirect ref in inner refrence");
17362 if (!offset
&& known_eq (bitpos
, 0))
17363 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1,
17366 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
17367 && (dwarf_version
>= 4 || !dwarf_strict
))
17369 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0, context
);
17374 /* Variable offset. */
17375 list_ret1
= loc_list_from_tree (offset
, 0, context
);
17376 if (list_ret1
== 0)
17378 add_loc_list (&list_ret
, list_ret1
);
17381 add_loc_descr_to_each (list_ret
,
17382 new_loc_descr (DW_OP_plus
, 0, 0));
17384 HOST_WIDE_INT value
;
17385 if (bytepos
.is_constant (&value
) && value
> 0)
17386 add_loc_descr_to_each (list_ret
,
17387 new_loc_descr (DW_OP_plus_uconst
, value
, 0));
17388 else if (maybe_ne (bytepos
, 0))
17389 loc_list_plus_const (list_ret
, bytepos
);
17390 add_loc_descr_to_each (list_ret
,
17391 new_loc_descr (DW_OP_stack_value
, 0, 0));
17396 /* Set LOC to the next operation that is not a DW_OP_nop operation. In the case
17397 all operations from LOC are nops, move to the last one. Insert in NOPS all
17398 operations that are skipped. */
17401 loc_descr_to_next_no_nop (dw_loc_descr_ref
&loc
,
17402 hash_set
<dw_loc_descr_ref
> &nops
)
17404 while (loc
->dw_loc_next
!= NULL
&& loc
->dw_loc_opc
== DW_OP_nop
)
17407 loc
= loc
->dw_loc_next
;
17411 /* Helper for loc_descr_without_nops: free the location description operation
17415 free_loc_descr (const dw_loc_descr_ref
&loc
, void *data ATTRIBUTE_UNUSED
)
17421 /* Remove all DW_OP_nop operations from LOC except, if it exists, the one that
17425 loc_descr_without_nops (dw_loc_descr_ref
&loc
)
17427 if (loc
->dw_loc_opc
== DW_OP_nop
&& loc
->dw_loc_next
== NULL
)
17430 /* Set of all DW_OP_nop operations we remove. */
17431 hash_set
<dw_loc_descr_ref
> nops
;
17433 /* First, strip all prefix NOP operations in order to keep the head of the
17434 operations list. */
17435 loc_descr_to_next_no_nop (loc
, nops
);
17437 for (dw_loc_descr_ref cur
= loc
; cur
!= NULL
;)
17439 /* For control flow operations: strip "prefix" nops in destination
17441 if (cur
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
)
17442 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd1
.v
.val_loc
, nops
);
17443 if (cur
->dw_loc_oprnd2
.val_class
== dw_val_class_loc
)
17444 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd2
.v
.val_loc
, nops
);
17446 /* Do the same for the operations that follow, then move to the next
17448 if (cur
->dw_loc_next
!= NULL
)
17449 loc_descr_to_next_no_nop (cur
->dw_loc_next
, nops
);
17450 cur
= cur
->dw_loc_next
;
17453 nops
.traverse
<void *, free_loc_descr
> (NULL
);
17457 struct dwarf_procedure_info
;
17459 /* Helper structure for location descriptions generation. */
17460 struct loc_descr_context
17462 /* The type that is implicitly referenced by DW_OP_push_object_address, or
17463 NULL_TREE if DW_OP_push_object_address in invalid for this location
17464 description. This is used when processing PLACEHOLDER_EXPR nodes. */
17466 /* The ..._DECL node that should be translated as a
17467 DW_OP_push_object_address operation. */
17469 /* Information about the DWARF procedure we are currently generating. NULL if
17470 we are not generating a DWARF procedure. */
17471 struct dwarf_procedure_info
*dpi
;
17472 /* True if integral PLACEHOLDER_EXPR stands for the first argument passed
17473 by consumer. Used for DW_TAG_generic_subrange attributes. */
17474 bool placeholder_arg
;
17475 /* True if PLACEHOLDER_EXPR has been seen. */
17476 bool placeholder_seen
;
17479 /* DWARF procedures generation
17481 DWARF expressions (aka. location descriptions) are used to encode variable
17482 things such as sizes or offsets. Such computations can have redundant parts
17483 that can be factorized in order to reduce the size of the output debug
17484 information. This is the whole point of DWARF procedures.
17486 Thanks to stor-layout.c, size and offset expressions in GENERIC trees are
17487 already factorized into functions ("size functions") in order to handle very
17488 big and complex types. Such functions are quite simple: they have integral
17489 arguments, they return an integral result and their body contains only a
17490 return statement with arithmetic expressions. This is the only kind of
17491 function we are interested in translating into DWARF procedures, here.
17493 DWARF expressions and DWARF procedure are executed using a stack, so we have
17494 to define some calling convention for them to interact. Let's say that:
17496 - Before calling a DWARF procedure, DWARF expressions must push on the stack
17497 all arguments in reverse order (right-to-left) so that when the DWARF
17498 procedure execution starts, the first argument is the top of the stack.
17500 - Then, when returning, the DWARF procedure must have consumed all arguments
17501 on the stack, must have pushed the result and touched nothing else.
17503 - Each integral argument and the result are integral types can be hold in a
17506 - We call "frame offset" the number of stack slots that are "under DWARF
17507 procedure control": it includes the arguments slots, the temporaries and
17508 the result slot. Thus, it is equal to the number of arguments when the
17509 procedure execution starts and must be equal to one (the result) when it
17512 /* Helper structure used when generating operations for a DWARF procedure. */
17513 struct dwarf_procedure_info
17515 /* The FUNCTION_DECL node corresponding to the DWARF procedure that is
17516 currently translated. */
17518 /* The number of arguments FNDECL takes. */
17519 unsigned args_count
;
17522 /* Return a pointer to a newly created DIE node for a DWARF procedure. Add
17523 LOCATION as its DW_AT_location attribute. If FNDECL is not NULL_TREE,
17524 equate it to this DIE. */
17527 new_dwarf_proc_die (dw_loc_descr_ref location
, tree fndecl
,
17528 dw_die_ref parent_die
)
17530 dw_die_ref dwarf_proc_die
;
17532 if ((dwarf_version
< 3 && dwarf_strict
)
17533 || location
== NULL
)
17536 dwarf_proc_die
= new_die (DW_TAG_dwarf_procedure
, parent_die
, fndecl
);
17538 equate_decl_number_to_die (fndecl
, dwarf_proc_die
);
17539 add_AT_loc (dwarf_proc_die
, DW_AT_location
, location
);
17540 return dwarf_proc_die
;
17543 /* Return whether TYPE is a supported type as a DWARF procedure argument
17544 type or return type (we handle only scalar types and pointer types that
17545 aren't wider than the DWARF expression evaluation stack. */
17548 is_handled_procedure_type (tree type
)
17550 return ((INTEGRAL_TYPE_P (type
)
17551 || TREE_CODE (type
) == OFFSET_TYPE
17552 || TREE_CODE (type
) == POINTER_TYPE
)
17553 && int_size_in_bytes (type
) <= DWARF2_ADDR_SIZE
);
17556 /* Helper for resolve_args_picking: do the same but stop when coming across
17557 visited nodes. For each node we visit, register in FRAME_OFFSETS the frame
17558 offset *before* evaluating the corresponding operation. */
17561 resolve_args_picking_1 (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
17562 struct dwarf_procedure_info
*dpi
,
17563 hash_map
<dw_loc_descr_ref
, unsigned> &frame_offsets
)
17565 /* The "frame_offset" identifier is already used to name a macro... */
17566 unsigned frame_offset_
= initial_frame_offset
;
17567 dw_loc_descr_ref l
;
17569 for (l
= loc
; l
!= NULL
;)
17572 unsigned &l_frame_offset
= frame_offsets
.get_or_insert (l
, &existed
);
17574 /* If we already met this node, there is nothing to compute anymore. */
17577 /* Make sure that the stack size is consistent wherever the execution
17578 flow comes from. */
17579 gcc_assert ((unsigned) l_frame_offset
== frame_offset_
);
17582 l_frame_offset
= frame_offset_
;
17584 /* If needed, relocate the picking offset with respect to the frame
17586 if (l
->frame_offset_rel
)
17588 unsigned HOST_WIDE_INT off
;
17589 switch (l
->dw_loc_opc
)
17592 off
= l
->dw_loc_oprnd1
.v
.val_unsigned
;
17601 gcc_unreachable ();
17603 /* frame_offset_ is the size of the current stack frame, including
17604 incoming arguments. Besides, the arguments are pushed
17605 right-to-left. Thus, in order to access the Nth argument from
17606 this operation node, the picking has to skip temporaries *plus*
17607 one stack slot per argument (0 for the first one, 1 for the second
17610 The targetted argument number (N) is already set as the operand,
17611 and the number of temporaries can be computed with:
17612 frame_offsets_ - dpi->args_count */
17613 off
+= frame_offset_
- dpi
->args_count
;
17615 /* DW_OP_pick handles only offsets from 0 to 255 (inclusive)... */
17621 l
->dw_loc_opc
= DW_OP_dup
;
17622 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
17626 l
->dw_loc_opc
= DW_OP_over
;
17627 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
17631 l
->dw_loc_opc
= DW_OP_pick
;
17632 l
->dw_loc_oprnd1
.v
.val_unsigned
= off
;
17636 /* Update frame_offset according to the effect the current operation has
17638 switch (l
->dw_loc_opc
)
17646 case DW_OP_plus_uconst
:
17682 case DW_OP_deref_size
:
17684 case DW_OP_bit_piece
:
17685 case DW_OP_implicit_value
:
17686 case DW_OP_stack_value
:
17690 case DW_OP_const1u
:
17691 case DW_OP_const1s
:
17692 case DW_OP_const2u
:
17693 case DW_OP_const2s
:
17694 case DW_OP_const4u
:
17695 case DW_OP_const4s
:
17696 case DW_OP_const8u
:
17697 case DW_OP_const8s
:
17768 case DW_OP_push_object_address
:
17769 case DW_OP_call_frame_cfa
:
17770 case DW_OP_GNU_variable_value
:
17795 case DW_OP_xderef_size
:
17801 case DW_OP_call_ref
:
17803 dw_die_ref dwarf_proc
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
17804 int *stack_usage
= dwarf_proc_stack_usage_map
->get (dwarf_proc
);
17806 if (stack_usage
== NULL
)
17808 frame_offset_
+= *stack_usage
;
17812 case DW_OP_implicit_pointer
:
17813 case DW_OP_entry_value
:
17814 case DW_OP_const_type
:
17815 case DW_OP_regval_type
:
17816 case DW_OP_deref_type
:
17817 case DW_OP_convert
:
17818 case DW_OP_reinterpret
:
17819 case DW_OP_form_tls_address
:
17820 case DW_OP_GNU_push_tls_address
:
17821 case DW_OP_GNU_uninit
:
17822 case DW_OP_GNU_encoded_addr
:
17823 case DW_OP_GNU_implicit_pointer
:
17824 case DW_OP_GNU_entry_value
:
17825 case DW_OP_GNU_const_type
:
17826 case DW_OP_GNU_regval_type
:
17827 case DW_OP_GNU_deref_type
:
17828 case DW_OP_GNU_convert
:
17829 case DW_OP_GNU_reinterpret
:
17830 case DW_OP_GNU_parameter_ref
:
17831 /* loc_list_from_tree will probably not output these operations for
17832 size functions, so assume they will not appear here. */
17833 /* Fall through... */
17836 gcc_unreachable ();
17839 /* Now, follow the control flow (except subroutine calls). */
17840 switch (l
->dw_loc_opc
)
17843 if (!resolve_args_picking_1 (l
->dw_loc_next
, frame_offset_
, dpi
,
17846 /* Fall through. */
17849 l
= l
->dw_loc_oprnd1
.v
.val_loc
;
17852 case DW_OP_stack_value
:
17856 l
= l
->dw_loc_next
;
17864 /* Make a DFS over operations reachable through LOC (i.e. follow branch
17865 operations) in order to resolve the operand of DW_OP_pick operations that
17866 target DWARF procedure arguments (DPI). INITIAL_FRAME_OFFSET is the frame
17867 offset *before* LOC is executed. Return if all relocations were
17871 resolve_args_picking (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
17872 struct dwarf_procedure_info
*dpi
)
17874 /* Associate to all visited operations the frame offset *before* evaluating
17876 hash_map
<dw_loc_descr_ref
, unsigned> frame_offsets
;
17878 return resolve_args_picking_1 (loc
, initial_frame_offset
, dpi
,
17882 /* Try to generate a DWARF procedure that computes the same result as FNDECL.
17883 Return NULL if it is not possible. */
17886 function_to_dwarf_procedure (tree fndecl
)
17888 struct loc_descr_context ctx
;
17889 struct dwarf_procedure_info dpi
;
17890 dw_die_ref dwarf_proc_die
;
17891 tree tree_body
= DECL_SAVED_TREE (fndecl
);
17892 dw_loc_descr_ref loc_body
, epilogue
;
17897 /* Do not generate multiple DWARF procedures for the same function
17899 dwarf_proc_die
= lookup_decl_die (fndecl
);
17900 if (dwarf_proc_die
!= NULL
)
17901 return dwarf_proc_die
;
17903 /* DWARF procedures are available starting with the DWARFv3 standard. */
17904 if (dwarf_version
< 3 && dwarf_strict
)
17907 /* We handle only functions for which we still have a body, that return a
17908 supported type and that takes arguments with supported types. Note that
17909 there is no point translating functions that return nothing. */
17910 if (tree_body
== NULL_TREE
17911 || DECL_RESULT (fndecl
) == NULL_TREE
17912 || !is_handled_procedure_type (TREE_TYPE (DECL_RESULT (fndecl
))))
17915 for (cursor
= DECL_ARGUMENTS (fndecl
);
17916 cursor
!= NULL_TREE
;
17917 cursor
= TREE_CHAIN (cursor
))
17918 if (!is_handled_procedure_type (TREE_TYPE (cursor
)))
17921 /* Match only "expr" in: RETURN_EXPR (MODIFY_EXPR (RESULT_DECL, expr)). */
17922 if (TREE_CODE (tree_body
) != RETURN_EXPR
)
17924 tree_body
= TREE_OPERAND (tree_body
, 0);
17925 if (TREE_CODE (tree_body
) != MODIFY_EXPR
17926 || TREE_OPERAND (tree_body
, 0) != DECL_RESULT (fndecl
))
17928 tree_body
= TREE_OPERAND (tree_body
, 1);
17930 /* Try to translate the body expression itself. Note that this will probably
17931 cause an infinite recursion if its call graph has a cycle. This is very
17932 unlikely for size functions, however, so don't bother with such things at
17934 ctx
.context_type
= NULL_TREE
;
17935 ctx
.base_decl
= NULL_TREE
;
17937 ctx
.placeholder_arg
= false;
17938 ctx
.placeholder_seen
= false;
17939 dpi
.fndecl
= fndecl
;
17940 dpi
.args_count
= list_length (DECL_ARGUMENTS (fndecl
));
17941 loc_body
= loc_descriptor_from_tree (tree_body
, 0, &ctx
);
17945 /* After evaluating all operands in "loc_body", we should still have on the
17946 stack all arguments plus the desired function result (top of the stack).
17947 Generate code in order to keep only the result in our stack frame. */
17949 for (i
= 0; i
< dpi
.args_count
; ++i
)
17951 dw_loc_descr_ref op_couple
= new_loc_descr (DW_OP_swap
, 0, 0);
17952 op_couple
->dw_loc_next
= new_loc_descr (DW_OP_drop
, 0, 0);
17953 op_couple
->dw_loc_next
->dw_loc_next
= epilogue
;
17954 epilogue
= op_couple
;
17956 add_loc_descr (&loc_body
, epilogue
);
17957 if (!resolve_args_picking (loc_body
, dpi
.args_count
, &dpi
))
17960 /* Trailing nops from loc_descriptor_from_tree (if any) cannot be removed
17961 because they are considered useful. Now there is an epilogue, they are
17962 not anymore, so give it another try. */
17963 loc_descr_without_nops (loc_body
);
17965 /* fndecl may be used both as a regular DW_TAG_subprogram DIE and as
17966 a DW_TAG_dwarf_procedure, so we may have a conflict, here. It's unlikely,
17967 though, given that size functions do not come from source, so they should
17968 not have a dedicated DW_TAG_subprogram DIE. */
17970 = new_dwarf_proc_die (loc_body
, fndecl
,
17971 get_context_die (DECL_CONTEXT (fndecl
)));
17973 /* The called DWARF procedure consumes one stack slot per argument and
17974 returns one stack slot. */
17975 dwarf_proc_stack_usage_map
->put (dwarf_proc_die
, 1 - dpi
.args_count
);
17977 return dwarf_proc_die
;
17981 /* Generate Dwarf location list representing LOC.
17982 If WANT_ADDRESS is false, expression computing LOC will be computed
17983 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
17984 if WANT_ADDRESS is 2, expression computing address useable in location
17985 will be returned (i.e. DW_OP_reg can be used
17986 to refer to register values).
17988 CONTEXT provides information to customize the location descriptions
17989 generation. Its context_type field specifies what type is implicitly
17990 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
17991 will not be generated.
17993 Its DPI field determines whether we are generating a DWARF expression for a
17994 DWARF procedure, so PARM_DECL references are processed specifically.
17996 If CONTEXT is NULL, the behavior is the same as if context_type, base_decl
17997 and dpi fields were null. */
17999 static dw_loc_list_ref
18000 loc_list_from_tree_1 (tree loc
, int want_address
,
18001 struct loc_descr_context
*context
)
18003 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
18004 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
18005 int have_address
= 0;
18006 enum dwarf_location_atom op
;
18008 /* ??? Most of the time we do not take proper care for sign/zero
18009 extending the values properly. Hopefully this won't be a real
18012 if (context
!= NULL
18013 && context
->base_decl
== loc
18014 && want_address
== 0)
18016 if (dwarf_version
>= 3 || !dwarf_strict
)
18017 return new_loc_list (new_loc_descr (DW_OP_push_object_address
, 0, 0),
18018 NULL
, 0, NULL
, 0, NULL
);
18023 switch (TREE_CODE (loc
))
18026 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
18029 case PLACEHOLDER_EXPR
:
18030 /* This case involves extracting fields from an object to determine the
18031 position of other fields. It is supposed to appear only as the first
18032 operand of COMPONENT_REF nodes and to reference precisely the type
18033 that the context allows. */
18034 if (context
!= NULL
18035 && TREE_TYPE (loc
) == context
->context_type
18036 && want_address
>= 1)
18038 if (dwarf_version
>= 3 || !dwarf_strict
)
18040 ret
= new_loc_descr (DW_OP_push_object_address
, 0, 0);
18047 /* For DW_TAG_generic_subrange attributes, PLACEHOLDER_EXPR stands for
18048 the single argument passed by consumer. */
18049 else if (context
!= NULL
18050 && context
->placeholder_arg
18051 && INTEGRAL_TYPE_P (TREE_TYPE (loc
))
18052 && want_address
== 0)
18054 ret
= new_loc_descr (DW_OP_pick
, 0, 0);
18055 ret
->frame_offset_rel
= 1;
18056 context
->placeholder_seen
= true;
18060 expansion_failed (loc
, NULL_RTX
,
18061 "PLACEHOLDER_EXPR for an unexpected type");
18066 const int nargs
= call_expr_nargs (loc
);
18067 tree callee
= get_callee_fndecl (loc
);
18069 dw_die_ref dwarf_proc
;
18071 if (callee
== NULL_TREE
)
18072 goto call_expansion_failed
;
18074 /* We handle only functions that return an integer. */
18075 if (!is_handled_procedure_type (TREE_TYPE (TREE_TYPE (callee
))))
18076 goto call_expansion_failed
;
18078 dwarf_proc
= function_to_dwarf_procedure (callee
);
18079 if (dwarf_proc
== NULL
)
18080 goto call_expansion_failed
;
18082 /* Evaluate arguments right-to-left so that the first argument will
18083 be the top-most one on the stack. */
18084 for (i
= nargs
- 1; i
>= 0; --i
)
18086 dw_loc_descr_ref loc_descr
18087 = loc_descriptor_from_tree (CALL_EXPR_ARG (loc
, i
), 0,
18090 if (loc_descr
== NULL
)
18091 goto call_expansion_failed
;
18093 add_loc_descr (&ret
, loc_descr
);
18096 ret1
= new_loc_descr (DW_OP_call4
, 0, 0);
18097 ret1
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18098 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.die
= dwarf_proc
;
18099 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18100 add_loc_descr (&ret
, ret1
);
18103 call_expansion_failed
:
18104 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
18105 /* There are no opcodes for these operations. */
18109 case PREINCREMENT_EXPR
:
18110 case PREDECREMENT_EXPR
:
18111 case POSTINCREMENT_EXPR
:
18112 case POSTDECREMENT_EXPR
:
18113 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
18114 /* There are no opcodes for these operations. */
18118 /* If we already want an address, see if there is INDIRECT_REF inside
18119 e.g. for &this->field. */
18122 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
18123 (loc
, want_address
== 2, context
);
18126 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
18127 && (ret
= cst_pool_loc_descr (loc
)))
18130 /* Otherwise, process the argument and look for the address. */
18131 if (!list_ret
&& !ret
)
18132 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 1, context
);
18136 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
18142 if (DECL_THREAD_LOCAL_P (loc
))
18145 enum dwarf_location_atom tls_op
;
18146 enum dtprel_bool dtprel
= dtprel_false
;
18148 if (targetm
.have_tls
)
18150 /* If this is not defined, we have no way to emit the
18152 if (!targetm
.asm_out
.output_dwarf_dtprel
)
18155 /* The way DW_OP_GNU_push_tls_address is specified, we
18156 can only look up addresses of objects in the current
18157 module. We used DW_OP_addr as first op, but that's
18158 wrong, because DW_OP_addr is relocated by the debug
18159 info consumer, while DW_OP_GNU_push_tls_address
18160 operand shouldn't be. */
18161 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
18163 dtprel
= dtprel_true
;
18164 /* We check for DWARF 5 here because gdb did not implement
18165 DW_OP_form_tls_address until after 7.12. */
18166 tls_op
= (dwarf_version
>= 5 ? DW_OP_form_tls_address
18167 : DW_OP_GNU_push_tls_address
);
18171 if (!targetm
.emutls
.debug_form_tls_address
18172 || !(dwarf_version
>= 3 || !dwarf_strict
))
18174 /* We stuffed the control variable into the DECL_VALUE_EXPR
18175 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
18176 no longer appear in gimple code. We used the control
18177 variable in specific so that we could pick it up here. */
18178 loc
= DECL_VALUE_EXPR (loc
);
18179 tls_op
= DW_OP_form_tls_address
;
18182 rtl
= rtl_for_decl_location (loc
);
18183 if (rtl
== NULL_RTX
)
18188 rtl
= XEXP (rtl
, 0);
18189 if (! CONSTANT_P (rtl
))
18192 ret
= new_addr_loc_descr (rtl
, dtprel
);
18193 ret1
= new_loc_descr (tls_op
, 0, 0);
18194 add_loc_descr (&ret
, ret1
);
18202 if (context
!= NULL
&& context
->dpi
!= NULL
18203 && DECL_CONTEXT (loc
) == context
->dpi
->fndecl
)
18205 /* We are generating code for a DWARF procedure and we want to access
18206 one of its arguments: find the appropriate argument offset and let
18207 the resolve_args_picking pass compute the offset that complies
18208 with the stack frame size. */
18212 for (cursor
= DECL_ARGUMENTS (context
->dpi
->fndecl
);
18213 cursor
!= NULL_TREE
&& cursor
!= loc
;
18214 cursor
= TREE_CHAIN (cursor
), ++i
)
18216 /* If we are translating a DWARF procedure, all referenced parameters
18217 must belong to the current function. */
18218 gcc_assert (cursor
!= NULL_TREE
);
18220 ret
= new_loc_descr (DW_OP_pick
, i
, 0);
18221 ret
->frame_offset_rel
= 1;
18227 if (DECL_HAS_VALUE_EXPR_P (loc
))
18228 return loc_list_from_tree_1 (DECL_VALUE_EXPR (loc
),
18229 want_address
, context
);
18232 case FUNCTION_DECL
:
18235 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
18237 if (loc_list
&& loc_list
->first
)
18239 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
18240 have_address
= want_address
!= 0;
18243 rtl
= rtl_for_decl_location (loc
);
18244 if (rtl
== NULL_RTX
)
18246 if (TREE_CODE (loc
) != FUNCTION_DECL
18248 && current_function_decl
18249 && want_address
!= 1
18250 && ! DECL_IGNORED_P (loc
)
18251 && (INTEGRAL_TYPE_P (TREE_TYPE (loc
))
18252 || POINTER_TYPE_P (TREE_TYPE (loc
)))
18253 && DECL_CONTEXT (loc
) == current_function_decl
18254 && (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (loc
)))
18255 <= DWARF2_ADDR_SIZE
))
18257 dw_die_ref ref
= lookup_decl_die (loc
);
18258 ret
= new_loc_descr (DW_OP_GNU_variable_value
, 0, 0);
18261 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18262 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
18263 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18267 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
18268 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= loc
;
18272 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
18275 else if (CONST_INT_P (rtl
))
18277 HOST_WIDE_INT val
= INTVAL (rtl
);
18278 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18279 val
&= GET_MODE_MASK (DECL_MODE (loc
));
18280 ret
= int_loc_descriptor (val
);
18282 else if (GET_CODE (rtl
) == CONST_STRING
)
18284 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
18287 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
18288 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
18291 machine_mode mode
, mem_mode
;
18293 /* Certain constructs can only be represented at top-level. */
18294 if (want_address
== 2)
18296 ret
= loc_descriptor (rtl
, VOIDmode
,
18297 VAR_INIT_STATUS_INITIALIZED
);
18302 mode
= GET_MODE (rtl
);
18303 mem_mode
= VOIDmode
;
18307 mode
= get_address_mode (rtl
);
18308 rtl
= XEXP (rtl
, 0);
18311 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
18312 VAR_INIT_STATUS_INITIALIZED
);
18315 expansion_failed (loc
, rtl
,
18316 "failed to produce loc descriptor for rtl");
18322 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
18329 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18333 case TARGET_MEM_REF
:
18335 case DEBUG_EXPR_DECL
:
18338 case COMPOUND_EXPR
:
18339 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), want_address
,
18343 case VIEW_CONVERT_EXPR
:
18346 case NON_LVALUE_EXPR
:
18347 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), want_address
,
18350 case COMPONENT_REF
:
18351 case BIT_FIELD_REF
:
18353 case ARRAY_RANGE_REF
:
18354 case REALPART_EXPR
:
18355 case IMAGPART_EXPR
:
18358 poly_int64 bitsize
, bitpos
, bytepos
;
18360 int unsignedp
, reversep
, volatilep
= 0;
18362 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
18363 &unsignedp
, &reversep
, &volatilep
);
18365 gcc_assert (obj
!= loc
);
18367 list_ret
= loc_list_from_tree_1 (obj
,
18369 && known_eq (bitpos
, 0)
18370 && !offset
? 2 : 1,
18372 /* TODO: We can extract value of the small expression via shifting even
18373 for nonzero bitpos. */
18376 if (!multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
18377 || !multiple_p (bitsize
, BITS_PER_UNIT
))
18379 expansion_failed (loc
, NULL_RTX
,
18380 "bitfield access");
18384 if (offset
!= NULL_TREE
)
18386 /* Variable offset. */
18387 list_ret1
= loc_list_from_tree_1 (offset
, 0, context
);
18388 if (list_ret1
== 0)
18390 add_loc_list (&list_ret
, list_ret1
);
18393 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
18396 HOST_WIDE_INT value
;
18397 if (bytepos
.is_constant (&value
) && value
> 0)
18398 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
,
18400 else if (maybe_ne (bytepos
, 0))
18401 loc_list_plus_const (list_ret
, bytepos
);
18408 if ((want_address
|| !tree_fits_shwi_p (loc
))
18409 && (ret
= cst_pool_loc_descr (loc
)))
18411 else if (want_address
== 2
18412 && tree_fits_shwi_p (loc
)
18413 && (ret
= address_of_int_loc_descriptor
18414 (int_size_in_bytes (TREE_TYPE (loc
)),
18415 tree_to_shwi (loc
))))
18417 else if (tree_fits_shwi_p (loc
))
18418 ret
= int_loc_descriptor (tree_to_shwi (loc
));
18419 else if (tree_fits_uhwi_p (loc
))
18420 ret
= uint_loc_descriptor (tree_to_uhwi (loc
));
18423 expansion_failed (loc
, NULL_RTX
,
18424 "Integer operand is not host integer");
18433 if ((ret
= cst_pool_loc_descr (loc
)))
18435 else if (TREE_CODE (loc
) == CONSTRUCTOR
)
18437 tree type
= TREE_TYPE (loc
);
18438 unsigned HOST_WIDE_INT size
= int_size_in_bytes (type
);
18439 unsigned HOST_WIDE_INT offset
= 0;
18440 unsigned HOST_WIDE_INT cnt
;
18441 constructor_elt
*ce
;
18443 if (TREE_CODE (type
) == RECORD_TYPE
)
18445 /* This is very limited, but it's enough to output
18446 pointers to member functions, as long as the
18447 referenced function is defined in the current
18448 translation unit. */
18449 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (loc
), cnt
, ce
)
18451 tree val
= ce
->value
;
18453 tree field
= ce
->index
;
18458 if (!field
|| DECL_BIT_FIELD (field
))
18460 expansion_failed (loc
, NULL_RTX
,
18461 "bitfield in record type constructor");
18462 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
18467 HOST_WIDE_INT fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
18468 unsigned HOST_WIDE_INT pos
= int_byte_position (field
);
18469 gcc_assert (pos
+ fieldsize
<= size
);
18472 expansion_failed (loc
, NULL_RTX
,
18473 "out-of-order fields in record constructor");
18474 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
18480 ret1
= new_loc_descr (DW_OP_piece
, pos
- offset
, 0);
18481 add_loc_descr (&ret
, ret1
);
18484 if (val
&& fieldsize
!= 0)
18486 ret1
= loc_descriptor_from_tree (val
, want_address
, context
);
18489 expansion_failed (loc
, NULL_RTX
,
18490 "unsupported expression in field");
18491 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
18495 add_loc_descr (&ret
, ret1
);
18499 ret1
= new_loc_descr (DW_OP_piece
, fieldsize
, 0);
18500 add_loc_descr (&ret
, ret1
);
18501 offset
= pos
+ fieldsize
;
18505 if (offset
!= size
)
18507 ret1
= new_loc_descr (DW_OP_piece
, size
- offset
, 0);
18508 add_loc_descr (&ret
, ret1
);
18512 have_address
= !!want_address
;
18515 expansion_failed (loc
, NULL_RTX
,
18516 "constructor of non-record type");
18519 /* We can construct small constants here using int_loc_descriptor. */
18520 expansion_failed (loc
, NULL_RTX
,
18521 "constructor or constant not in constant pool");
18524 case TRUTH_AND_EXPR
:
18525 case TRUTH_ANDIF_EXPR
:
18530 case TRUTH_XOR_EXPR
:
18535 case TRUTH_OR_EXPR
:
18536 case TRUTH_ORIF_EXPR
:
18541 case FLOOR_DIV_EXPR
:
18542 case CEIL_DIV_EXPR
:
18543 case ROUND_DIV_EXPR
:
18544 case TRUNC_DIV_EXPR
:
18545 case EXACT_DIV_EXPR
:
18546 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18555 case FLOOR_MOD_EXPR
:
18556 case CEIL_MOD_EXPR
:
18557 case ROUND_MOD_EXPR
:
18558 case TRUNC_MOD_EXPR
:
18559 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18564 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18565 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
18566 if (list_ret
== 0 || list_ret1
== 0)
18569 add_loc_list (&list_ret
, list_ret1
);
18572 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
18573 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
18574 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
18575 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
18576 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
18588 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
18591 case POINTER_PLUS_EXPR
:
18594 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
18596 /* Big unsigned numbers can fit in HOST_WIDE_INT but it may be
18597 smarter to encode their opposite. The DW_OP_plus_uconst operation
18598 takes 1 + X bytes, X being the size of the ULEB128 addend. On the
18599 other hand, a "<push literal>; DW_OP_minus" pattern takes 1 + Y
18600 bytes, Y being the size of the operation that pushes the opposite
18601 of the addend. So let's choose the smallest representation. */
18602 const tree tree_addend
= TREE_OPERAND (loc
, 1);
18603 offset_int wi_addend
;
18604 HOST_WIDE_INT shwi_addend
;
18605 dw_loc_descr_ref loc_naddend
;
18607 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18611 /* Try to get the literal to push. It is the opposite of the addend,
18612 so as we rely on wrapping during DWARF evaluation, first decode
18613 the literal as a "DWARF-sized" signed number. */
18614 wi_addend
= wi::to_offset (tree_addend
);
18615 wi_addend
= wi::sext (wi_addend
, DWARF2_ADDR_SIZE
* 8);
18616 shwi_addend
= wi_addend
.to_shwi ();
18617 loc_naddend
= (shwi_addend
!= INTTYPE_MINIMUM (HOST_WIDE_INT
))
18618 ? int_loc_descriptor (-shwi_addend
)
18621 if (loc_naddend
!= NULL
18622 && ((unsigned) size_of_uleb128 (shwi_addend
)
18623 > size_of_loc_descr (loc_naddend
)))
18625 add_loc_descr_to_each (list_ret
, loc_naddend
);
18626 add_loc_descr_to_each (list_ret
,
18627 new_loc_descr (DW_OP_minus
, 0, 0));
18631 for (dw_loc_descr_ref loc_cur
= loc_naddend
; loc_cur
!= NULL
; )
18633 loc_naddend
= loc_cur
;
18634 loc_cur
= loc_cur
->dw_loc_next
;
18635 ggc_free (loc_naddend
);
18637 loc_list_plus_const (list_ret
, wi_addend
.to_shwi ());
18647 goto do_comp_binop
;
18651 goto do_comp_binop
;
18655 goto do_comp_binop
;
18659 goto do_comp_binop
;
18662 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
18664 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0, context
);
18665 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
18666 list_ret
= loc_list_from_uint_comparison (list_ret
, list_ret1
,
18682 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18683 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
18684 if (list_ret
== 0 || list_ret1
== 0)
18687 add_loc_list (&list_ret
, list_ret1
);
18690 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
18693 case TRUTH_NOT_EXPR
:
18707 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18711 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
18717 const enum tree_code code
=
18718 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
18720 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
18721 build2 (code
, integer_type_node
,
18722 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
18723 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
18730 dw_loc_descr_ref lhs
18731 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
18732 dw_loc_list_ref rhs
18733 = loc_list_from_tree_1 (TREE_OPERAND (loc
, 2), 0, context
);
18734 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
18736 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18737 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
18740 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
18741 add_loc_descr_to_each (list_ret
, bra_node
);
18743 add_loc_list (&list_ret
, rhs
);
18744 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
18745 add_loc_descr_to_each (list_ret
, jump_node
);
18747 add_loc_descr_to_each (list_ret
, lhs
);
18748 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
18749 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
18751 /* ??? Need a node to point the skip at. Use a nop. */
18752 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
18753 add_loc_descr_to_each (list_ret
, tmp
);
18754 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
18755 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
18759 case FIX_TRUNC_EXPR
:
18763 /* Leave front-end specific codes as simply unknown. This comes
18764 up, for instance, with the C STMT_EXPR. */
18765 if ((unsigned int) TREE_CODE (loc
)
18766 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
18768 expansion_failed (loc
, NULL_RTX
,
18769 "language specific tree node");
18773 /* Otherwise this is a generic code; we should just lists all of
18774 these explicitly. We forgot one. */
18776 gcc_unreachable ();
18778 /* In a release build, we want to degrade gracefully: better to
18779 generate incomplete debugging information than to crash. */
18783 if (!ret
&& !list_ret
)
18786 if (want_address
== 2 && !have_address
18787 && (dwarf_version
>= 4 || !dwarf_strict
))
18789 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
18791 expansion_failed (loc
, NULL_RTX
,
18792 "DWARF address size mismatch");
18796 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
18798 add_loc_descr_to_each (list_ret
,
18799 new_loc_descr (DW_OP_stack_value
, 0, 0));
18802 /* Show if we can't fill the request for an address. */
18803 if (want_address
&& !have_address
)
18805 expansion_failed (loc
, NULL_RTX
,
18806 "Want address and only have value");
18810 gcc_assert (!ret
|| !list_ret
);
18812 /* If we've got an address and don't want one, dereference. */
18813 if (!want_address
&& have_address
)
18815 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
18817 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
18819 expansion_failed (loc
, NULL_RTX
,
18820 "DWARF address size mismatch");
18823 else if (size
== DWARF2_ADDR_SIZE
)
18826 op
= DW_OP_deref_size
;
18829 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
18831 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
18834 list_ret
= new_loc_list (ret
, NULL
, 0, NULL
, 0, NULL
);
18839 /* Likewise, but strip useless DW_OP_nop operations in the resulting
18842 static dw_loc_list_ref
18843 loc_list_from_tree (tree loc
, int want_address
,
18844 struct loc_descr_context
*context
)
18846 dw_loc_list_ref result
= loc_list_from_tree_1 (loc
, want_address
, context
);
18848 for (dw_loc_list_ref loc_cur
= result
;
18849 loc_cur
!= NULL
; loc_cur
= loc_cur
->dw_loc_next
)
18850 loc_descr_without_nops (loc_cur
->expr
);
18854 /* Same as above but return only single location expression. */
18855 static dw_loc_descr_ref
18856 loc_descriptor_from_tree (tree loc
, int want_address
,
18857 struct loc_descr_context
*context
)
18859 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
, context
);
18862 if (ret
->dw_loc_next
)
18864 expansion_failed (loc
, NULL_RTX
,
18865 "Location list where only loc descriptor needed");
18871 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
18872 pointer to the declared type for the relevant field variable, or return
18873 `integer_type_node' if the given node turns out to be an
18874 ERROR_MARK node. */
18877 field_type (const_tree decl
)
18881 if (TREE_CODE (decl
) == ERROR_MARK
)
18882 return integer_type_node
;
18884 type
= DECL_BIT_FIELD_TYPE (decl
);
18885 if (type
== NULL_TREE
)
18886 type
= TREE_TYPE (decl
);
18891 /* Given a pointer to a tree node, return the alignment in bits for
18892 it, or else return BITS_PER_WORD if the node actually turns out to
18893 be an ERROR_MARK node. */
18895 static inline unsigned
18896 simple_type_align_in_bits (const_tree type
)
18898 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
18901 static inline unsigned
18902 simple_decl_align_in_bits (const_tree decl
)
18904 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
18907 /* Return the result of rounding T up to ALIGN. */
18909 static inline offset_int
18910 round_up_to_align (const offset_int
&t
, unsigned int align
)
18912 return wi::udiv_trunc (t
+ align
- 1, align
) * align
;
18915 /* Compute the size of TYPE in bytes. If possible, return NULL and store the
18916 size as an integer constant in CST_SIZE. Otherwise, if possible, return a
18917 DWARF expression that computes the size. Return NULL and set CST_SIZE to -1
18918 if we fail to return the size in one of these two forms. */
18920 static dw_loc_descr_ref
18921 type_byte_size (const_tree type
, HOST_WIDE_INT
*cst_size
)
18924 struct loc_descr_context ctx
;
18926 /* Return a constant integer in priority, if possible. */
18927 *cst_size
= int_size_in_bytes (type
);
18928 if (*cst_size
!= -1)
18931 ctx
.context_type
= const_cast<tree
> (type
);
18932 ctx
.base_decl
= NULL_TREE
;
18934 ctx
.placeholder_arg
= false;
18935 ctx
.placeholder_seen
= false;
18937 type
= TYPE_MAIN_VARIANT (type
);
18938 tree_size
= TYPE_SIZE_UNIT (type
);
18939 return ((tree_size
!= NULL_TREE
)
18940 ? loc_descriptor_from_tree (tree_size
, 0, &ctx
)
18944 /* Helper structure for RECORD_TYPE processing. */
18947 /* Root RECORD_TYPE. It is needed to generate data member location
18948 descriptions in variable-length records (VLR), but also to cope with
18949 variants, which are composed of nested structures multiplexed with
18950 QUAL_UNION_TYPE nodes. Each time such a structure is passed to a
18951 function processing a FIELD_DECL, it is required to be non null. */
18953 /* When generating a variant part in a RECORD_TYPE (i.e. a nested
18954 QUAL_UNION_TYPE), this holds an expression that computes the offset for
18955 this variant part as part of the root record (in storage units). For
18956 regular records, it must be NULL_TREE. */
18957 tree variant_part_offset
;
18960 /* Given a pointer to a FIELD_DECL, compute the byte offset of the lowest
18961 addressed byte of the "containing object" for the given FIELD_DECL. If
18962 possible, return a native constant through CST_OFFSET (in which case NULL is
18963 returned); otherwise return a DWARF expression that computes the offset.
18965 Set *CST_OFFSET to 0 and return NULL if we are unable to determine what
18966 that offset is, either because the argument turns out to be a pointer to an
18967 ERROR_MARK node, or because the offset expression is too complex for us.
18969 CTX is required: see the comment for VLR_CONTEXT. */
18971 static dw_loc_descr_ref
18972 field_byte_offset (const_tree decl
, struct vlr_context
*ctx
,
18973 HOST_WIDE_INT
*cst_offset
)
18976 dw_loc_list_ref loc_result
;
18980 if (TREE_CODE (decl
) == ERROR_MARK
)
18983 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
18985 /* We cannot handle variable bit offsets at the moment, so abort if it's the
18987 if (TREE_CODE (DECL_FIELD_BIT_OFFSET (decl
)) != INTEGER_CST
)
18990 /* We used to handle only constant offsets in all cases. Now, we handle
18991 properly dynamic byte offsets only when PCC bitfield type doesn't
18993 if (PCC_BITFIELD_TYPE_MATTERS
18994 && TREE_CODE (DECL_FIELD_OFFSET (decl
)) == INTEGER_CST
)
18996 offset_int object_offset_in_bits
;
18997 offset_int object_offset_in_bytes
;
18998 offset_int bitpos_int
;
19000 tree field_size_tree
;
19001 offset_int deepest_bitpos
;
19002 offset_int field_size_in_bits
;
19003 unsigned int type_align_in_bits
;
19004 unsigned int decl_align_in_bits
;
19005 offset_int type_size_in_bits
;
19007 bitpos_int
= wi::to_offset (bit_position (decl
));
19008 type
= field_type (decl
);
19009 type_size_in_bits
= offset_int_type_size_in_bits (type
);
19010 type_align_in_bits
= simple_type_align_in_bits (type
);
19012 field_size_tree
= DECL_SIZE (decl
);
19014 /* The size could be unspecified if there was an error, or for
19015 a flexible array member. */
19016 if (!field_size_tree
)
19017 field_size_tree
= bitsize_zero_node
;
19019 /* If the size of the field is not constant, use the type size. */
19020 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
19021 field_size_in_bits
= wi::to_offset (field_size_tree
);
19023 field_size_in_bits
= type_size_in_bits
;
19025 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
19027 /* The GCC front-end doesn't make any attempt to keep track of the
19028 starting bit offset (relative to the start of the containing
19029 structure type) of the hypothetical "containing object" for a
19030 bit-field. Thus, when computing the byte offset value for the
19031 start of the "containing object" of a bit-field, we must deduce
19032 this information on our own. This can be rather tricky to do in
19033 some cases. For example, handling the following structure type
19034 definition when compiling for an i386/i486 target (which only
19035 aligns long long's to 32-bit boundaries) can be very tricky:
19037 struct S { int field1; long long field2:31; };
19039 Fortunately, there is a simple rule-of-thumb which can be used
19040 in such cases. When compiling for an i386/i486, GCC will
19041 allocate 8 bytes for the structure shown above. It decides to
19042 do this based upon one simple rule for bit-field allocation.
19043 GCC allocates each "containing object" for each bit-field at
19044 the first (i.e. lowest addressed) legitimate alignment boundary
19045 (based upon the required minimum alignment for the declared
19046 type of the field) which it can possibly use, subject to the
19047 condition that there is still enough available space remaining
19048 in the containing object (when allocated at the selected point)
19049 to fully accommodate all of the bits of the bit-field itself.
19051 This simple rule makes it obvious why GCC allocates 8 bytes for
19052 each object of the structure type shown above. When looking
19053 for a place to allocate the "containing object" for `field2',
19054 the compiler simply tries to allocate a 64-bit "containing
19055 object" at each successive 32-bit boundary (starting at zero)
19056 until it finds a place to allocate that 64- bit field such that
19057 at least 31 contiguous (and previously unallocated) bits remain
19058 within that selected 64 bit field. (As it turns out, for the
19059 example above, the compiler finds it is OK to allocate the
19060 "containing object" 64-bit field at bit-offset zero within the
19063 Here we attempt to work backwards from the limited set of facts
19064 we're given, and we try to deduce from those facts, where GCC
19065 must have believed that the containing object started (within
19066 the structure type). The value we deduce is then used (by the
19067 callers of this routine) to generate DW_AT_location and
19068 DW_AT_bit_offset attributes for fields (both bit-fields and, in
19069 the case of DW_AT_location, regular fields as well). */
19071 /* Figure out the bit-distance from the start of the structure to
19072 the "deepest" bit of the bit-field. */
19073 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
19075 /* This is the tricky part. Use some fancy footwork to deduce
19076 where the lowest addressed bit of the containing object must
19078 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
19080 /* Round up to type_align by default. This works best for
19082 object_offset_in_bits
19083 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
19085 if (wi::gtu_p (object_offset_in_bits
, bitpos_int
))
19087 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
19089 /* Round up to decl_align instead. */
19090 object_offset_in_bits
19091 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
19094 object_offset_in_bytes
19095 = wi::lrshift (object_offset_in_bits
, LOG2_BITS_PER_UNIT
);
19096 if (ctx
->variant_part_offset
== NULL_TREE
)
19098 *cst_offset
= object_offset_in_bytes
.to_shwi ();
19101 tree_result
= wide_int_to_tree (sizetype
, object_offset_in_bytes
);
19104 tree_result
= byte_position (decl
);
19106 if (ctx
->variant_part_offset
!= NULL_TREE
)
19107 tree_result
= fold_build2 (PLUS_EXPR
, TREE_TYPE (tree_result
),
19108 ctx
->variant_part_offset
, tree_result
);
19110 /* If the byte offset is a constant, it's simplier to handle a native
19111 constant rather than a DWARF expression. */
19112 if (TREE_CODE (tree_result
) == INTEGER_CST
)
19114 *cst_offset
= wi::to_offset (tree_result
).to_shwi ();
19117 struct loc_descr_context loc_ctx
= {
19118 ctx
->struct_type
, /* context_type */
19119 NULL_TREE
, /* base_decl */
19121 false, /* placeholder_arg */
19122 false /* placeholder_seen */
19124 loc_result
= loc_list_from_tree (tree_result
, 0, &loc_ctx
);
19126 /* We want a DWARF expression: abort if we only have a location list with
19127 multiple elements. */
19128 if (!loc_result
|| !single_element_loc_list_p (loc_result
))
19131 return loc_result
->expr
;
19134 /* The following routines define various Dwarf attributes and any data
19135 associated with them. */
19137 /* Add a location description attribute value to a DIE.
19139 This emits location attributes suitable for whole variables and
19140 whole parameters. Note that the location attributes for struct fields are
19141 generated by the routine `data_member_location_attribute' below. */
19144 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
19145 dw_loc_list_ref descr
)
19147 bool check_no_locviews
= true;
19150 if (single_element_loc_list_p (descr
))
19151 add_AT_loc (die
, attr_kind
, descr
->expr
);
19154 add_AT_loc_list (die
, attr_kind
, descr
);
19155 gcc_assert (descr
->ll_symbol
);
19156 if (attr_kind
== DW_AT_location
&& descr
->vl_symbol
19157 && dwarf2out_locviews_in_attribute ())
19159 add_AT_view_list (die
, DW_AT_GNU_locviews
);
19160 check_no_locviews
= false;
19164 if (check_no_locviews
)
19165 gcc_assert (!get_AT (die
, DW_AT_GNU_locviews
));
19168 /* Add DW_AT_accessibility attribute to DIE if needed. */
19171 add_accessibility_attribute (dw_die_ref die
, tree decl
)
19173 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19174 children, otherwise the default is DW_ACCESS_public. In DWARF2
19175 the default has always been DW_ACCESS_public. */
19176 if (TREE_PROTECTED (decl
))
19177 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
19178 else if (TREE_PRIVATE (decl
))
19180 if (dwarf_version
== 2
19181 || die
->die_parent
== NULL
19182 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
19183 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
19185 else if (dwarf_version
> 2
19187 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
19188 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
19191 /* Attach the specialized form of location attribute used for data members of
19192 struct and union types. In the special case of a FIELD_DECL node which
19193 represents a bit-field, the "offset" part of this special location
19194 descriptor must indicate the distance in bytes from the lowest-addressed
19195 byte of the containing struct or union type to the lowest-addressed byte of
19196 the "containing object" for the bit-field. (See the `field_byte_offset'
19199 For any given bit-field, the "containing object" is a hypothetical object
19200 (of some integral or enum type) within which the given bit-field lives. The
19201 type of this hypothetical "containing object" is always the same as the
19202 declared type of the individual bit-field itself (for GCC anyway... the
19203 DWARF spec doesn't actually mandate this). Note that it is the size (in
19204 bytes) of the hypothetical "containing object" which will be given in the
19205 DW_AT_byte_size attribute for this bit-field. (See the
19206 `byte_size_attribute' function below.) It is also used when calculating the
19207 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
19210 CTX is required: see the comment for VLR_CONTEXT. */
19213 add_data_member_location_attribute (dw_die_ref die
,
19215 struct vlr_context
*ctx
)
19217 HOST_WIDE_INT offset
;
19218 dw_loc_descr_ref loc_descr
= 0;
19220 if (TREE_CODE (decl
) == TREE_BINFO
)
19222 /* We're working on the TAG_inheritance for a base class. */
19223 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
19225 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
19226 aren't at a fixed offset from all (sub)objects of the same
19227 type. We need to extract the appropriate offset from our
19228 vtable. The following dwarf expression means
19230 BaseAddr = ObAddr + *((*ObAddr) - Offset)
19232 This is specific to the V3 ABI, of course. */
19234 dw_loc_descr_ref tmp
;
19236 /* Make a copy of the object address. */
19237 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
19238 add_loc_descr (&loc_descr
, tmp
);
19240 /* Extract the vtable address. */
19241 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
19242 add_loc_descr (&loc_descr
, tmp
);
19244 /* Calculate the address of the offset. */
19245 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
19246 gcc_assert (offset
< 0);
19248 tmp
= int_loc_descriptor (-offset
);
19249 add_loc_descr (&loc_descr
, tmp
);
19250 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
19251 add_loc_descr (&loc_descr
, tmp
);
19253 /* Extract the offset. */
19254 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
19255 add_loc_descr (&loc_descr
, tmp
);
19257 /* Add it to the object address. */
19258 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
19259 add_loc_descr (&loc_descr
, tmp
);
19262 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
19266 loc_descr
= field_byte_offset (decl
, ctx
, &offset
);
19268 /* If loc_descr is available then we know the field offset is dynamic.
19269 However, GDB does not handle dynamic field offsets very well at the
19271 if (loc_descr
!= NULL
&& gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
)
19277 /* Data member location evalutation starts with the base address on the
19278 stack. Compute the field offset and add it to this base address. */
19279 else if (loc_descr
!= NULL
)
19280 add_loc_descr (&loc_descr
, new_loc_descr (DW_OP_plus
, 0, 0));
19285 /* While DW_AT_data_bit_offset has been added already in DWARF4,
19286 e.g. GDB only added support to it in November 2016. For DWARF5
19287 we need newer debug info consumers anyway. We might change this
19288 to dwarf_version >= 4 once most consumers catched up. */
19289 if (dwarf_version
>= 5
19290 && TREE_CODE (decl
) == FIELD_DECL
19291 && DECL_BIT_FIELD_TYPE (decl
))
19293 tree off
= bit_position (decl
);
19294 if (tree_fits_uhwi_p (off
) && get_AT (die
, DW_AT_bit_size
))
19296 remove_AT (die
, DW_AT_byte_size
);
19297 remove_AT (die
, DW_AT_bit_offset
);
19298 add_AT_unsigned (die
, DW_AT_data_bit_offset
, tree_to_uhwi (off
));
19302 if (dwarf_version
> 2)
19304 /* Don't need to output a location expression, just the constant. */
19306 add_AT_int (die
, DW_AT_data_member_location
, offset
);
19308 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
19313 enum dwarf_location_atom op
;
19315 /* The DWARF2 standard says that we should assume that the structure
19316 address is already on the stack, so we can specify a structure
19317 field address by using DW_OP_plus_uconst. */
19318 op
= DW_OP_plus_uconst
;
19319 loc_descr
= new_loc_descr (op
, offset
, 0);
19323 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
19326 /* Writes integer values to dw_vec_const array. */
19329 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
19333 *dest
++ = val
& 0xff;
19339 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
19341 static HOST_WIDE_INT
19342 extract_int (const unsigned char *src
, unsigned int size
)
19344 HOST_WIDE_INT val
= 0;
19350 val
|= *--src
& 0xff;
19356 /* Writes wide_int values to dw_vec_const array. */
19359 insert_wide_int (const wide_int
&val
, unsigned char *dest
, int elt_size
)
19363 if (elt_size
<= HOST_BITS_PER_WIDE_INT
/BITS_PER_UNIT
)
19365 insert_int ((HOST_WIDE_INT
) val
.elt (0), elt_size
, dest
);
19369 /* We'd have to extend this code to support odd sizes. */
19370 gcc_assert (elt_size
% (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
) == 0);
19372 int n
= elt_size
/ (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
19374 if (WORDS_BIG_ENDIAN
)
19375 for (i
= n
- 1; i
>= 0; i
--)
19377 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
19378 dest
+= sizeof (HOST_WIDE_INT
);
19381 for (i
= 0; i
< n
; i
++)
19383 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
19384 dest
+= sizeof (HOST_WIDE_INT
);
19388 /* Writes floating point values to dw_vec_const array. */
19391 insert_float (const_rtx rtl
, unsigned char *array
)
19395 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
19397 real_to_target (val
, CONST_DOUBLE_REAL_VALUE (rtl
), mode
);
19399 /* real_to_target puts 32-bit pieces in each long. Pack them. */
19400 for (i
= 0; i
< GET_MODE_SIZE (mode
) / 4; i
++)
19402 insert_int (val
[i
], 4, array
);
19407 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
19408 does not have a "location" either in memory or in a register. These
19409 things can arise in GNU C when a constant is passed as an actual parameter
19410 to an inlined function. They can also arise in C++ where declared
19411 constants do not necessarily get memory "homes". */
19414 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
19416 switch (GET_CODE (rtl
))
19420 HOST_WIDE_INT val
= INTVAL (rtl
);
19423 add_AT_int (die
, DW_AT_const_value
, val
);
19425 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
19429 case CONST_WIDE_INT
:
19431 wide_int w1
= rtx_mode_t (rtl
, MAX_MODE_INT
);
19432 unsigned int prec
= MIN (wi::min_precision (w1
, UNSIGNED
),
19433 (unsigned int)CONST_WIDE_INT_NUNITS (rtl
) * HOST_BITS_PER_WIDE_INT
);
19434 wide_int w
= wi::zext (w1
, prec
);
19435 add_AT_wide (die
, DW_AT_const_value
, w
);
19440 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
19441 floating-point constant. A CONST_DOUBLE is used whenever the
19442 constant requires more than one word in order to be adequately
19444 if (TARGET_SUPPORTS_WIDE_INT
== 0
19445 && !SCALAR_FLOAT_MODE_P (GET_MODE (rtl
)))
19446 add_AT_double (die
, DW_AT_const_value
,
19447 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
19450 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
19451 unsigned int length
= GET_MODE_SIZE (mode
);
19452 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
19454 insert_float (rtl
, array
);
19455 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
19461 unsigned int length
;
19462 if (!CONST_VECTOR_NUNITS (rtl
).is_constant (&length
))
19465 machine_mode mode
= GET_MODE (rtl
);
19466 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
19467 unsigned char *array
19468 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
19471 machine_mode imode
= GET_MODE_INNER (mode
);
19473 switch (GET_MODE_CLASS (mode
))
19475 case MODE_VECTOR_INT
:
19476 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
19478 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
19479 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
19483 case MODE_VECTOR_FLOAT
:
19484 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
19486 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
19487 insert_float (elt
, p
);
19492 gcc_unreachable ();
19495 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
19500 if (dwarf_version
>= 4 || !dwarf_strict
)
19502 dw_loc_descr_ref loc_result
;
19503 resolve_one_addr (&rtl
);
19505 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
19506 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
19507 add_AT_loc (die
, DW_AT_location
, loc_result
);
19508 vec_safe_push (used_rtx_array
, rtl
);
19514 if (CONSTANT_P (XEXP (rtl
, 0)))
19515 return add_const_value_attribute (die
, XEXP (rtl
, 0));
19518 if (!const_ok_for_output (rtl
))
19522 if (dwarf_version
>= 4 || !dwarf_strict
)
19527 /* In cases where an inlined instance of an inline function is passed
19528 the address of an `auto' variable (which is local to the caller) we
19529 can get a situation where the DECL_RTL of the artificial local
19530 variable (for the inlining) which acts as a stand-in for the
19531 corresponding formal parameter (of the inline function) will look
19532 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
19533 exactly a compile-time constant expression, but it isn't the address
19534 of the (artificial) local variable either. Rather, it represents the
19535 *value* which the artificial local variable always has during its
19536 lifetime. We currently have no way to represent such quasi-constant
19537 values in Dwarf, so for now we just punt and generate nothing. */
19545 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
19546 && MEM_READONLY_P (rtl
)
19547 && GET_MODE (rtl
) == BLKmode
)
19549 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
19555 /* No other kinds of rtx should be possible here. */
19556 gcc_unreachable ();
19561 /* Determine whether the evaluation of EXPR references any variables
19562 or functions which aren't otherwise used (and therefore may not be
19565 reference_to_unused (tree
* tp
, int * walk_subtrees
,
19566 void * data ATTRIBUTE_UNUSED
)
19568 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
19569 *walk_subtrees
= 0;
19571 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
19572 && ! TREE_ASM_WRITTEN (*tp
))
19574 /* ??? The C++ FE emits debug information for using decls, so
19575 putting gcc_unreachable here falls over. See PR31899. For now
19576 be conservative. */
19577 else if (!symtab
->global_info_ready
&& VAR_OR_FUNCTION_DECL_P (*tp
))
19579 else if (VAR_P (*tp
))
19581 varpool_node
*node
= varpool_node::get (*tp
);
19582 if (!node
|| !node
->definition
)
19585 else if (TREE_CODE (*tp
) == FUNCTION_DECL
19586 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
19588 /* The call graph machinery must have finished analyzing,
19589 optimizing and gimplifying the CU by now.
19590 So if *TP has no call graph node associated
19591 to it, it means *TP will not be emitted. */
19592 if (!cgraph_node::get (*tp
))
19595 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
19601 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
19602 for use in a later add_const_value_attribute call. */
19605 rtl_for_decl_init (tree init
, tree type
)
19607 rtx rtl
= NULL_RTX
;
19611 /* If a variable is initialized with a string constant without embedded
19612 zeros, build CONST_STRING. */
19613 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
19615 tree enttype
= TREE_TYPE (type
);
19616 tree domain
= TYPE_DOMAIN (type
);
19617 scalar_int_mode mode
;
19619 if (is_int_mode (TYPE_MODE (enttype
), &mode
)
19620 && GET_MODE_SIZE (mode
) == 1
19622 && TYPE_MAX_VALUE (domain
)
19623 && TREE_CODE (TYPE_MAX_VALUE (domain
)) == INTEGER_CST
19624 && integer_zerop (TYPE_MIN_VALUE (domain
))
19625 && compare_tree_int (TYPE_MAX_VALUE (domain
),
19626 TREE_STRING_LENGTH (init
) - 1) == 0
19627 && ((size_t) TREE_STRING_LENGTH (init
)
19628 == strlen (TREE_STRING_POINTER (init
)) + 1))
19630 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
19631 ggc_strdup (TREE_STRING_POINTER (init
)));
19632 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
19633 MEM_READONLY_P (rtl
) = 1;
19636 /* Other aggregates, and complex values, could be represented using
19638 else if (AGGREGATE_TYPE_P (type
)
19639 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
19640 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
19641 || TREE_CODE (type
) == COMPLEX_TYPE
)
19643 /* Vectors only work if their mode is supported by the target.
19644 FIXME: generic vectors ought to work too. */
19645 else if (TREE_CODE (type
) == VECTOR_TYPE
19646 && !VECTOR_MODE_P (TYPE_MODE (type
)))
19648 /* If the initializer is something that we know will expand into an
19649 immediate RTL constant, expand it now. We must be careful not to
19650 reference variables which won't be output. */
19651 else if (initializer_constant_valid_p (init
, type
)
19652 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
19654 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
19656 if (TREE_CODE (type
) == VECTOR_TYPE
)
19657 switch (TREE_CODE (init
))
19662 if (TREE_CONSTANT (init
))
19664 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
19665 bool constant_p
= true;
19667 unsigned HOST_WIDE_INT ix
;
19669 /* Even when ctor is constant, it might contain non-*_CST
19670 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
19671 belong into VECTOR_CST nodes. */
19672 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
19673 if (!CONSTANT_CLASS_P (value
))
19675 constant_p
= false;
19681 init
= build_vector_from_ctor (type
, elts
);
19691 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
19693 /* If expand_expr returns a MEM, it wasn't immediate. */
19694 gcc_assert (!rtl
|| !MEM_P (rtl
));
19700 /* Generate RTL for the variable DECL to represent its location. */
19703 rtl_for_decl_location (tree decl
)
19707 /* Here we have to decide where we are going to say the parameter "lives"
19708 (as far as the debugger is concerned). We only have a couple of
19709 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
19711 DECL_RTL normally indicates where the parameter lives during most of the
19712 activation of the function. If optimization is enabled however, this
19713 could be either NULL or else a pseudo-reg. Both of those cases indicate
19714 that the parameter doesn't really live anywhere (as far as the code
19715 generation parts of GCC are concerned) during most of the function's
19716 activation. That will happen (for example) if the parameter is never
19717 referenced within the function.
19719 We could just generate a location descriptor here for all non-NULL
19720 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
19721 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
19722 where DECL_RTL is NULL or is a pseudo-reg.
19724 Note however that we can only get away with using DECL_INCOMING_RTL as
19725 a backup substitute for DECL_RTL in certain limited cases. In cases
19726 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
19727 we can be sure that the parameter was passed using the same type as it is
19728 declared to have within the function, and that its DECL_INCOMING_RTL
19729 points us to a place where a value of that type is passed.
19731 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
19732 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
19733 because in these cases DECL_INCOMING_RTL points us to a value of some
19734 type which is *different* from the type of the parameter itself. Thus,
19735 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
19736 such cases, the debugger would end up (for example) trying to fetch a
19737 `float' from a place which actually contains the first part of a
19738 `double'. That would lead to really incorrect and confusing
19739 output at debug-time.
19741 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
19742 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
19743 are a couple of exceptions however. On little-endian machines we can
19744 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
19745 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
19746 an integral type that is smaller than TREE_TYPE (decl). These cases arise
19747 when (on a little-endian machine) a non-prototyped function has a
19748 parameter declared to be of type `short' or `char'. In such cases,
19749 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
19750 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
19751 passed `int' value. If the debugger then uses that address to fetch
19752 a `short' or a `char' (on a little-endian machine) the result will be
19753 the correct data, so we allow for such exceptional cases below.
19755 Note that our goal here is to describe the place where the given formal
19756 parameter lives during most of the function's activation (i.e. between the
19757 end of the prologue and the start of the epilogue). We'll do that as best
19758 as we can. Note however that if the given formal parameter is modified
19759 sometime during the execution of the function, then a stack backtrace (at
19760 debug-time) will show the function as having been called with the *new*
19761 value rather than the value which was originally passed in. This happens
19762 rarely enough that it is not a major problem, but it *is* a problem, and
19763 I'd like to fix it.
19765 A future version of dwarf2out.c may generate two additional attributes for
19766 any given DW_TAG_formal_parameter DIE which will describe the "passed
19767 type" and the "passed location" for the given formal parameter in addition
19768 to the attributes we now generate to indicate the "declared type" and the
19769 "active location" for each parameter. This additional set of attributes
19770 could be used by debuggers for stack backtraces. Separately, note that
19771 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
19772 This happens (for example) for inlined-instances of inline function formal
19773 parameters which are never referenced. This really shouldn't be
19774 happening. All PARM_DECL nodes should get valid non-NULL
19775 DECL_INCOMING_RTL values. FIXME. */
19777 /* Use DECL_RTL as the "location" unless we find something better. */
19778 rtl
= DECL_RTL_IF_SET (decl
);
19780 /* When generating abstract instances, ignore everything except
19781 constants, symbols living in memory, and symbols living in
19782 fixed registers. */
19783 if (! reload_completed
)
19786 && (CONSTANT_P (rtl
)
19788 && CONSTANT_P (XEXP (rtl
, 0)))
19791 && TREE_STATIC (decl
))))
19793 rtl
= targetm
.delegitimize_address (rtl
);
19798 else if (TREE_CODE (decl
) == PARM_DECL
)
19800 if (rtl
== NULL_RTX
19801 || is_pseudo_reg (rtl
)
19803 && is_pseudo_reg (XEXP (rtl
, 0))
19804 && DECL_INCOMING_RTL (decl
)
19805 && MEM_P (DECL_INCOMING_RTL (decl
))
19806 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
19808 tree declared_type
= TREE_TYPE (decl
);
19809 tree passed_type
= DECL_ARG_TYPE (decl
);
19810 machine_mode dmode
= TYPE_MODE (declared_type
);
19811 machine_mode pmode
= TYPE_MODE (passed_type
);
19813 /* This decl represents a formal parameter which was optimized out.
19814 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
19815 all cases where (rtl == NULL_RTX) just below. */
19816 if (dmode
== pmode
)
19817 rtl
= DECL_INCOMING_RTL (decl
);
19818 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
19819 && SCALAR_INT_MODE_P (dmode
)
19820 && known_le (GET_MODE_SIZE (dmode
), GET_MODE_SIZE (pmode
))
19821 && DECL_INCOMING_RTL (decl
))
19823 rtx inc
= DECL_INCOMING_RTL (decl
);
19826 else if (MEM_P (inc
))
19828 if (BYTES_BIG_ENDIAN
)
19829 rtl
= adjust_address_nv (inc
, dmode
,
19830 GET_MODE_SIZE (pmode
)
19831 - GET_MODE_SIZE (dmode
));
19838 /* If the parm was passed in registers, but lives on the stack, then
19839 make a big endian correction if the mode of the type of the
19840 parameter is not the same as the mode of the rtl. */
19841 /* ??? This is the same series of checks that are made in dbxout.c before
19842 we reach the big endian correction code there. It isn't clear if all
19843 of these checks are necessary here, but keeping them all is the safe
19845 else if (MEM_P (rtl
)
19846 && XEXP (rtl
, 0) != const0_rtx
19847 && ! CONSTANT_P (XEXP (rtl
, 0))
19848 /* Not passed in memory. */
19849 && !MEM_P (DECL_INCOMING_RTL (decl
))
19850 /* Not passed by invisible reference. */
19851 && (!REG_P (XEXP (rtl
, 0))
19852 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
19853 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
19854 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
19855 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
19858 /* Big endian correction check. */
19859 && BYTES_BIG_ENDIAN
19860 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
19861 && known_lt (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))),
19864 machine_mode addr_mode
= get_address_mode (rtl
);
19865 poly_int64 offset
= (UNITS_PER_WORD
19866 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
19868 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
19869 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
19872 else if (VAR_P (decl
)
19875 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
)))
19877 machine_mode addr_mode
= get_address_mode (rtl
);
19878 poly_int64 offset
= byte_lowpart_offset (TYPE_MODE (TREE_TYPE (decl
)),
19881 /* If a variable is declared "register" yet is smaller than
19882 a register, then if we store the variable to memory, it
19883 looks like we're storing a register-sized value, when in
19884 fact we are not. We need to adjust the offset of the
19885 storage location to reflect the actual value's bytes,
19886 else gdb will not be able to display it. */
19887 if (maybe_ne (offset
, 0))
19888 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
19889 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
19892 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
19893 and will have been substituted directly into all expressions that use it.
19894 C does not have such a concept, but C++ and other languages do. */
19895 if (!rtl
&& VAR_P (decl
) && DECL_INITIAL (decl
))
19896 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
19899 rtl
= targetm
.delegitimize_address (rtl
);
19901 /* If we don't look past the constant pool, we risk emitting a
19902 reference to a constant pool entry that isn't referenced from
19903 code, and thus is not emitted. */
19905 rtl
= avoid_constant_pool_reference (rtl
);
19907 /* Try harder to get a rtl. If this symbol ends up not being emitted
19908 in the current CU, resolve_addr will remove the expression referencing
19910 if (rtl
== NULL_RTX
19911 && !(early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
19913 && !DECL_EXTERNAL (decl
)
19914 && TREE_STATIC (decl
)
19915 && DECL_NAME (decl
)
19916 && !DECL_HARD_REGISTER (decl
)
19917 && DECL_MODE (decl
) != VOIDmode
)
19919 rtl
= make_decl_rtl_for_debug (decl
);
19921 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
19922 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
19929 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
19930 returned. If so, the decl for the COMMON block is returned, and the
19931 value is the offset into the common block for the symbol. */
19934 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
19936 tree val_expr
, cvar
;
19938 poly_int64 bitsize
, bitpos
;
19940 HOST_WIDE_INT cbitpos
;
19941 int unsignedp
, reversep
, volatilep
= 0;
19943 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
19944 it does not have a value (the offset into the common area), or if it
19945 is thread local (as opposed to global) then it isn't common, and shouldn't
19946 be handled as such. */
19948 || !TREE_STATIC (decl
)
19949 || !DECL_HAS_VALUE_EXPR_P (decl
)
19953 val_expr
= DECL_VALUE_EXPR (decl
);
19954 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
19957 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
, &mode
,
19958 &unsignedp
, &reversep
, &volatilep
);
19960 if (cvar
== NULL_TREE
19962 || DECL_ARTIFICIAL (cvar
)
19963 || !TREE_PUBLIC (cvar
)
19964 /* We don't expect to have to cope with variable offsets,
19965 since at present all static data must have a constant size. */
19966 || !bitpos
.is_constant (&cbitpos
))
19970 if (offset
!= NULL
)
19972 if (!tree_fits_shwi_p (offset
))
19974 *value
= tree_to_shwi (offset
);
19977 *value
+= cbitpos
/ BITS_PER_UNIT
;
19982 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
19983 data attribute for a variable or a parameter. We generate the
19984 DW_AT_const_value attribute only in those cases where the given variable
19985 or parameter does not have a true "location" either in memory or in a
19986 register. This can happen (for example) when a constant is passed as an
19987 actual argument in a call to an inline function. (It's possible that
19988 these things can crop up in other ways also.) Note that one type of
19989 constant value which can be passed into an inlined function is a constant
19990 pointer. This can happen for example if an actual argument in an inlined
19991 function call evaluates to a compile-time constant address.
19993 CACHE_P is true if it is worth caching the location list for DECL,
19994 so that future calls can reuse it rather than regenerate it from scratch.
19995 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
19996 since we will need to refer to them each time the function is inlined. */
19999 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
)
20002 dw_loc_list_ref list
;
20003 var_loc_list
*loc_list
;
20004 cached_dw_loc_list
*cache
;
20009 if (TREE_CODE (decl
) == ERROR_MARK
)
20012 if (get_AT (die
, DW_AT_location
)
20013 || get_AT (die
, DW_AT_const_value
))
20016 gcc_assert (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
20017 || TREE_CODE (decl
) == RESULT_DECL
);
20019 /* Try to get some constant RTL for this decl, and use that as the value of
20022 rtl
= rtl_for_decl_location (decl
);
20023 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
20024 && add_const_value_attribute (die
, rtl
))
20027 /* See if we have single element location list that is equivalent to
20028 a constant value. That way we are better to use add_const_value_attribute
20029 rather than expanding constant value equivalent. */
20030 loc_list
= lookup_decl_loc (decl
);
20033 && loc_list
->first
->next
== NULL
20034 && NOTE_P (loc_list
->first
->loc
)
20035 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
20036 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
20038 struct var_loc_node
*node
;
20040 node
= loc_list
->first
;
20041 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
20042 if (GET_CODE (rtl
) == EXPR_LIST
)
20043 rtl
= XEXP (rtl
, 0);
20044 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
20045 && add_const_value_attribute (die
, rtl
))
20048 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
20049 list several times. See if we've already cached the contents. */
20051 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
20055 cache
= cached_dw_loc_list_table
->find_with_hash (decl
, DECL_UID (decl
));
20057 list
= cache
->loc_list
;
20061 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2,
20063 /* It is usually worth caching this result if the decl is from
20064 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
20065 if (cache_p
&& list
&& list
->dw_loc_next
)
20067 cached_dw_loc_list
**slot
20068 = cached_dw_loc_list_table
->find_slot_with_hash (decl
,
20071 cache
= ggc_cleared_alloc
<cached_dw_loc_list
> ();
20072 cache
->decl_id
= DECL_UID (decl
);
20073 cache
->loc_list
= list
;
20079 add_AT_location_description (die
, DW_AT_location
, list
);
20082 /* None of that worked, so it must not really have a location;
20083 try adding a constant value attribute from the DECL_INITIAL. */
20084 return tree_add_const_value_attribute_for_decl (die
, decl
);
20087 /* Helper function for tree_add_const_value_attribute. Natively encode
20088 initializer INIT into an array. Return true if successful. */
20091 native_encode_initializer (tree init
, unsigned char *array
, int size
)
20095 if (init
== NULL_TREE
)
20099 switch (TREE_CODE (init
))
20102 type
= TREE_TYPE (init
);
20103 if (TREE_CODE (type
) == ARRAY_TYPE
)
20105 tree enttype
= TREE_TYPE (type
);
20106 scalar_int_mode mode
;
20108 if (!is_int_mode (TYPE_MODE (enttype
), &mode
)
20109 || GET_MODE_SIZE (mode
) != 1)
20111 if (int_size_in_bytes (type
) != size
)
20113 if (size
> TREE_STRING_LENGTH (init
))
20115 memcpy (array
, TREE_STRING_POINTER (init
),
20116 TREE_STRING_LENGTH (init
));
20117 memset (array
+ TREE_STRING_LENGTH (init
),
20118 '\0', size
- TREE_STRING_LENGTH (init
));
20121 memcpy (array
, TREE_STRING_POINTER (init
), size
);
20126 type
= TREE_TYPE (init
);
20127 if (int_size_in_bytes (type
) != size
)
20129 if (TREE_CODE (type
) == ARRAY_TYPE
)
20131 HOST_WIDE_INT min_index
;
20132 unsigned HOST_WIDE_INT cnt
;
20133 int curpos
= 0, fieldsize
;
20134 constructor_elt
*ce
;
20136 if (TYPE_DOMAIN (type
) == NULL_TREE
20137 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
20140 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
20141 if (fieldsize
<= 0)
20144 min_index
= tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)));
20145 memset (array
, '\0', size
);
20146 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
20148 tree val
= ce
->value
;
20149 tree index
= ce
->index
;
20151 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
20152 pos
= (tree_to_shwi (TREE_OPERAND (index
, 0)) - min_index
)
20155 pos
= (tree_to_shwi (index
) - min_index
) * fieldsize
;
20160 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
20163 curpos
= pos
+ fieldsize
;
20164 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
20166 int count
= tree_to_shwi (TREE_OPERAND (index
, 1))
20167 - tree_to_shwi (TREE_OPERAND (index
, 0));
20168 while (count
-- > 0)
20171 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
20172 curpos
+= fieldsize
;
20175 gcc_assert (curpos
<= size
);
20179 else if (TREE_CODE (type
) == RECORD_TYPE
20180 || TREE_CODE (type
) == UNION_TYPE
)
20182 tree field
= NULL_TREE
;
20183 unsigned HOST_WIDE_INT cnt
;
20184 constructor_elt
*ce
;
20186 if (int_size_in_bytes (type
) != size
)
20189 if (TREE_CODE (type
) == RECORD_TYPE
)
20190 field
= TYPE_FIELDS (type
);
20192 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
20194 tree val
= ce
->value
;
20195 int pos
, fieldsize
;
20197 if (ce
->index
!= 0)
20203 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
20206 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
20207 && TYPE_DOMAIN (TREE_TYPE (field
))
20208 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
20210 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
20211 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field
)))
20213 fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
20214 pos
= int_byte_position (field
);
20215 gcc_assert (pos
+ fieldsize
<= size
);
20216 if (val
&& fieldsize
!= 0
20217 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
20223 case VIEW_CONVERT_EXPR
:
20224 case NON_LVALUE_EXPR
:
20225 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
20227 return native_encode_expr (init
, array
, size
) == size
;
20231 /* Attach a DW_AT_const_value attribute to DIE. The value of the
20232 attribute is the const value T. */
20235 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
20238 tree type
= TREE_TYPE (t
);
20241 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
20245 gcc_assert (!DECL_P (init
));
20247 if (TREE_CODE (init
) == INTEGER_CST
)
20249 if (tree_fits_uhwi_p (init
))
20251 add_AT_unsigned (die
, DW_AT_const_value
, tree_to_uhwi (init
));
20254 if (tree_fits_shwi_p (init
))
20256 add_AT_int (die
, DW_AT_const_value
, tree_to_shwi (init
));
20262 rtl
= rtl_for_decl_init (init
, type
);
20264 return add_const_value_attribute (die
, rtl
);
20266 /* If the host and target are sane, try harder. */
20267 if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
20268 && initializer_constant_valid_p (init
, type
))
20270 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
20271 if (size
> 0 && (int) size
== size
)
20273 unsigned char *array
= ggc_cleared_vec_alloc
<unsigned char> (size
);
20275 if (native_encode_initializer (init
, array
, size
))
20277 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
20286 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
20287 attribute is the const value of T, where T is an integral constant
20288 variable with static storage duration
20289 (so it can't be a PARM_DECL or a RESULT_DECL). */
20292 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
20296 || (!VAR_P (decl
) && TREE_CODE (decl
) != CONST_DECL
)
20297 || (VAR_P (decl
) && !TREE_STATIC (decl
)))
20300 if (TREE_READONLY (decl
)
20301 && ! TREE_THIS_VOLATILE (decl
)
20302 && DECL_INITIAL (decl
))
20307 /* Don't add DW_AT_const_value if abstract origin already has one. */
20308 if (get_AT (var_die
, DW_AT_const_value
))
20311 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
20314 /* Convert the CFI instructions for the current function into a
20315 location list. This is used for DW_AT_frame_base when we targeting
20316 a dwarf2 consumer that does not support the dwarf3
20317 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
20320 static dw_loc_list_ref
20321 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
20325 dw_loc_list_ref list
, *list_tail
;
20327 dw_cfa_location last_cfa
, next_cfa
;
20328 const char *start_label
, *last_label
, *section
;
20329 dw_cfa_location remember
;
20332 gcc_assert (fde
!= NULL
);
20334 section
= secname_for_decl (current_function_decl
);
20338 memset (&next_cfa
, 0, sizeof (next_cfa
));
20339 next_cfa
.reg
= INVALID_REGNUM
;
20340 remember
= next_cfa
;
20342 start_label
= fde
->dw_fde_begin
;
20344 /* ??? Bald assumption that the CIE opcode list does not contain
20345 advance opcodes. */
20346 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
20347 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
20349 last_cfa
= next_cfa
;
20350 last_label
= start_label
;
20352 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
20354 /* If the first partition contained no CFI adjustments, the
20355 CIE opcodes apply to the whole first partition. */
20356 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20357 fde
->dw_fde_begin
, 0, fde
->dw_fde_end
, 0, section
);
20358 list_tail
=&(*list_tail
)->dw_loc_next
;
20359 start_label
= last_label
= fde
->dw_fde_second_begin
;
20362 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
20364 switch (cfi
->dw_cfi_opc
)
20366 case DW_CFA_set_loc
:
20367 case DW_CFA_advance_loc1
:
20368 case DW_CFA_advance_loc2
:
20369 case DW_CFA_advance_loc4
:
20370 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
20372 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20373 start_label
, 0, last_label
, 0, section
);
20375 list_tail
= &(*list_tail
)->dw_loc_next
;
20376 last_cfa
= next_cfa
;
20377 start_label
= last_label
;
20379 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
20382 case DW_CFA_advance_loc
:
20383 /* The encoding is complex enough that we should never emit this. */
20384 gcc_unreachable ();
20387 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
20390 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
20392 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
20394 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20395 start_label
, 0, last_label
, 0, section
);
20397 list_tail
= &(*list_tail
)->dw_loc_next
;
20398 last_cfa
= next_cfa
;
20399 start_label
= last_label
;
20401 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20402 start_label
, 0, fde
->dw_fde_end
, 0, section
);
20403 list_tail
= &(*list_tail
)->dw_loc_next
;
20404 start_label
= last_label
= fde
->dw_fde_second_begin
;
20408 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
20410 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20411 start_label
, 0, last_label
, 0, section
);
20412 list_tail
= &(*list_tail
)->dw_loc_next
;
20413 start_label
= last_label
;
20416 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
20418 fde
->dw_fde_second_begin
20419 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
, 0,
20422 maybe_gen_llsym (list
);
20427 /* Compute a displacement from the "steady-state frame pointer" to the
20428 frame base (often the same as the CFA), and store it in
20429 frame_pointer_fb_offset. OFFSET is added to the displacement
20430 before the latter is negated. */
20433 compute_frame_pointer_to_fb_displacement (poly_int64 offset
)
20437 #ifdef FRAME_POINTER_CFA_OFFSET
20438 reg
= frame_pointer_rtx
;
20439 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
20441 reg
= arg_pointer_rtx
;
20442 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
20445 elim
= (ira_use_lra_p
20446 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
20447 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
20448 elim
= strip_offset_and_add (elim
, &offset
);
20450 frame_pointer_fb_offset
= -offset
;
20452 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
20453 in which to eliminate. This is because it's stack pointer isn't
20454 directly accessible as a register within the ISA. To work around
20455 this, assume that while we cannot provide a proper value for
20456 frame_pointer_fb_offset, we won't need one either. We can use
20457 hard frame pointer in debug info even if frame pointer isn't used
20458 since hard frame pointer in debug info is encoded with DW_OP_fbreg
20459 which uses the DW_AT_frame_base attribute, not hard frame pointer
20461 frame_pointer_fb_offset_valid
20462 = (elim
== hard_frame_pointer_rtx
|| elim
== stack_pointer_rtx
);
20465 /* Generate a DW_AT_name attribute given some string value to be included as
20466 the value of the attribute. */
20469 add_name_attribute (dw_die_ref die
, const char *name_string
)
20471 if (name_string
!= NULL
&& *name_string
!= 0)
20473 if (demangle_name_func
)
20474 name_string
= (*demangle_name_func
) (name_string
);
20476 add_AT_string (die
, DW_AT_name
, name_string
);
20480 /* Generate a DW_AT_description attribute given some string value to be included
20481 as the value of the attribute. */
20484 add_desc_attribute (dw_die_ref die
, const char *name_string
)
20486 if (!flag_describe_dies
|| (dwarf_version
< 3 && dwarf_strict
))
20489 if (name_string
== NULL
|| *name_string
== 0)
20492 if (demangle_name_func
)
20493 name_string
= (*demangle_name_func
) (name_string
);
20495 add_AT_string (die
, DW_AT_description
, name_string
);
20498 /* Generate a DW_AT_description attribute given some decl to be included
20499 as the value of the attribute. */
20502 add_desc_attribute (dw_die_ref die
, tree decl
)
20506 if (!flag_describe_dies
|| (dwarf_version
< 3 && dwarf_strict
))
20509 if (decl
== NULL_TREE
|| !DECL_P (decl
))
20511 decl_name
= DECL_NAME (decl
);
20513 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
20515 const char *name
= dwarf2_name (decl
, 0);
20516 add_desc_attribute (die
, name
? name
: IDENTIFIER_POINTER (decl_name
));
20520 char *desc
= print_generic_expr_to_str (decl
);
20521 add_desc_attribute (die
, desc
);
20526 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
20527 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
20528 of TYPE accordingly.
20530 ??? This is a temporary measure until after we're able to generate
20531 regular DWARF for the complex Ada type system. */
20534 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
20535 dw_die_ref context_die
)
20538 dw_die_ref dtype_die
;
20540 if (!lang_hooks
.types
.descriptive_type
)
20543 dtype
= lang_hooks
.types
.descriptive_type (type
);
20547 dtype_die
= lookup_type_die (dtype
);
20550 gen_type_die (dtype
, context_die
);
20551 dtype_die
= lookup_type_die (dtype
);
20552 gcc_assert (dtype_die
);
20555 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
20558 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
20560 static const char *
20561 comp_dir_string (void)
20565 static const char *cached_wd
= NULL
;
20567 if (cached_wd
!= NULL
)
20570 wd
= get_src_pwd ();
20574 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
20578 wdlen
= strlen (wd
);
20579 wd1
= ggc_vec_alloc
<char> (wdlen
+ 2);
20581 wd1
[wdlen
] = DIR_SEPARATOR
;
20582 wd1
[wdlen
+ 1] = 0;
20586 cached_wd
= remap_debug_filename (wd
);
20590 /* Generate a DW_AT_comp_dir attribute for DIE. */
20593 add_comp_dir_attribute (dw_die_ref die
)
20595 const char * wd
= comp_dir_string ();
20597 add_AT_string (die
, DW_AT_comp_dir
, wd
);
20600 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
20601 pointer computation, ...), output a representation for that bound according
20602 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
20603 loc_list_from_tree for the meaning of CONTEXT. */
20606 add_scalar_info (dw_die_ref die
, enum dwarf_attribute attr
, tree value
,
20607 int forms
, struct loc_descr_context
*context
)
20609 dw_die_ref context_die
, decl_die
= NULL
;
20610 dw_loc_list_ref list
;
20611 bool strip_conversions
= true;
20612 bool placeholder_seen
= false;
20614 while (strip_conversions
)
20615 switch (TREE_CODE (value
))
20622 case VIEW_CONVERT_EXPR
:
20623 value
= TREE_OPERAND (value
, 0);
20627 strip_conversions
= false;
20631 /* If possible and permitted, output the attribute as a constant. */
20632 if ((forms
& dw_scalar_form_constant
) != 0
20633 && TREE_CODE (value
) == INTEGER_CST
)
20635 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (value
));
20637 /* If HOST_WIDE_INT is big enough then represent the bound as
20638 a constant value. We need to choose a form based on
20639 whether the type is signed or unsigned. We cannot just
20640 call add_AT_unsigned if the value itself is positive
20641 (add_AT_unsigned might add the unsigned value encoded as
20642 DW_FORM_data[1248]). Some DWARF consumers will lookup the
20643 bounds type and then sign extend any unsigned values found
20644 for signed types. This is needed only for
20645 DW_AT_{lower,upper}_bound, since for most other attributes,
20646 consumers will treat DW_FORM_data[1248] as unsigned values,
20647 regardless of the underlying type. */
20648 if (prec
<= HOST_BITS_PER_WIDE_INT
20649 || tree_fits_uhwi_p (value
))
20651 if (TYPE_UNSIGNED (TREE_TYPE (value
)))
20652 add_AT_unsigned (die
, attr
, TREE_INT_CST_LOW (value
));
20654 add_AT_int (die
, attr
, TREE_INT_CST_LOW (value
));
20657 /* Otherwise represent the bound as an unsigned value with
20658 the precision of its type. The precision and signedness
20659 of the type will be necessary to re-interpret it
20661 add_AT_wide (die
, attr
, wi::to_wide (value
));
20665 /* Otherwise, if it's possible and permitted too, output a reference to
20667 if ((forms
& dw_scalar_form_reference
) != 0)
20669 tree decl
= NULL_TREE
;
20671 /* Some type attributes reference an outer type. For instance, the upper
20672 bound of an array may reference an embedding record (this happens in
20674 if (TREE_CODE (value
) == COMPONENT_REF
20675 && TREE_CODE (TREE_OPERAND (value
, 0)) == PLACEHOLDER_EXPR
20676 && TREE_CODE (TREE_OPERAND (value
, 1)) == FIELD_DECL
)
20677 decl
= TREE_OPERAND (value
, 1);
20679 else if (VAR_P (value
)
20680 || TREE_CODE (value
) == PARM_DECL
20681 || TREE_CODE (value
) == RESULT_DECL
)
20684 if (decl
!= NULL_TREE
)
20686 decl_die
= lookup_decl_die (decl
);
20688 /* ??? Can this happen, or should the variable have been bound
20689 first? Probably it can, since I imagine that we try to create
20690 the types of parameters in the order in which they exist in
20691 the list, and won't have created a forward reference to a
20692 later parameter. */
20693 if (decl_die
!= NULL
)
20695 if (get_AT (decl_die
, DW_AT_location
)
20696 || get_AT (decl_die
, DW_AT_const_value
))
20698 add_AT_die_ref (die
, attr
, decl_die
);
20705 /* Last chance: try to create a stack operation procedure to evaluate the
20706 value. Do nothing if even that is not possible or permitted. */
20707 if ((forms
& dw_scalar_form_exprloc
) == 0)
20710 list
= loc_list_from_tree (value
, 2, context
);
20711 if (context
&& context
->placeholder_arg
)
20713 placeholder_seen
= context
->placeholder_seen
;
20714 context
->placeholder_seen
= false;
20716 if (list
== NULL
|| single_element_loc_list_p (list
))
20718 /* If this attribute is not a reference nor constant, it is
20719 a DWARF expression rather than location description. For that
20720 loc_list_from_tree (value, 0, &context) is needed. */
20721 dw_loc_list_ref list2
= loc_list_from_tree (value
, 0, context
);
20722 if (list2
&& single_element_loc_list_p (list2
))
20724 if (placeholder_seen
)
20726 struct dwarf_procedure_info dpi
;
20727 dpi
.fndecl
= NULL_TREE
;
20728 dpi
.args_count
= 1;
20729 if (!resolve_args_picking (list2
->expr
, 1, &dpi
))
20732 add_AT_loc (die
, attr
, list2
->expr
);
20737 /* If that failed to give a single element location list, fall back to
20738 outputting this as a reference... still if permitted. */
20740 || (forms
& dw_scalar_form_reference
) == 0
20741 || placeholder_seen
)
20746 if (current_function_decl
== 0)
20747 context_die
= comp_unit_die ();
20749 context_die
= lookup_decl_die (current_function_decl
);
20751 decl_die
= new_die (DW_TAG_variable
, context_die
, value
);
20752 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
20753 add_type_attribute (decl_die
, TREE_TYPE (value
), TYPE_QUAL_CONST
, false,
20757 add_AT_location_description (decl_die
, DW_AT_location
, list
);
20758 add_AT_die_ref (die
, attr
, decl_die
);
20761 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
20765 lower_bound_default (void)
20767 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
20773 case DW_LANG_C_plus_plus
:
20774 case DW_LANG_C_plus_plus_11
:
20775 case DW_LANG_C_plus_plus_14
:
20777 case DW_LANG_ObjC_plus_plus
:
20779 case DW_LANG_Fortran77
:
20780 case DW_LANG_Fortran90
:
20781 case DW_LANG_Fortran95
:
20782 case DW_LANG_Fortran03
:
20783 case DW_LANG_Fortran08
:
20787 case DW_LANG_Python
:
20788 return dwarf_version
>= 4 ? 0 : -1;
20789 case DW_LANG_Ada95
:
20790 case DW_LANG_Ada83
:
20791 case DW_LANG_Cobol74
:
20792 case DW_LANG_Cobol85
:
20793 case DW_LANG_Modula2
:
20795 return dwarf_version
>= 4 ? 1 : -1;
20801 /* Given a tree node describing an array bound (either lower or upper) output
20802 a representation for that bound. */
20805 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
,
20806 tree bound
, struct loc_descr_context
*context
)
20811 switch (TREE_CODE (bound
))
20813 /* Strip all conversions. */
20815 case VIEW_CONVERT_EXPR
:
20816 bound
= TREE_OPERAND (bound
, 0);
20819 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
20820 are even omitted when they are the default. */
20822 /* If the value for this bound is the default one, we can even omit the
20824 if (bound_attr
== DW_AT_lower_bound
20825 && tree_fits_shwi_p (bound
)
20826 && (dflt
= lower_bound_default ()) != -1
20827 && tree_to_shwi (bound
) == dflt
)
20833 /* Because of the complex interaction there can be with other GNAT
20834 encodings, GDB isn't ready yet to handle proper DWARF description
20835 for self-referencial subrange bounds: let GNAT encodings do the
20836 magic in such a case. */
20838 && gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
20839 && contains_placeholder_p (bound
))
20842 add_scalar_info (subrange_die
, bound_attr
, bound
,
20843 dw_scalar_form_constant
20844 | dw_scalar_form_exprloc
20845 | dw_scalar_form_reference
,
20851 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
20852 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
20853 Note that the block of subscript information for an array type also
20854 includes information about the element type of the given array type.
20856 This function reuses previously set type and bound information if
20860 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
20862 unsigned dimension_number
;
20864 dw_die_ref child
= type_die
->die_child
;
20866 for (dimension_number
= 0;
20867 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
20868 type
= TREE_TYPE (type
), dimension_number
++)
20870 tree domain
= TYPE_DOMAIN (type
);
20872 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
20875 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
20876 and (in GNU C only) variable bounds. Handle all three forms
20879 /* Find and reuse a previously generated DW_TAG_subrange_type if
20882 For multi-dimensional arrays, as we iterate through the
20883 various dimensions in the enclosing for loop above, we also
20884 iterate through the DIE children and pick at each
20885 DW_TAG_subrange_type previously generated (if available).
20886 Each child DW_TAG_subrange_type DIE describes the range of
20887 the current dimension. At this point we should have as many
20888 DW_TAG_subrange_type's as we have dimensions in the
20890 dw_die_ref subrange_die
= NULL
;
20894 child
= child
->die_sib
;
20895 if (child
->die_tag
== DW_TAG_subrange_type
)
20896 subrange_die
= child
;
20897 if (child
== type_die
->die_child
)
20899 /* If we wrapped around, stop looking next time. */
20903 if (child
->die_tag
== DW_TAG_subrange_type
)
20907 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
20911 /* We have an array type with specified bounds. */
20912 lower
= TYPE_MIN_VALUE (domain
);
20913 upper
= TYPE_MAX_VALUE (domain
);
20915 /* Define the index type. */
20916 if (TREE_TYPE (domain
)
20917 && !get_AT (subrange_die
, DW_AT_type
))
20919 /* ??? This is probably an Ada unnamed subrange type. Ignore the
20920 TREE_TYPE field. We can't emit debug info for this
20921 because it is an unnamed integral type. */
20922 if (TREE_CODE (domain
) == INTEGER_TYPE
20923 && TYPE_NAME (domain
) == NULL_TREE
20924 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
20925 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
20928 add_type_attribute (subrange_die
, TREE_TYPE (domain
),
20929 TYPE_UNQUALIFIED
, false, type_die
);
20932 /* ??? If upper is NULL, the array has unspecified length,
20933 but it does have a lower bound. This happens with Fortran
20935 Since the debugger is definitely going to need to know N
20936 to produce useful results, go ahead and output the lower
20937 bound solo, and hope the debugger can cope. */
20939 if (!get_AT (subrange_die
, DW_AT_lower_bound
))
20940 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
, NULL
);
20941 if (!get_AT (subrange_die
, DW_AT_upper_bound
)
20942 && !get_AT (subrange_die
, DW_AT_count
))
20945 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
, NULL
);
20946 else if ((is_c () || is_cxx ()) && COMPLETE_TYPE_P (type
))
20947 /* Zero-length array. */
20948 add_bound_info (subrange_die
, DW_AT_count
,
20949 build_int_cst (TREE_TYPE (lower
), 0), NULL
);
20953 /* Otherwise we have an array type with an unspecified length. The
20954 DWARF-2 spec does not say how to handle this; let's just leave out the
20959 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
20962 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
20964 dw_die_ref decl_die
;
20965 HOST_WIDE_INT size
;
20966 dw_loc_descr_ref size_expr
= NULL
;
20968 switch (TREE_CODE (tree_node
))
20973 case ENUMERAL_TYPE
:
20976 case QUAL_UNION_TYPE
:
20977 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
20978 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
20980 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
20983 size_expr
= type_byte_size (tree_node
, &size
);
20986 /* For a data member of a struct or union, the DW_AT_byte_size is
20987 generally given as the number of bytes normally allocated for an
20988 object of the *declared* type of the member itself. This is true
20989 even for bit-fields. */
20990 size
= int_size_in_bytes (field_type (tree_node
));
20993 gcc_unreachable ();
20996 /* Support for dynamically-sized objects was introduced by DWARFv3.
20997 At the moment, GDB does not handle variable byte sizes very well,
20999 if ((dwarf_version
>= 3 || !dwarf_strict
)
21000 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
21001 && size_expr
!= NULL
)
21002 add_AT_loc (die
, DW_AT_byte_size
, size_expr
);
21004 /* Note that `size' might be -1 when we get to this point. If it is, that
21005 indicates that the byte size of the entity in question is variable and
21006 that we could not generate a DWARF expression that computes it. */
21008 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
21011 /* Add a DW_AT_alignment attribute to DIE with TREE_NODE's non-default
21015 add_alignment_attribute (dw_die_ref die
, tree tree_node
)
21017 if (dwarf_version
< 5 && dwarf_strict
)
21022 if (DECL_P (tree_node
))
21024 if (!DECL_USER_ALIGN (tree_node
))
21027 align
= DECL_ALIGN_UNIT (tree_node
);
21029 else if (TYPE_P (tree_node
))
21031 if (!TYPE_USER_ALIGN (tree_node
))
21034 align
= TYPE_ALIGN_UNIT (tree_node
);
21037 gcc_unreachable ();
21039 add_AT_unsigned (die
, DW_AT_alignment
, align
);
21042 /* For a FIELD_DECL node which represents a bit-field, output an attribute
21043 which specifies the distance in bits from the highest order bit of the
21044 "containing object" for the bit-field to the highest order bit of the
21047 For any given bit-field, the "containing object" is a hypothetical object
21048 (of some integral or enum type) within which the given bit-field lives. The
21049 type of this hypothetical "containing object" is always the same as the
21050 declared type of the individual bit-field itself. The determination of the
21051 exact location of the "containing object" for a bit-field is rather
21052 complicated. It's handled by the `field_byte_offset' function (above).
21054 CTX is required: see the comment for VLR_CONTEXT.
21056 Note that it is the size (in bytes) of the hypothetical "containing object"
21057 which will be given in the DW_AT_byte_size attribute for this bit-field.
21058 (See `byte_size_attribute' above). */
21061 add_bit_offset_attribute (dw_die_ref die
, tree decl
, struct vlr_context
*ctx
)
21063 HOST_WIDE_INT object_offset_in_bytes
;
21064 tree original_type
= DECL_BIT_FIELD_TYPE (decl
);
21065 HOST_WIDE_INT bitpos_int
;
21066 HOST_WIDE_INT highest_order_object_bit_offset
;
21067 HOST_WIDE_INT highest_order_field_bit_offset
;
21068 HOST_WIDE_INT bit_offset
;
21070 field_byte_offset (decl
, ctx
, &object_offset_in_bytes
);
21072 /* Must be a field and a bit field. */
21073 gcc_assert (original_type
&& TREE_CODE (decl
) == FIELD_DECL
);
21075 /* We can't yet handle bit-fields whose offsets are variable, so if we
21076 encounter such things, just return without generating any attribute
21077 whatsoever. Likewise for variable or too large size. */
21078 if (! tree_fits_shwi_p (bit_position (decl
))
21079 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
21082 bitpos_int
= int_bit_position (decl
);
21084 /* Note that the bit offset is always the distance (in bits) from the
21085 highest-order bit of the "containing object" to the highest-order bit of
21086 the bit-field itself. Since the "high-order end" of any object or field
21087 is different on big-endian and little-endian machines, the computation
21088 below must take account of these differences. */
21089 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
21090 highest_order_field_bit_offset
= bitpos_int
;
21092 if (! BYTES_BIG_ENDIAN
)
21094 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
21095 highest_order_object_bit_offset
+=
21096 simple_type_size_in_bits (original_type
);
21100 = (! BYTES_BIG_ENDIAN
21101 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
21102 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
21104 if (bit_offset
< 0)
21105 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
21107 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
21110 /* For a FIELD_DECL node which represents a bit field, output an attribute
21111 which specifies the length in bits of the given field. */
21114 add_bit_size_attribute (dw_die_ref die
, tree decl
)
21116 /* Must be a field and a bit field. */
21117 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
21118 && DECL_BIT_FIELD_TYPE (decl
));
21120 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
21121 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
21124 /* If the compiled language is ANSI C, then add a 'prototyped'
21125 attribute, if arg types are given for the parameters of a function. */
21128 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
21130 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
21137 if (prototype_p (func_type
))
21138 add_AT_flag (die
, DW_AT_prototyped
, 1);
21145 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
21146 by looking in the type declaration, the object declaration equate table or
21147 the block mapping. */
21150 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
21152 dw_die_ref origin_die
= NULL
;
21154 /* For late LTO debug output we want to refer directly to the abstract
21155 DIE in the early debug rather to the possibly existing concrete
21156 instance and avoid creating that just for this purpose. */
21157 sym_off_pair
*desc
;
21159 && external_die_map
21160 && (desc
= external_die_map
->get (origin
)))
21162 add_AT_external_die_ref (die
, DW_AT_abstract_origin
,
21163 desc
->sym
, desc
->off
);
21167 if (DECL_P (origin
))
21168 origin_die
= lookup_decl_die (origin
);
21169 else if (TYPE_P (origin
))
21170 origin_die
= lookup_type_die (origin
);
21171 else if (TREE_CODE (origin
) == BLOCK
)
21172 origin_die
= lookup_block_die (origin
);
21174 /* XXX: Functions that are never lowered don't always have correct block
21175 trees (in the case of java, they simply have no block tree, in some other
21176 languages). For these functions, there is nothing we can really do to
21177 output correct debug info for inlined functions in all cases. Rather
21178 than die, we'll just produce deficient debug info now, in that we will
21179 have variables without a proper abstract origin. In the future, when all
21180 functions are lowered, we should re-add a gcc_assert (origin_die)
21184 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
21187 /* We do not currently support the pure_virtual attribute. */
21190 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
21192 if (DECL_VINDEX (func_decl
))
21194 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
21196 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
21197 add_AT_loc (die
, DW_AT_vtable_elem_location
,
21198 new_loc_descr (DW_OP_constu
,
21199 tree_to_shwi (DECL_VINDEX (func_decl
)),
21202 /* GNU extension: Record what type this method came from originally. */
21203 if (debug_info_level
> DINFO_LEVEL_TERSE
21204 && DECL_CONTEXT (func_decl
))
21205 add_AT_die_ref (die
, DW_AT_containing_type
,
21206 lookup_type_die (DECL_CONTEXT (func_decl
)));
21210 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
21211 given decl. This used to be a vendor extension until after DWARF 4
21212 standardized it. */
21215 add_linkage_attr (dw_die_ref die
, tree decl
)
21217 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
21219 /* Mimic what assemble_name_raw does with a leading '*'. */
21220 if (name
[0] == '*')
21223 if (dwarf_version
>= 4)
21224 add_AT_string (die
, DW_AT_linkage_name
, name
);
21226 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
21229 /* Add source coordinate attributes for the given decl. */
21232 add_src_coords_attributes (dw_die_ref die
, tree decl
)
21234 expanded_location s
;
21236 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
21238 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
21239 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
21240 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
21241 if (debug_column_info
&& s
.column
)
21242 add_AT_unsigned (die
, DW_AT_decl_column
, s
.column
);
21245 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
21248 add_linkage_name_raw (dw_die_ref die
, tree decl
)
21250 /* Defer until we have an assembler name set. */
21251 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
21253 limbo_die_node
*asm_name
;
21255 asm_name
= ggc_cleared_alloc
<limbo_die_node
> ();
21256 asm_name
->die
= die
;
21257 asm_name
->created_for
= decl
;
21258 asm_name
->next
= deferred_asm_name
;
21259 deferred_asm_name
= asm_name
;
21261 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
21262 add_linkage_attr (die
, decl
);
21265 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl if desired. */
21268 add_linkage_name (dw_die_ref die
, tree decl
)
21270 if (debug_info_level
> DINFO_LEVEL_NONE
21271 && VAR_OR_FUNCTION_DECL_P (decl
)
21272 && TREE_PUBLIC (decl
)
21273 && !(VAR_P (decl
) && DECL_REGISTER (decl
))
21274 && die
->die_tag
!= DW_TAG_member
)
21275 add_linkage_name_raw (die
, decl
);
21278 /* Add a DW_AT_name attribute and source coordinate attribute for the
21279 given decl, but only if it actually has a name. */
21282 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
,
21283 bool no_linkage_name
)
21287 decl_name
= DECL_NAME (decl
);
21288 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
21290 const char *name
= dwarf2_name (decl
, 0);
21292 add_name_attribute (die
, name
);
21294 add_desc_attribute (die
, decl
);
21296 if (! DECL_ARTIFICIAL (decl
))
21297 add_src_coords_attributes (die
, decl
);
21299 if (!no_linkage_name
)
21300 add_linkage_name (die
, decl
);
21303 add_desc_attribute (die
, decl
);
21305 #ifdef VMS_DEBUGGING_INFO
21306 /* Get the function's name, as described by its RTL. This may be different
21307 from the DECL_NAME name used in the source file. */
21308 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
21310 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
21311 XEXP (DECL_RTL (decl
), 0), false);
21312 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
21314 #endif /* VMS_DEBUGGING_INFO */
21317 /* Add VALUE as a DW_AT_discr_value attribute to DIE. */
21320 add_discr_value (dw_die_ref die
, dw_discr_value
*value
)
21324 attr
.dw_attr
= DW_AT_discr_value
;
21325 attr
.dw_attr_val
.val_class
= dw_val_class_discr_value
;
21326 attr
.dw_attr_val
.val_entry
= NULL
;
21327 attr
.dw_attr_val
.v
.val_discr_value
.pos
= value
->pos
;
21329 attr
.dw_attr_val
.v
.val_discr_value
.v
.uval
= value
->v
.uval
;
21331 attr
.dw_attr_val
.v
.val_discr_value
.v
.sval
= value
->v
.sval
;
21332 add_dwarf_attr (die
, &attr
);
21335 /* Add DISCR_LIST as a DW_AT_discr_list to DIE. */
21338 add_discr_list (dw_die_ref die
, dw_discr_list_ref discr_list
)
21342 attr
.dw_attr
= DW_AT_discr_list
;
21343 attr
.dw_attr_val
.val_class
= dw_val_class_discr_list
;
21344 attr
.dw_attr_val
.val_entry
= NULL
;
21345 attr
.dw_attr_val
.v
.val_discr_list
= discr_list
;
21346 add_dwarf_attr (die
, &attr
);
21349 static inline dw_discr_list_ref
21350 AT_discr_list (dw_attr_node
*attr
)
21352 return attr
->dw_attr_val
.v
.val_discr_list
;
21355 #ifdef VMS_DEBUGGING_INFO
21356 /* Output the debug main pointer die for VMS */
21359 dwarf2out_vms_debug_main_pointer (void)
21361 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21364 /* Allocate the VMS debug main subprogram die. */
21365 die
= new_die_raw (DW_TAG_subprogram
);
21366 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
21367 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
21368 current_function_funcdef_no
);
21369 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
21371 /* Make it the first child of comp_unit_die (). */
21372 die
->die_parent
= comp_unit_die ();
21373 if (comp_unit_die ()->die_child
)
21375 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
21376 comp_unit_die ()->die_child
->die_sib
= die
;
21380 die
->die_sib
= die
;
21381 comp_unit_die ()->die_child
= die
;
21384 #endif /* VMS_DEBUGGING_INFO */
21386 /* walk_tree helper function for uses_local_type, below. */
21389 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
21392 *walk_subtrees
= 0;
21395 tree name
= TYPE_NAME (*tp
);
21396 if (name
&& DECL_P (name
) && decl_function_context (name
))
21402 /* If TYPE involves a function-local type (including a local typedef to a
21403 non-local type), returns that type; otherwise returns NULL_TREE. */
21406 uses_local_type (tree type
)
21408 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
21412 /* Return the DIE for the scope that immediately contains this type.
21413 Non-named types that do not involve a function-local type get global
21414 scope. Named types nested in namespaces or other types get their
21415 containing scope. All other types (i.e. function-local named types) get
21416 the current active scope. */
21419 scope_die_for (tree t
, dw_die_ref context_die
)
21421 dw_die_ref scope_die
= NULL
;
21422 tree containing_scope
;
21424 /* Non-types always go in the current scope. */
21425 gcc_assert (TYPE_P (t
));
21427 /* Use the scope of the typedef, rather than the scope of the type
21429 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
21430 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
21432 containing_scope
= TYPE_CONTEXT (t
);
21434 /* Use the containing namespace if there is one. */
21435 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
21437 if (context_die
== lookup_decl_die (containing_scope
))
21439 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
21440 context_die
= get_context_die (containing_scope
);
21442 containing_scope
= NULL_TREE
;
21445 /* Ignore function type "scopes" from the C frontend. They mean that
21446 a tagged type is local to a parmlist of a function declarator, but
21447 that isn't useful to DWARF. */
21448 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
21449 containing_scope
= NULL_TREE
;
21451 if (SCOPE_FILE_SCOPE_P (containing_scope
))
21453 /* If T uses a local type keep it local as well, to avoid references
21454 to function-local DIEs from outside the function. */
21455 if (current_function_decl
&& uses_local_type (t
))
21456 scope_die
= context_die
;
21458 scope_die
= comp_unit_die ();
21460 else if (TYPE_P (containing_scope
))
21462 /* For types, we can just look up the appropriate DIE. */
21463 if (debug_info_level
> DINFO_LEVEL_TERSE
)
21464 scope_die
= get_context_die (containing_scope
);
21467 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
21468 if (scope_die
== NULL
)
21469 scope_die
= comp_unit_die ();
21473 scope_die
= context_die
;
21478 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
21481 local_scope_p (dw_die_ref context_die
)
21483 for (; context_die
; context_die
= context_die
->die_parent
)
21484 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
21485 || context_die
->die_tag
== DW_TAG_subprogram
)
21491 /* Returns nonzero if CONTEXT_DIE is a class. */
21494 class_scope_p (dw_die_ref context_die
)
21496 return (context_die
21497 && (context_die
->die_tag
== DW_TAG_structure_type
21498 || context_die
->die_tag
== DW_TAG_class_type
21499 || context_die
->die_tag
== DW_TAG_interface_type
21500 || context_die
->die_tag
== DW_TAG_union_type
));
21503 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
21504 whether or not to treat a DIE in this context as a declaration. */
21507 class_or_namespace_scope_p (dw_die_ref context_die
)
21509 return (class_scope_p (context_die
)
21510 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
21513 /* Many forms of DIEs require a "type description" attribute. This
21514 routine locates the proper "type descriptor" die for the type given
21515 by 'type' plus any additional qualifiers given by 'cv_quals', and
21516 adds a DW_AT_type attribute below the given die. */
21519 add_type_attribute (dw_die_ref object_die
, tree type
, int cv_quals
,
21520 bool reverse
, dw_die_ref context_die
)
21522 enum tree_code code
= TREE_CODE (type
);
21523 dw_die_ref type_die
= NULL
;
21525 /* ??? If this type is an unnamed subrange type of an integral, floating-point
21526 or fixed-point type, use the inner type. This is because we have no
21527 support for unnamed types in base_type_die. This can happen if this is
21528 an Ada subrange type. Correct solution is emit a subrange type die. */
21529 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
21530 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
21531 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
21533 if (code
== ERROR_MARK
21534 /* Handle a special case. For functions whose return type is void, we
21535 generate *no* type attribute. (Note that no object may have type
21536 `void', so this only applies to function return types). */
21537 || code
== VOID_TYPE
)
21540 type_die
= modified_type_die (type
,
21541 cv_quals
| TYPE_QUALS (type
),
21545 if (type_die
!= NULL
)
21546 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
21549 /* Given an object die, add the calling convention attribute for the
21550 function call type. */
21552 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
21554 enum dwarf_calling_convention value
= DW_CC_normal
;
21556 value
= ((enum dwarf_calling_convention
)
21557 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
21560 && id_equal (DECL_ASSEMBLER_NAME (decl
), "MAIN__"))
21562 /* DWARF 2 doesn't provide a way to identify a program's source-level
21563 entry point. DW_AT_calling_convention attributes are only meant
21564 to describe functions' calling conventions. However, lacking a
21565 better way to signal the Fortran main program, we used this for
21566 a long time, following existing custom. Now, DWARF 4 has
21567 DW_AT_main_subprogram, which we add below, but some tools still
21568 rely on the old way, which we thus keep. */
21569 value
= DW_CC_program
;
21571 if (dwarf_version
>= 4 || !dwarf_strict
)
21572 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
21575 /* Only add the attribute if the backend requests it, and
21576 is not DW_CC_normal. */
21577 if (value
&& (value
!= DW_CC_normal
))
21578 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
21581 /* Given a tree pointer to a struct, class, union, or enum type node, return
21582 a pointer to the (string) tag name for the given type, or zero if the type
21583 was declared without a tag. */
21585 static const char *
21586 type_tag (const_tree type
)
21588 const char *name
= 0;
21590 if (TYPE_NAME (type
) != 0)
21594 /* Find the IDENTIFIER_NODE for the type name. */
21595 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
21596 && !TYPE_NAMELESS (type
))
21597 t
= TYPE_NAME (type
);
21599 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
21600 a TYPE_DECL node, regardless of whether or not a `typedef' was
21602 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
21603 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
21605 /* We want to be extra verbose. Don't call dwarf_name if
21606 DECL_NAME isn't set. The default hook for decl_printable_name
21607 doesn't like that, and in this context it's correct to return
21608 0, instead of "<anonymous>" or the like. */
21609 if (DECL_NAME (TYPE_NAME (type
))
21610 && !DECL_NAMELESS (TYPE_NAME (type
)))
21611 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
21614 /* Now get the name as a string, or invent one. */
21615 if (!name
&& t
!= 0)
21616 name
= IDENTIFIER_POINTER (t
);
21619 return (name
== 0 || *name
== '\0') ? 0 : name
;
21622 /* Return the type associated with a data member, make a special check
21623 for bit field types. */
21626 member_declared_type (const_tree member
)
21628 return (DECL_BIT_FIELD_TYPE (member
)
21629 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
21632 /* Get the decl's label, as described by its RTL. This may be different
21633 from the DECL_NAME name used in the source file. */
21636 static const char *
21637 decl_start_label (tree decl
)
21640 const char *fnname
;
21642 x
= DECL_RTL (decl
);
21643 gcc_assert (MEM_P (x
));
21646 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
21648 fnname
= XSTR (x
, 0);
21653 /* For variable-length arrays that have been previously generated, but
21654 may be incomplete due to missing subscript info, fill the subscript
21655 info. Return TRUE if this is one of those cases. */
21657 fill_variable_array_bounds (tree type
)
21659 if (TREE_ASM_WRITTEN (type
)
21660 && TREE_CODE (type
) == ARRAY_TYPE
21661 && variably_modified_type_p (type
, NULL
))
21663 dw_die_ref array_die
= lookup_type_die (type
);
21666 add_subscript_info (array_die
, type
, !is_ada ());
21672 /* These routines generate the internal representation of the DIE's for
21673 the compilation unit. Debugging information is collected by walking
21674 the declaration trees passed in from dwarf2out_decl(). */
21677 gen_array_type_die (tree type
, dw_die_ref context_die
)
21679 dw_die_ref array_die
;
21681 /* GNU compilers represent multidimensional array types as sequences of one
21682 dimensional array types whose element types are themselves array types.
21683 We sometimes squish that down to a single array_type DIE with multiple
21684 subscripts in the Dwarf debugging info. The draft Dwarf specification
21685 say that we are allowed to do this kind of compression in C, because
21686 there is no difference between an array of arrays and a multidimensional
21687 array. We don't do this for Ada to remain as close as possible to the
21688 actual representation, which is especially important against the language
21689 flexibilty wrt arrays of variable size. */
21691 bool collapse_nested_arrays
= !is_ada ();
21693 if (fill_variable_array_bounds (type
))
21696 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
21699 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
21700 DW_TAG_string_type doesn't have DW_AT_type attribute). */
21701 if (TYPE_STRING_FLAG (type
)
21702 && TREE_CODE (type
) == ARRAY_TYPE
21704 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
21706 HOST_WIDE_INT size
;
21708 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
21709 add_name_attribute (array_die
, type_tag (type
));
21710 equate_type_number_to_die (type
, array_die
);
21711 size
= int_size_in_bytes (type
);
21713 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
21714 /* ??? We can't annotate types late, but for LTO we may not
21715 generate a location early either (gfortran.dg/save_6.f90). */
21716 else if (! (early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
21717 && TYPE_DOMAIN (type
) != NULL_TREE
21718 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
)
21720 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
21721 tree rszdecl
= szdecl
;
21723 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
21724 if (!DECL_P (szdecl
))
21726 if (TREE_CODE (szdecl
) == INDIRECT_REF
21727 && DECL_P (TREE_OPERAND (szdecl
, 0)))
21729 rszdecl
= TREE_OPERAND (szdecl
, 0);
21730 if (int_size_in_bytes (TREE_TYPE (rszdecl
))
21731 != DWARF2_ADDR_SIZE
)
21739 dw_loc_list_ref loc
21740 = loc_list_from_tree (rszdecl
, szdecl
== rszdecl
? 2 : 0,
21744 add_AT_location_description (array_die
, DW_AT_string_length
,
21746 if (size
!= DWARF2_ADDR_SIZE
)
21747 add_AT_unsigned (array_die
, dwarf_version
>= 5
21748 ? DW_AT_string_length_byte_size
21749 : DW_AT_byte_size
, size
);
21756 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
21757 add_name_attribute (array_die
, type_tag (type
));
21758 equate_type_number_to_die (type
, array_die
);
21760 if (TREE_CODE (type
) == VECTOR_TYPE
)
21761 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
21763 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
21765 && TREE_CODE (type
) == ARRAY_TYPE
21766 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
21767 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
21768 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
21771 /* We default the array ordering. Debuggers will probably do the right
21772 things even if DW_AT_ordering is not present. It's not even an issue
21773 until we start to get into multidimensional arrays anyway. If a debugger
21774 is ever caught doing the Wrong Thing for multi-dimensional arrays,
21775 then we'll have to put the DW_AT_ordering attribute back in. (But if
21776 and when we find out that we need to put these in, we will only do so
21777 for multidimensional arrays. */
21778 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
21781 if (TREE_CODE (type
) == VECTOR_TYPE
)
21783 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
21784 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
21785 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
, NULL
);
21786 add_bound_info (subrange_die
, DW_AT_upper_bound
,
21787 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1), NULL
);
21790 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
21792 /* Add representation of the type of the elements of this array type and
21793 emit the corresponding DIE if we haven't done it already. */
21794 element_type
= TREE_TYPE (type
);
21795 if (collapse_nested_arrays
)
21796 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
21798 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
21800 element_type
= TREE_TYPE (element_type
);
21803 add_type_attribute (array_die
, element_type
, TYPE_UNQUALIFIED
,
21804 TREE_CODE (type
) == ARRAY_TYPE
21805 && TYPE_REVERSE_STORAGE_ORDER (type
),
21808 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
21809 if (TYPE_ARTIFICIAL (type
))
21810 add_AT_flag (array_die
, DW_AT_artificial
, 1);
21812 if (get_AT (array_die
, DW_AT_name
))
21813 add_pubtype (type
, array_die
);
21815 add_alignment_attribute (array_die
, type
);
21818 /* This routine generates DIE for array with hidden descriptor, details
21819 are filled into *info by a langhook. */
21822 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
21823 dw_die_ref context_die
)
21825 const dw_die_ref scope_die
= scope_die_for (type
, context_die
);
21826 const dw_die_ref array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
21827 struct loc_descr_context context
= { type
, info
->base_decl
, NULL
,
21829 enum dwarf_tag subrange_tag
= DW_TAG_subrange_type
;
21832 add_name_attribute (array_die
, type_tag (type
));
21833 equate_type_number_to_die (type
, array_die
);
21835 if (info
->ndimensions
> 1)
21836 switch (info
->ordering
)
21838 case array_descr_ordering_row_major
:
21839 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
21841 case array_descr_ordering_column_major
:
21842 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
21848 if (dwarf_version
>= 3 || !dwarf_strict
)
21850 if (info
->data_location
)
21851 add_scalar_info (array_die
, DW_AT_data_location
, info
->data_location
,
21852 dw_scalar_form_exprloc
, &context
);
21853 if (info
->associated
)
21854 add_scalar_info (array_die
, DW_AT_associated
, info
->associated
,
21855 dw_scalar_form_constant
21856 | dw_scalar_form_exprloc
21857 | dw_scalar_form_reference
, &context
);
21858 if (info
->allocated
)
21859 add_scalar_info (array_die
, DW_AT_allocated
, info
->allocated
,
21860 dw_scalar_form_constant
21861 | dw_scalar_form_exprloc
21862 | dw_scalar_form_reference
, &context
);
21865 const enum dwarf_attribute attr
21866 = (info
->stride_in_bits
) ? DW_AT_bit_stride
: DW_AT_byte_stride
;
21868 = (info
->stride_in_bits
)
21869 ? dw_scalar_form_constant
21870 : (dw_scalar_form_constant
21871 | dw_scalar_form_exprloc
21872 | dw_scalar_form_reference
);
21874 add_scalar_info (array_die
, attr
, info
->stride
, forms
, &context
);
21877 if (dwarf_version
>= 5)
21881 add_scalar_info (array_die
, DW_AT_rank
, info
->rank
,
21882 dw_scalar_form_constant
21883 | dw_scalar_form_exprloc
, &context
);
21884 subrange_tag
= DW_TAG_generic_subrange
;
21885 context
.placeholder_arg
= true;
21889 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
21891 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
21893 dw_die_ref subrange_die
= new_die (subrange_tag
, array_die
, NULL
);
21895 if (info
->dimen
[dim
].bounds_type
)
21896 add_type_attribute (subrange_die
,
21897 info
->dimen
[dim
].bounds_type
, TYPE_UNQUALIFIED
,
21898 false, context_die
);
21899 if (info
->dimen
[dim
].lower_bound
)
21900 add_bound_info (subrange_die
, DW_AT_lower_bound
,
21901 info
->dimen
[dim
].lower_bound
, &context
);
21902 if (info
->dimen
[dim
].upper_bound
)
21903 add_bound_info (subrange_die
, DW_AT_upper_bound
,
21904 info
->dimen
[dim
].upper_bound
, &context
);
21905 if ((dwarf_version
>= 3 || !dwarf_strict
) && info
->dimen
[dim
].stride
)
21906 add_scalar_info (subrange_die
, DW_AT_byte_stride
,
21907 info
->dimen
[dim
].stride
,
21908 dw_scalar_form_constant
21909 | dw_scalar_form_exprloc
21910 | dw_scalar_form_reference
,
21914 gen_type_die (info
->element_type
, context_die
);
21915 add_type_attribute (array_die
, info
->element_type
, TYPE_UNQUALIFIED
,
21916 TREE_CODE (type
) == ARRAY_TYPE
21917 && TYPE_REVERSE_STORAGE_ORDER (type
),
21920 if (get_AT (array_die
, DW_AT_name
))
21921 add_pubtype (type
, array_die
);
21923 add_alignment_attribute (array_die
, type
);
21928 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
21930 tree origin
= decl_ultimate_origin (decl
);
21931 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
21933 if (origin
!= NULL
)
21934 add_abstract_origin_attribute (decl_die
, origin
);
21937 add_name_and_src_coords_attributes (decl_die
, decl
);
21938 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
21939 TYPE_UNQUALIFIED
, false, context_die
);
21942 if (DECL_ABSTRACT_P (decl
))
21943 equate_decl_number_to_die (decl
, decl_die
);
21945 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
21949 /* Walk through the list of incomplete types again, trying once more to
21950 emit full debugging info for them. */
21953 retry_incomplete_types (void)
21958 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
21959 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
21960 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
21961 vec_safe_truncate (incomplete_types
, 0);
21964 /* Determine what tag to use for a record type. */
21966 static enum dwarf_tag
21967 record_type_tag (tree type
)
21969 if (! lang_hooks
.types
.classify_record
)
21970 return DW_TAG_structure_type
;
21972 switch (lang_hooks
.types
.classify_record (type
))
21974 case RECORD_IS_STRUCT
:
21975 return DW_TAG_structure_type
;
21977 case RECORD_IS_CLASS
:
21978 return DW_TAG_class_type
;
21980 case RECORD_IS_INTERFACE
:
21981 if (dwarf_version
>= 3 || !dwarf_strict
)
21982 return DW_TAG_interface_type
;
21983 return DW_TAG_structure_type
;
21986 gcc_unreachable ();
21990 /* Generate a DIE to represent an enumeration type. Note that these DIEs
21991 include all of the information about the enumeration values also. Each
21992 enumerated type name/value is listed as a child of the enumerated type
21996 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
21998 dw_die_ref type_die
= lookup_type_die (type
);
21999 dw_die_ref orig_type_die
= type_die
;
22001 if (type_die
== NULL
)
22003 type_die
= new_die (DW_TAG_enumeration_type
,
22004 scope_die_for (type
, context_die
), type
);
22005 equate_type_number_to_die (type
, type_die
);
22006 add_name_attribute (type_die
, type_tag (type
));
22007 if ((dwarf_version
>= 4 || !dwarf_strict
)
22008 && ENUM_IS_SCOPED (type
))
22009 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
22010 if (ENUM_IS_OPAQUE (type
) && TYPE_SIZE (type
))
22011 add_AT_flag (type_die
, DW_AT_declaration
, 1);
22013 add_AT_unsigned (type_die
, DW_AT_encoding
,
22014 TYPE_UNSIGNED (type
)
22018 else if (! TYPE_SIZE (type
) || ENUM_IS_OPAQUE (type
))
22021 remove_AT (type_die
, DW_AT_declaration
);
22023 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
22024 given enum type is incomplete, do not generate the DW_AT_byte_size
22025 attribute or the DW_AT_element_list attribute. */
22026 if (TYPE_SIZE (type
))
22030 if (!ENUM_IS_OPAQUE (type
))
22031 TREE_ASM_WRITTEN (type
) = 1;
22032 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_byte_size
))
22033 add_byte_size_attribute (type_die
, type
);
22034 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_alignment
))
22035 add_alignment_attribute (type_die
, type
);
22036 if ((dwarf_version
>= 3 || !dwarf_strict
)
22037 && (!orig_type_die
|| !get_AT (type_die
, DW_AT_type
)))
22039 tree underlying
= lang_hooks
.types
.enum_underlying_base_type (type
);
22040 add_type_attribute (type_die
, underlying
, TYPE_UNQUALIFIED
, false,
22043 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
22045 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_decl_file
))
22046 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
22047 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_accessibility
))
22048 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
22051 /* If the first reference to this type was as the return type of an
22052 inline function, then it may not have a parent. Fix this now. */
22053 if (type_die
->die_parent
== NULL
)
22054 add_child_die (scope_die_for (type
, context_die
), type_die
);
22056 for (link
= TYPE_VALUES (type
);
22057 link
!= NULL
; link
= TREE_CHAIN (link
))
22059 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
22060 tree value
= TREE_VALUE (link
);
22062 gcc_assert (!ENUM_IS_OPAQUE (type
));
22063 add_name_attribute (enum_die
,
22064 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
22066 if (TREE_CODE (value
) == CONST_DECL
)
22067 value
= DECL_INITIAL (value
);
22069 if (simple_type_size_in_bits (TREE_TYPE (value
))
22070 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
22072 /* For constant forms created by add_AT_unsigned DWARF
22073 consumers (GDB, elfutils, etc.) always zero extend
22074 the value. Only when the actual value is negative
22075 do we need to use add_AT_int to generate a constant
22076 form that can represent negative values. */
22077 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
22078 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
22079 add_AT_unsigned (enum_die
, DW_AT_const_value
,
22080 (unsigned HOST_WIDE_INT
) val
);
22082 add_AT_int (enum_die
, DW_AT_const_value
, val
);
22085 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
22086 that here. TODO: This should be re-worked to use correct
22087 signed/unsigned double tags for all cases. */
22088 add_AT_wide (enum_die
, DW_AT_const_value
, wi::to_wide (value
));
22091 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
22092 if (TYPE_ARTIFICIAL (type
)
22093 && (!orig_type_die
|| !get_AT (type_die
, DW_AT_artificial
)))
22094 add_AT_flag (type_die
, DW_AT_artificial
, 1);
22097 add_AT_flag (type_die
, DW_AT_declaration
, 1);
22099 add_pubtype (type
, type_die
);
22104 /* Generate a DIE to represent either a real live formal parameter decl or to
22105 represent just the type of some formal parameter position in some function
22108 Note that this routine is a bit unusual because its argument may be a
22109 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
22110 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
22111 node. If it's the former then this function is being called to output a
22112 DIE to represent a formal parameter object (or some inlining thereof). If
22113 it's the latter, then this function is only being called to output a
22114 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
22115 argument type of some subprogram type.
22116 If EMIT_NAME_P is true, name and source coordinate attributes
22120 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
22121 dw_die_ref context_die
)
22123 tree node_or_origin
= node
? node
: origin
;
22124 tree ultimate_origin
;
22125 dw_die_ref parm_die
= NULL
;
22127 if (DECL_P (node_or_origin
))
22129 parm_die
= lookup_decl_die (node
);
22131 /* If the contexts differ, we may not be talking about the same
22133 ??? When in LTO the DIE parent is the "abstract" copy and the
22134 context_die is the specification "copy". But this whole block
22135 should eventually be no longer needed. */
22136 if (parm_die
&& parm_die
->die_parent
!= context_die
&& !in_lto_p
)
22138 if (!DECL_ABSTRACT_P (node
))
22140 /* This can happen when creating an inlined instance, in
22141 which case we need to create a new DIE that will get
22142 annotated with DW_AT_abstract_origin. */
22146 gcc_unreachable ();
22149 if (parm_die
&& parm_die
->die_parent
== NULL
)
22151 /* Check that parm_die already has the right attributes that
22152 we would have added below. If any attributes are
22153 missing, fall through to add them. */
22154 if (! DECL_ABSTRACT_P (node_or_origin
)
22155 && !get_AT (parm_die
, DW_AT_location
)
22156 && !get_AT (parm_die
, DW_AT_const_value
))
22157 /* We are missing location info, and are about to add it. */
22161 add_child_die (context_die
, parm_die
);
22167 /* If we have a previously generated DIE, use it, unless this is an
22168 concrete instance (origin != NULL), in which case we need a new
22169 DIE with a corresponding DW_AT_abstract_origin. */
22171 if (parm_die
&& origin
== NULL
)
22172 reusing_die
= true;
22175 parm_die
= new_die (DW_TAG_formal_parameter
, context_die
, node
);
22176 reusing_die
= false;
22179 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
22181 case tcc_declaration
:
22182 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
22183 if (node
|| ultimate_origin
)
22184 origin
= ultimate_origin
;
22189 if (origin
!= NULL
)
22190 add_abstract_origin_attribute (parm_die
, origin
);
22191 else if (emit_name_p
)
22192 add_name_and_src_coords_attributes (parm_die
, node
);
22194 || (! DECL_ABSTRACT_P (node_or_origin
)
22195 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
22196 decl_function_context
22197 (node_or_origin
))))
22199 tree type
= TREE_TYPE (node_or_origin
);
22200 if (decl_by_reference_p (node_or_origin
))
22201 add_type_attribute (parm_die
, TREE_TYPE (type
),
22203 false, context_die
);
22205 add_type_attribute (parm_die
, type
,
22206 decl_quals (node_or_origin
),
22207 false, context_die
);
22209 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
22210 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22212 if (node
&& node
!= origin
)
22213 equate_decl_number_to_die (node
, parm_die
);
22214 if (! DECL_ABSTRACT_P (node_or_origin
))
22215 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
22221 /* We were called with some kind of a ..._TYPE node. */
22222 add_type_attribute (parm_die
, node_or_origin
, TYPE_UNQUALIFIED
, false,
22227 gcc_unreachable ();
22233 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
22234 children DW_TAG_formal_parameter DIEs representing the arguments of the
22237 PARM_PACK must be a function parameter pack.
22238 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
22239 must point to the subsequent arguments of the function PACK_ARG belongs to.
22240 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
22241 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
22242 following the last one for which a DIE was generated. */
22245 gen_formal_parameter_pack_die (tree parm_pack
,
22247 dw_die_ref subr_die
,
22251 dw_die_ref parm_pack_die
;
22253 gcc_assert (parm_pack
22254 && lang_hooks
.function_parameter_pack_p (parm_pack
)
22257 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
22258 add_src_coords_attributes (parm_pack_die
, parm_pack
);
22260 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
22262 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
22265 gen_formal_parameter_die (arg
, NULL
,
22266 false /* Don't emit name attribute. */,
22271 return parm_pack_die
;
22274 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
22275 at the end of an (ANSI prototyped) formal parameters list. */
22278 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
22280 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
22283 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
22284 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
22285 parameters as specified in some function type specification (except for
22286 those which appear as part of a function *definition*). */
22289 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
22292 tree formal_type
= NULL
;
22293 tree first_parm_type
;
22296 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
22298 arg
= DECL_ARGUMENTS (function_or_method_type
);
22299 function_or_method_type
= TREE_TYPE (function_or_method_type
);
22304 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
22306 /* Make our first pass over the list of formal parameter types and output a
22307 DW_TAG_formal_parameter DIE for each one. */
22308 for (link
= first_parm_type
; link
; )
22310 dw_die_ref parm_die
;
22312 formal_type
= TREE_VALUE (link
);
22313 if (formal_type
== void_type_node
)
22316 /* Output a (nameless) DIE to represent the formal parameter itself. */
22317 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
22318 true /* Emit name attribute. */,
22320 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
22321 && link
== first_parm_type
)
22323 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22324 if (dwarf_version
>= 3 || !dwarf_strict
)
22325 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
22327 else if (arg
&& DECL_ARTIFICIAL (arg
))
22328 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22330 link
= TREE_CHAIN (link
);
22332 arg
= DECL_CHAIN (arg
);
22335 /* If this function type has an ellipsis, add a
22336 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
22337 if (formal_type
!= void_type_node
)
22338 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
22340 /* Make our second (and final) pass over the list of formal parameter types
22341 and output DIEs to represent those types (as necessary). */
22342 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
22343 link
&& TREE_VALUE (link
);
22344 link
= TREE_CHAIN (link
))
22345 gen_type_die (TREE_VALUE (link
), context_die
);
22348 /* We want to generate the DIE for TYPE so that we can generate the
22349 die for MEMBER, which has been defined; we will need to refer back
22350 to the member declaration nested within TYPE. If we're trying to
22351 generate minimal debug info for TYPE, processing TYPE won't do the
22352 trick; we need to attach the member declaration by hand. */
22355 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
22357 gen_type_die (type
, context_die
);
22359 /* If we're trying to avoid duplicate debug info, we may not have
22360 emitted the member decl for this function. Emit it now. */
22361 if (TYPE_STUB_DECL (type
)
22362 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
22363 && ! lookup_decl_die (member
))
22365 dw_die_ref type_die
;
22366 gcc_assert (!decl_ultimate_origin (member
));
22368 type_die
= lookup_type_die_strip_naming_typedef (type
);
22369 if (TREE_CODE (member
) == FUNCTION_DECL
)
22370 gen_subprogram_die (member
, type_die
);
22371 else if (TREE_CODE (member
) == FIELD_DECL
)
22373 /* Ignore the nameless fields that are used to skip bits but handle
22374 C++ anonymous unions and structs. */
22375 if (DECL_NAME (member
) != NULL_TREE
22376 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
22377 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
22379 struct vlr_context vlr_ctx
= {
22380 DECL_CONTEXT (member
), /* struct_type */
22381 NULL_TREE
/* variant_part_offset */
22383 gen_type_die (member_declared_type (member
), type_die
);
22384 gen_field_die (member
, &vlr_ctx
, type_die
);
22388 gen_variable_die (member
, NULL_TREE
, type_die
);
22392 /* Forward declare these functions, because they are mutually recursive
22393 with their set_block_* pairing functions. */
22394 static void set_decl_origin_self (tree
);
22396 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
22397 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
22398 that it points to the node itself, thus indicating that the node is its
22399 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
22400 the given node is NULL, recursively descend the decl/block tree which
22401 it is the root of, and for each other ..._DECL or BLOCK node contained
22402 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
22403 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
22404 values to point to themselves. */
22407 set_block_origin_self (tree stmt
)
22409 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
22411 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
22416 for (local_decl
= BLOCK_VARS (stmt
);
22417 local_decl
!= NULL_TREE
;
22418 local_decl
= DECL_CHAIN (local_decl
))
22419 /* Do not recurse on nested functions since the inlining status
22420 of parent and child can be different as per the DWARF spec. */
22421 if (TREE_CODE (local_decl
) != FUNCTION_DECL
22422 && !DECL_EXTERNAL (local_decl
))
22423 set_decl_origin_self (local_decl
);
22429 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
22430 subblock
!= NULL_TREE
;
22431 subblock
= BLOCK_CHAIN (subblock
))
22432 set_block_origin_self (subblock
); /* Recurse. */
22437 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
22438 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
22439 node to so that it points to the node itself, thus indicating that the
22440 node represents its own (abstract) origin. Additionally, if the
22441 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
22442 the decl/block tree of which the given node is the root of, and for
22443 each other ..._DECL or BLOCK node contained therein whose
22444 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
22445 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
22446 point to themselves. */
22449 set_decl_origin_self (tree decl
)
22451 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
22453 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
22454 if (TREE_CODE (decl
) == FUNCTION_DECL
)
22458 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
22459 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
22460 if (DECL_INITIAL (decl
) != NULL_TREE
22461 && DECL_INITIAL (decl
) != error_mark_node
)
22462 set_block_origin_self (DECL_INITIAL (decl
));
22467 /* Mark the early DIE for DECL as the abstract instance. */
22470 dwarf2out_abstract_function (tree decl
)
22472 dw_die_ref old_die
;
22474 /* Make sure we have the actual abstract inline, not a clone. */
22475 decl
= DECL_ORIGIN (decl
);
22477 if (DECL_IGNORED_P (decl
))
22480 /* In LTO we're all set. We already created abstract instances
22481 early and we want to avoid creating a concrete instance of that
22482 if we don't output it. */
22486 old_die
= lookup_decl_die (decl
);
22487 gcc_assert (old_die
!= NULL
);
22488 if (get_AT (old_die
, DW_AT_inline
))
22489 /* We've already generated the abstract instance. */
22492 /* Go ahead and put DW_AT_inline on the DIE. */
22493 if (DECL_DECLARED_INLINE_P (decl
))
22495 if (cgraph_function_possibly_inlined_p (decl
))
22496 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_inlined
);
22498 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
22502 if (cgraph_function_possibly_inlined_p (decl
))
22503 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_inlined
);
22505 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_not_inlined
);
22508 if (DECL_DECLARED_INLINE_P (decl
)
22509 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
22510 add_AT_flag (old_die
, DW_AT_artificial
, 1);
22512 set_decl_origin_self (decl
);
22515 /* Helper function of premark_used_types() which gets called through
22518 Marks the DIE of a given type in *SLOT as perennial, so it never gets
22519 marked as unused by prune_unused_types. */
22522 premark_used_types_helper (tree
const &type
, void *)
22526 die
= lookup_type_die (type
);
22528 die
->die_perennial_p
= 1;
22532 /* Helper function of premark_types_used_by_global_vars which gets called
22533 through htab_traverse.
22535 Marks the DIE of a given type in *SLOT as perennial, so it never gets
22536 marked as unused by prune_unused_types. The DIE of the type is marked
22537 only if the global variable using the type will actually be emitted. */
22540 premark_types_used_by_global_vars_helper (types_used_by_vars_entry
**slot
,
22543 struct types_used_by_vars_entry
*entry
;
22546 entry
= (struct types_used_by_vars_entry
*) *slot
;
22547 gcc_assert (entry
->type
!= NULL
22548 && entry
->var_decl
!= NULL
);
22549 die
= lookup_type_die (entry
->type
);
22552 /* Ask cgraph if the global variable really is to be emitted.
22553 If yes, then we'll keep the DIE of ENTRY->TYPE. */
22554 varpool_node
*node
= varpool_node::get (entry
->var_decl
);
22555 if (node
&& node
->definition
)
22557 die
->die_perennial_p
= 1;
22558 /* Keep the parent DIEs as well. */
22559 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
22560 die
->die_perennial_p
= 1;
22566 /* Mark all members of used_types_hash as perennial. */
22569 premark_used_types (struct function
*fun
)
22571 if (fun
&& fun
->used_types_hash
)
22572 fun
->used_types_hash
->traverse
<void *, premark_used_types_helper
> (NULL
);
22575 /* Mark all members of types_used_by_vars_entry as perennial. */
22578 premark_types_used_by_global_vars (void)
22580 if (types_used_by_vars_hash
)
22581 types_used_by_vars_hash
22582 ->traverse
<void *, premark_types_used_by_global_vars_helper
> (NULL
);
22585 /* Generate a DW_TAG_call_site DIE in function DECL under SUBR_DIE
22586 for CA_LOC call arg loc node. */
22589 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
22590 struct call_arg_loc_node
*ca_loc
)
22592 dw_die_ref stmt_die
= NULL
, die
;
22593 tree block
= ca_loc
->block
;
22596 && block
!= DECL_INITIAL (decl
)
22597 && TREE_CODE (block
) == BLOCK
)
22599 stmt_die
= lookup_block_die (block
);
22602 block
= BLOCK_SUPERCONTEXT (block
);
22604 if (stmt_die
== NULL
)
22605 stmt_die
= subr_die
;
22606 die
= new_die (dwarf_TAG (DW_TAG_call_site
), stmt_die
, NULL_TREE
);
22607 add_AT_lbl_id (die
, dwarf_AT (DW_AT_call_return_pc
), ca_loc
->label
);
22608 if (ca_loc
->tail_call_p
)
22609 add_AT_flag (die
, dwarf_AT (DW_AT_call_tail_call
), 1);
22610 if (ca_loc
->symbol_ref
)
22612 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
22614 add_AT_die_ref (die
, dwarf_AT (DW_AT_call_origin
), tdie
);
22616 add_AT_addr (die
, dwarf_AT (DW_AT_call_origin
), ca_loc
->symbol_ref
,
22622 /* Generate a DIE to represent a declared function (either file-scope or
22626 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
22628 tree origin
= decl_ultimate_origin (decl
);
22629 dw_die_ref subr_die
;
22630 dw_die_ref old_die
= lookup_decl_die (decl
);
22632 /* This function gets called multiple times for different stages of
22633 the debug process. For example, for func() in this code:
22637 void func() { ... }
22640 ...we get called 4 times. Twice in early debug and twice in
22646 1. Once while generating func() within the namespace. This is
22647 the declaration. The declaration bit below is set, as the
22648 context is the namespace.
22650 A new DIE will be generated with DW_AT_declaration set.
22652 2. Once for func() itself. This is the specification. The
22653 declaration bit below is clear as the context is the CU.
22655 We will use the cached DIE from (1) to create a new DIE with
22656 DW_AT_specification pointing to the declaration in (1).
22658 Late debug via rest_of_handle_final()
22659 -------------------------------------
22661 3. Once generating func() within the namespace. This is also the
22662 declaration, as in (1), but this time we will early exit below
22663 as we have a cached DIE and a declaration needs no additional
22664 annotations (no locations), as the source declaration line
22667 4. Once for func() itself. As in (2), this is the specification,
22668 but this time we will re-use the cached DIE, and just annotate
22669 it with the location information that should now be available.
22671 For something without namespaces, but with abstract instances, we
22672 are also called a multiple times:
22677 Base (); // constructor declaration (1)
22680 Base::Base () { } // constructor specification (2)
22685 1. Once for the Base() constructor by virtue of it being a
22686 member of the Base class. This is done via
22687 rest_of_type_compilation.
22689 This is a declaration, so a new DIE will be created with
22692 2. Once for the Base() constructor definition, but this time
22693 while generating the abstract instance of the base
22694 constructor (__base_ctor) which is being generated via early
22695 debug of reachable functions.
22697 Even though we have a cached version of the declaration (1),
22698 we will create a DW_AT_specification of the declaration DIE
22701 3. Once for the __base_ctor itself, but this time, we generate
22702 an DW_AT_abstract_origin version of the DW_AT_specification in
22705 Late debug via rest_of_handle_final
22706 -----------------------------------
22708 4. One final time for the __base_ctor (which will have a cached
22709 DIE with DW_AT_abstract_origin created in (3). This time,
22710 we will just annotate the location information now
22713 int declaration
= (current_function_decl
!= decl
22714 || class_or_namespace_scope_p (context_die
));
22716 /* A declaration that has been previously dumped needs no
22717 additional information. */
22718 if (old_die
&& declaration
)
22721 /* Now that the C++ front end lazily declares artificial member fns, we
22722 might need to retrofit the declaration into its class. */
22723 if (!declaration
&& !origin
&& !old_die
22724 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
22725 && !class_or_namespace_scope_p (context_die
)
22726 && debug_info_level
> DINFO_LEVEL_TERSE
)
22727 old_die
= force_decl_die (decl
);
22729 /* A concrete instance, tag a new DIE with DW_AT_abstract_origin. */
22730 if (origin
!= NULL
)
22732 gcc_assert (!declaration
|| local_scope_p (context_die
));
22734 /* Fixup die_parent for the abstract instance of a nested
22735 inline function. */
22736 if (old_die
&& old_die
->die_parent
== NULL
)
22737 add_child_die (context_die
, old_die
);
22739 if (old_die
&& get_AT_ref (old_die
, DW_AT_abstract_origin
))
22741 /* If we have a DW_AT_abstract_origin we have a working
22743 subr_die
= old_die
;
22747 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22748 add_abstract_origin_attribute (subr_die
, origin
);
22749 /* This is where the actual code for a cloned function is.
22750 Let's emit linkage name attribute for it. This helps
22751 debuggers to e.g, set breakpoints into
22752 constructors/destructors when the user asks "break
22754 add_linkage_name (subr_die
, decl
);
22757 /* A cached copy, possibly from early dwarf generation. Reuse as
22758 much as possible. */
22761 if (!get_AT_flag (old_die
, DW_AT_declaration
)
22762 /* We can have a normal definition following an inline one in the
22763 case of redefinition of GNU C extern inlines.
22764 It seems reasonable to use AT_specification in this case. */
22765 && !get_AT (old_die
, DW_AT_inline
))
22767 /* Detect and ignore this case, where we are trying to output
22768 something we have already output. */
22769 if (get_AT (old_die
, DW_AT_low_pc
)
22770 || get_AT (old_die
, DW_AT_ranges
))
22773 /* If we have no location information, this must be a
22774 partially generated DIE from early dwarf generation.
22775 Fall through and generate it. */
22778 /* If the definition comes from the same place as the declaration,
22779 maybe use the old DIE. We always want the DIE for this function
22780 that has the *_pc attributes to be under comp_unit_die so the
22781 debugger can find it. We also need to do this for abstract
22782 instances of inlines, since the spec requires the out-of-line copy
22783 to have the same parent. For local class methods, this doesn't
22784 apply; we just use the old DIE. */
22785 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
22786 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
22787 if (((is_unit_die (old_die
->die_parent
)
22788 /* This condition fixes the inconsistency/ICE with the
22789 following Fortran test (or some derivative thereof) while
22790 building libgfortran:
22794 logical function funky (FLAG)
22799 || (old_die
->die_parent
22800 && old_die
->die_parent
->die_tag
== DW_TAG_module
)
22801 || local_scope_p (old_die
->die_parent
)
22802 || context_die
== NULL
)
22803 && (DECL_ARTIFICIAL (decl
)
22804 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
22805 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
22806 == (unsigned) s
.line
)
22807 && (!debug_column_info
22809 || (get_AT_unsigned (old_die
, DW_AT_decl_column
)
22810 == (unsigned) s
.column
)))))
22811 /* With LTO if there's an abstract instance for
22812 the old DIE, this is a concrete instance and
22813 thus re-use the DIE. */
22814 || get_AT (old_die
, DW_AT_abstract_origin
))
22816 subr_die
= old_die
;
22818 /* Clear out the declaration attribute, but leave the
22819 parameters so they can be augmented with location
22820 information later. Unless this was a declaration, in
22821 which case, wipe out the nameless parameters and recreate
22822 them further down. */
22823 if (remove_AT (subr_die
, DW_AT_declaration
))
22826 remove_AT (subr_die
, DW_AT_object_pointer
);
22827 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
22830 /* Make a specification pointing to the previously built
22834 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22835 add_AT_specification (subr_die
, old_die
);
22836 add_pubname (decl
, subr_die
);
22837 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
22838 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
22839 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
22840 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
22841 if (debug_column_info
22843 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
22844 != (unsigned) s
.column
))
22845 add_AT_unsigned (subr_die
, DW_AT_decl_column
, s
.column
);
22847 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
22848 emit the real type on the definition die. */
22849 if (is_cxx () && debug_info_level
> DINFO_LEVEL_TERSE
)
22851 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
22852 if (die
== auto_die
|| die
== decltype_auto_die
)
22853 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
22854 TYPE_UNQUALIFIED
, false, context_die
);
22857 /* When we process the method declaration, we haven't seen
22858 the out-of-class defaulted definition yet, so we have to
22860 if ((dwarf_version
>= 5 || ! dwarf_strict
)
22861 && !get_AT (subr_die
, DW_AT_defaulted
))
22864 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22866 if (defaulted
!= -1)
22868 /* Other values must have been handled before. */
22869 gcc_assert (defaulted
== DW_DEFAULTED_out_of_class
);
22870 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
22875 /* Create a fresh DIE for anything else. */
22878 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22880 if (TREE_PUBLIC (decl
))
22881 add_AT_flag (subr_die
, DW_AT_external
, 1);
22883 add_name_and_src_coords_attributes (subr_die
, decl
);
22884 add_pubname (decl
, subr_die
);
22885 if (debug_info_level
> DINFO_LEVEL_TERSE
)
22887 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
22888 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
22889 TYPE_UNQUALIFIED
, false, context_die
);
22892 add_pure_or_virtual_attribute (subr_die
, decl
);
22893 if (DECL_ARTIFICIAL (decl
))
22894 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
22896 if (TREE_THIS_VOLATILE (decl
) && (dwarf_version
>= 5 || !dwarf_strict
))
22897 add_AT_flag (subr_die
, DW_AT_noreturn
, 1);
22899 add_alignment_attribute (subr_die
, decl
);
22901 add_accessibility_attribute (subr_die
, decl
);
22904 /* Unless we have an existing non-declaration DIE, equate the new
22906 if (!old_die
|| is_declaration_die (old_die
))
22907 equate_decl_number_to_die (decl
, subr_die
);
22911 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
22913 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
22915 /* If this is an explicit function declaration then generate
22916 a DW_AT_explicit attribute. */
22917 if ((dwarf_version
>= 3 || !dwarf_strict
)
22918 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22919 DW_AT_explicit
) == 1)
22920 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
22922 /* If this is a C++11 deleted special function member then generate
22923 a DW_AT_deleted attribute. */
22924 if ((dwarf_version
>= 5 || !dwarf_strict
)
22925 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22926 DW_AT_deleted
) == 1)
22927 add_AT_flag (subr_die
, DW_AT_deleted
, 1);
22929 /* If this is a C++11 defaulted special function member then
22930 generate a DW_AT_defaulted attribute. */
22931 if (dwarf_version
>= 5 || !dwarf_strict
)
22934 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22936 if (defaulted
!= -1)
22937 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
22940 /* If this is a C++11 non-static member function with & ref-qualifier
22941 then generate a DW_AT_reference attribute. */
22942 if ((dwarf_version
>= 5 || !dwarf_strict
)
22943 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22944 DW_AT_reference
) == 1)
22945 add_AT_flag (subr_die
, DW_AT_reference
, 1);
22947 /* If this is a C++11 non-static member function with &&
22948 ref-qualifier then generate a DW_AT_reference attribute. */
22949 if ((dwarf_version
>= 5 || !dwarf_strict
)
22950 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22951 DW_AT_rvalue_reference
)
22953 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
22956 /* For non DECL_EXTERNALs, if range information is available, fill
22957 the DIE with it. */
22958 else if (!DECL_EXTERNAL (decl
) && !early_dwarf
)
22960 HOST_WIDE_INT cfa_fb_offset
;
22962 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
22964 if (!crtl
->has_bb_partition
)
22966 dw_fde_ref fde
= fun
->fde
;
22967 if (fde
->dw_fde_begin
)
22969 /* We have already generated the labels. */
22970 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
22971 fde
->dw_fde_end
, false);
22975 /* Create start/end labels and add the range. */
22976 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
22977 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
22978 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
22979 current_function_funcdef_no
);
22980 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
22981 current_function_funcdef_no
);
22982 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
22986 #if VMS_DEBUGGING_INFO
22987 /* HP OpenVMS Industry Standard 64: DWARF Extensions
22988 Section 2.3 Prologue and Epilogue Attributes:
22989 When a breakpoint is set on entry to a function, it is generally
22990 desirable for execution to be suspended, not on the very first
22991 instruction of the function, but rather at a point after the
22992 function's frame has been set up, after any language defined local
22993 declaration processing has been completed, and before execution of
22994 the first statement of the function begins. Debuggers generally
22995 cannot properly determine where this point is. Similarly for a
22996 breakpoint set on exit from a function. The prologue and epilogue
22997 attributes allow a compiler to communicate the location(s) to use. */
23000 if (fde
->dw_fde_vms_end_prologue
)
23001 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
23002 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
23004 if (fde
->dw_fde_vms_begin_epilogue
)
23005 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
23006 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
23013 /* Generate pubnames entries for the split function code ranges. */
23014 dw_fde_ref fde
= fun
->fde
;
23016 if (fde
->dw_fde_second_begin
)
23018 if (dwarf_version
>= 3 || !dwarf_strict
)
23020 /* We should use ranges for non-contiguous code section
23021 addresses. Use the actual code range for the initial
23022 section, since the HOT/COLD labels might precede an
23023 alignment offset. */
23024 bool range_list_added
= false;
23025 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
23026 fde
->dw_fde_end
, &range_list_added
,
23028 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
23029 fde
->dw_fde_second_end
,
23030 &range_list_added
, false);
23031 if (range_list_added
)
23036 /* There is no real support in DW2 for this .. so we make
23037 a work-around. First, emit the pub name for the segment
23038 containing the function label. Then make and emit a
23039 simplified subprogram DIE for the second segment with the
23040 name pre-fixed by __hot/cold_sect_of_. We use the same
23041 linkage name for the second die so that gdb will find both
23042 sections when given "b foo". */
23043 const char *name
= NULL
;
23044 tree decl_name
= DECL_NAME (decl
);
23045 dw_die_ref seg_die
;
23047 /* Do the 'primary' section. */
23048 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
23049 fde
->dw_fde_end
, false);
23051 /* Build a minimal DIE for the secondary section. */
23052 seg_die
= new_die (DW_TAG_subprogram
,
23053 subr_die
->die_parent
, decl
);
23055 if (TREE_PUBLIC (decl
))
23056 add_AT_flag (seg_die
, DW_AT_external
, 1);
23058 if (decl_name
!= NULL
23059 && IDENTIFIER_POINTER (decl_name
) != NULL
)
23061 name
= dwarf2_name (decl
, 1);
23062 if (! DECL_ARTIFICIAL (decl
))
23063 add_src_coords_attributes (seg_die
, decl
);
23065 add_linkage_name (seg_die
, decl
);
23067 gcc_assert (name
!= NULL
);
23068 add_pure_or_virtual_attribute (seg_die
, decl
);
23069 if (DECL_ARTIFICIAL (decl
))
23070 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
23072 name
= concat ("__second_sect_of_", name
, NULL
);
23073 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
23074 fde
->dw_fde_second_end
, false);
23075 add_name_attribute (seg_die
, name
);
23076 if (want_pubnames ())
23077 add_pubname_string (name
, seg_die
);
23081 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
23085 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
23087 /* We define the "frame base" as the function's CFA. This is more
23088 convenient for several reasons: (1) It's stable across the prologue
23089 and epilogue, which makes it better than just a frame pointer,
23090 (2) With dwarf3, there exists a one-byte encoding that allows us
23091 to reference the .debug_frame data by proxy, but failing that,
23092 (3) We can at least reuse the code inspection and interpretation
23093 code that determines the CFA position at various points in the
23095 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
23097 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
23098 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
23102 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
23103 if (list
->dw_loc_next
)
23104 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
23106 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
23109 /* Compute a displacement from the "steady-state frame pointer" to
23110 the CFA. The former is what all stack slots and argument slots
23111 will reference in the rtl; the latter is what we've told the
23112 debugger about. We'll need to adjust all frame_base references
23113 by this displacement. */
23114 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
23116 if (fun
->static_chain_decl
)
23118 /* DWARF requires here a location expression that computes the
23119 address of the enclosing subprogram's frame base. The machinery
23120 in tree-nested.c is supposed to store this specific address in the
23121 last field of the FRAME record. */
23122 const tree frame_type
23123 = TREE_TYPE (TREE_TYPE (fun
->static_chain_decl
));
23124 const tree fb_decl
= tree_last (TYPE_FIELDS (frame_type
));
23127 = build1 (INDIRECT_REF
, frame_type
, fun
->static_chain_decl
);
23128 fb_expr
= build3 (COMPONENT_REF
, TREE_TYPE (fb_decl
),
23129 fb_expr
, fb_decl
, NULL_TREE
);
23131 add_AT_location_description (subr_die
, DW_AT_static_link
,
23132 loc_list_from_tree (fb_expr
, 0, NULL
));
23135 resolve_variable_values ();
23138 /* Generate child dies for template paramaters. */
23139 if (early_dwarf
&& debug_info_level
> DINFO_LEVEL_TERSE
)
23140 gen_generic_params_dies (decl
);
23142 /* Now output descriptions of the arguments for this function. This gets
23143 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
23144 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
23145 `...' at the end of the formal parameter list. In order to find out if
23146 there was a trailing ellipsis or not, we must instead look at the type
23147 associated with the FUNCTION_DECL. This will be a node of type
23148 FUNCTION_TYPE. If the chain of type nodes hanging off of this
23149 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
23150 an ellipsis at the end. */
23152 /* In the case where we are describing a mere function declaration, all we
23153 need to do here (and all we *can* do here) is to describe the *types* of
23154 its formal parameters. */
23155 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
23157 else if (declaration
)
23158 gen_formal_types_die (decl
, subr_die
);
23161 /* Generate DIEs to represent all known formal parameters. */
23162 tree parm
= DECL_ARGUMENTS (decl
);
23163 tree generic_decl
= early_dwarf
23164 ? lang_hooks
.decls
.get_generic_function_decl (decl
) : NULL
;
23165 tree generic_decl_parm
= generic_decl
23166 ? DECL_ARGUMENTS (generic_decl
)
23169 /* Now we want to walk the list of parameters of the function and
23170 emit their relevant DIEs.
23172 We consider the case of DECL being an instance of a generic function
23173 as well as it being a normal function.
23175 If DECL is an instance of a generic function we walk the
23176 parameters of the generic function declaration _and_ the parameters of
23177 DECL itself. This is useful because we want to emit specific DIEs for
23178 function parameter packs and those are declared as part of the
23179 generic function declaration. In that particular case,
23180 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
23181 That DIE has children DIEs representing the set of arguments
23182 of the pack. Note that the set of pack arguments can be empty.
23183 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
23186 Otherwise, we just consider the parameters of DECL. */
23187 while (generic_decl_parm
|| parm
)
23189 if (generic_decl_parm
23190 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
23191 gen_formal_parameter_pack_die (generic_decl_parm
,
23196 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, NULL
, subr_die
);
23199 && parm
== DECL_ARGUMENTS (decl
)
23200 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
23202 && (dwarf_version
>= 3 || !dwarf_strict
))
23203 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
23205 parm
= DECL_CHAIN (parm
);
23208 parm
= DECL_CHAIN (parm
);
23210 if (generic_decl_parm
)
23211 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
23214 /* Decide whether we need an unspecified_parameters DIE at the end.
23215 There are 2 more cases to do this for: 1) the ansi ... declaration -
23216 this is detectable when the end of the arg list is not a
23217 void_type_node 2) an unprototyped function declaration (not a
23218 definition). This just means that we have no info about the
23219 parameters at all. */
23222 if (prototype_p (TREE_TYPE (decl
)))
23224 /* This is the prototyped case, check for.... */
23225 if (stdarg_p (TREE_TYPE (decl
)))
23226 gen_unspecified_parameters_die (decl
, subr_die
);
23228 else if (DECL_INITIAL (decl
) == NULL_TREE
)
23229 gen_unspecified_parameters_die (decl
, subr_die
);
23233 if (subr_die
!= old_die
)
23234 /* Add the calling convention attribute if requested. */
23235 add_calling_convention_attribute (subr_die
, decl
);
23237 /* Output Dwarf info for all of the stuff within the body of the function
23238 (if it has one - it may be just a declaration).
23240 OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
23241 a function. This BLOCK actually represents the outermost binding contour
23242 for the function, i.e. the contour in which the function's formal
23243 parameters and labels get declared. Curiously, it appears that the front
23244 end doesn't actually put the PARM_DECL nodes for the current function onto
23245 the BLOCK_VARS list for this outer scope, but are strung off of the
23246 DECL_ARGUMENTS list for the function instead.
23248 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
23249 the LABEL_DECL nodes for the function however, and we output DWARF info
23250 for those in decls_for_scope. Just within the `outer_scope' there will be
23251 a BLOCK node representing the function's outermost pair of curly braces,
23252 and any blocks used for the base and member initializers of a C++
23253 constructor function. */
23254 tree outer_scope
= DECL_INITIAL (decl
);
23255 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
23257 int call_site_note_count
= 0;
23258 int tail_call_site_note_count
= 0;
23260 /* Emit a DW_TAG_variable DIE for a named return value. */
23261 if (DECL_NAME (DECL_RESULT (decl
)))
23262 gen_decl_die (DECL_RESULT (decl
), NULL
, NULL
, subr_die
);
23264 /* The first time through decls_for_scope we will generate the
23265 DIEs for the locals. The second time, we fill in the
23267 decls_for_scope (outer_scope
, subr_die
);
23269 if (call_arg_locations
&& (!dwarf_strict
|| dwarf_version
>= 5))
23271 struct call_arg_loc_node
*ca_loc
;
23272 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
23274 dw_die_ref die
= NULL
;
23275 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
23277 tree arg_decl
= NULL_TREE
;
23279 for (arg
= (ca_loc
->call_arg_loc_note
!= NULL_RTX
23280 ? XEXP (ca_loc
->call_arg_loc_note
, 0)
23282 arg
; arg
= next_arg
)
23284 dw_loc_descr_ref reg
, val
;
23285 machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
23286 dw_die_ref cdie
, tdie
= NULL
;
23288 next_arg
= XEXP (arg
, 1);
23289 if (REG_P (XEXP (XEXP (arg
, 0), 0))
23291 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
23292 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
23293 && REGNO (XEXP (XEXP (arg
, 0), 0))
23294 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
23295 next_arg
= XEXP (next_arg
, 1);
23296 if (mode
== VOIDmode
)
23298 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
23299 if (mode
== VOIDmode
)
23300 mode
= GET_MODE (XEXP (arg
, 0));
23302 if (mode
== VOIDmode
|| mode
== BLKmode
)
23304 /* Get dynamic information about call target only if we
23305 have no static information: we cannot generate both
23306 DW_AT_call_origin and DW_AT_call_target
23308 if (ca_loc
->symbol_ref
== NULL_RTX
)
23310 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
23312 tloc
= XEXP (XEXP (arg
, 0), 1);
23315 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
23316 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
23318 tlocc
= XEXP (XEXP (arg
, 0), 1);
23323 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
23324 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
23325 VAR_INIT_STATUS_INITIALIZED
);
23326 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
23328 rtx mem
= XEXP (XEXP (arg
, 0), 0);
23329 reg
= mem_loc_descriptor (XEXP (mem
, 0),
23330 get_address_mode (mem
),
23332 VAR_INIT_STATUS_INITIALIZED
);
23334 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
23335 == DEBUG_PARAMETER_REF
)
23338 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
23339 tdie
= lookup_decl_die (tdecl
);
23347 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
23348 != DEBUG_PARAMETER_REF
)
23350 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
23352 VAR_INIT_STATUS_INITIALIZED
);
23356 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
23357 cdie
= new_die (dwarf_TAG (DW_TAG_call_site_parameter
), die
,
23359 add_desc_attribute (cdie
, arg_decl
);
23361 add_AT_loc (cdie
, DW_AT_location
, reg
);
23362 else if (tdie
!= NULL
)
23363 add_AT_die_ref (cdie
, dwarf_AT (DW_AT_call_parameter
),
23365 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_value
), val
);
23366 if (next_arg
!= XEXP (arg
, 1))
23368 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
23369 if (mode
== VOIDmode
)
23370 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
23371 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
23374 VAR_INIT_STATUS_INITIALIZED
);
23376 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_data_value
),
23381 && (ca_loc
->symbol_ref
|| tloc
))
23382 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
23383 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
23385 dw_loc_descr_ref tval
= NULL
;
23387 if (tloc
!= NULL_RTX
)
23388 tval
= mem_loc_descriptor (tloc
,
23389 GET_MODE (tloc
) == VOIDmode
23390 ? Pmode
: GET_MODE (tloc
),
23392 VAR_INIT_STATUS_INITIALIZED
);
23394 add_AT_loc (die
, dwarf_AT (DW_AT_call_target
), tval
);
23395 else if (tlocc
!= NULL_RTX
)
23397 tval
= mem_loc_descriptor (tlocc
,
23398 GET_MODE (tlocc
) == VOIDmode
23399 ? Pmode
: GET_MODE (tlocc
),
23401 VAR_INIT_STATUS_INITIALIZED
);
23404 dwarf_AT (DW_AT_call_target_clobbered
),
23410 call_site_note_count
++;
23411 if (ca_loc
->tail_call_p
)
23412 tail_call_site_note_count
++;
23416 call_arg_locations
= NULL
;
23417 call_arg_loc_last
= NULL
;
23418 if (tail_call_site_count
>= 0
23419 && tail_call_site_count
== tail_call_site_note_count
23420 && (!dwarf_strict
|| dwarf_version
>= 5))
23422 if (call_site_count
>= 0
23423 && call_site_count
== call_site_note_count
)
23424 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_calls
), 1);
23426 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_tail_calls
), 1);
23428 call_site_count
= -1;
23429 tail_call_site_count
= -1;
23432 /* Mark used types after we have created DIEs for the functions scopes. */
23433 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
23436 /* Returns a hash value for X (which really is a die_struct). */
23439 block_die_hasher::hash (die_struct
*d
)
23441 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
23444 /* Return nonzero if decl_id and die_parent of die_struct X is the same
23445 as decl_id and die_parent of die_struct Y. */
23448 block_die_hasher::equal (die_struct
*x
, die_struct
*y
)
23450 return x
->decl_id
== y
->decl_id
&& x
->die_parent
== y
->die_parent
;
23453 /* Hold information about markers for inlined entry points. */
23454 struct GTY ((for_user
)) inline_entry_data
23456 /* The block that's the inlined_function_outer_scope for an inlined
23460 /* The label at the inlined entry point. */
23461 const char *label_pfx
;
23462 unsigned int label_num
;
23464 /* The view number to be used as the inlined entry point. */
23468 struct inline_entry_data_hasher
: ggc_ptr_hash
<inline_entry_data
>
23470 typedef tree compare_type
;
23471 static inline hashval_t
hash (const inline_entry_data
*);
23472 static inline bool equal (const inline_entry_data
*, const_tree
);
23475 /* Hash table routines for inline_entry_data. */
23478 inline_entry_data_hasher::hash (const inline_entry_data
*data
)
23480 return htab_hash_pointer (data
->block
);
23484 inline_entry_data_hasher::equal (const inline_entry_data
*data
,
23487 return data
->block
== block
;
23490 /* Inlined entry points pending DIE creation in this compilation unit. */
23492 static GTY(()) hash_table
<inline_entry_data_hasher
> *inline_entry_data_table
;
23495 /* Return TRUE if DECL, which may have been previously generated as
23496 OLD_DIE, is a candidate for a DW_AT_specification. DECLARATION is
23497 true if decl (or its origin) is either an extern declaration or a
23498 class/namespace scoped declaration.
23500 The declare_in_namespace support causes us to get two DIEs for one
23501 variable, both of which are declarations. We want to avoid
23502 considering one to be a specification, so we must test for
23503 DECLARATION and DW_AT_declaration. */
23505 decl_will_get_specification_p (dw_die_ref old_die
, tree decl
, bool declaration
)
23507 return (old_die
&& TREE_STATIC (decl
) && !declaration
23508 && get_AT_flag (old_die
, DW_AT_declaration
) == 1);
23511 /* Return true if DECL is a local static. */
23514 local_function_static (tree decl
)
23516 gcc_assert (VAR_P (decl
));
23517 return TREE_STATIC (decl
)
23518 && DECL_CONTEXT (decl
)
23519 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
;
23522 /* Generate a DIE to represent a declared data object.
23523 Either DECL or ORIGIN must be non-null. */
23526 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
23528 HOST_WIDE_INT off
= 0;
23530 tree decl_or_origin
= decl
? decl
: origin
;
23531 tree ultimate_origin
;
23532 dw_die_ref var_die
;
23533 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
23534 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
23535 || class_or_namespace_scope_p (context_die
));
23536 bool specialization_p
= false;
23537 bool no_linkage_name
= false;
23539 /* While C++ inline static data members have definitions inside of the
23540 class, force the first DIE to be a declaration, then let gen_member_die
23541 reparent it to the class context and call gen_variable_die again
23542 to create the outside of the class DIE for the definition. */
23546 && DECL_CONTEXT (decl
)
23547 && TYPE_P (DECL_CONTEXT (decl
))
23548 && lang_hooks
.decls
.decl_dwarf_attribute (decl
, DW_AT_inline
) != -1)
23550 declaration
= true;
23551 if (dwarf_version
< 5)
23552 no_linkage_name
= true;
23555 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
23556 if (decl
|| ultimate_origin
)
23557 origin
= ultimate_origin
;
23558 com_decl
= fortran_common (decl_or_origin
, &off
);
23560 /* Symbol in common gets emitted as a child of the common block, in the form
23561 of a data member. */
23564 dw_die_ref com_die
;
23565 dw_loc_list_ref loc
= NULL
;
23566 die_node com_die_arg
;
23568 var_die
= lookup_decl_die (decl_or_origin
);
23571 if (! early_dwarf
&& get_AT (var_die
, DW_AT_location
) == NULL
)
23573 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2, NULL
);
23578 /* Optimize the common case. */
23579 if (single_element_loc_list_p (loc
)
23580 && loc
->expr
->dw_loc_opc
== DW_OP_addr
23581 && loc
->expr
->dw_loc_next
== NULL
23582 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
23585 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
23586 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
23587 = plus_constant (GET_MODE (x
), x
, off
);
23590 loc_list_plus_const (loc
, off
);
23592 add_AT_location_description (var_die
, DW_AT_location
, loc
);
23593 remove_AT (var_die
, DW_AT_declaration
);
23599 if (common_block_die_table
== NULL
)
23600 common_block_die_table
= hash_table
<block_die_hasher
>::create_ggc (10);
23602 com_die_arg
.decl_id
= DECL_UID (com_decl
);
23603 com_die_arg
.die_parent
= context_die
;
23604 com_die
= common_block_die_table
->find (&com_die_arg
);
23606 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
23607 if (com_die
== NULL
)
23610 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
23613 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
23614 add_name_and_src_coords_attributes (com_die
, com_decl
);
23617 add_AT_location_description (com_die
, DW_AT_location
, loc
);
23618 /* Avoid sharing the same loc descriptor between
23619 DW_TAG_common_block and DW_TAG_variable. */
23620 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
23622 else if (DECL_EXTERNAL (decl_or_origin
))
23623 add_AT_flag (com_die
, DW_AT_declaration
, 1);
23624 if (want_pubnames ())
23625 add_pubname_string (cnam
, com_die
); /* ??? needed? */
23626 com_die
->decl_id
= DECL_UID (com_decl
);
23627 slot
= common_block_die_table
->find_slot (com_die
, INSERT
);
23630 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
23632 add_AT_location_description (com_die
, DW_AT_location
, loc
);
23633 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
23634 remove_AT (com_die
, DW_AT_declaration
);
23636 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
23637 add_name_and_src_coords_attributes (var_die
, decl_or_origin
);
23638 add_type_attribute (var_die
, TREE_TYPE (decl_or_origin
),
23639 decl_quals (decl_or_origin
), false,
23641 add_alignment_attribute (var_die
, decl
);
23642 add_AT_flag (var_die
, DW_AT_external
, 1);
23647 /* Optimize the common case. */
23648 if (single_element_loc_list_p (loc
)
23649 && loc
->expr
->dw_loc_opc
== DW_OP_addr
23650 && loc
->expr
->dw_loc_next
== NULL
23651 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
23653 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
23654 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
23655 = plus_constant (GET_MODE (x
), x
, off
);
23658 loc_list_plus_const (loc
, off
);
23660 add_AT_location_description (var_die
, DW_AT_location
, loc
);
23662 else if (DECL_EXTERNAL (decl_or_origin
))
23663 add_AT_flag (var_die
, DW_AT_declaration
, 1);
23665 equate_decl_number_to_die (decl
, var_die
);
23673 /* A declaration that has been previously dumped, needs no
23674 further annotations, since it doesn't need location on
23675 the second pass. */
23678 else if (decl_will_get_specification_p (old_die
, decl
, declaration
)
23679 && !get_AT (old_die
, DW_AT_specification
))
23681 /* Fall-thru so we can make a new variable die along with a
23682 DW_AT_specification. */
23684 else if (origin
&& old_die
->die_parent
!= context_die
)
23686 /* If we will be creating an inlined instance, we need a
23687 new DIE that will get annotated with
23688 DW_AT_abstract_origin. */
23689 gcc_assert (!DECL_ABSTRACT_P (decl
));
23693 /* If a DIE was dumped early, it still needs location info.
23694 Skip to where we fill the location bits. */
23697 /* ??? In LTRANS we cannot annotate early created variably
23698 modified type DIEs without copying them and adjusting all
23699 references to them. Thus we dumped them again. Also add a
23700 reference to them but beware of -g0 compile and -g link
23701 in which case the reference will be already present. */
23702 tree type
= TREE_TYPE (decl_or_origin
);
23704 && ! get_AT (var_die
, DW_AT_type
)
23705 && variably_modified_type_p
23706 (type
, decl_function_context (decl_or_origin
)))
23708 if (decl_by_reference_p (decl_or_origin
))
23709 add_type_attribute (var_die
, TREE_TYPE (type
),
23710 TYPE_UNQUALIFIED
, false, context_die
);
23712 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
),
23713 false, context_die
);
23716 goto gen_variable_die_location
;
23720 /* For static data members, the declaration in the class is supposed
23721 to have DW_TAG_member tag in DWARF{3,4} and we emit it for compatibility
23722 also in DWARF2; the specification should still be DW_TAG_variable
23723 referencing the DW_TAG_member DIE. */
23724 if (declaration
&& class_scope_p (context_die
) && dwarf_version
< 5)
23725 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
23727 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
23729 if (origin
!= NULL
)
23730 add_abstract_origin_attribute (var_die
, origin
);
23732 /* Loop unrolling can create multiple blocks that refer to the same
23733 static variable, so we must test for the DW_AT_declaration flag.
23735 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
23736 copy decls and set the DECL_ABSTRACT_P flag on them instead of
23739 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
23740 else if (decl_will_get_specification_p (old_die
, decl
, declaration
))
23742 /* This is a definition of a C++ class level static. */
23743 add_AT_specification (var_die
, old_die
);
23744 specialization_p
= true;
23745 if (DECL_NAME (decl
))
23747 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
23748 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
23750 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
23751 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
23753 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
23754 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
23756 if (debug_column_info
23758 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
23759 != (unsigned) s
.column
))
23760 add_AT_unsigned (var_die
, DW_AT_decl_column
, s
.column
);
23762 if (old_die
->die_tag
== DW_TAG_member
)
23763 add_linkage_name (var_die
, decl
);
23767 add_name_and_src_coords_attributes (var_die
, decl
, no_linkage_name
);
23769 if ((origin
== NULL
&& !specialization_p
)
23771 && !DECL_ABSTRACT_P (decl_or_origin
)
23772 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
23773 decl_function_context
23774 (decl_or_origin
))))
23776 tree type
= TREE_TYPE (decl_or_origin
);
23778 if (decl_by_reference_p (decl_or_origin
))
23779 add_type_attribute (var_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
23782 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
), false,
23786 if (origin
== NULL
&& !specialization_p
)
23788 if (TREE_PUBLIC (decl
))
23789 add_AT_flag (var_die
, DW_AT_external
, 1);
23791 if (DECL_ARTIFICIAL (decl
))
23792 add_AT_flag (var_die
, DW_AT_artificial
, 1);
23794 add_alignment_attribute (var_die
, decl
);
23796 add_accessibility_attribute (var_die
, decl
);
23800 add_AT_flag (var_die
, DW_AT_declaration
, 1);
23802 if (decl
&& (DECL_ABSTRACT_P (decl
)
23803 || !old_die
|| is_declaration_die (old_die
)))
23804 equate_decl_number_to_die (decl
, var_die
);
23806 gen_variable_die_location
:
23808 && (! DECL_ABSTRACT_P (decl_or_origin
)
23809 /* Local static vars are shared between all clones/inlines,
23810 so emit DW_AT_location on the abstract DIE if DECL_RTL is
23812 || (VAR_P (decl_or_origin
)
23813 && TREE_STATIC (decl_or_origin
)
23814 && DECL_RTL_SET_P (decl_or_origin
))))
23817 add_pubname (decl_or_origin
, var_die
);
23819 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
23823 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
23825 if ((dwarf_version
>= 4 || !dwarf_strict
)
23826 && lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
23827 DW_AT_const_expr
) == 1
23828 && !get_AT (var_die
, DW_AT_const_expr
)
23829 && !specialization_p
)
23830 add_AT_flag (var_die
, DW_AT_const_expr
, 1);
23834 int inl
= lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
23837 && !get_AT (var_die
, DW_AT_inline
)
23838 && !specialization_p
)
23839 add_AT_unsigned (var_die
, DW_AT_inline
, inl
);
23843 /* Generate a DIE to represent a named constant. */
23846 gen_const_die (tree decl
, dw_die_ref context_die
)
23848 dw_die_ref const_die
;
23849 tree type
= TREE_TYPE (decl
);
23851 const_die
= lookup_decl_die (decl
);
23855 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
23856 equate_decl_number_to_die (decl
, const_die
);
23857 add_name_and_src_coords_attributes (const_die
, decl
);
23858 add_type_attribute (const_die
, type
, TYPE_QUAL_CONST
, false, context_die
);
23859 if (TREE_PUBLIC (decl
))
23860 add_AT_flag (const_die
, DW_AT_external
, 1);
23861 if (DECL_ARTIFICIAL (decl
))
23862 add_AT_flag (const_die
, DW_AT_artificial
, 1);
23863 tree_add_const_value_attribute_for_decl (const_die
, decl
);
23866 /* Generate a DIE to represent a label identifier. */
23869 gen_label_die (tree decl
, dw_die_ref context_die
)
23871 tree origin
= decl_ultimate_origin (decl
);
23872 dw_die_ref lbl_die
= lookup_decl_die (decl
);
23874 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
23878 lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
23879 equate_decl_number_to_die (decl
, lbl_die
);
23881 if (origin
!= NULL
)
23882 add_abstract_origin_attribute (lbl_die
, origin
);
23884 add_name_and_src_coords_attributes (lbl_die
, decl
);
23887 if (DECL_ABSTRACT_P (decl
))
23888 equate_decl_number_to_die (decl
, lbl_die
);
23889 else if (! early_dwarf
)
23891 insn
= DECL_RTL_IF_SET (decl
);
23893 /* Deleted labels are programmer specified labels which have been
23894 eliminated because of various optimizations. We still emit them
23895 here so that it is possible to put breakpoints on them. */
23899 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
23901 /* When optimization is enabled (via -O) some parts of the compiler
23902 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
23903 represent source-level labels which were explicitly declared by
23904 the user. This really shouldn't be happening though, so catch
23905 it if it ever does happen. */
23906 gcc_assert (!as_a
<rtx_insn
*> (insn
)->deleted ());
23908 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
23909 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
23913 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
23914 && CODE_LABEL_NUMBER (insn
) != -1)
23916 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
23917 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
23922 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
23923 attributes to the DIE for a block STMT, to describe where the inlined
23924 function was called from. This is similar to add_src_coords_attributes. */
23927 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
23929 /* We can end up with BUILTINS_LOCATION here. */
23930 if (RESERVED_LOCATION_P (BLOCK_SOURCE_LOCATION (stmt
)))
23933 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
23935 if (dwarf_version
>= 3 || !dwarf_strict
)
23937 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
23938 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
23939 if (debug_column_info
&& s
.column
)
23940 add_AT_unsigned (die
, DW_AT_call_column
, s
.column
);
23945 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
23946 Add low_pc and high_pc attributes to the DIE for a block STMT. */
23949 add_high_low_attributes (tree stmt
, dw_die_ref die
)
23951 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
23953 if (inline_entry_data
**iedp
23954 = !inline_entry_data_table
? NULL
23955 : inline_entry_data_table
->find_slot_with_hash (stmt
,
23956 htab_hash_pointer (stmt
),
23959 inline_entry_data
*ied
= *iedp
;
23960 gcc_assert (MAY_HAVE_DEBUG_MARKER_INSNS
);
23961 gcc_assert (debug_inline_points
);
23962 gcc_assert (inlined_function_outer_scope_p (stmt
));
23964 ASM_GENERATE_INTERNAL_LABEL (label
, ied
->label_pfx
, ied
->label_num
);
23965 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
23967 if (debug_variable_location_views
&& !ZERO_VIEW_P (ied
->view
)
23970 if (!output_asm_line_debug_info ())
23971 add_AT_unsigned (die
, DW_AT_GNU_entry_view
, ied
->view
);
23974 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", ied
->view
);
23975 /* FIXME: this will resolve to a small number. Could we
23976 possibly emit smaller data? Ideally we'd emit a
23977 uleb128, but that would make the size of DIEs
23978 impossible for the compiler to compute, since it's
23979 the assembler that computes the value of the view
23980 label in this case. Ideally, we'd have a single form
23981 encompassing both the address and the view, and
23982 indirecting them through a table might make things
23983 easier, but even that would be more wasteful,
23984 space-wise, than what we have now. */
23985 add_AT_symview (die
, DW_AT_GNU_entry_view
, label
);
23989 inline_entry_data_table
->clear_slot (iedp
);
23992 if (BLOCK_FRAGMENT_CHAIN (stmt
)
23993 && (dwarf_version
>= 3 || !dwarf_strict
))
23995 tree chain
, superblock
= NULL_TREE
;
23997 dw_attr_node
*attr
= NULL
;
23999 if (!debug_inline_points
&& inlined_function_outer_scope_p (stmt
))
24001 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
24002 BLOCK_NUMBER (stmt
));
24003 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
24006 /* Optimize duplicate .debug_ranges lists or even tails of
24007 lists. If this BLOCK has same ranges as its supercontext,
24008 lookup DW_AT_ranges attribute in the supercontext (and
24009 recursively so), verify that the ranges_table contains the
24010 right values and use it instead of adding a new .debug_range. */
24011 for (chain
= stmt
, pdie
= die
;
24012 BLOCK_SAME_RANGE (chain
);
24013 chain
= BLOCK_SUPERCONTEXT (chain
))
24015 dw_attr_node
*new_attr
;
24017 pdie
= pdie
->die_parent
;
24020 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
24022 new_attr
= get_AT (pdie
, DW_AT_ranges
);
24023 if (new_attr
== NULL
24024 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
24027 superblock
= BLOCK_SUPERCONTEXT (chain
);
24030 && ((*ranges_table
)[attr
->dw_attr_val
.v
.val_offset
].num
24031 == (int)BLOCK_NUMBER (superblock
))
24032 && BLOCK_FRAGMENT_CHAIN (superblock
))
24034 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
;
24035 unsigned long supercnt
= 0, thiscnt
= 0;
24036 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
24037 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
24040 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
].num
24041 == (int)BLOCK_NUMBER (chain
));
24043 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
+ 1].num
== 0);
24044 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
24045 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
24047 gcc_assert (supercnt
>= thiscnt
);
24048 add_AT_range_list (die
, DW_AT_ranges
, off
+ supercnt
- thiscnt
,
24050 note_rnglist_head (off
+ supercnt
- thiscnt
);
24054 unsigned int offset
= add_ranges (stmt
, true);
24055 add_AT_range_list (die
, DW_AT_ranges
, offset
, false);
24056 note_rnglist_head (offset
);
24058 bool prev_in_cold
= BLOCK_IN_COLD_SECTION_P (stmt
);
24059 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
24062 add_ranges (chain
, prev_in_cold
!= BLOCK_IN_COLD_SECTION_P (chain
));
24063 prev_in_cold
= BLOCK_IN_COLD_SECTION_P (chain
);
24064 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
24071 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
24072 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
24073 BLOCK_NUMBER (stmt
));
24074 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
24075 BLOCK_NUMBER (stmt
));
24076 add_AT_low_high_pc (die
, label
, label_high
, false);
24080 /* Generate a DIE for a lexical block. */
24083 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
)
24085 dw_die_ref old_die
= lookup_block_die (stmt
);
24086 dw_die_ref stmt_die
= NULL
;
24089 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
24090 equate_block_to_die (stmt
, stmt_die
);
24093 if (BLOCK_ABSTRACT_ORIGIN (stmt
))
24095 /* If this is an inlined or conrecte instance, create a new lexical
24096 die for anything below to attach DW_AT_abstract_origin to. */
24098 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
24100 tree origin
= block_ultimate_origin (stmt
);
24101 if (origin
!= NULL_TREE
&& (origin
!= stmt
|| old_die
))
24102 add_abstract_origin_attribute (stmt_die
, origin
);
24108 stmt_die
= old_die
;
24110 /* A non abstract block whose blocks have already been reordered
24111 should have the instruction range for this block. If so, set the
24112 high/low attributes. */
24113 if (!early_dwarf
&& TREE_ASM_WRITTEN (stmt
))
24115 gcc_assert (stmt_die
);
24116 add_high_low_attributes (stmt
, stmt_die
);
24119 decls_for_scope (stmt
, stmt_die
);
24122 /* Generate a DIE for an inlined subprogram. */
24125 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
)
24127 tree decl
= block_ultimate_origin (stmt
);
24129 /* Make sure any inlined functions are known to be inlineable. */
24130 gcc_checking_assert (DECL_ABSTRACT_P (decl
)
24131 || cgraph_function_possibly_inlined_p (decl
));
24133 dw_die_ref subr_die
= new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
24135 if (call_arg_locations
|| debug_inline_points
)
24136 equate_block_to_die (stmt
, subr_die
);
24137 add_abstract_origin_attribute (subr_die
, decl
);
24138 if (TREE_ASM_WRITTEN (stmt
))
24139 add_high_low_attributes (stmt
, subr_die
);
24140 add_call_src_coords_attributes (stmt
, subr_die
);
24142 /* The inliner creates an extra BLOCK for the parameter setup,
24143 we want to merge that with the actual outermost BLOCK of the
24144 inlined function to avoid duplicate locals in consumers.
24145 Do that by doing the recursion to subblocks on the single subblock
24147 bool unwrap_one
= false;
24148 if (BLOCK_SUBBLOCKS (stmt
) && !BLOCK_CHAIN (BLOCK_SUBBLOCKS (stmt
)))
24150 tree origin
= block_ultimate_origin (BLOCK_SUBBLOCKS (stmt
));
24152 && TREE_CODE (origin
) == BLOCK
24153 && BLOCK_SUPERCONTEXT (origin
) == decl
)
24156 decls_for_scope (stmt
, subr_die
, !unwrap_one
);
24158 decls_for_scope (BLOCK_SUBBLOCKS (stmt
), subr_die
);
24161 /* Generate a DIE for a field in a record, or structure. CTX is required: see
24162 the comment for VLR_CONTEXT. */
24165 gen_field_die (tree decl
, struct vlr_context
*ctx
, dw_die_ref context_die
)
24167 dw_die_ref decl_die
;
24169 if (TREE_TYPE (decl
) == error_mark_node
)
24172 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
24173 add_name_and_src_coords_attributes (decl_die
, decl
);
24174 add_type_attribute (decl_die
, member_declared_type (decl
), decl_quals (decl
),
24175 TYPE_REVERSE_STORAGE_ORDER (DECL_FIELD_CONTEXT (decl
)),
24178 if (DECL_BIT_FIELD_TYPE (decl
))
24180 add_byte_size_attribute (decl_die
, decl
);
24181 add_bit_size_attribute (decl_die
, decl
);
24182 add_bit_offset_attribute (decl_die
, decl
, ctx
);
24185 add_alignment_attribute (decl_die
, decl
);
24187 /* If we have a variant part offset, then we are supposed to process a member
24188 of a QUAL_UNION_TYPE, which is how we represent variant parts in
24190 gcc_assert (ctx
->variant_part_offset
== NULL_TREE
24191 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != QUAL_UNION_TYPE
);
24192 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
24193 add_data_member_location_attribute (decl_die
, decl
, ctx
);
24195 if (DECL_ARTIFICIAL (decl
))
24196 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
24198 add_accessibility_attribute (decl_die
, decl
);
24200 /* Equate decl number to die, so that we can look up this decl later on. */
24201 equate_decl_number_to_die (decl
, decl_die
);
24204 /* Generate a DIE for a pointer to a member type. TYPE can be an
24205 OFFSET_TYPE, for a pointer to data member, or a RECORD_TYPE, for a
24206 pointer to member function. */
24209 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
24211 if (lookup_type_die (type
))
24214 dw_die_ref ptr_die
= new_die (DW_TAG_ptr_to_member_type
,
24215 scope_die_for (type
, context_die
), type
);
24217 equate_type_number_to_die (type
, ptr_die
);
24218 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
24219 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
24220 add_type_attribute (ptr_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
24222 add_alignment_attribute (ptr_die
, type
);
24224 if (TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
24225 && TREE_CODE (TREE_TYPE (type
)) != METHOD_TYPE
)
24227 dw_loc_descr_ref op
= new_loc_descr (DW_OP_plus
, 0, 0);
24228 add_AT_loc (ptr_die
, DW_AT_use_location
, op
);
24232 static char *producer_string
;
24234 /* Return a heap allocated producer string including command line options
24235 if -grecord-gcc-switches. */
24238 gen_producer_string (void)
24241 auto_vec
<const char *> switches
;
24242 const char *language_string
= lang_hooks
.name
;
24243 char *producer
, *tail
;
24245 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
24246 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
24248 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
24249 switch (save_decoded_options
[j
].opt_index
)
24256 case OPT_auxbase_strip
:
24265 case OPT_SPECIAL_unknown
:
24266 case OPT_SPECIAL_ignore
:
24267 case OPT_SPECIAL_deprecated
:
24268 case OPT_SPECIAL_program_name
:
24269 case OPT_SPECIAL_input_file
:
24270 case OPT_grecord_gcc_switches
:
24271 case OPT__output_pch_
:
24272 case OPT_fdiagnostics_show_location_
:
24273 case OPT_fdiagnostics_show_option
:
24274 case OPT_fdiagnostics_show_caret
:
24275 case OPT_fdiagnostics_show_labels
:
24276 case OPT_fdiagnostics_show_line_numbers
:
24277 case OPT_fdiagnostics_color_
:
24278 case OPT_fdiagnostics_format_
:
24279 case OPT_fverbose_asm
:
24281 case OPT__sysroot_
:
24283 case OPT_nostdinc__
:
24284 case OPT_fpreprocessed
:
24285 case OPT_fltrans_output_list_
:
24286 case OPT_fresolution_
:
24287 case OPT_fdebug_prefix_map_
:
24288 case OPT_fmacro_prefix_map_
:
24289 case OPT_ffile_prefix_map_
:
24290 case OPT_fcompare_debug
:
24291 case OPT_fchecking
:
24292 case OPT_fchecking_
:
24293 /* Ignore these. */
24296 if (cl_options
[save_decoded_options
[j
].opt_index
].flags
24297 & CL_NO_DWARF_RECORD
)
24299 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
24301 switch (save_decoded_options
[j
].canonical_option
[0][1])
24308 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
24315 switches
.safe_push (save_decoded_options
[j
].orig_option_with_args_text
);
24316 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
24320 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
24322 sprintf (tail
, "%s %s", language_string
, version_string
);
24325 FOR_EACH_VEC_ELT (switches
, j
, p
)
24329 memcpy (tail
+ 1, p
, len
);
24337 /* Given a C and/or C++ language/version string return the "highest".
24338 C++ is assumed to be "higher" than C in this case. Used for merging
24339 LTO translation unit languages. */
24340 static const char *
24341 highest_c_language (const char *lang1
, const char *lang2
)
24343 if (strcmp ("GNU C++17", lang1
) == 0 || strcmp ("GNU C++17", lang2
) == 0)
24344 return "GNU C++17";
24345 if (strcmp ("GNU C++14", lang1
) == 0 || strcmp ("GNU C++14", lang2
) == 0)
24346 return "GNU C++14";
24347 if (strcmp ("GNU C++11", lang1
) == 0 || strcmp ("GNU C++11", lang2
) == 0)
24348 return "GNU C++11";
24349 if (strcmp ("GNU C++98", lang1
) == 0 || strcmp ("GNU C++98", lang2
) == 0)
24350 return "GNU C++98";
24352 if (strcmp ("GNU C2X", lang1
) == 0 || strcmp ("GNU C2X", lang2
) == 0)
24354 if (strcmp ("GNU C17", lang1
) == 0 || strcmp ("GNU C17", lang2
) == 0)
24356 if (strcmp ("GNU C11", lang1
) == 0 || strcmp ("GNU C11", lang2
) == 0)
24358 if (strcmp ("GNU C99", lang1
) == 0 || strcmp ("GNU C99", lang2
) == 0)
24360 if (strcmp ("GNU C89", lang1
) == 0 || strcmp ("GNU C89", lang2
) == 0)
24363 gcc_unreachable ();
24367 /* Generate the DIE for the compilation unit. */
24370 gen_compile_unit_die (const char *filename
)
24373 const char *language_string
= lang_hooks
.name
;
24376 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
24380 add_name_attribute (die
, filename
);
24381 /* Don't add cwd for <built-in>. */
24382 if (filename
[0] != '<')
24383 add_comp_dir_attribute (die
);
24386 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
24388 /* If our producer is LTO try to figure out a common language to use
24389 from the global list of translation units. */
24390 if (strcmp (language_string
, "GNU GIMPLE") == 0)
24394 const char *common_lang
= NULL
;
24396 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
24398 if (!TRANSLATION_UNIT_LANGUAGE (t
))
24401 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
24402 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
24404 else if (strncmp (common_lang
, "GNU C", 5) == 0
24405 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
24406 /* Mixing C and C++ is ok, use C++ in that case. */
24407 common_lang
= highest_c_language (common_lang
,
24408 TRANSLATION_UNIT_LANGUAGE (t
));
24411 /* Fall back to C. */
24412 common_lang
= NULL
;
24418 language_string
= common_lang
;
24421 language
= DW_LANG_C
;
24422 if (strncmp (language_string
, "GNU C", 5) == 0
24423 && ISDIGIT (language_string
[5]))
24425 language
= DW_LANG_C89
;
24426 if (dwarf_version
>= 3 || !dwarf_strict
)
24428 if (strcmp (language_string
, "GNU C89") != 0)
24429 language
= DW_LANG_C99
;
24431 if (dwarf_version
>= 5 /* || !dwarf_strict */)
24432 if (strcmp (language_string
, "GNU C11") == 0
24433 || strcmp (language_string
, "GNU C17") == 0
24434 || strcmp (language_string
, "GNU C2X"))
24435 language
= DW_LANG_C11
;
24438 else if (strncmp (language_string
, "GNU C++", 7) == 0)
24440 language
= DW_LANG_C_plus_plus
;
24441 if (dwarf_version
>= 5 /* || !dwarf_strict */)
24443 if (strcmp (language_string
, "GNU C++11") == 0)
24444 language
= DW_LANG_C_plus_plus_11
;
24445 else if (strcmp (language_string
, "GNU C++14") == 0)
24446 language
= DW_LANG_C_plus_plus_14
;
24447 else if (strcmp (language_string
, "GNU C++17") == 0)
24449 language
= DW_LANG_C_plus_plus_14
;
24452 else if (strcmp (language_string
, "GNU F77") == 0)
24453 language
= DW_LANG_Fortran77
;
24454 else if (dwarf_version
>= 3 || !dwarf_strict
)
24456 if (strcmp (language_string
, "GNU Ada") == 0)
24457 language
= DW_LANG_Ada95
;
24458 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
24460 language
= DW_LANG_Fortran95
;
24461 if (dwarf_version
>= 5 /* || !dwarf_strict */)
24463 if (strcmp (language_string
, "GNU Fortran2003") == 0)
24464 language
= DW_LANG_Fortran03
;
24465 else if (strcmp (language_string
, "GNU Fortran2008") == 0)
24466 language
= DW_LANG_Fortran08
;
24469 else if (strcmp (language_string
, "GNU Objective-C") == 0)
24470 language
= DW_LANG_ObjC
;
24471 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
24472 language
= DW_LANG_ObjC_plus_plus
;
24473 else if (strcmp (language_string
, "GNU D") == 0)
24474 language
= DW_LANG_D
;
24475 else if (dwarf_version
>= 5 || !dwarf_strict
)
24477 if (strcmp (language_string
, "GNU Go") == 0)
24478 language
= DW_LANG_Go
;
24481 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
24482 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
24483 language
= DW_LANG_Fortran90
;
24484 /* Likewise for Ada. */
24485 else if (strcmp (language_string
, "GNU Ada") == 0)
24486 language
= DW_LANG_Ada83
;
24488 add_AT_unsigned (die
, DW_AT_language
, language
);
24492 case DW_LANG_Fortran77
:
24493 case DW_LANG_Fortran90
:
24494 case DW_LANG_Fortran95
:
24495 case DW_LANG_Fortran03
:
24496 case DW_LANG_Fortran08
:
24497 /* Fortran has case insensitive identifiers and the front-end
24498 lowercases everything. */
24499 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
24502 /* The default DW_ID_case_sensitive doesn't need to be specified. */
24508 /* Generate the DIE for a base class. */
24511 gen_inheritance_die (tree binfo
, tree access
, tree type
,
24512 dw_die_ref context_die
)
24514 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
24515 struct vlr_context ctx
= { type
, NULL
};
24517 add_type_attribute (die
, BINFO_TYPE (binfo
), TYPE_UNQUALIFIED
, false,
24519 add_data_member_location_attribute (die
, binfo
, &ctx
);
24521 if (BINFO_VIRTUAL_P (binfo
))
24522 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
24524 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
24525 children, otherwise the default is DW_ACCESS_public. In DWARF2
24526 the default has always been DW_ACCESS_private. */
24527 if (access
== access_public_node
)
24529 if (dwarf_version
== 2
24530 || context_die
->die_tag
== DW_TAG_class_type
)
24531 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
24533 else if (access
== access_protected_node
)
24534 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
24535 else if (dwarf_version
> 2
24536 && context_die
->die_tag
!= DW_TAG_class_type
)
24537 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
24540 /* Return whether DECL is a FIELD_DECL that represents the variant part of a
24544 is_variant_part (tree decl
)
24546 return (TREE_CODE (decl
) == FIELD_DECL
24547 && TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
);
24550 /* Check that OPERAND is a reference to a field in STRUCT_TYPE. If it is,
24551 return the FIELD_DECL. Return NULL_TREE otherwise. */
24554 analyze_discr_in_predicate (tree operand
, tree struct_type
)
24556 while (CONVERT_EXPR_P (operand
))
24557 operand
= TREE_OPERAND (operand
, 0);
24559 /* Match field access to members of struct_type only. */
24560 if (TREE_CODE (operand
) == COMPONENT_REF
24561 && TREE_CODE (TREE_OPERAND (operand
, 0)) == PLACEHOLDER_EXPR
24562 && TREE_TYPE (TREE_OPERAND (operand
, 0)) == struct_type
24563 && TREE_CODE (TREE_OPERAND (operand
, 1)) == FIELD_DECL
)
24564 return TREE_OPERAND (operand
, 1);
24569 /* Check that SRC is a constant integer that can be represented as a native
24570 integer constant (either signed or unsigned). If so, store it into DEST and
24571 return true. Return false otherwise. */
24574 get_discr_value (tree src
, dw_discr_value
*dest
)
24576 tree discr_type
= TREE_TYPE (src
);
24578 if (lang_hooks
.types
.get_debug_type
)
24580 tree debug_type
= lang_hooks
.types
.get_debug_type (discr_type
);
24581 if (debug_type
!= NULL
)
24582 discr_type
= debug_type
;
24585 if (TREE_CODE (src
) != INTEGER_CST
|| !INTEGRAL_TYPE_P (discr_type
))
24588 /* Signedness can vary between the original type and the debug type. This
24589 can happen for character types in Ada for instance: the character type
24590 used for code generation can be signed, to be compatible with the C one,
24591 but from a debugger point of view, it must be unsigned. */
24592 bool is_orig_unsigned
= TYPE_UNSIGNED (TREE_TYPE (src
));
24593 bool is_debug_unsigned
= TYPE_UNSIGNED (discr_type
);
24595 if (is_orig_unsigned
!= is_debug_unsigned
)
24596 src
= fold_convert (discr_type
, src
);
24598 if (!(is_debug_unsigned
? tree_fits_uhwi_p (src
) : tree_fits_shwi_p (src
)))
24601 dest
->pos
= is_debug_unsigned
;
24602 if (is_debug_unsigned
)
24603 dest
->v
.uval
= tree_to_uhwi (src
);
24605 dest
->v
.sval
= tree_to_shwi (src
);
24610 /* Try to extract synthetic properties out of VARIANT_PART_DECL, which is a
24611 FIELD_DECL in STRUCT_TYPE that represents a variant part. If unsuccessful,
24612 store NULL_TREE in DISCR_DECL. Otherwise:
24614 - store the discriminant field in STRUCT_TYPE that controls the variant
24615 part to *DISCR_DECL
24617 - put in *DISCR_LISTS_P an array where for each variant, the item
24618 represents the corresponding matching list of discriminant values.
24620 - put in *DISCR_LISTS_LENGTH the number of variants, which is the size of
24623 Note that when the array is allocated (i.e. when the analysis is
24624 successful), it is up to the caller to free the array. */
24627 analyze_variants_discr (tree variant_part_decl
,
24630 dw_discr_list_ref
**discr_lists_p
,
24631 unsigned *discr_lists_length
)
24633 tree variant_part_type
= TREE_TYPE (variant_part_decl
);
24635 dw_discr_list_ref
*discr_lists
;
24638 /* Compute how many variants there are in this variant part. */
24639 *discr_lists_length
= 0;
24640 for (variant
= TYPE_FIELDS (variant_part_type
);
24641 variant
!= NULL_TREE
;
24642 variant
= DECL_CHAIN (variant
))
24643 ++*discr_lists_length
;
24645 *discr_decl
= NULL_TREE
;
24647 = (dw_discr_list_ref
*) xcalloc (*discr_lists_length
,
24648 sizeof (**discr_lists_p
));
24649 discr_lists
= *discr_lists_p
;
24651 /* And then analyze all variants to extract discriminant information for all
24652 of them. This analysis is conservative: as soon as we detect something we
24653 do not support, abort everything and pretend we found nothing. */
24654 for (variant
= TYPE_FIELDS (variant_part_type
), i
= 0;
24655 variant
!= NULL_TREE
;
24656 variant
= DECL_CHAIN (variant
), ++i
)
24658 tree match_expr
= DECL_QUALIFIER (variant
);
24660 /* Now, try to analyze the predicate and deduce a discriminant for
24662 if (match_expr
== boolean_true_node
)
24663 /* Typically happens for the default variant: it matches all cases that
24664 previous variants rejected. Don't output any matching value for
24668 /* The following loop tries to iterate over each discriminant
24669 possibility: single values or ranges. */
24670 while (match_expr
!= NULL_TREE
)
24672 tree next_round_match_expr
;
24673 tree candidate_discr
= NULL_TREE
;
24674 dw_discr_list_ref new_node
= NULL
;
24676 /* Possibilities are matched one after the other by nested
24677 TRUTH_ORIF_EXPR expressions. Process the current possibility and
24678 continue with the rest at next iteration. */
24679 if (TREE_CODE (match_expr
) == TRUTH_ORIF_EXPR
)
24681 next_round_match_expr
= TREE_OPERAND (match_expr
, 0);
24682 match_expr
= TREE_OPERAND (match_expr
, 1);
24685 next_round_match_expr
= NULL_TREE
;
24687 if (match_expr
== boolean_false_node
)
24688 /* This sub-expression matches nothing: just wait for the next
24692 else if (TREE_CODE (match_expr
) == EQ_EXPR
)
24694 /* We are matching: <discr_field> == <integer_cst>
24695 This sub-expression matches a single value. */
24696 tree integer_cst
= TREE_OPERAND (match_expr
, 1);
24699 = analyze_discr_in_predicate (TREE_OPERAND (match_expr
, 0),
24702 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
24703 if (!get_discr_value (integer_cst
,
24704 &new_node
->dw_discr_lower_bound
))
24706 new_node
->dw_discr_range
= false;
24709 else if (TREE_CODE (match_expr
) == TRUTH_ANDIF_EXPR
)
24711 /* We are matching:
24712 <discr_field> > <integer_cst>
24713 && <discr_field> < <integer_cst>.
24714 This sub-expression matches the range of values between the
24715 two matched integer constants. Note that comparisons can be
24716 inclusive or exclusive. */
24717 tree candidate_discr_1
, candidate_discr_2
;
24718 tree lower_cst
, upper_cst
;
24719 bool lower_cst_included
, upper_cst_included
;
24720 tree lower_op
= TREE_OPERAND (match_expr
, 0);
24721 tree upper_op
= TREE_OPERAND (match_expr
, 1);
24723 /* When the comparison is exclusive, the integer constant is not
24724 the discriminant range bound we are looking for: we will have
24725 to increment or decrement it. */
24726 if (TREE_CODE (lower_op
) == GE_EXPR
)
24727 lower_cst_included
= true;
24728 else if (TREE_CODE (lower_op
) == GT_EXPR
)
24729 lower_cst_included
= false;
24733 if (TREE_CODE (upper_op
) == LE_EXPR
)
24734 upper_cst_included
= true;
24735 else if (TREE_CODE (upper_op
) == LT_EXPR
)
24736 upper_cst_included
= false;
24740 /* Extract the discriminant from the first operand and check it
24741 is consistant with the same analysis in the second
24744 = analyze_discr_in_predicate (TREE_OPERAND (lower_op
, 0),
24747 = analyze_discr_in_predicate (TREE_OPERAND (upper_op
, 0),
24749 if (candidate_discr_1
== candidate_discr_2
)
24750 candidate_discr
= candidate_discr_1
;
24754 /* Extract bounds from both. */
24755 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
24756 lower_cst
= TREE_OPERAND (lower_op
, 1);
24757 upper_cst
= TREE_OPERAND (upper_op
, 1);
24759 if (!lower_cst_included
)
24761 = fold_build2 (PLUS_EXPR
, TREE_TYPE (lower_cst
), lower_cst
,
24762 build_int_cst (TREE_TYPE (lower_cst
), 1));
24763 if (!upper_cst_included
)
24765 = fold_build2 (MINUS_EXPR
, TREE_TYPE (upper_cst
), upper_cst
,
24766 build_int_cst (TREE_TYPE (upper_cst
), 1));
24768 if (!get_discr_value (lower_cst
,
24769 &new_node
->dw_discr_lower_bound
)
24770 || !get_discr_value (upper_cst
,
24771 &new_node
->dw_discr_upper_bound
))
24774 new_node
->dw_discr_range
= true;
24777 else if ((candidate_discr
24778 = analyze_discr_in_predicate (match_expr
, struct_type
))
24779 && TREE_TYPE (candidate_discr
) == boolean_type_node
)
24781 /* We are matching: <discr_field> for a boolean discriminant.
24782 This sub-expression matches boolean_true_node. */
24783 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
24784 if (!get_discr_value (boolean_true_node
,
24785 &new_node
->dw_discr_lower_bound
))
24787 new_node
->dw_discr_range
= false;
24791 /* Unsupported sub-expression: we cannot determine the set of
24792 matching discriminant values. Abort everything. */
24795 /* If the discriminant info is not consistant with what we saw so
24796 far, consider the analysis failed and abort everything. */
24797 if (candidate_discr
== NULL_TREE
24798 || (*discr_decl
!= NULL_TREE
&& candidate_discr
!= *discr_decl
))
24801 *discr_decl
= candidate_discr
;
24803 if (new_node
!= NULL
)
24805 new_node
->dw_discr_next
= discr_lists
[i
];
24806 discr_lists
[i
] = new_node
;
24808 match_expr
= next_round_match_expr
;
24812 /* If we reach this point, we could match everything we were interested
24817 /* Clean all data structure and return no result. */
24818 free (*discr_lists_p
);
24819 *discr_lists_p
= NULL
;
24820 *discr_decl
= NULL_TREE
;
24823 /* Generate a DIE to represent VARIANT_PART_DECL, a variant part that is part
24824 of STRUCT_TYPE, a record type. This new DIE is emitted as the next child
24827 Variant parts are supposed to be implemented as a FIELD_DECL whose type is a
24828 QUAL_UNION_TYPE: this is the VARIANT_PART_DECL parameter. The members for
24829 this type, which are record types, represent the available variants and each
24830 has a DECL_QUALIFIER attribute. The discriminant and the discriminant
24831 values are inferred from these attributes.
24833 In trees, the offsets for the fields inside these sub-records are relative
24834 to the variant part itself, whereas the corresponding DIEs should have
24835 offset attributes that are relative to the embedding record base address.
24836 This is why the caller must provide a VARIANT_PART_OFFSET expression: it
24837 must be an expression that computes the offset of the variant part to
24838 describe in DWARF. */
24841 gen_variant_part (tree variant_part_decl
, struct vlr_context
*vlr_ctx
,
24842 dw_die_ref context_die
)
24844 const tree variant_part_type
= TREE_TYPE (variant_part_decl
);
24845 tree variant_part_offset
= vlr_ctx
->variant_part_offset
;
24846 struct loc_descr_context ctx
= {
24847 vlr_ctx
->struct_type
, /* context_type */
24848 NULL_TREE
, /* base_decl */
24850 false, /* placeholder_arg */
24851 false /* placeholder_seen */
24854 /* The FIELD_DECL node in STRUCT_TYPE that acts as the discriminant, or
24855 NULL_TREE if there is no such field. */
24856 tree discr_decl
= NULL_TREE
;
24857 dw_discr_list_ref
*discr_lists
;
24858 unsigned discr_lists_length
= 0;
24861 dw_die_ref dwarf_proc_die
= NULL
;
24862 dw_die_ref variant_part_die
24863 = new_die (DW_TAG_variant_part
, context_die
, variant_part_type
);
24865 equate_decl_number_to_die (variant_part_decl
, variant_part_die
);
24867 analyze_variants_discr (variant_part_decl
, vlr_ctx
->struct_type
,
24868 &discr_decl
, &discr_lists
, &discr_lists_length
);
24870 if (discr_decl
!= NULL_TREE
)
24872 dw_die_ref discr_die
= lookup_decl_die (discr_decl
);
24875 add_AT_die_ref (variant_part_die
, DW_AT_discr
, discr_die
);
24877 /* We have no DIE for the discriminant, so just discard all
24878 discrimimant information in the output. */
24879 discr_decl
= NULL_TREE
;
24882 /* If the offset for this variant part is more complex than a constant,
24883 create a DWARF procedure for it so that we will not have to generate DWARF
24884 expressions for it for each member. */
24885 if (TREE_CODE (variant_part_offset
) != INTEGER_CST
24886 && (dwarf_version
>= 3 || !dwarf_strict
))
24888 const tree dwarf_proc_fndecl
24889 = build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
24890 build_function_type (TREE_TYPE (variant_part_offset
),
24892 const tree dwarf_proc_call
= build_call_expr (dwarf_proc_fndecl
, 0);
24893 const dw_loc_descr_ref dwarf_proc_body
24894 = loc_descriptor_from_tree (variant_part_offset
, 0, &ctx
);
24896 dwarf_proc_die
= new_dwarf_proc_die (dwarf_proc_body
,
24897 dwarf_proc_fndecl
, context_die
);
24898 if (dwarf_proc_die
!= NULL
)
24899 variant_part_offset
= dwarf_proc_call
;
24902 /* Output DIEs for all variants. */
24904 for (tree variant
= TYPE_FIELDS (variant_part_type
);
24905 variant
!= NULL_TREE
;
24906 variant
= DECL_CHAIN (variant
), ++i
)
24908 tree variant_type
= TREE_TYPE (variant
);
24909 dw_die_ref variant_die
;
24911 /* All variants (i.e. members of a variant part) are supposed to be
24912 encoded as structures. Sub-variant parts are QUAL_UNION_TYPE fields
24913 under these records. */
24914 gcc_assert (TREE_CODE (variant_type
) == RECORD_TYPE
);
24916 variant_die
= new_die (DW_TAG_variant
, variant_part_die
, variant_type
);
24917 equate_decl_number_to_die (variant
, variant_die
);
24919 /* Output discriminant values this variant matches, if any. */
24920 if (discr_decl
== NULL
|| discr_lists
[i
] == NULL
)
24921 /* In the case we have discriminant information at all, this is
24922 probably the default variant: as the standard says, don't
24923 output any discriminant value/list attribute. */
24925 else if (discr_lists
[i
]->dw_discr_next
== NULL
24926 && !discr_lists
[i
]->dw_discr_range
)
24927 /* If there is only one accepted value, don't bother outputting a
24929 add_discr_value (variant_die
, &discr_lists
[i
]->dw_discr_lower_bound
);
24931 add_discr_list (variant_die
, discr_lists
[i
]);
24933 for (tree member
= TYPE_FIELDS (variant_type
);
24934 member
!= NULL_TREE
;
24935 member
= DECL_CHAIN (member
))
24937 struct vlr_context vlr_sub_ctx
= {
24938 vlr_ctx
->struct_type
, /* struct_type */
24939 NULL
/* variant_part_offset */
24941 if (is_variant_part (member
))
24943 /* All offsets for fields inside variant parts are relative to
24944 the top-level embedding RECORD_TYPE's base address. On the
24945 other hand, offsets in GCC's types are relative to the
24946 nested-most variant part. So we have to sum offsets each time
24949 vlr_sub_ctx
.variant_part_offset
24950 = fold_build2 (PLUS_EXPR
, TREE_TYPE (variant_part_offset
),
24951 variant_part_offset
, byte_position (member
));
24952 gen_variant_part (member
, &vlr_sub_ctx
, variant_die
);
24956 vlr_sub_ctx
.variant_part_offset
= variant_part_offset
;
24957 gen_decl_die (member
, NULL
, &vlr_sub_ctx
, variant_die
);
24962 free (discr_lists
);
24965 /* Generate a DIE for a class member. */
24968 gen_member_die (tree type
, dw_die_ref context_die
)
24971 tree binfo
= TYPE_BINFO (type
);
24973 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
24975 /* If this is not an incomplete type, output descriptions of each of its
24976 members. Note that as we output the DIEs necessary to represent the
24977 members of this record or union type, we will also be trying to output
24978 DIEs to represent the *types* of those members. However the `type'
24979 function (above) will specifically avoid generating type DIEs for member
24980 types *within* the list of member DIEs for this (containing) type except
24981 for those types (of members) which are explicitly marked as also being
24982 members of this (containing) type themselves. The g++ front- end can
24983 force any given type to be treated as a member of some other (containing)
24984 type by setting the TYPE_CONTEXT of the given (member) type to point to
24985 the TREE node representing the appropriate (containing) type. */
24987 /* First output info about the base classes. */
24990 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
24994 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
24995 gen_inheritance_die (base
,
24996 (accesses
? (*accesses
)[i
] : access_public_node
),
25001 /* Now output info about the data members and type members. */
25002 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
25004 struct vlr_context vlr_ctx
= { type
, NULL_TREE
};
25005 bool static_inline_p
25006 = (TREE_STATIC (member
)
25007 && (lang_hooks
.decls
.decl_dwarf_attribute (member
, DW_AT_inline
)
25010 /* Ignore clones. */
25011 if (DECL_ABSTRACT_ORIGIN (member
))
25014 /* If we thought we were generating minimal debug info for TYPE
25015 and then changed our minds, some of the member declarations
25016 may have already been defined. Don't define them again, but
25017 do put them in the right order. */
25019 if (dw_die_ref child
= lookup_decl_die (member
))
25021 /* Handle inline static data members, which only have in-class
25023 dw_die_ref ref
= NULL
;
25024 if (child
->die_tag
== DW_TAG_variable
25025 && child
->die_parent
== comp_unit_die ())
25027 ref
= get_AT_ref (child
, DW_AT_specification
);
25028 /* For C++17 inline static data members followed by redundant
25029 out of class redeclaration, we might get here with
25030 child being the DIE created for the out of class
25031 redeclaration and with its DW_AT_specification being
25032 the DIE created for in-class definition. We want to
25033 reparent the latter, and don't want to create another
25034 DIE with DW_AT_specification in that case, because
25035 we already have one. */
25038 && ref
->die_tag
== DW_TAG_variable
25039 && ref
->die_parent
== comp_unit_die ()
25040 && get_AT (ref
, DW_AT_specification
) == NULL
)
25044 static_inline_p
= false;
25048 if (child
->die_tag
== DW_TAG_variable
25049 && child
->die_parent
== comp_unit_die ()
25052 reparent_child (child
, context_die
);
25053 if (dwarf_version
< 5)
25054 child
->die_tag
= DW_TAG_member
;
25057 splice_child_die (context_die
, child
);
25060 /* Do not generate standard DWARF for variant parts if we are generating
25061 the corresponding GNAT encodings: DIEs generated for both would
25062 conflict in our mappings. */
25063 else if (is_variant_part (member
)
25064 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
)
25066 vlr_ctx
.variant_part_offset
= byte_position (member
);
25067 gen_variant_part (member
, &vlr_ctx
, context_die
);
25071 vlr_ctx
.variant_part_offset
= NULL_TREE
;
25072 gen_decl_die (member
, NULL
, &vlr_ctx
, context_die
);
25075 /* For C++ inline static data members emit immediately a DW_TAG_variable
25076 DIE that will refer to that DW_TAG_member/DW_TAG_variable through
25077 DW_AT_specification. */
25078 if (static_inline_p
)
25080 int old_extern
= DECL_EXTERNAL (member
);
25081 DECL_EXTERNAL (member
) = 0;
25082 gen_decl_die (member
, NULL
, NULL
, comp_unit_die ());
25083 DECL_EXTERNAL (member
) = old_extern
;
25088 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
25089 is set, we pretend that the type was never defined, so we only get the
25090 member DIEs needed by later specification DIEs. */
25093 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
25094 enum debug_info_usage usage
)
25096 if (TREE_ASM_WRITTEN (type
))
25098 /* Fill in the bound of variable-length fields in late dwarf if
25099 still incomplete. */
25100 if (!early_dwarf
&& variably_modified_type_p (type
, NULL
))
25101 for (tree member
= TYPE_FIELDS (type
);
25103 member
= DECL_CHAIN (member
))
25104 fill_variable_array_bounds (TREE_TYPE (member
));
25108 dw_die_ref type_die
= lookup_type_die (type
);
25109 dw_die_ref scope_die
= 0;
25111 int complete
= (TYPE_SIZE (type
)
25112 && (! TYPE_STUB_DECL (type
)
25113 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
25114 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
25115 complete
= complete
&& should_emit_struct_debug (type
, usage
);
25117 if (type_die
&& ! complete
)
25120 if (TYPE_CONTEXT (type
) != NULL_TREE
25121 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
25122 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
25125 scope_die
= scope_die_for (type
, context_die
);
25127 /* Generate child dies for template paramaters. */
25128 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
25129 schedule_generic_params_dies_gen (type
);
25131 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
25132 /* First occurrence of type or toplevel definition of nested class. */
25134 dw_die_ref old_die
= type_die
;
25136 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
25137 ? record_type_tag (type
) : DW_TAG_union_type
,
25139 equate_type_number_to_die (type
, type_die
);
25141 add_AT_specification (type_die
, old_die
);
25143 add_name_attribute (type_die
, type_tag (type
));
25146 remove_AT (type_die
, DW_AT_declaration
);
25148 /* If this type has been completed, then give it a byte_size attribute and
25149 then give a list of members. */
25150 if (complete
&& !ns_decl
)
25152 /* Prevent infinite recursion in cases where the type of some member of
25153 this type is expressed in terms of this type itself. */
25154 TREE_ASM_WRITTEN (type
) = 1;
25155 add_byte_size_attribute (type_die
, type
);
25156 add_alignment_attribute (type_die
, type
);
25157 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
25159 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
25160 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
25163 /* If the first reference to this type was as the return type of an
25164 inline function, then it may not have a parent. Fix this now. */
25165 if (type_die
->die_parent
== NULL
)
25166 add_child_die (scope_die
, type_die
);
25168 gen_member_die (type
, type_die
);
25170 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
25171 if (TYPE_ARTIFICIAL (type
))
25172 add_AT_flag (type_die
, DW_AT_artificial
, 1);
25174 /* GNU extension: Record what type our vtable lives in. */
25175 if (TYPE_VFIELD (type
))
25177 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
25179 gen_type_die (vtype
, context_die
);
25180 add_AT_die_ref (type_die
, DW_AT_containing_type
,
25181 lookup_type_die (vtype
));
25186 add_AT_flag (type_die
, DW_AT_declaration
, 1);
25188 /* We don't need to do this for function-local types. */
25189 if (TYPE_STUB_DECL (type
)
25190 && ! decl_function_context (TYPE_STUB_DECL (type
)))
25191 vec_safe_push (incomplete_types
, type
);
25194 if (get_AT (type_die
, DW_AT_name
))
25195 add_pubtype (type
, type_die
);
25198 /* Generate a DIE for a subroutine _type_. */
25201 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
25203 tree return_type
= TREE_TYPE (type
);
25204 dw_die_ref subr_die
25205 = new_die (DW_TAG_subroutine_type
,
25206 scope_die_for (type
, context_die
), type
);
25208 equate_type_number_to_die (type
, subr_die
);
25209 add_prototyped_attribute (subr_die
, type
);
25210 add_type_attribute (subr_die
, return_type
, TYPE_UNQUALIFIED
, false,
25212 add_alignment_attribute (subr_die
, type
);
25213 gen_formal_types_die (type
, subr_die
);
25215 if (get_AT (subr_die
, DW_AT_name
))
25216 add_pubtype (type
, subr_die
);
25217 if ((dwarf_version
>= 5 || !dwarf_strict
)
25218 && lang_hooks
.types
.type_dwarf_attribute (type
, DW_AT_reference
) != -1)
25219 add_AT_flag (subr_die
, DW_AT_reference
, 1);
25220 if ((dwarf_version
>= 5 || !dwarf_strict
)
25221 && lang_hooks
.types
.type_dwarf_attribute (type
,
25222 DW_AT_rvalue_reference
) != -1)
25223 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
25226 /* Generate a DIE for a type definition. */
25229 gen_typedef_die (tree decl
, dw_die_ref context_die
)
25231 dw_die_ref type_die
;
25234 if (TREE_ASM_WRITTEN (decl
))
25236 if (DECL_ORIGINAL_TYPE (decl
))
25237 fill_variable_array_bounds (DECL_ORIGINAL_TYPE (decl
));
25241 /* As we avoid creating DIEs for local typedefs (see decl_ultimate_origin
25242 checks in process_scope_var and modified_type_die), this should be called
25243 only for original types. */
25244 gcc_assert (decl_ultimate_origin (decl
) == NULL
25245 || decl_ultimate_origin (decl
) == decl
);
25247 TREE_ASM_WRITTEN (decl
) = 1;
25248 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
25250 add_name_and_src_coords_attributes (type_die
, decl
);
25251 if (DECL_ORIGINAL_TYPE (decl
))
25253 type
= DECL_ORIGINAL_TYPE (decl
);
25254 if (type
== error_mark_node
)
25257 gcc_assert (type
!= TREE_TYPE (decl
));
25258 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
25262 type
= TREE_TYPE (decl
);
25263 if (type
== error_mark_node
)
25266 if (is_naming_typedef_decl (TYPE_NAME (type
)))
25268 /* Here, we are in the case of decl being a typedef naming
25269 an anonymous type, e.g:
25270 typedef struct {...} foo;
25271 In that case TREE_TYPE (decl) is not a typedef variant
25272 type and TYPE_NAME of the anonymous type is set to the
25273 TYPE_DECL of the typedef. This construct is emitted by
25276 TYPE is the anonymous struct named by the typedef
25277 DECL. As we need the DW_AT_type attribute of the
25278 DW_TAG_typedef to point to the DIE of TYPE, let's
25279 generate that DIE right away. add_type_attribute
25280 called below will then pick (via lookup_type_die) that
25281 anonymous struct DIE. */
25282 if (!TREE_ASM_WRITTEN (type
))
25283 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
25285 /* This is a GNU Extension. We are adding a
25286 DW_AT_linkage_name attribute to the DIE of the
25287 anonymous struct TYPE. The value of that attribute
25288 is the name of the typedef decl naming the anonymous
25289 struct. This greatly eases the work of consumers of
25290 this debug info. */
25291 add_linkage_name_raw (lookup_type_die (type
), decl
);
25295 add_type_attribute (type_die
, type
, decl_quals (decl
), false,
25298 if (is_naming_typedef_decl (decl
))
25299 /* We want that all subsequent calls to lookup_type_die with
25300 TYPE in argument yield the DW_TAG_typedef we have just
25302 equate_type_number_to_die (type
, type_die
);
25304 add_alignment_attribute (type_die
, TREE_TYPE (decl
));
25306 add_accessibility_attribute (type_die
, decl
);
25308 if (DECL_ABSTRACT_P (decl
))
25309 equate_decl_number_to_die (decl
, type_die
);
25311 if (get_AT (type_die
, DW_AT_name
))
25312 add_pubtype (decl
, type_die
);
25315 /* Generate a DIE for a struct, class, enum or union type. */
25318 gen_tagged_type_die (tree type
,
25319 dw_die_ref context_die
,
25320 enum debug_info_usage usage
)
25322 if (type
== NULL_TREE
25323 || !is_tagged_type (type
))
25326 if (TREE_ASM_WRITTEN (type
))
25328 /* If this is a nested type whose containing class hasn't been written
25329 out yet, writing it out will cover this one, too. This does not apply
25330 to instantiations of member class templates; they need to be added to
25331 the containing class as they are generated. FIXME: This hurts the
25332 idea of combining type decls from multiple TUs, since we can't predict
25333 what set of template instantiations we'll get. */
25334 else if (TYPE_CONTEXT (type
)
25335 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
25336 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
25338 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
25340 if (TREE_ASM_WRITTEN (type
))
25343 /* If that failed, attach ourselves to the stub. */
25344 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
25346 else if (TYPE_CONTEXT (type
) != NULL_TREE
25347 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
25349 /* If this type is local to a function that hasn't been written
25350 out yet, use a NULL context for now; it will be fixed up in
25351 decls_for_scope. */
25352 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
25353 /* A declaration DIE doesn't count; nested types need to go in the
25355 if (context_die
&& is_declaration_die (context_die
))
25356 context_die
= NULL
;
25359 context_die
= declare_in_namespace (type
, context_die
);
25361 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
25363 /* This might have been written out by the call to
25364 declare_in_namespace. */
25365 if (!TREE_ASM_WRITTEN (type
))
25366 gen_enumeration_type_die (type
, context_die
);
25369 gen_struct_or_union_type_die (type
, context_die
, usage
);
25371 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
25372 it up if it is ever completed. gen_*_type_die will set it for us
25373 when appropriate. */
25376 /* Generate a type description DIE. */
25379 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
25380 enum debug_info_usage usage
)
25382 struct array_descr_info info
;
25384 if (type
== NULL_TREE
|| type
== error_mark_node
)
25387 if (flag_checking
&& type
)
25388 verify_type (type
);
25390 if (TYPE_NAME (type
) != NULL_TREE
25391 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
25392 && is_redundant_typedef (TYPE_NAME (type
))
25393 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
25394 /* The DECL of this type is a typedef we don't want to emit debug
25395 info for but we want debug info for its underlying typedef.
25396 This can happen for e.g, the injected-class-name of a C++
25398 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
25400 /* If TYPE is a typedef type variant, let's generate debug info
25401 for the parent typedef which TYPE is a type of. */
25402 if (typedef_variant_p (type
))
25404 if (TREE_ASM_WRITTEN (type
))
25407 tree name
= TYPE_NAME (type
);
25408 tree origin
= decl_ultimate_origin (name
);
25409 if (origin
!= NULL
&& origin
!= name
)
25411 gen_decl_die (origin
, NULL
, NULL
, context_die
);
25415 /* Prevent broken recursion; we can't hand off to the same type. */
25416 gcc_assert (DECL_ORIGINAL_TYPE (name
) != type
);
25418 /* Give typedefs the right scope. */
25419 context_die
= scope_die_for (type
, context_die
);
25421 TREE_ASM_WRITTEN (type
) = 1;
25423 gen_decl_die (name
, NULL
, NULL
, context_die
);
25427 /* If type is an anonymous tagged type named by a typedef, let's
25428 generate debug info for the typedef. */
25429 if (is_naming_typedef_decl (TYPE_NAME (type
)))
25431 /* Give typedefs the right scope. */
25432 context_die
= scope_die_for (type
, context_die
);
25434 gen_decl_die (TYPE_NAME (type
), NULL
, NULL
, context_die
);
25438 if (lang_hooks
.types
.get_debug_type
)
25440 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
25442 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
25444 gen_type_die_with_usage (debug_type
, context_die
, usage
);
25449 /* We are going to output a DIE to represent the unqualified version
25450 of this type (i.e. without any const or volatile qualifiers) so
25451 get the main variant (i.e. the unqualified version) of this type
25452 now. (Vectors and arrays are special because the debugging info is in the
25453 cloned type itself. Similarly function/method types can contain extra
25454 ref-qualification). */
25455 if (TREE_CODE (type
) == FUNCTION_TYPE
25456 || TREE_CODE (type
) == METHOD_TYPE
)
25458 /* For function/method types, can't use type_main_variant here,
25459 because that can have different ref-qualifiers for C++,
25460 but try to canonicalize. */
25461 tree main
= TYPE_MAIN_VARIANT (type
);
25462 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
25463 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
25464 && check_base_type (t
, main
)
25465 && check_lang_type (t
, type
))
25471 else if (TREE_CODE (type
) != VECTOR_TYPE
25472 && TREE_CODE (type
) != ARRAY_TYPE
)
25473 type
= type_main_variant (type
);
25475 /* If this is an array type with hidden descriptor, handle it first. */
25476 if (!TREE_ASM_WRITTEN (type
)
25477 && lang_hooks
.types
.get_array_descr_info
)
25479 memset (&info
, 0, sizeof (info
));
25480 if (lang_hooks
.types
.get_array_descr_info (type
, &info
))
25482 /* Fortran sometimes emits array types with no dimension. */
25483 gcc_assert (info
.ndimensions
>= 0
25484 && (info
.ndimensions
25485 <= DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN
));
25486 gen_descr_array_type_die (type
, &info
, context_die
);
25487 TREE_ASM_WRITTEN (type
) = 1;
25492 if (TREE_ASM_WRITTEN (type
))
25494 /* Variable-length types may be incomplete even if
25495 TREE_ASM_WRITTEN. For such types, fall through to
25496 gen_array_type_die() and possibly fill in
25497 DW_AT_{upper,lower}_bound attributes. */
25498 if ((TREE_CODE (type
) != ARRAY_TYPE
25499 && TREE_CODE (type
) != RECORD_TYPE
25500 && TREE_CODE (type
) != UNION_TYPE
25501 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
25502 || !variably_modified_type_p (type
, NULL
))
25506 switch (TREE_CODE (type
))
25512 case REFERENCE_TYPE
:
25513 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
25514 ensures that the gen_type_die recursion will terminate even if the
25515 type is recursive. Recursive types are possible in Ada. */
25516 /* ??? We could perhaps do this for all types before the switch
25518 TREE_ASM_WRITTEN (type
) = 1;
25520 /* For these types, all that is required is that we output a DIE (or a
25521 set of DIEs) to represent the "basis" type. */
25522 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25523 DINFO_USAGE_IND_USE
);
25527 /* This code is used for C++ pointer-to-data-member types.
25528 Output a description of the relevant class type. */
25529 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
25530 DINFO_USAGE_IND_USE
);
25532 /* Output a description of the type of the object pointed to. */
25533 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25534 DINFO_USAGE_IND_USE
);
25536 /* Now output a DIE to represent this pointer-to-data-member type
25538 gen_ptr_to_mbr_type_die (type
, context_die
);
25541 case FUNCTION_TYPE
:
25542 /* Force out return type (in case it wasn't forced out already). */
25543 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25544 DINFO_USAGE_DIR_USE
);
25545 gen_subroutine_type_die (type
, context_die
);
25549 /* Force out return type (in case it wasn't forced out already). */
25550 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25551 DINFO_USAGE_DIR_USE
);
25552 gen_subroutine_type_die (type
, context_die
);
25557 gen_array_type_die (type
, context_die
);
25560 case ENUMERAL_TYPE
:
25563 case QUAL_UNION_TYPE
:
25564 gen_tagged_type_die (type
, context_die
, usage
);
25570 case FIXED_POINT_TYPE
:
25573 /* No DIEs needed for fundamental types. */
25578 /* Just use DW_TAG_unspecified_type. */
25580 dw_die_ref type_die
= lookup_type_die (type
);
25581 if (type_die
== NULL
)
25583 tree name
= TYPE_IDENTIFIER (type
);
25584 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
25586 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
25587 equate_type_number_to_die (type
, type_die
);
25593 if (is_cxx_auto (type
))
25595 tree name
= TYPE_IDENTIFIER (type
);
25596 dw_die_ref
*die
= (name
== get_identifier ("auto")
25597 ? &auto_die
: &decltype_auto_die
);
25600 *die
= new_die (DW_TAG_unspecified_type
,
25601 comp_unit_die (), NULL_TREE
);
25602 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
25604 equate_type_number_to_die (type
, *die
);
25607 gcc_unreachable ();
25610 TREE_ASM_WRITTEN (type
) = 1;
25614 gen_type_die (tree type
, dw_die_ref context_die
)
25616 if (type
!= error_mark_node
)
25618 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
25621 dw_die_ref die
= lookup_type_die (type
);
25628 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
25629 things which are local to the given block. */
25632 gen_block_die (tree stmt
, dw_die_ref context_die
)
25634 int must_output_die
= 0;
25637 /* Ignore blocks that are NULL. */
25638 if (stmt
== NULL_TREE
)
25641 inlined_func
= inlined_function_outer_scope_p (stmt
);
25643 /* If the block is one fragment of a non-contiguous block, do not
25644 process the variables, since they will have been done by the
25645 origin block. Do process subblocks. */
25646 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
25650 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
25651 gen_block_die (sub
, context_die
);
25656 /* Determine if we need to output any Dwarf DIEs at all to represent this
25659 /* The outer scopes for inlinings *must* always be represented. We
25660 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
25661 must_output_die
= 1;
25662 else if (lookup_block_die (stmt
))
25663 /* If we already have a DIE then it was filled early. Meanwhile
25664 we might have pruned all BLOCK_VARS as optimized out but we
25665 still want to generate high/low PC attributes so output it. */
25666 must_output_die
= 1;
25667 else if (TREE_USED (stmt
)
25668 || TREE_ASM_WRITTEN (stmt
))
25670 /* Determine if this block directly contains any "significant"
25671 local declarations which we will need to output DIEs for. */
25672 if (debug_info_level
> DINFO_LEVEL_TERSE
)
25674 /* We are not in terse mode so any local declaration that
25675 is not ignored for debug purposes counts as being a
25676 "significant" one. */
25677 if (BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
25678 must_output_die
= 1;
25680 for (tree var
= BLOCK_VARS (stmt
); var
; var
= DECL_CHAIN (var
))
25681 if (!DECL_IGNORED_P (var
))
25683 must_output_die
= 1;
25687 else if (!dwarf2out_ignore_block (stmt
))
25688 must_output_die
= 1;
25691 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
25692 DIE for any block which contains no significant local declarations at
25693 all. Rather, in such cases we just call `decls_for_scope' so that any
25694 needed Dwarf info for any sub-blocks will get properly generated. Note
25695 that in terse mode, our definition of what constitutes a "significant"
25696 local declaration gets restricted to include only inlined function
25697 instances and local (nested) function definitions. */
25698 if (must_output_die
)
25701 gen_inlined_subroutine_die (stmt
, context_die
);
25703 gen_lexical_block_die (stmt
, context_die
);
25706 decls_for_scope (stmt
, context_die
);
25709 /* Process variable DECL (or variable with origin ORIGIN) within
25710 block STMT and add it to CONTEXT_DIE. */
25712 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
25715 tree decl_or_origin
= decl
? decl
: origin
;
25717 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
25718 die
= lookup_decl_die (decl_or_origin
);
25719 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
)
25721 if (TYPE_DECL_IS_STUB (decl_or_origin
))
25722 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
25724 die
= lookup_decl_die (decl_or_origin
);
25725 /* Avoid re-creating the DIE late if it was optimized as unused early. */
25726 if (! die
&& ! early_dwarf
)
25732 /* Avoid creating DIEs for local typedefs and concrete static variables that
25733 will only be pruned later. */
25734 if ((origin
|| decl_ultimate_origin (decl
))
25735 && (TREE_CODE (decl_or_origin
) == TYPE_DECL
25736 || (VAR_P (decl_or_origin
) && TREE_STATIC (decl_or_origin
))))
25738 origin
= decl_ultimate_origin (decl_or_origin
);
25739 if (decl
&& VAR_P (decl
) && die
!= NULL
)
25741 die
= lookup_decl_die (origin
);
25743 equate_decl_number_to_die (decl
, die
);
25748 if (die
!= NULL
&& die
->die_parent
== NULL
)
25749 add_child_die (context_die
, die
);
25750 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
25753 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
25754 stmt
, context_die
);
25758 if (decl
&& DECL_P (decl
))
25760 die
= lookup_decl_die (decl
);
25762 /* Early created DIEs do not have a parent as the decls refer
25763 to the function as DECL_CONTEXT rather than the BLOCK. */
25764 if (die
&& die
->die_parent
== NULL
)
25766 gcc_assert (in_lto_p
);
25767 add_child_die (context_die
, die
);
25771 gen_decl_die (decl
, origin
, NULL
, context_die
);
25775 /* Generate all of the decls declared within a given scope and (recursively)
25776 all of its sub-blocks. */
25779 decls_for_scope (tree stmt
, dw_die_ref context_die
, bool recurse
)
25785 /* Ignore NULL blocks. */
25786 if (stmt
== NULL_TREE
)
25789 /* Output the DIEs to represent all of the data objects and typedefs
25790 declared directly within this block but not within any nested
25791 sub-blocks. Also, nested function and tag DIEs have been
25792 generated with a parent of NULL; fix that up now. We don't
25793 have to do this if we're at -g1. */
25794 if (debug_info_level
> DINFO_LEVEL_TERSE
)
25796 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
25797 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
25798 /* BLOCK_NONLOCALIZED_VARs simply generate DIE stubs with abstract
25799 origin - avoid doing this twice as we have no good way to see
25800 if we've done it once already. */
25802 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
25804 decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
25805 if (decl
== current_function_decl
)
25806 /* Ignore declarations of the current function, while they
25807 are declarations, gen_subprogram_die would treat them
25808 as definitions again, because they are equal to
25809 current_function_decl and endlessly recurse. */;
25810 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
25811 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
25813 process_scope_var (stmt
, NULL_TREE
, decl
, context_die
);
25817 /* Even if we're at -g1, we need to process the subblocks in order to get
25818 inlined call information. */
25820 /* Output the DIEs to represent all sub-blocks (and the items declared
25821 therein) of this block. */
25823 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
25825 subblocks
= BLOCK_CHAIN (subblocks
))
25826 gen_block_die (subblocks
, context_die
);
25829 /* Is this a typedef we can avoid emitting? */
25832 is_redundant_typedef (const_tree decl
)
25834 if (TYPE_DECL_IS_STUB (decl
))
25837 if (DECL_ARTIFICIAL (decl
)
25838 && DECL_CONTEXT (decl
)
25839 && is_tagged_type (DECL_CONTEXT (decl
))
25840 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
25841 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
25842 /* Also ignore the artificial member typedef for the class name. */
25848 /* Return TRUE if TYPE is a typedef that names a type for linkage
25849 purposes. This kind of typedefs is produced by the C++ FE for
25852 typedef struct {...} foo;
25854 In that case, there is no typedef variant type produced for foo.
25855 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
25859 is_naming_typedef_decl (const_tree decl
)
25861 if (decl
== NULL_TREE
25862 || TREE_CODE (decl
) != TYPE_DECL
25863 || DECL_NAMELESS (decl
)
25864 || !is_tagged_type (TREE_TYPE (decl
))
25865 || DECL_IS_BUILTIN (decl
)
25866 || is_redundant_typedef (decl
)
25867 /* It looks like Ada produces TYPE_DECLs that are very similar
25868 to C++ naming typedefs but that have different
25869 semantics. Let's be specific to c++ for now. */
25873 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
25874 && TYPE_NAME (TREE_TYPE (decl
)) == decl
25875 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
25876 != TYPE_NAME (TREE_TYPE (decl
))));
25879 /* Looks up the DIE for a context. */
25881 static inline dw_die_ref
25882 lookup_context_die (tree context
)
25886 /* Find die that represents this context. */
25887 if (TYPE_P (context
))
25889 context
= TYPE_MAIN_VARIANT (context
);
25890 dw_die_ref ctx
= lookup_type_die (context
);
25893 return strip_naming_typedef (context
, ctx
);
25896 return lookup_decl_die (context
);
25898 return comp_unit_die ();
25901 /* Returns the DIE for a context. */
25903 static inline dw_die_ref
25904 get_context_die (tree context
)
25908 /* Find die that represents this context. */
25909 if (TYPE_P (context
))
25911 context
= TYPE_MAIN_VARIANT (context
);
25912 return strip_naming_typedef (context
, force_type_die (context
));
25915 return force_decl_die (context
);
25917 return comp_unit_die ();
25920 /* Returns the DIE for decl. A DIE will always be returned. */
25923 force_decl_die (tree decl
)
25925 dw_die_ref decl_die
;
25926 unsigned saved_external_flag
;
25927 tree save_fn
= NULL_TREE
;
25928 decl_die
= lookup_decl_die (decl
);
25931 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
25933 decl_die
= lookup_decl_die (decl
);
25937 switch (TREE_CODE (decl
))
25939 case FUNCTION_DECL
:
25940 /* Clear current_function_decl, so that gen_subprogram_die thinks
25941 that this is a declaration. At this point, we just want to force
25942 declaration die. */
25943 save_fn
= current_function_decl
;
25944 current_function_decl
= NULL_TREE
;
25945 gen_subprogram_die (decl
, context_die
);
25946 current_function_decl
= save_fn
;
25950 /* Set external flag to force declaration die. Restore it after
25951 gen_decl_die() call. */
25952 saved_external_flag
= DECL_EXTERNAL (decl
);
25953 DECL_EXTERNAL (decl
) = 1;
25954 gen_decl_die (decl
, NULL
, NULL
, context_die
);
25955 DECL_EXTERNAL (decl
) = saved_external_flag
;
25958 case NAMESPACE_DECL
:
25959 if (dwarf_version
>= 3 || !dwarf_strict
)
25960 dwarf2out_decl (decl
);
25962 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
25963 decl_die
= comp_unit_die ();
25966 case TRANSLATION_UNIT_DECL
:
25967 decl_die
= comp_unit_die ();
25971 gcc_unreachable ();
25974 /* We should be able to find the DIE now. */
25976 decl_die
= lookup_decl_die (decl
);
25977 gcc_assert (decl_die
);
25983 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
25984 always returned. */
25987 force_type_die (tree type
)
25989 dw_die_ref type_die
;
25991 type_die
= lookup_type_die (type
);
25994 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
25996 type_die
= modified_type_die (type
, TYPE_QUALS_NO_ADDR_SPACE (type
),
25997 false, context_die
);
25998 gcc_assert (type_die
);
26003 /* Force out any required namespaces to be able to output DECL,
26004 and return the new context_die for it, if it's changed. */
26007 setup_namespace_context (tree thing
, dw_die_ref context_die
)
26009 tree context
= (DECL_P (thing
)
26010 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
26011 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
26012 /* Force out the namespace. */
26013 context_die
= force_decl_die (context
);
26015 return context_die
;
26018 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
26019 type) within its namespace, if appropriate.
26021 For compatibility with older debuggers, namespace DIEs only contain
26022 declarations; all definitions are emitted at CU scope, with
26023 DW_AT_specification pointing to the declaration (like with class
26027 declare_in_namespace (tree thing
, dw_die_ref context_die
)
26029 dw_die_ref ns_context
;
26031 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26032 return context_die
;
26034 /* External declarations in the local scope only need to be emitted
26035 once, not once in the namespace and once in the scope.
26037 This avoids declaring the `extern' below in the
26038 namespace DIE as well as in the innermost scope:
26051 if (DECL_P (thing
) && DECL_EXTERNAL (thing
) && local_scope_p (context_die
))
26052 return context_die
;
26054 /* If this decl is from an inlined function, then don't try to emit it in its
26055 namespace, as we will get confused. It would have already been emitted
26056 when the abstract instance of the inline function was emitted anyways. */
26057 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
26058 return context_die
;
26060 ns_context
= setup_namespace_context (thing
, context_die
);
26062 if (ns_context
!= context_die
)
26064 if (is_fortran () || is_dlang ())
26066 if (DECL_P (thing
))
26067 gen_decl_die (thing
, NULL
, NULL
, ns_context
);
26069 gen_type_die (thing
, ns_context
);
26071 return context_die
;
26074 /* Generate a DIE for a namespace or namespace alias. */
26077 gen_namespace_die (tree decl
, dw_die_ref context_die
)
26079 dw_die_ref namespace_die
;
26081 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
26082 they are an alias of. */
26083 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
26085 /* Output a real namespace or module. */
26086 context_die
= setup_namespace_context (decl
, comp_unit_die ());
26087 namespace_die
= new_die (is_fortran () || is_dlang ()
26088 ? DW_TAG_module
: DW_TAG_namespace
,
26089 context_die
, decl
);
26090 /* For Fortran modules defined in different CU don't add src coords. */
26091 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
26093 const char *name
= dwarf2_name (decl
, 0);
26095 add_name_attribute (namespace_die
, name
);
26098 add_name_and_src_coords_attributes (namespace_die
, decl
);
26099 if (DECL_EXTERNAL (decl
))
26100 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
26101 equate_decl_number_to_die (decl
, namespace_die
);
26105 /* Output a namespace alias. */
26107 /* Force out the namespace we are an alias of, if necessary. */
26108 dw_die_ref origin_die
26109 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
26111 if (DECL_FILE_SCOPE_P (decl
)
26112 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
26113 context_die
= setup_namespace_context (decl
, comp_unit_die ());
26114 /* Now create the namespace alias DIE. */
26115 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
26116 add_name_and_src_coords_attributes (namespace_die
, decl
);
26117 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
26118 equate_decl_number_to_die (decl
, namespace_die
);
26120 if ((dwarf_version
>= 5 || !dwarf_strict
)
26121 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
26122 DW_AT_export_symbols
) == 1)
26123 add_AT_flag (namespace_die
, DW_AT_export_symbols
, 1);
26125 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
26126 if (want_pubnames ())
26127 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
26130 /* Generate Dwarf debug information for a decl described by DECL.
26131 The return value is currently only meaningful for PARM_DECLs,
26132 for all other decls it returns NULL.
26134 If DECL is a FIELD_DECL, CTX is required: see the comment for VLR_CONTEXT.
26135 It can be NULL otherwise. */
26138 gen_decl_die (tree decl
, tree origin
, struct vlr_context
*ctx
,
26139 dw_die_ref context_die
)
26141 tree decl_or_origin
= decl
? decl
: origin
;
26142 tree class_origin
= NULL
, ultimate_origin
;
26144 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
26147 switch (TREE_CODE (decl_or_origin
))
26153 if (!is_fortran () && !is_ada () && !is_dlang ())
26155 /* The individual enumerators of an enum type get output when we output
26156 the Dwarf representation of the relevant enum type itself. */
26160 /* Emit its type. */
26161 gen_type_die (TREE_TYPE (decl
), context_die
);
26163 /* And its containing namespace. */
26164 context_die
= declare_in_namespace (decl
, context_die
);
26166 gen_const_die (decl
, context_die
);
26169 case FUNCTION_DECL
:
26172 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
26173 on local redeclarations of global functions. That seems broken. */
26174 if (current_function_decl
!= decl
)
26175 /* This is only a declaration. */;
26178 /* We should have abstract copies already and should not generate
26179 stray type DIEs in late LTO dumping. */
26183 /* If we're emitting a clone, emit info for the abstract instance. */
26184 else if (origin
|| DECL_ORIGIN (decl
) != decl
)
26185 dwarf2out_abstract_function (origin
26186 ? DECL_ORIGIN (origin
)
26187 : DECL_ABSTRACT_ORIGIN (decl
));
26189 /* If we're emitting a possibly inlined function emit it as
26190 abstract instance. */
26191 else if (cgraph_function_possibly_inlined_p (decl
)
26192 && ! DECL_ABSTRACT_P (decl
)
26193 && ! class_or_namespace_scope_p (context_die
)
26194 /* dwarf2out_abstract_function won't emit a die if this is just
26195 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
26196 that case, because that works only if we have a die. */
26197 && DECL_INITIAL (decl
) != NULL_TREE
)
26198 dwarf2out_abstract_function (decl
);
26200 /* Otherwise we're emitting the primary DIE for this decl. */
26201 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
26203 /* Before we describe the FUNCTION_DECL itself, make sure that we
26204 have its containing type. */
26206 origin
= decl_class_context (decl
);
26207 if (origin
!= NULL_TREE
)
26208 gen_type_die (origin
, context_die
);
26210 /* And its return type. */
26211 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
26213 /* And its virtual context. */
26214 if (DECL_VINDEX (decl
) != NULL_TREE
)
26215 gen_type_die (DECL_CONTEXT (decl
), context_die
);
26217 /* Make sure we have a member DIE for decl. */
26218 if (origin
!= NULL_TREE
)
26219 gen_type_die_for_member (origin
, decl
, context_die
);
26221 /* And its containing namespace. */
26222 context_die
= declare_in_namespace (decl
, context_die
);
26225 /* Now output a DIE to represent the function itself. */
26227 gen_subprogram_die (decl
, context_die
);
26231 /* If we are in terse mode, don't generate any DIEs to represent any
26232 actual typedefs. */
26233 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26236 /* In the special case of a TYPE_DECL node representing the declaration
26237 of some type tag, if the given TYPE_DECL is marked as having been
26238 instantiated from some other (original) TYPE_DECL node (e.g. one which
26239 was generated within the original definition of an inline function) we
26240 used to generate a special (abbreviated) DW_TAG_structure_type,
26241 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
26242 should be actually referencing those DIEs, as variable DIEs with that
26243 type would be emitted already in the abstract origin, so it was always
26244 removed during unused type prunning. Don't add anything in this
26246 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
26249 if (is_redundant_typedef (decl
))
26250 gen_type_die (TREE_TYPE (decl
), context_die
);
26252 /* Output a DIE to represent the typedef itself. */
26253 gen_typedef_die (decl
, context_die
);
26257 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
26258 gen_label_die (decl
, context_die
);
26263 /* If we are in terse mode, don't generate any DIEs to represent any
26264 variable declarations or definitions. */
26265 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26268 /* Avoid generating stray type DIEs during late dwarf dumping.
26269 All types have been dumped early. */
26271 /* ??? But in LTRANS we cannot annotate early created variably
26272 modified type DIEs without copying them and adjusting all
26273 references to them. Dump them again as happens for inlining
26274 which copies both the decl and the types. */
26275 /* ??? And even non-LTO needs to re-visit type DIEs to fill
26276 in VLA bound information for example. */
26277 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
26278 current_function_decl
)))
26280 /* Output any DIEs that are needed to specify the type of this data
26282 if (decl_by_reference_p (decl_or_origin
))
26283 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
26285 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
26290 /* And its containing type. */
26291 class_origin
= decl_class_context (decl_or_origin
);
26292 if (class_origin
!= NULL_TREE
)
26293 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
26295 /* And its containing namespace. */
26296 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
26299 /* Now output the DIE to represent the data object itself. This gets
26300 complicated because of the possibility that the VAR_DECL really
26301 represents an inlined instance of a formal parameter for an inline
26303 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
26304 if (ultimate_origin
!= NULL_TREE
26305 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
26306 gen_formal_parameter_die (decl
, origin
,
26307 true /* Emit name attribute. */,
26310 gen_variable_die (decl
, origin
, context_die
);
26314 gcc_assert (ctx
!= NULL
&& ctx
->struct_type
!= NULL
);
26315 /* Ignore the nameless fields that are used to skip bits but handle C++
26316 anonymous unions and structs. */
26317 if (DECL_NAME (decl
) != NULL_TREE
26318 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
26319 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
26321 gen_type_die (member_declared_type (decl
), context_die
);
26322 gen_field_die (decl
, ctx
, context_die
);
26327 /* Avoid generating stray type DIEs during late dwarf dumping.
26328 All types have been dumped early. */
26330 /* ??? But in LTRANS we cannot annotate early created variably
26331 modified type DIEs without copying them and adjusting all
26332 references to them. Dump them again as happens for inlining
26333 which copies both the decl and the types. */
26334 /* ??? And even non-LTO needs to re-visit type DIEs to fill
26335 in VLA bound information for example. */
26336 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
26337 current_function_decl
)))
26339 if (DECL_BY_REFERENCE (decl_or_origin
))
26340 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
26342 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
26344 return gen_formal_parameter_die (decl
, origin
,
26345 true /* Emit name attribute. */,
26348 case NAMESPACE_DECL
:
26349 if (dwarf_version
>= 3 || !dwarf_strict
)
26350 gen_namespace_die (decl
, context_die
);
26353 case IMPORTED_DECL
:
26354 dwarf2out_imported_module_or_decl_1 (decl
, DECL_NAME (decl
),
26355 DECL_CONTEXT (decl
), context_die
);
26358 case NAMELIST_DECL
:
26359 gen_namelist_decl (DECL_NAME (decl
), context_die
,
26360 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
26364 /* Probably some frontend-internal decl. Assume we don't care. */
26365 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
26372 /* Output initial debug information for global DECL. Called at the
26373 end of the parsing process.
26375 This is the initial debug generation process. As such, the DIEs
26376 generated may be incomplete. A later debug generation pass
26377 (dwarf2out_late_global_decl) will augment the information generated
26378 in this pass (e.g., with complete location info). */
26381 dwarf2out_early_global_decl (tree decl
)
26385 /* gen_decl_die() will set DECL_ABSTRACT because
26386 cgraph_function_possibly_inlined_p() returns true. This is in
26387 turn will cause DW_AT_inline attributes to be set.
26389 This happens because at early dwarf generation, there is no
26390 cgraph information, causing cgraph_function_possibly_inlined_p()
26391 to return true. Trick cgraph_function_possibly_inlined_p()
26392 while we generate dwarf early. */
26393 bool save
= symtab
->global_info_ready
;
26394 symtab
->global_info_ready
= true;
26396 /* We don't handle TYPE_DECLs. If required, they'll be reached via
26397 other DECLs and they can point to template types or other things
26398 that dwarf2out can't handle when done via dwarf2out_decl. */
26399 if (TREE_CODE (decl
) != TYPE_DECL
26400 && TREE_CODE (decl
) != PARM_DECL
)
26402 if (TREE_CODE (decl
) == FUNCTION_DECL
)
26404 tree save_fndecl
= current_function_decl
;
26406 /* For nested functions, make sure we have DIEs for the parents first
26407 so that all nested DIEs are generated at the proper scope in the
26409 tree context
= decl_function_context (decl
);
26410 if (context
!= NULL
)
26412 dw_die_ref context_die
= lookup_decl_die (context
);
26413 current_function_decl
= context
;
26415 /* Avoid emitting DIEs multiple times, but still process CONTEXT
26416 enough so that it lands in its own context. This avoids type
26417 pruning issues later on. */
26418 if (context_die
== NULL
|| is_declaration_die (context_die
))
26419 dwarf2out_early_global_decl (context
);
26422 /* Emit an abstract origin of a function first. This happens
26423 with C++ constructor clones for example and makes
26424 dwarf2out_abstract_function happy which requires the early
26425 DIE of the abstract instance to be present. */
26426 tree origin
= DECL_ABSTRACT_ORIGIN (decl
);
26427 dw_die_ref origin_die
;
26429 /* Do not emit the DIE multiple times but make sure to
26430 process it fully here in case we just saw a declaration. */
26431 && ((origin_die
= lookup_decl_die (origin
)) == NULL
26432 || is_declaration_die (origin_die
)))
26434 current_function_decl
= origin
;
26435 dwarf2out_decl (origin
);
26438 /* Emit the DIE for decl but avoid doing that multiple times. */
26439 dw_die_ref old_die
;
26440 if ((old_die
= lookup_decl_die (decl
)) == NULL
26441 || is_declaration_die (old_die
))
26443 current_function_decl
= decl
;
26444 dwarf2out_decl (decl
);
26447 current_function_decl
= save_fndecl
;
26450 dwarf2out_decl (decl
);
26452 symtab
->global_info_ready
= save
;
26455 /* Return whether EXPR is an expression with the following pattern:
26456 INDIRECT_REF (NOP_EXPR (INTEGER_CST)). */
26459 is_trivial_indirect_ref (tree expr
)
26461 if (expr
== NULL_TREE
|| TREE_CODE (expr
) != INDIRECT_REF
)
26464 tree nop
= TREE_OPERAND (expr
, 0);
26465 if (nop
== NULL_TREE
|| TREE_CODE (nop
) != NOP_EXPR
)
26468 tree int_cst
= TREE_OPERAND (nop
, 0);
26469 return int_cst
!= NULL_TREE
&& TREE_CODE (int_cst
) == INTEGER_CST
;
26472 /* Output debug information for global decl DECL. Called from
26473 toplev.c after compilation proper has finished. */
26476 dwarf2out_late_global_decl (tree decl
)
26478 /* Fill-in any location information we were unable to determine
26479 on the first pass. */
26482 dw_die_ref die
= lookup_decl_die (decl
);
26484 /* We may have to generate early debug late for LTO in case debug
26485 was not enabled at compile-time or the target doesn't support
26486 the LTO early debug scheme. */
26487 if (! die
&& in_lto_p
)
26489 dwarf2out_decl (decl
);
26490 die
= lookup_decl_die (decl
);
26495 /* We get called via the symtab code invoking late_global_decl
26496 for symbols that are optimized out.
26498 Do not add locations for those, except if they have a
26499 DECL_VALUE_EXPR, in which case they are relevant for debuggers.
26500 Still don't add a location if the DECL_VALUE_EXPR is not a trivial
26501 INDIRECT_REF expression, as this could generate relocations to
26502 text symbols in LTO object files, which is invalid. */
26503 varpool_node
*node
= varpool_node::get (decl
);
26504 if ((! node
|| ! node
->definition
)
26505 && ! (DECL_HAS_VALUE_EXPR_P (decl
)
26506 && is_trivial_indirect_ref (DECL_VALUE_EXPR (decl
))))
26507 tree_add_const_value_attribute_for_decl (die
, decl
);
26509 add_location_or_const_value_attribute (die
, decl
, false);
26514 /* Output debug information for type decl DECL. Called from toplev.c
26515 and from language front ends (to record built-in types). */
26517 dwarf2out_type_decl (tree decl
, int local
)
26522 dwarf2out_decl (decl
);
26526 /* Output debug information for imported module or decl DECL.
26527 NAME is non-NULL name in the lexical block if the decl has been renamed.
26528 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
26529 that DECL belongs to.
26530 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
26532 dwarf2out_imported_module_or_decl_1 (tree decl
,
26534 tree lexical_block
,
26535 dw_die_ref lexical_block_die
)
26537 expanded_location xloc
;
26538 dw_die_ref imported_die
= NULL
;
26539 dw_die_ref at_import_die
;
26541 if (TREE_CODE (decl
) == IMPORTED_DECL
)
26543 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
26544 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
26548 xloc
= expand_location (input_location
);
26550 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
26552 at_import_die
= force_type_die (TREE_TYPE (decl
));
26553 /* For namespace N { typedef void T; } using N::T; base_type_die
26554 returns NULL, but DW_TAG_imported_declaration requires
26555 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
26556 if (!at_import_die
)
26558 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
26559 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
26560 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
26561 gcc_assert (at_import_die
);
26566 at_import_die
= lookup_decl_die (decl
);
26567 if (!at_import_die
)
26569 /* If we're trying to avoid duplicate debug info, we may not have
26570 emitted the member decl for this field. Emit it now. */
26571 if (TREE_CODE (decl
) == FIELD_DECL
)
26573 tree type
= DECL_CONTEXT (decl
);
26575 if (TYPE_CONTEXT (type
)
26576 && TYPE_P (TYPE_CONTEXT (type
))
26577 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
26578 DINFO_USAGE_DIR_USE
))
26580 gen_type_die_for_member (type
, decl
,
26581 get_context_die (TYPE_CONTEXT (type
)));
26583 if (TREE_CODE (decl
) == NAMELIST_DECL
)
26584 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
26585 get_context_die (DECL_CONTEXT (decl
)),
26588 at_import_die
= force_decl_die (decl
);
26592 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
26594 if (dwarf_version
>= 3 || !dwarf_strict
)
26595 imported_die
= new_die (DW_TAG_imported_module
,
26602 imported_die
= new_die (DW_TAG_imported_declaration
,
26606 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
26607 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
26608 if (debug_column_info
&& xloc
.column
)
26609 add_AT_unsigned (imported_die
, DW_AT_decl_column
, xloc
.column
);
26611 add_AT_string (imported_die
, DW_AT_name
,
26612 IDENTIFIER_POINTER (name
));
26613 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
26616 /* Output debug information for imported module or decl DECL.
26617 NAME is non-NULL name in context if the decl has been renamed.
26618 CHILD is true if decl is one of the renamed decls as part of
26619 importing whole module.
26620 IMPLICIT is set if this hook is called for an implicit import
26621 such as inline namespace. */
26624 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
26625 bool child
, bool implicit
)
26627 /* dw_die_ref at_import_die; */
26628 dw_die_ref scope_die
;
26630 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26635 /* For DWARF5, just DW_AT_export_symbols on the DW_TAG_namespace
26636 should be enough, for DWARF4 and older even if we emit as extension
26637 DW_AT_export_symbols add the implicit DW_TAG_imported_module anyway
26638 for the benefit of consumers unaware of DW_AT_export_symbols. */
26640 && dwarf_version
>= 5
26641 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
26642 DW_AT_export_symbols
) == 1)
26647 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
26648 We need decl DIE for reference and scope die. First, get DIE for the decl
26651 /* Get the scope die for decl context. Use comp_unit_die for global module
26652 or decl. If die is not found for non globals, force new die. */
26654 && TYPE_P (context
)
26655 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
26658 scope_die
= get_context_die (context
);
26662 /* DW_TAG_imported_module was introduced in the DWARFv3 specification, so
26663 there is nothing we can do, here. */
26664 if (dwarf_version
< 3 && dwarf_strict
)
26667 gcc_assert (scope_die
->die_child
);
26668 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
26669 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
26670 scope_die
= scope_die
->die_child
;
26673 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
26674 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
26677 /* Output debug information for namelists. */
26680 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
26682 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
26686 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26689 gcc_assert (scope_die
!= NULL
);
26690 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
26691 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
26693 /* If there are no item_decls, we have a nondefining namelist, e.g.
26694 with USE association; hence, set DW_AT_declaration. */
26695 if (item_decls
== NULL_TREE
)
26697 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
26701 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
26703 nml_item_ref_die
= lookup_decl_die (value
);
26704 if (!nml_item_ref_die
)
26705 nml_item_ref_die
= force_decl_die (value
);
26707 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
26708 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
26714 /* Write the debugging output for DECL and return the DIE. */
26717 dwarf2out_decl (tree decl
)
26719 dw_die_ref context_die
= comp_unit_die ();
26721 switch (TREE_CODE (decl
))
26726 case FUNCTION_DECL
:
26727 /* If we're a nested function, initially use a parent of NULL; if we're
26728 a plain function, this will be fixed up in decls_for_scope. If
26729 we're a method, it will be ignored, since we already have a DIE.
26730 Avoid doing this late though since clones of class methods may
26731 otherwise end up in limbo and create type DIEs late. */
26733 && decl_function_context (decl
)
26734 /* But if we're in terse mode, we don't care about scope. */
26735 && debug_info_level
> DINFO_LEVEL_TERSE
)
26736 context_die
= NULL
;
26740 /* For local statics lookup proper context die. */
26741 if (local_function_static (decl
))
26742 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
26744 /* If we are in terse mode, don't generate any DIEs to represent any
26745 variable declarations or definitions. */
26746 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26751 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26753 if (!is_fortran () && !is_ada () && !is_dlang ())
26755 if (TREE_STATIC (decl
) && decl_function_context (decl
))
26756 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
26759 case NAMESPACE_DECL
:
26760 case IMPORTED_DECL
:
26761 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26763 if (lookup_decl_die (decl
) != NULL
)
26768 /* Don't emit stubs for types unless they are needed by other DIEs. */
26769 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
26772 /* Don't bother trying to generate any DIEs to represent any of the
26773 normal built-in types for the language we are compiling. */
26774 if (DECL_IS_BUILTIN (decl
))
26777 /* If we are in terse mode, don't generate any DIEs for types. */
26778 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26781 /* If we're a function-scope tag, initially use a parent of NULL;
26782 this will be fixed up in decls_for_scope. */
26783 if (decl_function_context (decl
))
26784 context_die
= NULL
;
26788 case NAMELIST_DECL
:
26795 gen_decl_die (decl
, NULL
, NULL
, context_die
);
26799 dw_die_ref die
= lookup_decl_die (decl
);
26805 /* Write the debugging output for DECL. */
26808 dwarf2out_function_decl (tree decl
)
26810 dwarf2out_decl (decl
);
26811 call_arg_locations
= NULL
;
26812 call_arg_loc_last
= NULL
;
26813 call_site_count
= -1;
26814 tail_call_site_count
= -1;
26815 decl_loc_table
->empty ();
26816 cached_dw_loc_list_table
->empty ();
26819 /* Output a marker (i.e. a label) for the beginning of the generated code for
26820 a lexical block. */
26823 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
26824 unsigned int blocknum
)
26826 switch_to_section (current_function_section ());
26827 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
26830 /* Output a marker (i.e. a label) for the end of the generated code for a
26834 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
26836 switch_to_section (current_function_section ());
26837 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
26840 /* Returns nonzero if it is appropriate not to emit any debugging
26841 information for BLOCK, because it doesn't contain any instructions.
26843 Don't allow this for blocks with nested functions or local classes
26844 as we would end up with orphans, and in the presence of scheduling
26845 we may end up calling them anyway. */
26848 dwarf2out_ignore_block (const_tree block
)
26853 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
26854 if (TREE_CODE (decl
) == FUNCTION_DECL
26855 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
26857 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
26859 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
26860 if (TREE_CODE (decl
) == FUNCTION_DECL
26861 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
26868 /* Hash table routines for file_hash. */
26871 dwarf_file_hasher::equal (dwarf_file_data
*p1
, const char *p2
)
26873 return filename_cmp (p1
->filename
, p2
) == 0;
26877 dwarf_file_hasher::hash (dwarf_file_data
*p
)
26879 return htab_hash_string (p
->filename
);
26882 /* Lookup FILE_NAME (in the list of filenames that we know about here in
26883 dwarf2out.c) and return its "index". The index of each (known) filename is
26884 just a unique number which is associated with only that one filename. We
26885 need such numbers for the sake of generating labels (in the .debug_sfnames
26886 section) and references to those files numbers (in the .debug_srcinfo
26887 and .debug_macinfo sections). If the filename given as an argument is not
26888 found in our current list, add it to the list and assign it the next
26889 available unique index number. */
26891 static struct dwarf_file_data
*
26892 lookup_filename (const char *file_name
)
26894 struct dwarf_file_data
* created
;
26899 dwarf_file_data
**slot
26900 = file_table
->find_slot_with_hash (file_name
, htab_hash_string (file_name
),
26905 created
= ggc_alloc
<dwarf_file_data
> ();
26906 created
->filename
= file_name
;
26907 created
->emitted_number
= 0;
26912 /* If the assembler will construct the file table, then translate the compiler
26913 internal file table number into the assembler file table number, and emit
26914 a .file directive if we haven't already emitted one yet. The file table
26915 numbers are different because we prune debug info for unused variables and
26916 types, which may include filenames. */
26919 maybe_emit_file (struct dwarf_file_data
* fd
)
26921 if (! fd
->emitted_number
)
26923 if (last_emitted_file
)
26924 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
26926 fd
->emitted_number
= 1;
26927 last_emitted_file
= fd
;
26929 if (output_asm_line_debug_info ())
26931 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
26932 output_quoted_string (asm_out_file
,
26933 remap_debug_filename (fd
->filename
));
26934 fputc ('\n', asm_out_file
);
26938 return fd
->emitted_number
;
26941 /* Schedule generation of a DW_AT_const_value attribute to DIE.
26942 That generation should happen after function debug info has been
26943 generated. The value of the attribute is the constant value of ARG. */
26946 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
26948 die_arg_entry entry
;
26953 gcc_assert (early_dwarf
);
26955 if (!tmpl_value_parm_die_table
)
26956 vec_alloc (tmpl_value_parm_die_table
, 32);
26960 vec_safe_push (tmpl_value_parm_die_table
, entry
);
26963 /* Return TRUE if T is an instance of generic type, FALSE
26967 generic_type_p (tree t
)
26969 if (t
== NULL_TREE
|| !TYPE_P (t
))
26971 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
26974 /* Schedule the generation of the generic parameter dies for the
26975 instance of generic type T. The proper generation itself is later
26976 done by gen_scheduled_generic_parms_dies. */
26979 schedule_generic_params_dies_gen (tree t
)
26981 if (!generic_type_p (t
))
26984 gcc_assert (early_dwarf
);
26986 if (!generic_type_instances
)
26987 vec_alloc (generic_type_instances
, 256);
26989 vec_safe_push (generic_type_instances
, t
);
26992 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
26993 by append_entry_to_tmpl_value_parm_die_table. This function must
26994 be called after function DIEs have been generated. */
26997 gen_remaining_tmpl_value_param_die_attribute (void)
26999 if (tmpl_value_parm_die_table
)
27004 /* We do this in two phases - first get the cases we can
27005 handle during early-finish, preserving those we cannot
27006 (containing symbolic constants where we don't yet know
27007 whether we are going to output the referenced symbols).
27008 For those we try again at late-finish. */
27010 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
27012 if (!e
->die
->removed
27013 && !tree_add_const_value_attribute (e
->die
, e
->arg
))
27015 dw_loc_descr_ref loc
= NULL
;
27017 && (dwarf_version
>= 5 || !dwarf_strict
))
27018 loc
= loc_descriptor_from_tree (e
->arg
, 2, NULL
);
27020 add_AT_loc (e
->die
, DW_AT_location
, loc
);
27022 (*tmpl_value_parm_die_table
)[j
++] = *e
;
27025 tmpl_value_parm_die_table
->truncate (j
);
27029 /* Generate generic parameters DIEs for instances of generic types
27030 that have been previously scheduled by
27031 schedule_generic_params_dies_gen. This function must be called
27032 after all the types of the CU have been laid out. */
27035 gen_scheduled_generic_parms_dies (void)
27040 if (!generic_type_instances
)
27043 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
27044 if (COMPLETE_TYPE_P (t
))
27045 gen_generic_params_dies (t
);
27047 generic_type_instances
= NULL
;
27051 /* Replace DW_AT_name for the decl with name. */
27054 dwarf2out_set_name (tree decl
, tree name
)
27057 dw_attr_node
*attr
;
27060 die
= TYPE_SYMTAB_DIE (decl
);
27064 dname
= dwarf2_name (name
, 0);
27068 attr
= get_AT (die
, DW_AT_name
);
27071 struct indirect_string_node
*node
;
27073 node
= find_AT_string (dname
);
27074 /* replace the string. */
27075 attr
->dw_attr_val
.v
.val_str
= node
;
27079 add_name_attribute (die
, dname
);
27082 /* True if before or during processing of the first function being emitted. */
27083 static bool in_first_function_p
= true;
27084 /* True if loc_note during dwarf2out_var_location call might still be
27085 before first real instruction at address equal to .Ltext0. */
27086 static bool maybe_at_text_label_p
= true;
27087 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
27088 static unsigned int first_loclabel_num_not_at_text_label
;
27090 /* Look ahead for a real insn, or for a begin stmt marker. */
27093 dwarf2out_next_real_insn (rtx_insn
*loc_note
)
27095 rtx_insn
*next_real
= NEXT_INSN (loc_note
);
27098 if (INSN_P (next_real
))
27101 next_real
= NEXT_INSN (next_real
);
27106 /* Called by the final INSN scan whenever we see a var location. We
27107 use it to drop labels in the right places, and throw the location in
27108 our lookup table. */
27111 dwarf2out_var_location (rtx_insn
*loc_note
)
27113 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
27114 struct var_loc_node
*newloc
;
27115 rtx_insn
*next_real
, *next_note
;
27116 rtx_insn
*call_insn
= NULL
;
27117 static const char *last_label
;
27118 static const char *last_postcall_label
;
27119 static bool last_in_cold_section_p
;
27120 static rtx_insn
*expected_next_loc_note
;
27123 var_loc_view view
= 0;
27125 if (!NOTE_P (loc_note
))
27127 if (CALL_P (loc_note
))
27129 maybe_reset_location_view (loc_note
, cur_line_info_table
);
27131 if (SIBLING_CALL_P (loc_note
))
27132 tail_call_site_count
++;
27133 if (find_reg_note (loc_note
, REG_CALL_ARG_LOCATION
, NULL_RTX
))
27135 call_insn
= loc_note
;
27139 next_real
= dwarf2out_next_real_insn (call_insn
);
27141 cached_next_real_insn
= NULL
;
27144 if (optimize
== 0 && !flag_var_tracking
)
27146 /* When the var-tracking pass is not running, there is no note
27147 for indirect calls whose target is compile-time known. In this
27148 case, process such calls specifically so that we generate call
27149 sites for them anyway. */
27150 rtx x
= PATTERN (loc_note
);
27151 if (GET_CODE (x
) == PARALLEL
)
27152 x
= XVECEXP (x
, 0, 0);
27153 if (GET_CODE (x
) == SET
)
27155 if (GET_CODE (x
) == CALL
)
27158 || GET_CODE (XEXP (x
, 0)) != SYMBOL_REF
27159 || !SYMBOL_REF_DECL (XEXP (x
, 0))
27160 || (TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0)))
27163 call_insn
= loc_note
;
27167 next_real
= dwarf2out_next_real_insn (call_insn
);
27169 cached_next_real_insn
= NULL
;
27174 else if (!debug_variable_location_views
)
27175 gcc_unreachable ();
27177 maybe_reset_location_view (loc_note
, cur_line_info_table
);
27182 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
27183 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
27186 /* Optimize processing a large consecutive sequence of location
27187 notes so we don't spend too much time in next_real_insn. If the
27188 next insn is another location note, remember the next_real_insn
27189 calculation for next time. */
27190 next_real
= cached_next_real_insn
;
27193 if (expected_next_loc_note
!= loc_note
)
27197 next_note
= NEXT_INSN (loc_note
);
27199 || next_note
->deleted ()
27200 || ! NOTE_P (next_note
)
27201 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
27202 && NOTE_KIND (next_note
) != NOTE_INSN_BEGIN_STMT
27203 && NOTE_KIND (next_note
) != NOTE_INSN_INLINE_ENTRY
))
27207 next_real
= dwarf2out_next_real_insn (loc_note
);
27211 expected_next_loc_note
= next_note
;
27212 cached_next_real_insn
= next_real
;
27215 cached_next_real_insn
= NULL
;
27217 /* If there are no instructions which would be affected by this note,
27218 don't do anything. */
27220 && next_real
== NULL_RTX
27221 && !NOTE_DURING_CALL_P (loc_note
))
27226 if (next_real
== NULL_RTX
)
27227 next_real
= get_last_insn ();
27229 /* If there were any real insns between note we processed last time
27230 and this note (or if it is the first note), clear
27231 last_{,postcall_}label so that they are not reused this time. */
27232 if (last_var_location_insn
== NULL_RTX
27233 || last_var_location_insn
!= next_real
27234 || last_in_cold_section_p
!= in_cold_section_p
)
27237 last_postcall_label
= NULL
;
27243 = NOTE_DURING_CALL_P (loc_note
) ? last_postcall_label
: last_label
;
27244 view
= cur_line_info_table
->view
;
27245 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
27246 newloc
= add_var_loc_to_decl (decl
, loc_note
, label
, view
);
27247 if (newloc
== NULL
)
27256 /* If there were no real insns between note we processed last time
27257 and this note, use the label we emitted last time. Otherwise
27258 create a new label and emit it. */
27259 if (last_label
== NULL
)
27261 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
27262 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
27264 last_label
= ggc_strdup (loclabel
);
27265 /* See if loclabel might be equal to .Ltext0. If yes,
27266 bump first_loclabel_num_not_at_text_label. */
27267 if (!have_multiple_function_sections
27268 && in_first_function_p
27269 && maybe_at_text_label_p
)
27271 static rtx_insn
*last_start
;
27273 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
27274 if (insn
== last_start
)
27276 else if (!NONDEBUG_INSN_P (insn
))
27280 rtx body
= PATTERN (insn
);
27281 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
27283 /* Inline asm could occupy zero bytes. */
27284 else if (GET_CODE (body
) == ASM_INPUT
27285 || asm_noperands (body
) >= 0)
27287 #ifdef HAVE_ATTR_length /* ??? We don't include insn-attr.h. */
27288 else if (HAVE_ATTR_length
&& get_attr_min_length (insn
) == 0)
27293 /* Assume insn has non-zero length. */
27294 maybe_at_text_label_p
= false;
27298 if (maybe_at_text_label_p
)
27300 last_start
= loc_note
;
27301 first_loclabel_num_not_at_text_label
= loclabel_num
;
27306 gcc_assert ((loc_note
== NULL_RTX
&& call_insn
!= NULL_RTX
)
27307 || (loc_note
!= NULL_RTX
&& call_insn
== NULL_RTX
));
27311 struct call_arg_loc_node
*ca_loc
27312 = ggc_cleared_alloc
<call_arg_loc_node
> ();
27313 rtx_insn
*prev
= call_insn
;
27315 ca_loc
->call_arg_loc_note
27316 = find_reg_note (call_insn
, REG_CALL_ARG_LOCATION
, NULL_RTX
);
27317 ca_loc
->next
= NULL
;
27318 ca_loc
->label
= last_label
;
27321 || (NONJUMP_INSN_P (prev
)
27322 && GET_CODE (PATTERN (prev
)) == SEQUENCE
27323 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
27324 if (!CALL_P (prev
))
27325 prev
= as_a
<rtx_sequence
*> (PATTERN (prev
))->insn (0);
27326 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
27328 /* Look for a SYMBOL_REF in the "prev" instruction. */
27329 rtx x
= get_call_rtx_from (PATTERN (prev
));
27332 /* Try to get the call symbol, if any. */
27333 if (MEM_P (XEXP (x
, 0)))
27335 /* First, look for a memory access to a symbol_ref. */
27336 if (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
27337 && SYMBOL_REF_DECL (XEXP (x
, 0))
27338 && TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0))) == FUNCTION_DECL
)
27339 ca_loc
->symbol_ref
= XEXP (x
, 0);
27340 /* Otherwise, look at a compile-time known user-level function
27344 && TREE_CODE (MEM_EXPR (x
)) == FUNCTION_DECL
)
27345 ca_loc
->symbol_ref
= XEXP (DECL_RTL (MEM_EXPR (x
)), 0);
27348 ca_loc
->block
= insn_scope (prev
);
27349 if (call_arg_locations
)
27350 call_arg_loc_last
->next
= ca_loc
;
27352 call_arg_locations
= ca_loc
;
27353 call_arg_loc_last
= ca_loc
;
27355 else if (loc_note
!= NULL_RTX
&& !NOTE_DURING_CALL_P (loc_note
))
27357 newloc
->label
= last_label
;
27358 newloc
->view
= view
;
27362 if (!last_postcall_label
)
27364 sprintf (loclabel
, "%s-1", last_label
);
27365 last_postcall_label
= ggc_strdup (loclabel
);
27367 newloc
->label
= last_postcall_label
;
27368 /* ??? This view is at last_label, not last_label-1, but we
27369 could only assume view at last_label-1 is zero if we could
27370 assume calls always have length greater than one. This is
27371 probably true in general, though there might be a rare
27372 exception to this rule, e.g. if a call insn is optimized out
27373 by target magic. Then, even the -1 in the label will be
27374 wrong, which might invalidate the range. Anyway, using view,
27375 though technically possibly incorrect, will work as far as
27376 ranges go: since L-1 is in the middle of the call insn,
27377 (L-1).0 and (L-1).V shouldn't make any difference, and having
27378 the loclist entry refer to the .loc entry might be useful, so
27379 leave it like this. */
27380 newloc
->view
= view
;
27383 if (var_loc_p
&& flag_debug_asm
)
27385 const char *name
, *sep
, *patstr
;
27386 if (decl
&& DECL_NAME (decl
))
27387 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
27390 if (NOTE_VAR_LOCATION_LOC (loc_note
))
27393 patstr
= str_pattern_slim (NOTE_VAR_LOCATION_LOC (loc_note
));
27400 fprintf (asm_out_file
, "\t%s DEBUG %s%s%s\n", ASM_COMMENT_START
,
27401 name
, sep
, patstr
);
27404 last_var_location_insn
= next_real
;
27405 last_in_cold_section_p
= in_cold_section_p
;
27408 /* Check whether BLOCK, a lexical block, is nested within OUTER, or is
27409 OUTER itself. If BOTHWAYS, check not only that BLOCK can reach
27410 OUTER through BLOCK_SUPERCONTEXT links, but also that there is a
27411 path from OUTER to BLOCK through BLOCK_SUBBLOCKs and
27412 BLOCK_FRAGMENT_ORIGIN links. */
27414 block_within_block_p (tree block
, tree outer
, bool bothways
)
27416 if (block
== outer
)
27419 /* Quickly check that OUTER is up BLOCK's supercontext chain. */
27420 for (tree context
= BLOCK_SUPERCONTEXT (block
);
27422 context
= BLOCK_SUPERCONTEXT (context
))
27423 if (!context
|| TREE_CODE (context
) != BLOCK
)
27429 /* Now check that each block is actually referenced by its
27431 for (tree context
= BLOCK_SUPERCONTEXT (block
); ;
27432 context
= BLOCK_SUPERCONTEXT (context
))
27434 if (BLOCK_FRAGMENT_ORIGIN (context
))
27436 gcc_assert (!BLOCK_SUBBLOCKS (context
));
27437 context
= BLOCK_FRAGMENT_ORIGIN (context
);
27439 for (tree sub
= BLOCK_SUBBLOCKS (context
);
27441 sub
= BLOCK_CHAIN (sub
))
27444 if (context
== outer
)
27451 /* Called during final while assembling the marker of the entry point
27452 for an inlined function. */
27455 dwarf2out_inline_entry (tree block
)
27457 gcc_assert (debug_inline_points
);
27459 /* If we can't represent it, don't bother. */
27460 if (!(dwarf_version
>= 3 || !dwarf_strict
))
27463 gcc_assert (DECL_P (block_ultimate_origin (block
)));
27465 /* Sanity check the block tree. This would catch a case in which
27466 BLOCK got removed from the tree reachable from the outermost
27467 lexical block, but got retained in markers. It would still link
27468 back to its parents, but some ancestor would be missing a link
27469 down the path to the sub BLOCK. If the block got removed, its
27470 BLOCK_NUMBER will not be a usable value. */
27472 gcc_assert (block_within_block_p (block
,
27473 DECL_INITIAL (current_function_decl
),
27476 gcc_assert (inlined_function_outer_scope_p (block
));
27477 gcc_assert (!lookup_block_die (block
));
27479 if (BLOCK_FRAGMENT_ORIGIN (block
))
27480 block
= BLOCK_FRAGMENT_ORIGIN (block
);
27481 /* Can the entry point ever not be at the beginning of an
27482 unfragmented lexical block? */
27483 else if (!(BLOCK_FRAGMENT_CHAIN (block
)
27484 || (cur_line_info_table
27485 && !ZERO_VIEW_P (cur_line_info_table
->view
))))
27488 if (!inline_entry_data_table
)
27489 inline_entry_data_table
27490 = hash_table
<inline_entry_data_hasher
>::create_ggc (10);
27493 inline_entry_data
**iedp
27494 = inline_entry_data_table
->find_slot_with_hash (block
,
27495 htab_hash_pointer (block
),
27498 /* ??? Ideally, we'd record all entry points for the same inlined
27499 function (some may have been duplicated by e.g. unrolling), but
27500 we have no way to represent that ATM. */
27503 inline_entry_data
*ied
= *iedp
= ggc_cleared_alloc
<inline_entry_data
> ();
27504 ied
->block
= block
;
27505 ied
->label_pfx
= BLOCK_INLINE_ENTRY_LABEL
;
27506 ied
->label_num
= BLOCK_NUMBER (block
);
27507 if (cur_line_info_table
)
27508 ied
->view
= cur_line_info_table
->view
;
27510 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27512 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_INLINE_ENTRY_LABEL
,
27513 BLOCK_NUMBER (block
));
27514 ASM_OUTPUT_LABEL (asm_out_file
, label
);
27517 /* Called from finalize_size_functions for size functions so that their body
27518 can be encoded in the debug info to describe the layout of variable-length
27522 dwarf2out_size_function (tree decl
)
27524 function_to_dwarf_procedure (decl
);
27527 /* Note in one location list that text section has changed. */
27530 var_location_switch_text_section_1 (var_loc_list
**slot
, void *)
27532 var_loc_list
*list
= *slot
;
27534 list
->last_before_switch
27535 = list
->last
->next
? list
->last
->next
: list
->last
;
27539 /* Note in all location lists that text section has changed. */
27542 var_location_switch_text_section (void)
27544 if (decl_loc_table
== NULL
)
27547 decl_loc_table
->traverse
<void *, var_location_switch_text_section_1
> (NULL
);
27550 /* Create a new line number table. */
27552 static dw_line_info_table
*
27553 new_line_info_table (void)
27555 dw_line_info_table
*table
;
27557 table
= ggc_cleared_alloc
<dw_line_info_table
> ();
27558 table
->file_num
= 1;
27559 table
->line_num
= 1;
27560 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
27561 FORCE_RESET_NEXT_VIEW (table
->view
);
27562 table
->symviews_since_reset
= 0;
27567 /* Lookup the "current" table into which we emit line info, so
27568 that we don't have to do it for every source line. */
27571 set_cur_line_info_table (section
*sec
)
27573 dw_line_info_table
*table
;
27575 if (sec
== text_section
)
27576 table
= text_section_line_info
;
27577 else if (sec
== cold_text_section
)
27579 table
= cold_text_section_line_info
;
27582 cold_text_section_line_info
= table
= new_line_info_table ();
27583 table
->end_label
= cold_end_label
;
27588 const char *end_label
;
27590 if (crtl
->has_bb_partition
)
27592 if (in_cold_section_p
)
27593 end_label
= crtl
->subsections
.cold_section_end_label
;
27595 end_label
= crtl
->subsections
.hot_section_end_label
;
27599 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27600 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
27601 current_function_funcdef_no
);
27602 end_label
= ggc_strdup (label
);
27605 table
= new_line_info_table ();
27606 table
->end_label
= end_label
;
27608 vec_safe_push (separate_line_info
, table
);
27611 if (output_asm_line_debug_info ())
27612 table
->is_stmt
= (cur_line_info_table
27613 ? cur_line_info_table
->is_stmt
27614 : DWARF_LINE_DEFAULT_IS_STMT_START
);
27615 cur_line_info_table
= table
;
27619 /* We need to reset the locations at the beginning of each
27620 function. We can't do this in the end_function hook, because the
27621 declarations that use the locations won't have been output when
27622 that hook is called. Also compute have_multiple_function_sections here. */
27625 dwarf2out_begin_function (tree fun
)
27627 section
*sec
= function_section (fun
);
27629 if (sec
!= text_section
)
27630 have_multiple_function_sections
= true;
27632 if (crtl
->has_bb_partition
&& !cold_text_section
)
27634 gcc_assert (current_function_decl
== fun
);
27635 cold_text_section
= unlikely_text_section ();
27636 switch_to_section (cold_text_section
);
27637 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
27638 switch_to_section (sec
);
27641 dwarf2out_note_section_used ();
27642 call_site_count
= 0;
27643 tail_call_site_count
= 0;
27645 set_cur_line_info_table (sec
);
27646 FORCE_RESET_NEXT_VIEW (cur_line_info_table
->view
);
27649 /* Helper function of dwarf2out_end_function, called only after emitting
27650 the very first function into assembly. Check if some .debug_loc range
27651 might end with a .LVL* label that could be equal to .Ltext0.
27652 In that case we must force using absolute addresses in .debug_loc ranges,
27653 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
27654 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
27656 Set have_multiple_function_sections to true in that case and
27657 terminate htab traversal. */
27660 find_empty_loc_ranges_at_text_label (var_loc_list
**slot
, int)
27662 var_loc_list
*entry
= *slot
;
27663 struct var_loc_node
*node
;
27665 node
= entry
->first
;
27666 if (node
&& node
->next
&& node
->next
->label
)
27669 const char *label
= node
->next
->label
;
27670 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
27672 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
27674 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
27675 if (strcmp (label
, loclabel
) == 0)
27677 have_multiple_function_sections
= true;
27685 /* Hook called after emitting a function into assembly.
27686 This does something only for the very first function emitted. */
27689 dwarf2out_end_function (unsigned int)
27691 if (in_first_function_p
27692 && !have_multiple_function_sections
27693 && first_loclabel_num_not_at_text_label
27695 decl_loc_table
->traverse
<int, find_empty_loc_ranges_at_text_label
> (0);
27696 in_first_function_p
= false;
27697 maybe_at_text_label_p
= false;
27700 /* Temporary holder for dwarf2out_register_main_translation_unit. Used to let
27701 front-ends register a translation unit even before dwarf2out_init is
27703 static tree main_translation_unit
= NULL_TREE
;
27705 /* Hook called by front-ends after they built their main translation unit.
27706 Associate comp_unit_die to UNIT. */
27709 dwarf2out_register_main_translation_unit (tree unit
)
27711 gcc_assert (TREE_CODE (unit
) == TRANSLATION_UNIT_DECL
27712 && main_translation_unit
== NULL_TREE
);
27713 main_translation_unit
= unit
;
27714 /* If dwarf2out_init has not been called yet, it will perform the association
27715 itself looking at main_translation_unit. */
27716 if (decl_die_table
!= NULL
)
27717 equate_decl_number_to_die (unit
, comp_unit_die ());
27720 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
27723 push_dw_line_info_entry (dw_line_info_table
*table
,
27724 enum dw_line_info_opcode opcode
, unsigned int val
)
27726 dw_line_info_entry e
;
27729 vec_safe_push (table
->entries
, e
);
27732 /* Output a label to mark the beginning of a source code line entry
27733 and record information relating to this source line, in
27734 'line_info_table' for later output of the .debug_line section. */
27735 /* ??? The discriminator parameter ought to be unsigned. */
27738 dwarf2out_source_line (unsigned int line
, unsigned int column
,
27739 const char *filename
,
27740 int discriminator
, bool is_stmt
)
27742 unsigned int file_num
;
27743 dw_line_info_table
*table
;
27744 static var_loc_view lvugid
;
27746 if (debug_info_level
< DINFO_LEVEL_TERSE
)
27749 table
= cur_line_info_table
;
27753 if (debug_variable_location_views
27754 && output_asm_line_debug_info ()
27755 && table
&& !RESETTING_VIEW_P (table
->view
))
27757 /* If we're using the assembler to compute view numbers, we
27758 can't issue a .loc directive for line zero, so we can't
27759 get a view number at this point. We might attempt to
27760 compute it from the previous view, or equate it to a
27761 subsequent view (though it might not be there!), but
27762 since we're omitting the line number entry, we might as
27763 well omit the view number as well. That means pretending
27764 it's a view number zero, which might very well turn out
27765 to be correct. ??? Extend the assembler so that the
27766 compiler could emit e.g. ".locview .LVU#", to output a
27767 view without changing line number information. We'd then
27768 have to count it in symviews_since_reset; when it's omitted,
27769 it doesn't count. */
27771 zero_view_p
= BITMAP_GGC_ALLOC ();
27772 bitmap_set_bit (zero_view_p
, table
->view
);
27773 if (flag_debug_asm
)
27775 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27776 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", table
->view
);
27777 fprintf (asm_out_file
, "\t%s line 0, omitted view ",
27778 ASM_COMMENT_START
);
27779 assemble_name (asm_out_file
, label
);
27780 putc ('\n', asm_out_file
);
27782 table
->view
= ++lvugid
;
27787 /* The discriminator column was added in dwarf4. Simplify the below
27788 by simply removing it if we're not supposed to output it. */
27789 if (dwarf_version
< 4 && dwarf_strict
)
27792 if (!debug_column_info
)
27795 file_num
= maybe_emit_file (lookup_filename (filename
));
27797 /* ??? TODO: Elide duplicate line number entries. Traditionally,
27798 the debugger has used the second (possibly duplicate) line number
27799 at the beginning of the function to mark the end of the prologue.
27800 We could eliminate any other duplicates within the function. For
27801 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
27802 that second line number entry. */
27803 /* Recall that this end-of-prologue indication is *not* the same thing
27804 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
27805 to which the hook corresponds, follows the last insn that was
27806 emitted by gen_prologue. What we need is to precede the first insn
27807 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
27808 insn that corresponds to something the user wrote. These may be
27809 very different locations once scheduling is enabled. */
27811 if (0 && file_num
== table
->file_num
27812 && line
== table
->line_num
27813 && column
== table
->column_num
27814 && discriminator
== table
->discrim_num
27815 && is_stmt
== table
->is_stmt
)
27818 switch_to_section (current_function_section ());
27820 /* If requested, emit something human-readable. */
27821 if (flag_debug_asm
)
27823 if (debug_column_info
)
27824 fprintf (asm_out_file
, "\t%s %s:%d:%d\n", ASM_COMMENT_START
,
27825 filename
, line
, column
);
27827 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
27831 if (output_asm_line_debug_info ())
27833 /* Emit the .loc directive understood by GNU as. */
27834 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
27835 file_num, line, is_stmt, discriminator */
27836 fputs ("\t.loc ", asm_out_file
);
27837 fprint_ul (asm_out_file
, file_num
);
27838 putc (' ', asm_out_file
);
27839 fprint_ul (asm_out_file
, line
);
27840 putc (' ', asm_out_file
);
27841 fprint_ul (asm_out_file
, column
);
27843 if (is_stmt
!= table
->is_stmt
)
27845 #if HAVE_GAS_LOC_STMT
27846 fputs (" is_stmt ", asm_out_file
);
27847 putc (is_stmt
? '1' : '0', asm_out_file
);
27850 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
27852 gcc_assert (discriminator
> 0);
27853 fputs (" discriminator ", asm_out_file
);
27854 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
27856 if (debug_variable_location_views
)
27858 if (!RESETTING_VIEW_P (table
->view
))
27860 table
->symviews_since_reset
++;
27861 if (table
->symviews_since_reset
> symview_upper_bound
)
27862 symview_upper_bound
= table
->symviews_since_reset
;
27863 /* When we're using the assembler to compute view
27864 numbers, we output symbolic labels after "view" in
27865 .loc directives, and the assembler will set them for
27866 us, so that we can refer to the view numbers in
27867 location lists. The only exceptions are when we know
27868 a view will be zero: "-0" is a forced reset, used
27869 e.g. in the beginning of functions, whereas "0" tells
27870 the assembler to check that there was a PC change
27871 since the previous view, in a way that implicitly
27872 resets the next view. */
27873 fputs (" view ", asm_out_file
);
27874 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27875 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", table
->view
);
27876 assemble_name (asm_out_file
, label
);
27877 table
->view
= ++lvugid
;
27881 table
->symviews_since_reset
= 0;
27882 if (FORCE_RESETTING_VIEW_P (table
->view
))
27883 fputs (" view -0", asm_out_file
);
27885 fputs (" view 0", asm_out_file
);
27886 /* Mark the present view as a zero view. Earlier debug
27887 binds may have already added its id to loclists to be
27888 emitted later, so we can't reuse the id for something
27889 else. However, it's good to know whether a view is
27890 known to be zero, because then we may be able to
27891 optimize out locviews that are all zeros, so take
27892 note of it in zero_view_p. */
27894 zero_view_p
= BITMAP_GGC_ALLOC ();
27895 bitmap_set_bit (zero_view_p
, lvugid
);
27896 table
->view
= ++lvugid
;
27899 putc ('\n', asm_out_file
);
27903 unsigned int label_num
= ++line_info_label_num
;
27905 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
27907 if (debug_variable_location_views
&& !RESETTING_VIEW_P (table
->view
))
27908 push_dw_line_info_entry (table
, LI_adv_address
, label_num
);
27910 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
27911 if (debug_variable_location_views
)
27913 bool resetting
= FORCE_RESETTING_VIEW_P (table
->view
);
27917 if (flag_debug_asm
)
27918 fprintf (asm_out_file
, "\t%s view %s%d\n",
27920 resetting
? "-" : "",
27925 if (file_num
!= table
->file_num
)
27926 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
27927 if (discriminator
!= table
->discrim_num
)
27928 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
27929 if (is_stmt
!= table
->is_stmt
)
27930 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
27931 push_dw_line_info_entry (table
, LI_set_line
, line
);
27932 if (debug_column_info
)
27933 push_dw_line_info_entry (table
, LI_set_column
, column
);
27936 table
->file_num
= file_num
;
27937 table
->line_num
= line
;
27938 table
->column_num
= column
;
27939 table
->discrim_num
= discriminator
;
27940 table
->is_stmt
= is_stmt
;
27941 table
->in_use
= true;
27944 /* Record the beginning of a new source file. */
27947 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
27949 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
27952 e
.code
= DW_MACINFO_start_file
;
27954 e
.info
= ggc_strdup (filename
);
27955 vec_safe_push (macinfo_table
, e
);
27959 /* Record the end of a source file. */
27962 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
27964 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
27967 e
.code
= DW_MACINFO_end_file
;
27970 vec_safe_push (macinfo_table
, e
);
27974 /* Called from debug_define in toplev.c. The `buffer' parameter contains
27975 the tail part of the directive line, i.e. the part which is past the
27976 initial whitespace, #, whitespace, directive-name, whitespace part. */
27979 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
27980 const char *buffer ATTRIBUTE_UNUSED
)
27982 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
27985 /* Insert a dummy first entry to be able to optimize the whole
27986 predefined macro block using DW_MACRO_import. */
27987 if (macinfo_table
->is_empty () && lineno
<= 1)
27992 vec_safe_push (macinfo_table
, e
);
27994 e
.code
= DW_MACINFO_define
;
27996 e
.info
= ggc_strdup (buffer
);
27997 vec_safe_push (macinfo_table
, e
);
28001 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
28002 the tail part of the directive line, i.e. the part which is past the
28003 initial whitespace, #, whitespace, directive-name, whitespace part. */
28006 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
28007 const char *buffer ATTRIBUTE_UNUSED
)
28009 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28012 /* Insert a dummy first entry to be able to optimize the whole
28013 predefined macro block using DW_MACRO_import. */
28014 if (macinfo_table
->is_empty () && lineno
<= 1)
28019 vec_safe_push (macinfo_table
, e
);
28021 e
.code
= DW_MACINFO_undef
;
28023 e
.info
= ggc_strdup (buffer
);
28024 vec_safe_push (macinfo_table
, e
);
28028 /* Helpers to manipulate hash table of CUs. */
28030 struct macinfo_entry_hasher
: nofree_ptr_hash
<macinfo_entry
>
28032 static inline hashval_t
hash (const macinfo_entry
*);
28033 static inline bool equal (const macinfo_entry
*, const macinfo_entry
*);
28037 macinfo_entry_hasher::hash (const macinfo_entry
*entry
)
28039 return htab_hash_string (entry
->info
);
28043 macinfo_entry_hasher::equal (const macinfo_entry
*entry1
,
28044 const macinfo_entry
*entry2
)
28046 return !strcmp (entry1
->info
, entry2
->info
);
28049 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
28051 /* Output a single .debug_macinfo entry. */
28054 output_macinfo_op (macinfo_entry
*ref
)
28058 struct indirect_string_node
*node
;
28059 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28060 struct dwarf_file_data
*fd
;
28064 case DW_MACINFO_start_file
:
28065 fd
= lookup_filename (ref
->info
);
28066 file_num
= maybe_emit_file (fd
);
28067 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
28068 dw2_asm_output_data_uleb128 (ref
->lineno
,
28069 "Included from line number %lu",
28070 (unsigned long) ref
->lineno
);
28071 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
28073 case DW_MACINFO_end_file
:
28074 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
28076 case DW_MACINFO_define
:
28077 case DW_MACINFO_undef
:
28078 len
= strlen (ref
->info
) + 1;
28080 && len
> DWARF_OFFSET_SIZE
28081 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
28082 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
28084 ref
->code
= ref
->code
== DW_MACINFO_define
28085 ? DW_MACRO_define_strp
: DW_MACRO_undef_strp
;
28086 output_macinfo_op (ref
);
28089 dw2_asm_output_data (1, ref
->code
,
28090 ref
->code
== DW_MACINFO_define
28091 ? "Define macro" : "Undefine macro");
28092 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
28093 (unsigned long) ref
->lineno
);
28094 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
28096 case DW_MACRO_define_strp
:
28097 case DW_MACRO_undef_strp
:
28098 node
= find_AT_string (ref
->info
);
28100 && (node
->form
== DW_FORM_strp
28101 || node
->form
== dwarf_FORM (DW_FORM_strx
)));
28102 dw2_asm_output_data (1, ref
->code
,
28103 ref
->code
== DW_MACRO_define_strp
28104 ? "Define macro strp"
28105 : "Undefine macro strp");
28106 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
28107 (unsigned long) ref
->lineno
);
28108 if (node
->form
== DW_FORM_strp
)
28109 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
28110 debug_str_section
, "The macro: \"%s\"",
28113 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
28116 case DW_MACRO_import
:
28117 dw2_asm_output_data (1, ref
->code
, "Import");
28118 ASM_GENERATE_INTERNAL_LABEL (label
,
28119 DEBUG_MACRO_SECTION_LABEL
,
28120 ref
->lineno
+ macinfo_label_base
);
28121 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
28124 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
28125 ASM_COMMENT_START
, (unsigned long) ref
->code
);
28130 /* Attempt to make a sequence of define/undef macinfo ops shareable with
28131 other compilation unit .debug_macinfo sections. IDX is the first
28132 index of a define/undef, return the number of ops that should be
28133 emitted in a comdat .debug_macinfo section and emit
28134 a DW_MACRO_import entry referencing it.
28135 If the define/undef entry should be emitted normally, return 0. */
28138 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
28139 macinfo_hash_type
**macinfo_htab
)
28141 macinfo_entry
*first
, *second
, *cur
, *inc
;
28142 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
28143 unsigned char checksum
[16];
28144 struct md5_ctx ctx
;
28145 char *grp_name
, *tail
;
28147 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
28148 macinfo_entry
**slot
;
28150 first
= &(*macinfo_table
)[idx
];
28151 second
= &(*macinfo_table
)[idx
+ 1];
28153 /* Optimize only if there are at least two consecutive define/undef ops,
28154 and either all of them are before first DW_MACINFO_start_file
28155 with lineno {0,1} (i.e. predefined macro block), or all of them are
28156 in some included header file. */
28157 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
28159 if (vec_safe_is_empty (files
))
28161 if (first
->lineno
> 1 || second
->lineno
> 1)
28164 else if (first
->lineno
== 0)
28167 /* Find the last define/undef entry that can be grouped together
28168 with first and at the same time compute md5 checksum of their
28169 codes, linenumbers and strings. */
28170 md5_init_ctx (&ctx
);
28171 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
28172 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
28174 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
28178 unsigned char code
= cur
->code
;
28179 md5_process_bytes (&code
, 1, &ctx
);
28180 checksum_uleb128 (cur
->lineno
, &ctx
);
28181 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
28183 md5_finish_ctx (&ctx
, checksum
);
28186 /* From the containing include filename (if any) pick up just
28187 usable characters from its basename. */
28188 if (vec_safe_is_empty (files
))
28191 base
= lbasename (files
->last ().info
);
28192 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
28193 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
28194 encoded_filename_len
++;
28195 /* Count . at the end. */
28196 if (encoded_filename_len
)
28197 encoded_filename_len
++;
28199 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
28200 linebuf_len
= strlen (linebuf
);
28202 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
28203 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
28205 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
28206 tail
= grp_name
+ 4;
28207 if (encoded_filename_len
)
28209 for (i
= 0; base
[i
]; i
++)
28210 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
28214 memcpy (tail
, linebuf
, linebuf_len
);
28215 tail
+= linebuf_len
;
28217 for (i
= 0; i
< 16; i
++)
28218 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
28220 /* Construct a macinfo_entry for DW_MACRO_import
28221 in the empty vector entry before the first define/undef. */
28222 inc
= &(*macinfo_table
)[idx
- 1];
28223 inc
->code
= DW_MACRO_import
;
28225 inc
->info
= ggc_strdup (grp_name
);
28226 if (!*macinfo_htab
)
28227 *macinfo_htab
= new macinfo_hash_type (10);
28228 /* Avoid emitting duplicates. */
28229 slot
= (*macinfo_htab
)->find_slot (inc
, INSERT
);
28234 /* If such an entry has been used before, just emit
28235 a DW_MACRO_import op. */
28237 output_macinfo_op (inc
);
28238 /* And clear all macinfo_entry in the range to avoid emitting them
28239 in the second pass. */
28240 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
28249 inc
->lineno
= (*macinfo_htab
)->elements ();
28250 output_macinfo_op (inc
);
28255 /* Save any strings needed by the macinfo table in the debug str
28256 table. All strings must be collected into the table by the time
28257 index_string is called. */
28260 save_macinfo_strings (void)
28264 macinfo_entry
*ref
;
28266 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
28270 /* Match the logic in output_macinfo_op to decide on
28271 indirect strings. */
28272 case DW_MACINFO_define
:
28273 case DW_MACINFO_undef
:
28274 len
= strlen (ref
->info
) + 1;
28276 && len
> DWARF_OFFSET_SIZE
28277 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
28278 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
28279 set_indirect_string (find_AT_string (ref
->info
));
28281 case DW_MACINFO_start_file
:
28282 /* -gsplit-dwarf -g3 will also output filename as indirect
28284 if (!dwarf_split_debug_info
)
28286 /* Fall through. */
28287 case DW_MACRO_define_strp
:
28288 case DW_MACRO_undef_strp
:
28289 set_indirect_string (find_AT_string (ref
->info
));
28297 /* Output macinfo section(s). */
28300 output_macinfo (const char *debug_line_label
, bool early_lto_debug
)
28303 unsigned long length
= vec_safe_length (macinfo_table
);
28304 macinfo_entry
*ref
;
28305 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
28306 macinfo_hash_type
*macinfo_htab
= NULL
;
28307 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
28312 /* output_macinfo* uses these interchangeably. */
28313 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_define
28314 && (int) DW_MACINFO_undef
== (int) DW_MACRO_undef
28315 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_start_file
28316 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_end_file
);
28318 /* AIX Assembler inserts the length, so adjust the reference to match the
28319 offset expected by debuggers. */
28320 strcpy (dl_section_ref
, debug_line_label
);
28321 if (XCOFF_DEBUGGING_INFO
)
28322 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
28324 /* For .debug_macro emit the section header. */
28325 if (!dwarf_strict
|| dwarf_version
>= 5)
28327 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
28328 "DWARF macro version number");
28329 if (DWARF_OFFSET_SIZE
== 8)
28330 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
28332 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
28333 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_line_label
,
28334 debug_line_section
, NULL
);
28337 /* In the first loop, it emits the primary .debug_macinfo section
28338 and after each emitted op the macinfo_entry is cleared.
28339 If a longer range of define/undef ops can be optimized using
28340 DW_MACRO_import, the DW_MACRO_import op is emitted and kept in
28341 the vector before the first define/undef in the range and the
28342 whole range of define/undef ops is not emitted and kept. */
28343 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
28347 case DW_MACINFO_start_file
:
28348 vec_safe_push (files
, *ref
);
28350 case DW_MACINFO_end_file
:
28351 if (!vec_safe_is_empty (files
))
28354 case DW_MACINFO_define
:
28355 case DW_MACINFO_undef
:
28356 if ((!dwarf_strict
|| dwarf_version
>= 5)
28357 && HAVE_COMDAT_GROUP
28358 && vec_safe_length (files
) != 1
28361 && (*macinfo_table
)[i
- 1].code
== 0)
28363 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
28372 /* A dummy entry may be inserted at the beginning to be able
28373 to optimize the whole block of predefined macros. */
28379 output_macinfo_op (ref
);
28387 /* Save the number of transparent includes so we can adjust the
28388 label number for the fat LTO object DWARF. */
28389 unsigned macinfo_label_base_adj
= macinfo_htab
->elements ();
28391 delete macinfo_htab
;
28392 macinfo_htab
= NULL
;
28394 /* If any DW_MACRO_import were used, on those DW_MACRO_import entries
28395 terminate the current chain and switch to a new comdat .debug_macinfo
28396 section and emit the define/undef entries within it. */
28397 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
28402 case DW_MACRO_import
:
28404 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28405 tree comdat_key
= get_identifier (ref
->info
);
28406 /* Terminate the previous .debug_macinfo section. */
28407 dw2_asm_output_data (1, 0, "End compilation unit");
28408 targetm
.asm_out
.named_section (debug_macinfo_section_name
,
28412 ? SECTION_EXCLUDE
: 0),
28414 ASM_GENERATE_INTERNAL_LABEL (label
,
28415 DEBUG_MACRO_SECTION_LABEL
,
28416 ref
->lineno
+ macinfo_label_base
);
28417 ASM_OUTPUT_LABEL (asm_out_file
, label
);
28420 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
28421 "DWARF macro version number");
28422 if (DWARF_OFFSET_SIZE
== 8)
28423 dw2_asm_output_data (1, 1, "Flags: 64-bit");
28425 dw2_asm_output_data (1, 0, "Flags: 32-bit");
28428 case DW_MACINFO_define
:
28429 case DW_MACINFO_undef
:
28430 output_macinfo_op (ref
);
28435 gcc_unreachable ();
28438 macinfo_label_base
+= macinfo_label_base_adj
;
28441 /* Initialize the various sections and labels for dwarf output and prefix
28442 them with PREFIX if non-NULL. Returns the generation (zero based
28443 number of times function was called). */
28446 init_sections_and_labels (bool early_lto_debug
)
28448 /* As we may get called multiple times have a generation count for
28450 static unsigned generation
= 0;
28452 if (early_lto_debug
)
28454 if (!dwarf_split_debug_info
)
28456 debug_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
28457 SECTION_DEBUG
| SECTION_EXCLUDE
,
28459 debug_abbrev_section
= get_section (DEBUG_LTO_ABBREV_SECTION
,
28460 SECTION_DEBUG
| SECTION_EXCLUDE
,
28462 debug_macinfo_section_name
28463 = ((dwarf_strict
&& dwarf_version
< 5)
28464 ? DEBUG_LTO_MACINFO_SECTION
: DEBUG_LTO_MACRO_SECTION
);
28465 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28467 | SECTION_EXCLUDE
, NULL
);
28471 /* ??? Which of the following do we need early? */
28472 debug_info_section
= get_section (DEBUG_LTO_DWO_INFO_SECTION
,
28473 SECTION_DEBUG
| SECTION_EXCLUDE
,
28475 debug_abbrev_section
= get_section (DEBUG_LTO_DWO_ABBREV_SECTION
,
28476 SECTION_DEBUG
| SECTION_EXCLUDE
,
28478 debug_skeleton_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
28480 | SECTION_EXCLUDE
, NULL
);
28481 debug_skeleton_abbrev_section
28482 = get_section (DEBUG_LTO_ABBREV_SECTION
,
28483 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28484 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
28485 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
28488 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
28489 stay in the main .o, but the skeleton_line goes into the split
28491 debug_skeleton_line_section
28492 = get_section (DEBUG_LTO_LINE_SECTION
,
28493 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28494 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
28495 DEBUG_SKELETON_LINE_SECTION_LABEL
,
28497 debug_str_offsets_section
28498 = get_section (DEBUG_LTO_DWO_STR_OFFSETS_SECTION
,
28499 SECTION_DEBUG
| SECTION_EXCLUDE
,
28501 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
28502 DEBUG_SKELETON_INFO_SECTION_LABEL
,
28504 debug_str_dwo_section
= get_section (DEBUG_LTO_STR_DWO_SECTION
,
28505 DEBUG_STR_DWO_SECTION_FLAGS
,
28507 debug_macinfo_section_name
28508 = ((dwarf_strict
&& dwarf_version
< 5)
28509 ? DEBUG_LTO_DWO_MACINFO_SECTION
: DEBUG_LTO_DWO_MACRO_SECTION
);
28510 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28511 SECTION_DEBUG
| SECTION_EXCLUDE
,
28514 /* For macro info and the file table we have to refer to a
28515 debug_line section. */
28516 debug_line_section
= get_section (DEBUG_LTO_LINE_SECTION
,
28517 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28518 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
28519 DEBUG_LINE_SECTION_LABEL
, generation
);
28521 debug_str_section
= get_section (DEBUG_LTO_STR_SECTION
,
28522 DEBUG_STR_SECTION_FLAGS
28523 | SECTION_EXCLUDE
, NULL
);
28524 if (!dwarf_split_debug_info
)
28525 debug_line_str_section
28526 = get_section (DEBUG_LTO_LINE_STR_SECTION
,
28527 DEBUG_STR_SECTION_FLAGS
| SECTION_EXCLUDE
, NULL
);
28531 if (!dwarf_split_debug_info
)
28533 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
28534 SECTION_DEBUG
, NULL
);
28535 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
28536 SECTION_DEBUG
, NULL
);
28537 debug_loc_section
= get_section (dwarf_version
>= 5
28538 ? DEBUG_LOCLISTS_SECTION
28539 : DEBUG_LOC_SECTION
,
28540 SECTION_DEBUG
, NULL
);
28541 debug_macinfo_section_name
28542 = ((dwarf_strict
&& dwarf_version
< 5)
28543 ? DEBUG_MACINFO_SECTION
: DEBUG_MACRO_SECTION
);
28544 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28545 SECTION_DEBUG
, NULL
);
28549 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
28550 SECTION_DEBUG
| SECTION_EXCLUDE
,
28552 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
28553 SECTION_DEBUG
| SECTION_EXCLUDE
,
28555 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
28556 SECTION_DEBUG
, NULL
);
28557 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
28558 SECTION_DEBUG
, NULL
);
28559 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
28560 SECTION_DEBUG
, NULL
);
28561 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
28562 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
28565 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
28566 stay in the main .o, but the skeleton_line goes into the
28568 debug_skeleton_line_section
28569 = get_section (DEBUG_DWO_LINE_SECTION
,
28570 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28571 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
28572 DEBUG_SKELETON_LINE_SECTION_LABEL
,
28574 debug_str_offsets_section
28575 = get_section (DEBUG_DWO_STR_OFFSETS_SECTION
,
28576 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28577 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
28578 DEBUG_SKELETON_INFO_SECTION_LABEL
,
28580 debug_loc_section
= get_section (dwarf_version
>= 5
28581 ? DEBUG_DWO_LOCLISTS_SECTION
28582 : DEBUG_DWO_LOC_SECTION
,
28583 SECTION_DEBUG
| SECTION_EXCLUDE
,
28585 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
28586 DEBUG_STR_DWO_SECTION_FLAGS
,
28588 debug_macinfo_section_name
28589 = ((dwarf_strict
&& dwarf_version
< 5)
28590 ? DEBUG_DWO_MACINFO_SECTION
: DEBUG_DWO_MACRO_SECTION
);
28591 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28592 SECTION_DEBUG
| SECTION_EXCLUDE
,
28595 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
28596 SECTION_DEBUG
, NULL
);
28597 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
28598 SECTION_DEBUG
, NULL
);
28599 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
28600 SECTION_DEBUG
, NULL
);
28601 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
28602 SECTION_DEBUG
, NULL
);
28603 debug_str_section
= get_section (DEBUG_STR_SECTION
,
28604 DEBUG_STR_SECTION_FLAGS
, NULL
);
28605 if (!dwarf_split_debug_info
&& !output_asm_line_debug_info ())
28606 debug_line_str_section
= get_section (DEBUG_LINE_STR_SECTION
,
28607 DEBUG_STR_SECTION_FLAGS
, NULL
);
28609 debug_ranges_section
= get_section (dwarf_version
>= 5
28610 ? DEBUG_RNGLISTS_SECTION
28611 : DEBUG_RANGES_SECTION
,
28612 SECTION_DEBUG
, NULL
);
28613 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
28614 SECTION_DEBUG
, NULL
);
28617 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
28618 DEBUG_ABBREV_SECTION_LABEL
, generation
);
28619 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
28620 DEBUG_INFO_SECTION_LABEL
, generation
);
28621 info_section_emitted
= false;
28622 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
28623 DEBUG_LINE_SECTION_LABEL
, generation
);
28624 /* There are up to 4 unique ranges labels per generation.
28625 See also output_rnglists. */
28626 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
28627 DEBUG_RANGES_SECTION_LABEL
, generation
* 4);
28628 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
28629 ASM_GENERATE_INTERNAL_LABEL (ranges_base_label
,
28630 DEBUG_RANGES_SECTION_LABEL
,
28631 1 + generation
* 4);
28632 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
28633 DEBUG_ADDR_SECTION_LABEL
, generation
);
28634 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
28635 (dwarf_strict
&& dwarf_version
< 5)
28636 ? DEBUG_MACINFO_SECTION_LABEL
28637 : DEBUG_MACRO_SECTION_LABEL
, generation
);
28638 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
,
28642 return generation
- 1;
28645 /* Set up for Dwarf output at the start of compilation. */
28648 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
28650 /* Allocate the file_table. */
28651 file_table
= hash_table
<dwarf_file_hasher
>::create_ggc (50);
28653 #ifndef DWARF2_LINENO_DEBUGGING_INFO
28654 /* Allocate the decl_die_table. */
28655 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (10);
28657 /* Allocate the decl_loc_table. */
28658 decl_loc_table
= hash_table
<decl_loc_hasher
>::create_ggc (10);
28660 /* Allocate the cached_dw_loc_list_table. */
28661 cached_dw_loc_list_table
= hash_table
<dw_loc_list_hasher
>::create_ggc (10);
28663 /* Allocate the initial hunk of the abbrev_die_table. */
28664 vec_alloc (abbrev_die_table
, 256);
28665 /* Zero-th entry is allocated, but unused. */
28666 abbrev_die_table
->quick_push (NULL
);
28668 /* Allocate the dwarf_proc_stack_usage_map. */
28669 dwarf_proc_stack_usage_map
= new hash_map
<dw_die_ref
, int>;
28671 /* Allocate the pubtypes and pubnames vectors. */
28672 vec_alloc (pubname_table
, 32);
28673 vec_alloc (pubtype_table
, 32);
28675 vec_alloc (incomplete_types
, 64);
28677 vec_alloc (used_rtx_array
, 32);
28679 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28680 vec_alloc (macinfo_table
, 64);
28683 /* If front-ends already registered a main translation unit but we were not
28684 ready to perform the association, do this now. */
28685 if (main_translation_unit
!= NULL_TREE
)
28686 equate_decl_number_to_die (main_translation_unit
, comp_unit_die ());
28689 /* Called before compile () starts outputtting functions, variables
28690 and toplevel asms into assembly. */
28693 dwarf2out_assembly_start (void)
28695 if (text_section_line_info
)
28698 #ifndef DWARF2_LINENO_DEBUGGING_INFO
28699 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
28700 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
28701 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
28702 COLD_TEXT_SECTION_LABEL
, 0);
28703 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
28705 switch_to_section (text_section
);
28706 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
28709 /* Make sure the line number table for .text always exists. */
28710 text_section_line_info
= new_line_info_table ();
28711 text_section_line_info
->end_label
= text_end_label
;
28713 #ifdef DWARF2_LINENO_DEBUGGING_INFO
28714 cur_line_info_table
= text_section_line_info
;
28717 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
28718 && dwarf2out_do_cfi_asm ()
28719 && !dwarf2out_do_eh_frame ())
28720 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
28723 /* A helper function for dwarf2out_finish called through
28724 htab_traverse. Assign a string its index. All strings must be
28725 collected into the table by the time index_string is called,
28726 because the indexing code relies on htab_traverse to traverse nodes
28727 in the same order for each run. */
28730 index_string (indirect_string_node
**h
, unsigned int *index
)
28732 indirect_string_node
*node
= *h
;
28734 find_string_form (node
);
28735 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28737 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
28738 node
->index
= *index
;
28744 /* A helper function for output_indirect_strings called through
28745 htab_traverse. Output the offset to a string and update the
28749 output_index_string_offset (indirect_string_node
**h
, unsigned int *offset
)
28751 indirect_string_node
*node
= *h
;
28753 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28755 /* Assert that this node has been assigned an index. */
28756 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
28757 && node
->index
!= NOT_INDEXED
);
28758 dw2_asm_output_data (DWARF_OFFSET_SIZE
, *offset
,
28759 "indexed string 0x%x: %s", node
->index
, node
->str
);
28760 *offset
+= strlen (node
->str
) + 1;
28765 /* A helper function for dwarf2out_finish called through
28766 htab_traverse. Output the indexed string. */
28769 output_index_string (indirect_string_node
**h
, unsigned int *cur_idx
)
28771 struct indirect_string_node
*node
= *h
;
28773 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28775 /* Assert that the strings are output in the same order as their
28776 indexes were assigned. */
28777 gcc_assert (*cur_idx
== node
->index
);
28778 assemble_string (node
->str
, strlen (node
->str
) + 1);
28784 /* A helper function for output_indirect_strings. Counts the number
28785 of index strings offsets. Must match the logic of the functions
28786 output_index_string[_offsets] above. */
28788 count_index_strings (indirect_string_node
**h
, unsigned int *last_idx
)
28790 struct indirect_string_node
*node
= *h
;
28792 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28797 /* A helper function for dwarf2out_finish called through
28798 htab_traverse. Emit one queued .debug_str string. */
28801 output_indirect_string (indirect_string_node
**h
, enum dwarf_form form
)
28803 struct indirect_string_node
*node
= *h
;
28805 node
->form
= find_string_form (node
);
28806 if (node
->form
== form
&& node
->refcount
> 0)
28808 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
28809 assemble_string (node
->str
, strlen (node
->str
) + 1);
28815 /* Output the indexed string table. */
28818 output_indirect_strings (void)
28820 switch_to_section (debug_str_section
);
28821 if (!dwarf_split_debug_info
)
28822 debug_str_hash
->traverse
<enum dwarf_form
,
28823 output_indirect_string
> (DW_FORM_strp
);
28826 unsigned int offset
= 0;
28827 unsigned int cur_idx
= 0;
28829 if (skeleton_debug_str_hash
)
28830 skeleton_debug_str_hash
->traverse
<enum dwarf_form
,
28831 output_indirect_string
> (DW_FORM_strp
);
28833 switch_to_section (debug_str_offsets_section
);
28834 /* For DWARF5 the .debug_str_offsets[.dwo] section needs a unit
28835 header. Note that we don't need to generate a label to the
28836 actual index table following the header here, because this is
28837 for the split dwarf case only. In an .dwo file there is only
28838 one string offsets table (and one debug info section). But
28839 if we would start using string offset tables for the main (or
28840 skeleton) unit, then we have to add a DW_AT_str_offsets_base
28841 pointing to the actual index after the header. Split dwarf
28842 units will never have a string offsets base attribute. When
28843 a split unit is moved into a .dwp file the string offsets can
28844 be found through the .debug_cu_index section table. */
28845 if (dwarf_version
>= 5)
28847 unsigned int last_idx
= 0;
28848 unsigned long str_offsets_length
;
28850 debug_str_hash
->traverse_noresize
28851 <unsigned int *, count_index_strings
> (&last_idx
);
28852 str_offsets_length
= last_idx
* DWARF_OFFSET_SIZE
+ 4;
28853 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
28854 dw2_asm_output_data (4, 0xffffffff,
28855 "Escape value for 64-bit DWARF extension");
28856 dw2_asm_output_data (DWARF_OFFSET_SIZE
, str_offsets_length
,
28857 "Length of string offsets unit");
28858 dw2_asm_output_data (2, 5, "DWARF string offsets version");
28859 dw2_asm_output_data (2, 0, "Header zero padding");
28861 debug_str_hash
->traverse_noresize
28862 <unsigned int *, output_index_string_offset
> (&offset
);
28863 switch_to_section (debug_str_dwo_section
);
28864 debug_str_hash
->traverse_noresize
<unsigned int *, output_index_string
>
28869 /* Callback for htab_traverse to assign an index to an entry in the
28870 table, and to write that entry to the .debug_addr section. */
28873 output_addr_table_entry (addr_table_entry
**slot
, unsigned int *cur_index
)
28875 addr_table_entry
*entry
= *slot
;
28877 if (entry
->refcount
== 0)
28879 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
28880 || entry
->index
== NOT_INDEXED
);
28884 gcc_assert (entry
->index
== *cur_index
);
28887 switch (entry
->kind
)
28890 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
28891 "0x%x", entry
->index
);
28893 case ate_kind_rtx_dtprel
:
28894 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
28895 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
28898 fputc ('\n', asm_out_file
);
28900 case ate_kind_label
:
28901 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
28902 "0x%x", entry
->index
);
28905 gcc_unreachable ();
28910 /* A helper function for dwarf2out_finish. Counts the number
28911 of indexed addresses. Must match the logic of the functions
28912 output_addr_table_entry above. */
28914 count_index_addrs (addr_table_entry
**slot
, unsigned int *last_idx
)
28916 addr_table_entry
*entry
= *slot
;
28918 if (entry
->refcount
> 0)
28923 /* Produce the .debug_addr section. */
28926 output_addr_table (void)
28928 unsigned int index
= 0;
28929 if (addr_index_table
== NULL
|| addr_index_table
->size () == 0)
28932 switch_to_section (debug_addr_section
);
28934 ->traverse_noresize
<unsigned int *, output_addr_table_entry
> (&index
);
28937 #if ENABLE_ASSERT_CHECKING
28938 /* Verify that all marks are clear. */
28941 verify_marks_clear (dw_die_ref die
)
28945 gcc_assert (! die
->die_mark
);
28946 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
28948 #endif /* ENABLE_ASSERT_CHECKING */
28950 /* Clear the marks for a die and its children.
28951 Be cool if the mark isn't set. */
28954 prune_unmark_dies (dw_die_ref die
)
28960 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
28963 /* Given LOC that is referenced by a DIE we're marking as used, find all
28964 referenced DWARF procedures it references and mark them as used. */
28967 prune_unused_types_walk_loc_descr (dw_loc_descr_ref loc
)
28969 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
28970 switch (loc
->dw_loc_opc
)
28972 case DW_OP_implicit_pointer
:
28973 case DW_OP_convert
:
28974 case DW_OP_reinterpret
:
28975 case DW_OP_GNU_implicit_pointer
:
28976 case DW_OP_GNU_convert
:
28977 case DW_OP_GNU_reinterpret
:
28978 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
)
28979 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
28981 case DW_OP_GNU_variable_value
:
28982 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
28985 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
28988 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
28989 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
28990 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
28995 case DW_OP_call_ref
:
28996 case DW_OP_const_type
:
28997 case DW_OP_GNU_const_type
:
28998 case DW_OP_GNU_parameter_ref
:
28999 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
);
29000 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
29002 case DW_OP_regval_type
:
29003 case DW_OP_deref_type
:
29004 case DW_OP_GNU_regval_type
:
29005 case DW_OP_GNU_deref_type
:
29006 gcc_assert (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_die_ref
);
29007 prune_unused_types_mark (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
, 1);
29009 case DW_OP_entry_value
:
29010 case DW_OP_GNU_entry_value
:
29011 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
);
29012 prune_unused_types_walk_loc_descr (loc
->dw_loc_oprnd1
.v
.val_loc
);
29019 /* Given DIE that we're marking as used, find any other dies
29020 it references as attributes and mark them as used. */
29023 prune_unused_types_walk_attribs (dw_die_ref die
)
29028 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29030 switch (AT_class (a
))
29032 /* Make sure DWARF procedures referenced by location descriptions will
29034 case dw_val_class_loc
:
29035 prune_unused_types_walk_loc_descr (AT_loc (a
));
29037 case dw_val_class_loc_list
:
29038 for (dw_loc_list_ref list
= AT_loc_list (a
);
29040 list
= list
->dw_loc_next
)
29041 prune_unused_types_walk_loc_descr (list
->expr
);
29044 case dw_val_class_view_list
:
29045 /* This points to a loc_list in another attribute, so it's
29046 already covered. */
29049 case dw_val_class_die_ref
:
29050 /* A reference to another DIE.
29051 Make sure that it will get emitted.
29052 If it was broken out into a comdat group, don't follow it. */
29053 if (! AT_ref (a
)->comdat_type_p
29054 || a
->dw_attr
== DW_AT_specification
)
29055 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
29058 case dw_val_class_str
:
29059 /* Set the string's refcount to 0 so that prune_unused_types_mark
29060 accounts properly for it. */
29061 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
29070 /* Mark the generic parameters and arguments children DIEs of DIE. */
29073 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
29077 if (die
== NULL
|| die
->die_child
== NULL
)
29079 c
= die
->die_child
;
29082 if (is_template_parameter (c
))
29083 prune_unused_types_mark (c
, 1);
29085 } while (c
&& c
!= die
->die_child
);
29088 /* Mark DIE as being used. If DOKIDS is true, then walk down
29089 to DIE's children. */
29092 prune_unused_types_mark (dw_die_ref die
, int dokids
)
29096 if (die
->die_mark
== 0)
29098 /* We haven't done this node yet. Mark it as used. */
29100 /* If this is the DIE of a generic type instantiation,
29101 mark the children DIEs that describe its generic parms and
29103 prune_unused_types_mark_generic_parms_dies (die
);
29105 /* We also have to mark its parents as used.
29106 (But we don't want to mark our parent's kids due to this,
29107 unless it is a class.) */
29108 if (die
->die_parent
)
29109 prune_unused_types_mark (die
->die_parent
,
29110 class_scope_p (die
->die_parent
));
29112 /* Mark any referenced nodes. */
29113 prune_unused_types_walk_attribs (die
);
29115 /* If this node is a specification,
29116 also mark the definition, if it exists. */
29117 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
29118 prune_unused_types_mark (die
->die_definition
, 1);
29121 if (dokids
&& die
->die_mark
!= 2)
29123 /* We need to walk the children, but haven't done so yet.
29124 Remember that we've walked the kids. */
29127 /* If this is an array type, we need to make sure our
29128 kids get marked, even if they're types. If we're
29129 breaking out types into comdat sections, do this
29130 for all type definitions. */
29131 if (die
->die_tag
== DW_TAG_array_type
29132 || (use_debug_types
29133 && is_type_die (die
) && ! is_declaration_die (die
)))
29134 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
29136 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
29140 /* For local classes, look if any static member functions were emitted
29141 and if so, mark them. */
29144 prune_unused_types_walk_local_classes (dw_die_ref die
)
29148 if (die
->die_mark
== 2)
29151 switch (die
->die_tag
)
29153 case DW_TAG_structure_type
:
29154 case DW_TAG_union_type
:
29155 case DW_TAG_class_type
:
29156 case DW_TAG_interface_type
:
29159 case DW_TAG_subprogram
:
29160 if (!get_AT_flag (die
, DW_AT_declaration
)
29161 || die
->die_definition
!= NULL
)
29162 prune_unused_types_mark (die
, 1);
29169 /* Mark children. */
29170 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
29173 /* Walk the tree DIE and mark types that we actually use. */
29176 prune_unused_types_walk (dw_die_ref die
)
29180 /* Don't do anything if this node is already marked and
29181 children have been marked as well. */
29182 if (die
->die_mark
== 2)
29185 switch (die
->die_tag
)
29187 case DW_TAG_structure_type
:
29188 case DW_TAG_union_type
:
29189 case DW_TAG_class_type
:
29190 case DW_TAG_interface_type
:
29191 if (die
->die_perennial_p
)
29194 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
29195 if (c
->die_tag
== DW_TAG_subprogram
)
29198 /* Finding used static member functions inside of classes
29199 is needed just for local classes, because for other classes
29200 static member function DIEs with DW_AT_specification
29201 are emitted outside of the DW_TAG_*_type. If we ever change
29202 it, we'd need to call this even for non-local classes. */
29204 prune_unused_types_walk_local_classes (die
);
29206 /* It's a type node --- don't mark it. */
29209 case DW_TAG_const_type
:
29210 case DW_TAG_packed_type
:
29211 case DW_TAG_pointer_type
:
29212 case DW_TAG_reference_type
:
29213 case DW_TAG_rvalue_reference_type
:
29214 case DW_TAG_volatile_type
:
29215 case DW_TAG_typedef
:
29216 case DW_TAG_array_type
:
29217 case DW_TAG_friend
:
29218 case DW_TAG_enumeration_type
:
29219 case DW_TAG_subroutine_type
:
29220 case DW_TAG_string_type
:
29221 case DW_TAG_set_type
:
29222 case DW_TAG_subrange_type
:
29223 case DW_TAG_ptr_to_member_type
:
29224 case DW_TAG_file_type
:
29225 /* Type nodes are useful only when other DIEs reference them --- don't
29229 case DW_TAG_dwarf_procedure
:
29230 /* Likewise for DWARF procedures. */
29232 if (die
->die_perennial_p
)
29238 /* Mark everything else. */
29242 if (die
->die_mark
== 0)
29246 /* Now, mark any dies referenced from here. */
29247 prune_unused_types_walk_attribs (die
);
29252 /* Mark children. */
29253 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
29256 /* Increment the string counts on strings referred to from DIE's
29260 prune_unused_types_update_strings (dw_die_ref die
)
29265 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29266 if (AT_class (a
) == dw_val_class_str
)
29268 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
29270 /* Avoid unnecessarily putting strings that are used less than
29271 twice in the hash table. */
29273 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
29275 indirect_string_node
**slot
29276 = debug_str_hash
->find_slot_with_hash (s
->str
,
29277 htab_hash_string (s
->str
),
29279 gcc_assert (*slot
== NULL
);
29285 /* Mark DIE and its children as removed. */
29288 mark_removed (dw_die_ref die
)
29291 die
->removed
= true;
29292 FOR_EACH_CHILD (die
, c
, mark_removed (c
));
29295 /* Remove from the tree DIE any dies that aren't marked. */
29298 prune_unused_types_prune (dw_die_ref die
)
29302 gcc_assert (die
->die_mark
);
29303 prune_unused_types_update_strings (die
);
29305 if (! die
->die_child
)
29308 c
= die
->die_child
;
29310 dw_die_ref prev
= c
, next
;
29311 for (c
= c
->die_sib
; ! c
->die_mark
; c
= next
)
29312 if (c
== die
->die_child
)
29314 /* No marked children between 'prev' and the end of the list. */
29316 /* No marked children at all. */
29317 die
->die_child
= NULL
;
29320 prev
->die_sib
= c
->die_sib
;
29321 die
->die_child
= prev
;
29334 if (c
!= prev
->die_sib
)
29336 prune_unused_types_prune (c
);
29337 } while (c
!= die
->die_child
);
29340 /* Remove dies representing declarations that we never use. */
29343 prune_unused_types (void)
29346 limbo_die_node
*node
;
29347 comdat_type_node
*ctnode
;
29348 pubname_entry
*pub
;
29349 dw_die_ref base_type
;
29351 #if ENABLE_ASSERT_CHECKING
29352 /* All the marks should already be clear. */
29353 verify_marks_clear (comp_unit_die ());
29354 for (node
= limbo_die_list
; node
; node
= node
->next
)
29355 verify_marks_clear (node
->die
);
29356 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29357 verify_marks_clear (ctnode
->root_die
);
29358 #endif /* ENABLE_ASSERT_CHECKING */
29360 /* Mark types that are used in global variables. */
29361 premark_types_used_by_global_vars ();
29363 /* Set the mark on nodes that are actually used. */
29364 prune_unused_types_walk (comp_unit_die ());
29365 for (node
= limbo_die_list
; node
; node
= node
->next
)
29366 prune_unused_types_walk (node
->die
);
29367 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29369 prune_unused_types_walk (ctnode
->root_die
);
29370 prune_unused_types_mark (ctnode
->type_die
, 1);
29373 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
29374 are unusual in that they are pubnames that are the children of pubtypes.
29375 They should only be marked via their parent DW_TAG_enumeration_type die,
29376 not as roots in themselves. */
29377 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
29378 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
29379 prune_unused_types_mark (pub
->die
, 1);
29380 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
29381 prune_unused_types_mark (base_type
, 1);
29383 /* For -fvar-tracking-assignments, also set the mark on nodes that could be
29384 referenced by DW_TAG_call_site DW_AT_call_origin (i.e. direct call
29386 cgraph_node
*cnode
;
29387 FOR_EACH_FUNCTION (cnode
)
29388 if (cnode
->referred_to_p (false))
29390 dw_die_ref die
= lookup_decl_die (cnode
->decl
);
29391 if (die
== NULL
|| die
->die_mark
)
29393 for (cgraph_edge
*e
= cnode
->callers
; e
; e
= e
->next_caller
)
29394 if (e
->caller
!= cnode
29395 && opt_for_fn (e
->caller
->decl
, flag_var_tracking_assignments
))
29397 prune_unused_types_mark (die
, 1);
29402 if (debug_str_hash
)
29403 debug_str_hash
->empty ();
29404 if (skeleton_debug_str_hash
)
29405 skeleton_debug_str_hash
->empty ();
29406 prune_unused_types_prune (comp_unit_die ());
29407 for (limbo_die_node
**pnode
= &limbo_die_list
; *pnode
; )
29410 if (!node
->die
->die_mark
)
29411 *pnode
= node
->next
;
29414 prune_unused_types_prune (node
->die
);
29415 pnode
= &node
->next
;
29418 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29419 prune_unused_types_prune (ctnode
->root_die
);
29421 /* Leave the marks clear. */
29422 prune_unmark_dies (comp_unit_die ());
29423 for (node
= limbo_die_list
; node
; node
= node
->next
)
29424 prune_unmark_dies (node
->die
);
29425 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29426 prune_unmark_dies (ctnode
->root_die
);
29429 /* Helpers to manipulate hash table of comdat type units. */
29431 struct comdat_type_hasher
: nofree_ptr_hash
<comdat_type_node
>
29433 static inline hashval_t
hash (const comdat_type_node
*);
29434 static inline bool equal (const comdat_type_node
*, const comdat_type_node
*);
29438 comdat_type_hasher::hash (const comdat_type_node
*type_node
)
29441 memcpy (&h
, type_node
->signature
, sizeof (h
));
29446 comdat_type_hasher::equal (const comdat_type_node
*type_node_1
,
29447 const comdat_type_node
*type_node_2
)
29449 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
29450 DWARF_TYPE_SIGNATURE_SIZE
));
29453 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
29454 to the location it would have been added, should we know its
29455 DECL_ASSEMBLER_NAME when we added other attributes. This will
29456 probably improve compactness of debug info, removing equivalent
29457 abbrevs, and hide any differences caused by deferring the
29458 computation of the assembler name, triggered by e.g. PCH. */
29461 move_linkage_attr (dw_die_ref die
)
29463 unsigned ix
= vec_safe_length (die
->die_attr
);
29464 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
29466 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
29467 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
29471 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
29473 if (prev
->dw_attr
== DW_AT_decl_line
29474 || prev
->dw_attr
== DW_AT_decl_column
29475 || prev
->dw_attr
== DW_AT_name
)
29479 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
29481 die
->die_attr
->pop ();
29482 die
->die_attr
->quick_insert (ix
, linkage
);
29486 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
29487 referenced from typed stack ops and count how often they are used. */
29490 mark_base_types (dw_loc_descr_ref loc
)
29492 dw_die_ref base_type
= NULL
;
29494 for (; loc
; loc
= loc
->dw_loc_next
)
29496 switch (loc
->dw_loc_opc
)
29498 case DW_OP_regval_type
:
29499 case DW_OP_deref_type
:
29500 case DW_OP_GNU_regval_type
:
29501 case DW_OP_GNU_deref_type
:
29502 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
29504 case DW_OP_convert
:
29505 case DW_OP_reinterpret
:
29506 case DW_OP_GNU_convert
:
29507 case DW_OP_GNU_reinterpret
:
29508 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
29511 case DW_OP_const_type
:
29512 case DW_OP_GNU_const_type
:
29513 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29515 case DW_OP_entry_value
:
29516 case DW_OP_GNU_entry_value
:
29517 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
29522 gcc_assert (base_type
->die_parent
== comp_unit_die ());
29523 if (base_type
->die_mark
)
29524 base_type
->die_mark
++;
29527 base_types
.safe_push (base_type
);
29528 base_type
->die_mark
= 1;
29533 /* Comparison function for sorting marked base types. */
29536 base_type_cmp (const void *x
, const void *y
)
29538 dw_die_ref dx
= *(const dw_die_ref
*) x
;
29539 dw_die_ref dy
= *(const dw_die_ref
*) y
;
29540 unsigned int byte_size1
, byte_size2
;
29541 unsigned int encoding1
, encoding2
;
29542 unsigned int align1
, align2
;
29543 if (dx
->die_mark
> dy
->die_mark
)
29545 if (dx
->die_mark
< dy
->die_mark
)
29547 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
29548 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
29549 if (byte_size1
< byte_size2
)
29551 if (byte_size1
> byte_size2
)
29553 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
29554 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
29555 if (encoding1
< encoding2
)
29557 if (encoding1
> encoding2
)
29559 align1
= get_AT_unsigned (dx
, DW_AT_alignment
);
29560 align2
= get_AT_unsigned (dy
, DW_AT_alignment
);
29561 if (align1
< align2
)
29563 if (align1
> align2
)
29568 /* Move base types marked by mark_base_types as early as possible
29569 in the CU, sorted by decreasing usage count both to make the
29570 uleb128 references as small as possible and to make sure they
29571 will have die_offset already computed by calc_die_sizes when
29572 sizes of typed stack loc ops is computed. */
29575 move_marked_base_types (void)
29578 dw_die_ref base_type
, die
, c
;
29580 if (base_types
.is_empty ())
29583 /* Sort by decreasing usage count, they will be added again in that
29585 base_types
.qsort (base_type_cmp
);
29586 die
= comp_unit_die ();
29587 c
= die
->die_child
;
29590 dw_die_ref prev
= c
;
29592 while (c
->die_mark
)
29594 remove_child_with_prev (c
, prev
);
29595 /* As base types got marked, there must be at least
29596 one node other than DW_TAG_base_type. */
29597 gcc_assert (die
->die_child
!= NULL
);
29601 while (c
!= die
->die_child
);
29602 gcc_assert (die
->die_child
);
29603 c
= die
->die_child
;
29604 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
29606 base_type
->die_mark
= 0;
29607 base_type
->die_sib
= c
->die_sib
;
29608 c
->die_sib
= base_type
;
29613 /* Helper function for resolve_addr, attempt to resolve
29614 one CONST_STRING, return true if successful. Similarly verify that
29615 SYMBOL_REFs refer to variables emitted in the current CU. */
29618 resolve_one_addr (rtx
*addr
)
29622 if (GET_CODE (rtl
) == CONST_STRING
)
29624 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
29625 tree t
= build_string (len
, XSTR (rtl
, 0));
29626 tree tlen
= size_int (len
- 1);
29628 = build_array_type (char_type_node
, build_index_type (tlen
));
29629 rtl
= lookup_constant_def (t
);
29630 if (!rtl
|| !MEM_P (rtl
))
29632 rtl
= XEXP (rtl
, 0);
29633 if (GET_CODE (rtl
) == SYMBOL_REF
29634 && SYMBOL_REF_DECL (rtl
)
29635 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
29637 vec_safe_push (used_rtx_array
, rtl
);
29642 if (GET_CODE (rtl
) == SYMBOL_REF
29643 && SYMBOL_REF_DECL (rtl
))
29645 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
29647 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
29650 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
29654 if (GET_CODE (rtl
) == CONST
)
29656 subrtx_ptr_iterator::array_type array
;
29657 FOR_EACH_SUBRTX_PTR (iter
, array
, &XEXP (rtl
, 0), ALL
)
29658 if (!resolve_one_addr (*iter
))
29665 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
29666 if possible, and create DW_TAG_dwarf_procedure that can be referenced
29667 from DW_OP_implicit_pointer if the string hasn't been seen yet. */
29670 string_cst_pool_decl (tree t
)
29672 rtx rtl
= output_constant_def (t
, 1);
29673 unsigned char *array
;
29674 dw_loc_descr_ref l
;
29679 if (!rtl
|| !MEM_P (rtl
))
29681 rtl
= XEXP (rtl
, 0);
29682 if (GET_CODE (rtl
) != SYMBOL_REF
29683 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
29686 decl
= SYMBOL_REF_DECL (rtl
);
29687 if (!lookup_decl_die (decl
))
29689 len
= TREE_STRING_LENGTH (t
);
29690 vec_safe_push (used_rtx_array
, rtl
);
29691 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
29692 array
= ggc_vec_alloc
<unsigned char> (len
);
29693 memcpy (array
, TREE_STRING_POINTER (t
), len
);
29694 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
29695 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
29696 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
29697 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
29698 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
29699 add_AT_loc (ref
, DW_AT_location
, l
);
29700 equate_decl_number_to_die (decl
, ref
);
29705 /* Helper function of resolve_addr_in_expr. LOC is
29706 a DW_OP_addr followed by DW_OP_stack_value, either at the start
29707 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
29708 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
29709 with DW_OP_implicit_pointer if possible
29710 and return true, if unsuccessful, return false. */
29713 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
29715 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
29716 HOST_WIDE_INT offset
= 0;
29717 dw_die_ref ref
= NULL
;
29720 if (GET_CODE (rtl
) == CONST
29721 && GET_CODE (XEXP (rtl
, 0)) == PLUS
29722 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
29724 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
29725 rtl
= XEXP (XEXP (rtl
, 0), 0);
29727 if (GET_CODE (rtl
) == CONST_STRING
)
29729 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
29730 tree t
= build_string (len
, XSTR (rtl
, 0));
29731 tree tlen
= size_int (len
- 1);
29734 = build_array_type (char_type_node
, build_index_type (tlen
));
29735 rtl
= string_cst_pool_decl (t
);
29739 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
29741 decl
= SYMBOL_REF_DECL (rtl
);
29742 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
29744 ref
= lookup_decl_die (decl
);
29745 if (ref
&& (get_AT (ref
, DW_AT_location
)
29746 || get_AT (ref
, DW_AT_const_value
)))
29748 loc
->dw_loc_opc
= dwarf_OP (DW_OP_implicit_pointer
);
29749 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
29750 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
29751 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
29752 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29753 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
29754 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
29762 /* Helper function for resolve_addr, handle one location
29763 expression, return false if at least one CONST_STRING or SYMBOL_REF in
29764 the location list couldn't be resolved. */
29767 resolve_addr_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
29769 dw_loc_descr_ref keep
= NULL
;
29770 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
29771 switch (loc
->dw_loc_opc
)
29774 if (!resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
29777 || prev
->dw_loc_opc
== DW_OP_piece
29778 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
29779 && loc
->dw_loc_next
29780 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
29781 && (!dwarf_strict
|| dwarf_version
>= 5)
29782 && optimize_one_addr_into_implicit_ptr (loc
))
29787 case DW_OP_GNU_addr_index
:
29789 case DW_OP_GNU_const_index
:
29791 if ((loc
->dw_loc_opc
== DW_OP_GNU_addr_index
29792 || loc
->dw_loc_opc
== DW_OP_addrx
)
29793 || ((loc
->dw_loc_opc
== DW_OP_GNU_const_index
29794 || loc
->dw_loc_opc
== DW_OP_constx
)
29797 rtx rtl
= loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
;
29798 if (!resolve_one_addr (&rtl
))
29800 remove_addr_table_entry (loc
->dw_loc_oprnd1
.val_entry
);
29801 loc
->dw_loc_oprnd1
.val_entry
29802 = add_addr_table_entry (rtl
, ate_kind_rtx
);
29805 case DW_OP_const4u
:
29806 case DW_OP_const8u
:
29808 && !resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
29811 case DW_OP_plus_uconst
:
29812 if (size_of_loc_descr (loc
)
29813 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
29815 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
29817 dw_loc_descr_ref repl
29818 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
29819 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
29820 add_loc_descr (&repl
, loc
->dw_loc_next
);
29824 case DW_OP_implicit_value
:
29825 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
29826 && !resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
))
29829 case DW_OP_implicit_pointer
:
29830 case DW_OP_GNU_implicit_pointer
:
29831 case DW_OP_GNU_parameter_ref
:
29832 case DW_OP_GNU_variable_value
:
29833 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
29836 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
29839 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
29840 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
29841 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29843 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
)
29846 && loc
->dw_loc_next
== NULL
29847 && AT_class (a
) == dw_val_class_loc
)
29848 switch (a
->dw_attr
)
29850 /* Following attributes allow both exprloc and reference,
29851 so if the whole expression is DW_OP_GNU_variable_value
29852 alone we could transform it into reference. */
29853 case DW_AT_byte_size
:
29854 case DW_AT_bit_size
:
29855 case DW_AT_lower_bound
:
29856 case DW_AT_upper_bound
:
29857 case DW_AT_bit_stride
:
29859 case DW_AT_allocated
:
29860 case DW_AT_associated
:
29861 case DW_AT_byte_stride
:
29862 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
29863 a
->dw_attr_val
.val_entry
= NULL
;
29864 a
->dw_attr_val
.v
.val_die_ref
.die
29865 = loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29866 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
29875 case DW_OP_const_type
:
29876 case DW_OP_regval_type
:
29877 case DW_OP_deref_type
:
29878 case DW_OP_convert
:
29879 case DW_OP_reinterpret
:
29880 case DW_OP_GNU_const_type
:
29881 case DW_OP_GNU_regval_type
:
29882 case DW_OP_GNU_deref_type
:
29883 case DW_OP_GNU_convert
:
29884 case DW_OP_GNU_reinterpret
:
29885 while (loc
->dw_loc_next
29886 && (loc
->dw_loc_next
->dw_loc_opc
== DW_OP_convert
29887 || loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
))
29889 dw_die_ref base1
, base2
;
29890 unsigned enc1
, enc2
, size1
, size2
;
29891 if (loc
->dw_loc_opc
== DW_OP_regval_type
29892 || loc
->dw_loc_opc
== DW_OP_deref_type
29893 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
29894 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
29895 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
29896 else if (loc
->dw_loc_oprnd1
.val_class
29897 == dw_val_class_unsigned_const
)
29900 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29901 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
29902 == dw_val_class_unsigned_const
)
29904 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29905 gcc_assert (base1
->die_tag
== DW_TAG_base_type
29906 && base2
->die_tag
== DW_TAG_base_type
);
29907 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
29908 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
29909 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
29910 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
29912 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
29913 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
29917 /* Optimize away next DW_OP_convert after
29918 adjusting LOC's base type die reference. */
29919 if (loc
->dw_loc_opc
== DW_OP_regval_type
29920 || loc
->dw_loc_opc
== DW_OP_deref_type
29921 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
29922 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
29923 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
29925 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
29926 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
29929 /* Don't change integer DW_OP_convert after e.g. floating
29930 point typed stack entry. */
29931 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
29932 keep
= loc
->dw_loc_next
;
29942 /* Helper function of resolve_addr. DIE had DW_AT_location of
29943 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
29944 and DW_OP_addr couldn't be resolved. resolve_addr has already
29945 removed the DW_AT_location attribute. This function attempts to
29946 add a new DW_AT_location attribute with DW_OP_implicit_pointer
29947 to it or DW_AT_const_value attribute, if possible. */
29950 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
29953 || lookup_decl_die (decl
) != die
29954 || DECL_EXTERNAL (decl
)
29955 || !TREE_STATIC (decl
)
29956 || DECL_INITIAL (decl
) == NULL_TREE
29957 || DECL_P (DECL_INITIAL (decl
))
29958 || get_AT (die
, DW_AT_const_value
))
29961 tree init
= DECL_INITIAL (decl
);
29962 HOST_WIDE_INT offset
= 0;
29963 /* For variables that have been optimized away and thus
29964 don't have a memory location, see if we can emit
29965 DW_AT_const_value instead. */
29966 if (tree_add_const_value_attribute (die
, init
))
29968 if (dwarf_strict
&& dwarf_version
< 5)
29970 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
29971 and ADDR_EXPR refers to a decl that has DW_AT_location or
29972 DW_AT_const_value (but isn't addressable, otherwise
29973 resolving the original DW_OP_addr wouldn't fail), see if
29974 we can add DW_OP_implicit_pointer. */
29976 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
29977 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
29979 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
29980 init
= TREE_OPERAND (init
, 0);
29983 if (TREE_CODE (init
) != ADDR_EXPR
)
29985 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
29986 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
29987 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
29988 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
29989 && TREE_OPERAND (init
, 0) != decl
))
29992 dw_loc_descr_ref l
;
29994 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
29996 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
29999 decl
= SYMBOL_REF_DECL (rtl
);
30002 decl
= TREE_OPERAND (init
, 0);
30003 ref
= lookup_decl_die (decl
);
30005 || (!get_AT (ref
, DW_AT_location
)
30006 && !get_AT (ref
, DW_AT_const_value
)))
30008 l
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
30009 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30010 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30011 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30012 add_AT_loc (die
, DW_AT_location
, l
);
30016 /* Return NULL if l is a DWARF expression, or first op that is not
30017 valid DWARF expression. */
30019 static dw_loc_descr_ref
30020 non_dwarf_expression (dw_loc_descr_ref l
)
30024 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
30026 switch (l
->dw_loc_opc
)
30029 case DW_OP_implicit_value
:
30030 case DW_OP_stack_value
:
30031 case DW_OP_implicit_pointer
:
30032 case DW_OP_GNU_implicit_pointer
:
30033 case DW_OP_GNU_parameter_ref
:
30035 case DW_OP_bit_piece
:
30040 l
= l
->dw_loc_next
;
30045 /* Return adjusted copy of EXPR:
30046 If it is empty DWARF expression, return it.
30047 If it is valid non-empty DWARF expression,
30048 return copy of EXPR with DW_OP_deref appended to it.
30049 If it is DWARF expression followed by DW_OP_reg{N,x}, return
30050 copy of the DWARF expression with DW_OP_breg{N,x} <0> appended.
30051 If it is DWARF expression followed by DW_OP_stack_value, return
30052 copy of the DWARF expression without anything appended.
30053 Otherwise, return NULL. */
30055 static dw_loc_descr_ref
30056 copy_deref_exprloc (dw_loc_descr_ref expr
)
30058 dw_loc_descr_ref tail
= NULL
;
30063 dw_loc_descr_ref l
= non_dwarf_expression (expr
);
30064 if (l
&& l
->dw_loc_next
)
30069 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
30070 tail
= new_loc_descr ((enum dwarf_location_atom
)
30071 (DW_OP_breg0
+ (l
->dw_loc_opc
- DW_OP_reg0
)),
30074 switch (l
->dw_loc_opc
)
30077 tail
= new_loc_descr (DW_OP_bregx
,
30078 l
->dw_loc_oprnd1
.v
.val_unsigned
, 0);
30080 case DW_OP_stack_value
:
30087 tail
= new_loc_descr (DW_OP_deref
, 0, 0);
30089 dw_loc_descr_ref ret
= NULL
, *p
= &ret
;
30092 *p
= new_loc_descr (expr
->dw_loc_opc
, 0, 0);
30093 (*p
)->dw_loc_oprnd1
= expr
->dw_loc_oprnd1
;
30094 (*p
)->dw_loc_oprnd2
= expr
->dw_loc_oprnd2
;
30095 p
= &(*p
)->dw_loc_next
;
30096 expr
= expr
->dw_loc_next
;
30102 /* For DW_AT_string_length attribute with DW_OP_GNU_variable_value
30103 reference to a variable or argument, adjust it if needed and return:
30104 -1 if the DW_AT_string_length attribute and DW_AT_{string_length_,}byte_size
30105 attribute if present should be removed
30106 0 keep the attribute perhaps with minor modifications, no need to rescan
30107 1 if the attribute has been successfully adjusted. */
30110 optimize_string_length (dw_attr_node
*a
)
30112 dw_loc_descr_ref l
= AT_loc (a
), lv
;
30114 if (l
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
30116 tree decl
= l
->dw_loc_oprnd1
.v
.val_decl_ref
;
30117 die
= lookup_decl_die (decl
);
30120 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30121 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= die
;
30122 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30128 die
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30130 /* DWARF5 allows reference class, so we can then reference the DIE.
30131 Only do this for DW_OP_GNU_variable_value DW_OP_stack_value. */
30132 if (l
->dw_loc_next
!= NULL
&& dwarf_version
>= 5)
30134 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
30135 a
->dw_attr_val
.val_entry
= NULL
;
30136 a
->dw_attr_val
.v
.val_die_ref
.die
= die
;
30137 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
30141 dw_attr_node
*av
= get_AT (die
, DW_AT_location
);
30143 bool non_dwarf_expr
= false;
30146 return dwarf_strict
? -1 : 0;
30147 switch (AT_class (av
))
30149 case dw_val_class_loc_list
:
30150 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
30151 if (d
->expr
&& non_dwarf_expression (d
->expr
))
30152 non_dwarf_expr
= true;
30154 case dw_val_class_view_list
:
30155 gcc_unreachable ();
30156 case dw_val_class_loc
:
30159 return dwarf_strict
? -1 : 0;
30160 if (non_dwarf_expression (lv
))
30161 non_dwarf_expr
= true;
30164 return dwarf_strict
? -1 : 0;
30167 /* If it is safe to transform DW_OP_GNU_variable_value DW_OP_stack_value
30168 into DW_OP_call4 or DW_OP_GNU_variable_value into
30169 DW_OP_call4 DW_OP_deref, do so. */
30170 if (!non_dwarf_expr
30171 && (l
->dw_loc_next
!= NULL
|| AT_class (av
) == dw_val_class_loc
))
30173 l
->dw_loc_opc
= DW_OP_call4
;
30174 if (l
->dw_loc_next
)
30175 l
->dw_loc_next
= NULL
;
30177 l
->dw_loc_next
= new_loc_descr (DW_OP_deref
, 0, 0);
30181 /* For DW_OP_GNU_variable_value DW_OP_stack_value, we can just
30182 copy over the DW_AT_location attribute from die to a. */
30183 if (l
->dw_loc_next
!= NULL
)
30185 a
->dw_attr_val
= av
->dw_attr_val
;
30189 dw_loc_list_ref list
, *p
;
30190 switch (AT_class (av
))
30192 case dw_val_class_loc_list
:
30195 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
30197 lv
= copy_deref_exprloc (d
->expr
);
30200 *p
= new_loc_list (lv
, d
->begin
, d
->vbegin
, d
->end
, d
->vend
, d
->section
);
30201 p
= &(*p
)->dw_loc_next
;
30203 else if (!dwarf_strict
&& d
->expr
)
30207 return dwarf_strict
? -1 : 0;
30208 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
30210 *AT_loc_list_ptr (a
) = list
;
30212 case dw_val_class_loc
:
30213 lv
= copy_deref_exprloc (AT_loc (av
));
30215 return dwarf_strict
? -1 : 0;
30216 a
->dw_attr_val
.v
.val_loc
= lv
;
30219 gcc_unreachable ();
30223 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
30224 an address in .rodata section if the string literal is emitted there,
30225 or remove the containing location list or replace DW_AT_const_value
30226 with DW_AT_location and empty location expression, if it isn't found
30227 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
30228 to something that has been emitted in the current CU. */
30231 resolve_addr (dw_die_ref die
)
30235 dw_loc_list_ref
*curr
, *start
, loc
;
30237 bool remove_AT_byte_size
= false;
30239 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30240 switch (AT_class (a
))
30242 case dw_val_class_loc_list
:
30243 start
= curr
= AT_loc_list_ptr (a
);
30246 /* The same list can be referenced more than once. See if we have
30247 already recorded the result from a previous pass. */
30249 *curr
= loc
->dw_loc_next
;
30250 else if (!loc
->resolved_addr
)
30252 /* As things stand, we do not expect or allow one die to
30253 reference a suffix of another die's location list chain.
30254 References must be identical or completely separate.
30255 There is therefore no need to cache the result of this
30256 pass on any list other than the first; doing so
30257 would lead to unnecessary writes. */
30260 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
30261 if (!resolve_addr_in_expr (a
, (*curr
)->expr
))
30263 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
30264 dw_loc_descr_ref l
= (*curr
)->expr
;
30266 if (next
&& (*curr
)->ll_symbol
)
30268 gcc_assert (!next
->ll_symbol
);
30269 next
->ll_symbol
= (*curr
)->ll_symbol
;
30270 next
->vl_symbol
= (*curr
)->vl_symbol
;
30272 if (dwarf_split_debug_info
)
30273 remove_loc_list_addr_table_entries (l
);
30278 mark_base_types ((*curr
)->expr
);
30279 curr
= &(*curr
)->dw_loc_next
;
30283 loc
->resolved_addr
= 1;
30287 loc
->dw_loc_next
= *start
;
30292 remove_AT (die
, a
->dw_attr
);
30296 case dw_val_class_view_list
:
30298 gcc_checking_assert (a
->dw_attr
== DW_AT_GNU_locviews
);
30299 gcc_checking_assert (dwarf2out_locviews_in_attribute ());
30300 dw_val_node
*llnode
30301 = view_list_to_loc_list_val_node (&a
->dw_attr_val
);
30302 /* If we no longer have a loclist, or it no longer needs
30303 views, drop this attribute. */
30304 if (!llnode
|| !llnode
->v
.val_loc_list
->vl_symbol
)
30306 remove_AT (die
, a
->dw_attr
);
30311 case dw_val_class_loc
:
30313 dw_loc_descr_ref l
= AT_loc (a
);
30314 /* DW_OP_GNU_variable_value DW_OP_stack_value or
30315 DW_OP_GNU_variable_value in DW_AT_string_length can be converted
30316 into DW_OP_call4 or DW_OP_call4 DW_OP_deref, which is standard
30317 DWARF4 unlike DW_OP_GNU_variable_value. Or for DWARF5
30318 DW_OP_GNU_variable_value DW_OP_stack_value can be replaced
30319 with DW_FORM_ref referencing the same DIE as
30320 DW_OP_GNU_variable_value used to reference. */
30321 if (a
->dw_attr
== DW_AT_string_length
30323 && l
->dw_loc_opc
== DW_OP_GNU_variable_value
30324 && (l
->dw_loc_next
== NULL
30325 || (l
->dw_loc_next
->dw_loc_next
== NULL
30326 && l
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
)))
30328 switch (optimize_string_length (a
))
30331 remove_AT (die
, a
->dw_attr
);
30333 /* If we drop DW_AT_string_length, we need to drop also
30334 DW_AT_{string_length_,}byte_size. */
30335 remove_AT_byte_size
= true;
30340 /* Even if we keep the optimized DW_AT_string_length,
30341 it might have changed AT_class, so process it again. */
30346 /* For -gdwarf-2 don't attempt to optimize
30347 DW_AT_data_member_location containing
30348 DW_OP_plus_uconst - older consumers might
30349 rely on it being that op instead of a more complex,
30350 but shorter, location description. */
30351 if ((dwarf_version
> 2
30352 || a
->dw_attr
!= DW_AT_data_member_location
30354 || l
->dw_loc_opc
!= DW_OP_plus_uconst
30355 || l
->dw_loc_next
!= NULL
)
30356 && !resolve_addr_in_expr (a
, l
))
30358 if (dwarf_split_debug_info
)
30359 remove_loc_list_addr_table_entries (l
);
30361 && l
->dw_loc_next
== NULL
30362 && l
->dw_loc_opc
== DW_OP_addr
30363 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
30364 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
30365 && a
->dw_attr
== DW_AT_location
)
30367 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
30368 remove_AT (die
, a
->dw_attr
);
30370 optimize_location_into_implicit_ptr (die
, decl
);
30373 if (a
->dw_attr
== DW_AT_string_length
)
30374 /* If we drop DW_AT_string_length, we need to drop also
30375 DW_AT_{string_length_,}byte_size. */
30376 remove_AT_byte_size
= true;
30377 remove_AT (die
, a
->dw_attr
);
30381 mark_base_types (l
);
30384 case dw_val_class_addr
:
30385 if (a
->dw_attr
== DW_AT_const_value
30386 && !resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
))
30388 if (AT_index (a
) != NOT_INDEXED
)
30389 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
30390 remove_AT (die
, a
->dw_attr
);
30393 if ((die
->die_tag
== DW_TAG_call_site
30394 && a
->dw_attr
== DW_AT_call_origin
)
30395 || (die
->die_tag
== DW_TAG_GNU_call_site
30396 && a
->dw_attr
== DW_AT_abstract_origin
))
30398 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
30399 dw_die_ref tdie
= lookup_decl_die (tdecl
);
30402 && DECL_EXTERNAL (tdecl
)
30403 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
30404 && (cdie
= lookup_context_die (DECL_CONTEXT (tdecl
))))
30406 dw_die_ref pdie
= cdie
;
30407 /* Make sure we don't add these DIEs into type units.
30408 We could emit skeleton DIEs for context (namespaces,
30409 outer structs/classes) and a skeleton DIE for the
30410 innermost context with DW_AT_signature pointing to the
30411 type unit. See PR78835. */
30412 while (pdie
&& pdie
->die_tag
!= DW_TAG_type_unit
)
30413 pdie
= pdie
->die_parent
;
30416 /* Creating a full DIE for tdecl is overly expensive and
30417 at this point even wrong when in the LTO phase
30418 as it can end up generating new type DIEs we didn't
30419 output and thus optimize_external_refs will crash. */
30420 tdie
= new_die (DW_TAG_subprogram
, cdie
, NULL_TREE
);
30421 add_AT_flag (tdie
, DW_AT_external
, 1);
30422 add_AT_flag (tdie
, DW_AT_declaration
, 1);
30423 add_linkage_attr (tdie
, tdecl
);
30424 add_name_and_src_coords_attributes (tdie
, tdecl
, true);
30425 equate_decl_number_to_die (tdecl
, tdie
);
30430 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
30431 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
30432 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
30436 if (AT_index (a
) != NOT_INDEXED
)
30437 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
30438 remove_AT (die
, a
->dw_attr
);
30447 if (remove_AT_byte_size
)
30448 remove_AT (die
, dwarf_version
>= 5
30449 ? DW_AT_string_length_byte_size
30450 : DW_AT_byte_size
);
30452 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
30455 /* Helper routines for optimize_location_lists.
30456 This pass tries to share identical local lists in .debug_loc
30459 /* Iteratively hash operands of LOC opcode into HSTATE. */
30462 hash_loc_operands (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
30464 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
30465 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
30467 switch (loc
->dw_loc_opc
)
30469 case DW_OP_const4u
:
30470 case DW_OP_const8u
:
30474 case DW_OP_const1u
:
30475 case DW_OP_const1s
:
30476 case DW_OP_const2u
:
30477 case DW_OP_const2s
:
30478 case DW_OP_const4s
:
30479 case DW_OP_const8s
:
30483 case DW_OP_plus_uconst
:
30519 case DW_OP_deref_size
:
30520 case DW_OP_xderef_size
:
30521 hstate
.add_object (val1
->v
.val_int
);
30528 gcc_assert (val1
->val_class
== dw_val_class_loc
);
30529 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
30530 hstate
.add_object (offset
);
30533 case DW_OP_implicit_value
:
30534 hstate
.add_object (val1
->v
.val_unsigned
);
30535 switch (val2
->val_class
)
30537 case dw_val_class_const
:
30538 hstate
.add_object (val2
->v
.val_int
);
30540 case dw_val_class_vec
:
30542 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
30543 unsigned int len
= val2
->v
.val_vec
.length
;
30545 hstate
.add_int (elt_size
);
30546 hstate
.add_int (len
);
30547 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
30550 case dw_val_class_const_double
:
30551 hstate
.add_object (val2
->v
.val_double
.low
);
30552 hstate
.add_object (val2
->v
.val_double
.high
);
30554 case dw_val_class_wide_int
:
30555 hstate
.add (val2
->v
.val_wide
->get_val (),
30556 get_full_len (*val2
->v
.val_wide
)
30557 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
30559 case dw_val_class_addr
:
30560 inchash::add_rtx (val2
->v
.val_addr
, hstate
);
30563 gcc_unreachable ();
30567 case DW_OP_bit_piece
:
30568 hstate
.add_object (val1
->v
.val_int
);
30569 hstate
.add_object (val2
->v
.val_int
);
30575 unsigned char dtprel
= 0xd1;
30576 hstate
.add_object (dtprel
);
30578 inchash::add_rtx (val1
->v
.val_addr
, hstate
);
30580 case DW_OP_GNU_addr_index
:
30582 case DW_OP_GNU_const_index
:
30587 unsigned char dtprel
= 0xd1;
30588 hstate
.add_object (dtprel
);
30590 inchash::add_rtx (val1
->val_entry
->addr
.rtl
, hstate
);
30593 case DW_OP_implicit_pointer
:
30594 case DW_OP_GNU_implicit_pointer
:
30595 hstate
.add_int (val2
->v
.val_int
);
30597 case DW_OP_entry_value
:
30598 case DW_OP_GNU_entry_value
:
30599 hstate
.add_object (val1
->v
.val_loc
);
30601 case DW_OP_regval_type
:
30602 case DW_OP_deref_type
:
30603 case DW_OP_GNU_regval_type
:
30604 case DW_OP_GNU_deref_type
:
30606 unsigned int byte_size
30607 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
30608 unsigned int encoding
30609 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
30610 hstate
.add_object (val1
->v
.val_int
);
30611 hstate
.add_object (byte_size
);
30612 hstate
.add_object (encoding
);
30615 case DW_OP_convert
:
30616 case DW_OP_reinterpret
:
30617 case DW_OP_GNU_convert
:
30618 case DW_OP_GNU_reinterpret
:
30619 if (val1
->val_class
== dw_val_class_unsigned_const
)
30621 hstate
.add_object (val1
->v
.val_unsigned
);
30625 case DW_OP_const_type
:
30626 case DW_OP_GNU_const_type
:
30628 unsigned int byte_size
30629 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
30630 unsigned int encoding
30631 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
30632 hstate
.add_object (byte_size
);
30633 hstate
.add_object (encoding
);
30634 if (loc
->dw_loc_opc
!= DW_OP_const_type
30635 && loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
30637 hstate
.add_object (val2
->val_class
);
30638 switch (val2
->val_class
)
30640 case dw_val_class_const
:
30641 hstate
.add_object (val2
->v
.val_int
);
30643 case dw_val_class_vec
:
30645 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
30646 unsigned int len
= val2
->v
.val_vec
.length
;
30648 hstate
.add_object (elt_size
);
30649 hstate
.add_object (len
);
30650 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
30653 case dw_val_class_const_double
:
30654 hstate
.add_object (val2
->v
.val_double
.low
);
30655 hstate
.add_object (val2
->v
.val_double
.high
);
30657 case dw_val_class_wide_int
:
30658 hstate
.add (val2
->v
.val_wide
->get_val (),
30659 get_full_len (*val2
->v
.val_wide
)
30660 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
30663 gcc_unreachable ();
30669 /* Other codes have no operands. */
30674 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
30677 hash_locs (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
30679 dw_loc_descr_ref l
;
30680 bool sizes_computed
= false;
30681 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
30682 size_of_locs (loc
);
30684 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
30686 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
30687 hstate
.add_object (opc
);
30688 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
30690 size_of_locs (loc
);
30691 sizes_computed
= true;
30693 hash_loc_operands (l
, hstate
);
30697 /* Compute hash of the whole location list LIST_HEAD. */
30700 hash_loc_list (dw_loc_list_ref list_head
)
30702 dw_loc_list_ref curr
= list_head
;
30703 inchash::hash hstate
;
30705 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
30707 hstate
.add (curr
->begin
, strlen (curr
->begin
) + 1);
30708 hstate
.add (curr
->end
, strlen (curr
->end
) + 1);
30709 hstate
.add_object (curr
->vbegin
);
30710 hstate
.add_object (curr
->vend
);
30712 hstate
.add (curr
->section
, strlen (curr
->section
) + 1);
30713 hash_locs (curr
->expr
, hstate
);
30715 list_head
->hash
= hstate
.end ();
30718 /* Return true if X and Y opcodes have the same operands. */
30721 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
30723 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
30724 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
30725 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
30726 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
30728 switch (x
->dw_loc_opc
)
30730 case DW_OP_const4u
:
30731 case DW_OP_const8u
:
30735 case DW_OP_const1u
:
30736 case DW_OP_const1s
:
30737 case DW_OP_const2u
:
30738 case DW_OP_const2s
:
30739 case DW_OP_const4s
:
30740 case DW_OP_const8s
:
30744 case DW_OP_plus_uconst
:
30780 case DW_OP_deref_size
:
30781 case DW_OP_xderef_size
:
30782 return valx1
->v
.val_int
== valy1
->v
.val_int
;
30785 /* If splitting debug info, the use of DW_OP_GNU_addr_index
30786 can cause irrelevant differences in dw_loc_addr. */
30787 gcc_assert (valx1
->val_class
== dw_val_class_loc
30788 && valy1
->val_class
== dw_val_class_loc
30789 && (dwarf_split_debug_info
30790 || x
->dw_loc_addr
== y
->dw_loc_addr
));
30791 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
30792 case DW_OP_implicit_value
:
30793 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
30794 || valx2
->val_class
!= valy2
->val_class
)
30796 switch (valx2
->val_class
)
30798 case dw_val_class_const
:
30799 return valx2
->v
.val_int
== valy2
->v
.val_int
;
30800 case dw_val_class_vec
:
30801 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
30802 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
30803 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
30804 valx2
->v
.val_vec
.elt_size
30805 * valx2
->v
.val_vec
.length
) == 0;
30806 case dw_val_class_const_double
:
30807 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
30808 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
30809 case dw_val_class_wide_int
:
30810 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
30811 case dw_val_class_addr
:
30812 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
30814 gcc_unreachable ();
30817 case DW_OP_bit_piece
:
30818 return valx1
->v
.val_int
== valy1
->v
.val_int
30819 && valx2
->v
.val_int
== valy2
->v
.val_int
;
30822 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
30823 case DW_OP_GNU_addr_index
:
30825 case DW_OP_GNU_const_index
:
30828 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
30829 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
30830 return rtx_equal_p (ax1
, ay1
);
30832 case DW_OP_implicit_pointer
:
30833 case DW_OP_GNU_implicit_pointer
:
30834 return valx1
->val_class
== dw_val_class_die_ref
30835 && valx1
->val_class
== valy1
->val_class
30836 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
30837 && valx2
->v
.val_int
== valy2
->v
.val_int
;
30838 case DW_OP_entry_value
:
30839 case DW_OP_GNU_entry_value
:
30840 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
30841 case DW_OP_const_type
:
30842 case DW_OP_GNU_const_type
:
30843 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
30844 || valx2
->val_class
!= valy2
->val_class
)
30846 switch (valx2
->val_class
)
30848 case dw_val_class_const
:
30849 return valx2
->v
.val_int
== valy2
->v
.val_int
;
30850 case dw_val_class_vec
:
30851 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
30852 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
30853 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
30854 valx2
->v
.val_vec
.elt_size
30855 * valx2
->v
.val_vec
.length
) == 0;
30856 case dw_val_class_const_double
:
30857 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
30858 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
30859 case dw_val_class_wide_int
:
30860 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
30862 gcc_unreachable ();
30864 case DW_OP_regval_type
:
30865 case DW_OP_deref_type
:
30866 case DW_OP_GNU_regval_type
:
30867 case DW_OP_GNU_deref_type
:
30868 return valx1
->v
.val_int
== valy1
->v
.val_int
30869 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
30870 case DW_OP_convert
:
30871 case DW_OP_reinterpret
:
30872 case DW_OP_GNU_convert
:
30873 case DW_OP_GNU_reinterpret
:
30874 if (valx1
->val_class
!= valy1
->val_class
)
30876 if (valx1
->val_class
== dw_val_class_unsigned_const
)
30877 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
30878 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
30879 case DW_OP_GNU_parameter_ref
:
30880 return valx1
->val_class
== dw_val_class_die_ref
30881 && valx1
->val_class
== valy1
->val_class
30882 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
30884 /* Other codes have no operands. */
30889 /* Return true if DWARF location expressions X and Y are the same. */
30892 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
30894 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
30895 if (x
->dw_loc_opc
!= y
->dw_loc_opc
30896 || x
->dtprel
!= y
->dtprel
30897 || !compare_loc_operands (x
, y
))
30899 return x
== NULL
&& y
== NULL
;
30902 /* Hashtable helpers. */
30904 struct loc_list_hasher
: nofree_ptr_hash
<dw_loc_list_struct
>
30906 static inline hashval_t
hash (const dw_loc_list_struct
*);
30907 static inline bool equal (const dw_loc_list_struct
*,
30908 const dw_loc_list_struct
*);
30911 /* Return precomputed hash of location list X. */
30914 loc_list_hasher::hash (const dw_loc_list_struct
*x
)
30919 /* Return true if location lists A and B are the same. */
30922 loc_list_hasher::equal (const dw_loc_list_struct
*a
,
30923 const dw_loc_list_struct
*b
)
30927 if (a
->hash
!= b
->hash
)
30929 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
30930 if (strcmp (a
->begin
, b
->begin
) != 0
30931 || strcmp (a
->end
, b
->end
) != 0
30932 || (a
->section
== NULL
) != (b
->section
== NULL
)
30933 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
30934 || a
->vbegin
!= b
->vbegin
|| a
->vend
!= b
->vend
30935 || !compare_locs (a
->expr
, b
->expr
))
30937 return a
== NULL
&& b
== NULL
;
30940 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
30943 /* Recursively optimize location lists referenced from DIE
30944 children and share them whenever possible. */
30947 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type
*htab
)
30952 dw_loc_list_struct
**slot
;
30953 bool drop_locviews
= false;
30954 bool has_locviews
= false;
30956 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30957 if (AT_class (a
) == dw_val_class_loc_list
)
30959 dw_loc_list_ref list
= AT_loc_list (a
);
30960 /* TODO: perform some optimizations here, before hashing
30961 it and storing into the hash table. */
30962 hash_loc_list (list
);
30963 slot
= htab
->find_slot_with_hash (list
, list
->hash
, INSERT
);
30967 if (loc_list_has_views (list
))
30968 gcc_assert (list
->vl_symbol
);
30969 else if (list
->vl_symbol
)
30971 drop_locviews
= true;
30972 list
->vl_symbol
= NULL
;
30977 if (list
->vl_symbol
&& !(*slot
)->vl_symbol
)
30978 drop_locviews
= true;
30979 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
30982 else if (AT_class (a
) == dw_val_class_view_list
)
30984 gcc_checking_assert (a
->dw_attr
== DW_AT_GNU_locviews
);
30985 has_locviews
= true;
30989 if (drop_locviews
&& has_locviews
)
30990 remove_AT (die
, DW_AT_GNU_locviews
);
30992 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
30996 /* Recursively assign each location list a unique index into the debug_addr
31000 index_location_lists (dw_die_ref die
)
31006 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31007 if (AT_class (a
) == dw_val_class_loc_list
)
31009 dw_loc_list_ref list
= AT_loc_list (a
);
31010 dw_loc_list_ref curr
;
31011 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
31013 /* Don't index an entry that has already been indexed
31014 or won't be output. Make sure skip_loc_list_entry doesn't
31015 call size_of_locs, because that might cause circular dependency,
31016 index_location_lists requiring address table indexes to be
31017 computed, but adding new indexes through add_addr_table_entry
31018 and address table index computation requiring no new additions
31019 to the hash table. In the rare case of DWARF[234] >= 64KB
31020 location expression, we'll just waste unused address table entry
31022 if (curr
->begin_entry
!= NULL
31023 || skip_loc_list_entry (curr
))
31027 = add_addr_table_entry (xstrdup (curr
->begin
), ate_kind_label
);
31031 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
31034 /* Optimize location lists referenced from DIE
31035 children and share them whenever possible. */
31038 optimize_location_lists (dw_die_ref die
)
31040 loc_list_hash_type
htab (500);
31041 optimize_location_lists_1 (die
, &htab
);
31044 /* Traverse the limbo die list, and add parent/child links. The only
31045 dies without parents that should be here are concrete instances of
31046 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
31047 For concrete instances, we can get the parent die from the abstract
31051 flush_limbo_die_list (void)
31053 limbo_die_node
*node
;
31055 /* get_context_die calls force_decl_die, which can put new DIEs on the
31056 limbo list in LTO mode when nested functions are put in a different
31057 partition than that of their parent function. */
31058 while ((node
= limbo_die_list
))
31060 dw_die_ref die
= node
->die
;
31061 limbo_die_list
= node
->next
;
31063 if (die
->die_parent
== NULL
)
31065 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
31067 if (origin
&& origin
->die_parent
)
31068 add_child_die (origin
->die_parent
, die
);
31069 else if (is_cu_die (die
))
31071 else if (seen_error ())
31072 /* It's OK to be confused by errors in the input. */
31073 add_child_die (comp_unit_die (), die
);
31076 /* In certain situations, the lexical block containing a
31077 nested function can be optimized away, which results
31078 in the nested function die being orphaned. Likewise
31079 with the return type of that nested function. Force
31080 this to be a child of the containing function.
31082 It may happen that even the containing function got fully
31083 inlined and optimized out. In that case we are lost and
31084 assign the empty child. This should not be big issue as
31085 the function is likely unreachable too. */
31086 gcc_assert (node
->created_for
);
31088 if (DECL_P (node
->created_for
))
31089 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
31090 else if (TYPE_P (node
->created_for
))
31091 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
31093 origin
= comp_unit_die ();
31095 add_child_die (origin
, die
);
31101 /* Reset DIEs so we can output them again. */
31104 reset_dies (dw_die_ref die
)
31108 /* Remove stuff we re-generate. */
31110 die
->die_offset
= 0;
31111 die
->die_abbrev
= 0;
31112 remove_AT (die
, DW_AT_sibling
);
31114 FOR_EACH_CHILD (die
, c
, reset_dies (c
));
31117 /* Output stuff that dwarf requires at the end of every file,
31118 and generate the DWARF-2 debugging info. */
31121 dwarf2out_finish (const char *filename
)
31123 comdat_type_node
*ctnode
;
31124 dw_die_ref main_comp_unit_die
;
31125 unsigned char checksum
[16];
31126 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
31128 /* Flush out any latecomers to the limbo party. */
31129 flush_limbo_die_list ();
31131 if (inline_entry_data_table
)
31132 gcc_assert (inline_entry_data_table
->elements () == 0);
31136 verify_die (comp_unit_die ());
31137 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
31138 verify_die (node
->die
);
31141 /* We shouldn't have any symbols with delayed asm names for
31142 DIEs generated after early finish. */
31143 gcc_assert (deferred_asm_name
== NULL
);
31145 gen_remaining_tmpl_value_param_die_attribute ();
31147 if (flag_generate_lto
|| flag_generate_offload
)
31149 gcc_assert (flag_fat_lto_objects
|| flag_generate_offload
);
31151 /* Prune stuff so that dwarf2out_finish runs successfully
31152 for the fat part of the object. */
31153 reset_dies (comp_unit_die ());
31154 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
31155 reset_dies (node
->die
);
31157 hash_table
<comdat_type_hasher
> comdat_type_table (100);
31158 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31160 comdat_type_node
**slot
31161 = comdat_type_table
.find_slot (ctnode
, INSERT
);
31163 /* Don't reset types twice. */
31164 if (*slot
!= HTAB_EMPTY_ENTRY
)
31167 /* Remove the pointer to the line table. */
31168 remove_AT (ctnode
->root_die
, DW_AT_stmt_list
);
31170 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31171 reset_dies (ctnode
->root_die
);
31176 /* Reset die CU symbol so we don't output it twice. */
31177 comp_unit_die ()->die_id
.die_symbol
= NULL
;
31179 /* Remove DW_AT_macro and DW_AT_stmt_list from the early output. */
31180 remove_AT (comp_unit_die (), DW_AT_stmt_list
);
31182 remove_AT (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
);
31184 /* Remove indirect string decisions. */
31185 debug_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
31186 if (debug_line_str_hash
)
31188 debug_line_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
31189 debug_line_str_hash
= NULL
;
31193 #if ENABLE_ASSERT_CHECKING
31195 dw_die_ref die
= comp_unit_die (), c
;
31196 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
31199 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31200 resolve_addr (ctnode
->root_die
);
31201 resolve_addr (comp_unit_die ());
31202 move_marked_base_types ();
31206 fprintf (dump_file
, "DWARF for %s\n", filename
);
31207 print_die (comp_unit_die (), dump_file
);
31210 /* Initialize sections and labels used for actual assembler output. */
31211 unsigned generation
= init_sections_and_labels (false);
31213 /* Traverse the DIE's and add sibling attributes to those DIE's that
31215 add_sibling_attributes (comp_unit_die ());
31216 limbo_die_node
*node
;
31217 for (node
= cu_die_list
; node
; node
= node
->next
)
31218 add_sibling_attributes (node
->die
);
31219 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31220 add_sibling_attributes (ctnode
->root_die
);
31222 /* When splitting DWARF info, we put some attributes in the
31223 skeleton compile_unit DIE that remains in the .o, while
31224 most attributes go in the DWO compile_unit_die. */
31225 if (dwarf_split_debug_info
)
31227 limbo_die_node
*cu
;
31228 main_comp_unit_die
= gen_compile_unit_die (NULL
);
31229 if (dwarf_version
>= 5)
31230 main_comp_unit_die
->die_tag
= DW_TAG_skeleton_unit
;
31231 cu
= limbo_die_list
;
31232 gcc_assert (cu
->die
== main_comp_unit_die
);
31233 limbo_die_list
= limbo_die_list
->next
;
31234 cu
->next
= cu_die_list
;
31238 main_comp_unit_die
= comp_unit_die ();
31240 /* Output a terminator label for the .text section. */
31241 switch_to_section (text_section
);
31242 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
31243 if (cold_text_section
)
31245 switch_to_section (cold_text_section
);
31246 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
31249 /* We can only use the low/high_pc attributes if all of the code was
31251 if (!have_multiple_function_sections
31252 || (dwarf_version
< 3 && dwarf_strict
))
31254 /* Don't add if the CU has no associated code. */
31255 if (text_section_used
)
31256 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
31257 text_end_label
, true);
31263 bool range_list_added
= false;
31265 if (text_section_used
)
31266 add_ranges_by_labels (main_comp_unit_die
, text_section_label
,
31267 text_end_label
, &range_list_added
, true);
31268 if (cold_text_section_used
)
31269 add_ranges_by_labels (main_comp_unit_die
, cold_text_section_label
,
31270 cold_end_label
, &range_list_added
, true);
31272 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
31274 if (DECL_IGNORED_P (fde
->decl
))
31276 if (!fde
->in_std_section
)
31277 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
31278 fde
->dw_fde_end
, &range_list_added
,
31280 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
31281 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
31282 fde
->dw_fde_second_end
, &range_list_added
,
31286 if (range_list_added
)
31288 /* We need to give .debug_loc and .debug_ranges an appropriate
31289 "base address". Use zero so that these addresses become
31290 absolute. Historically, we've emitted the unexpected
31291 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
31292 Emit both to give time for other tools to adapt. */
31293 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
31294 if (! dwarf_strict
&& dwarf_version
< 4)
31295 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
31301 /* AIX Assembler inserts the length, so adjust the reference to match the
31302 offset expected by debuggers. */
31303 strcpy (dl_section_ref
, debug_line_section_label
);
31304 if (XCOFF_DEBUGGING_INFO
)
31305 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
31307 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31308 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
31312 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
31313 macinfo_section_label
);
31315 if (dwarf_split_debug_info
)
31317 if (have_location_lists
)
31319 /* Since we generate the loclists in the split DWARF .dwo
31320 file itself, we don't need to generate a loclists_base
31321 attribute for the split compile unit DIE. That attribute
31322 (and using relocatable sec_offset FORMs) isn't allowed
31323 for a split compile unit. Only if the .debug_loclists
31324 section was in the main file, would we need to generate a
31325 loclists_base attribute here (for the full or skeleton
31328 /* optimize_location_lists calculates the size of the lists,
31329 so index them first, and assign indices to the entries.
31330 Although optimize_location_lists will remove entries from
31331 the table, it only does so for duplicates, and therefore
31332 only reduces ref_counts to 1. */
31333 index_location_lists (comp_unit_die ());
31336 if (addr_index_table
!= NULL
)
31338 unsigned int index
= 0;
31340 ->traverse_noresize
<unsigned int *, index_addr_table_entry
>
31346 if (have_location_lists
)
31348 optimize_location_lists (comp_unit_die ());
31349 /* And finally assign indexes to the entries for -gsplit-dwarf. */
31350 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
31351 assign_location_list_indexes (comp_unit_die ());
31354 save_macinfo_strings ();
31356 if (dwarf_split_debug_info
)
31358 unsigned int index
= 0;
31360 /* Add attributes common to skeleton compile_units and
31361 type_units. Because these attributes include strings, it
31362 must be done before freezing the string table. Top-level
31363 skeleton die attrs are added when the skeleton type unit is
31364 created, so ensure it is created by this point. */
31365 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
31366 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
31369 /* Output all of the compilation units. We put the main one last so that
31370 the offsets are available to output_pubnames. */
31371 for (node
= cu_die_list
; node
; node
= node
->next
)
31372 output_comp_unit (node
->die
, 0, NULL
);
31374 hash_table
<comdat_type_hasher
> comdat_type_table (100);
31375 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31377 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
31379 /* Don't output duplicate types. */
31380 if (*slot
!= HTAB_EMPTY_ENTRY
)
31383 /* Add a pointer to the line table for the main compilation unit
31384 so that the debugger can make sense of DW_AT_decl_file
31386 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31387 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
31388 (!dwarf_split_debug_info
31390 : debug_skeleton_line_section_label
));
31392 output_comdat_type_unit (ctnode
);
31396 if (dwarf_split_debug_info
)
31399 struct md5_ctx ctx
;
31401 if (dwarf_version
>= 5 && !vec_safe_is_empty (ranges_table
))
31404 /* Compute a checksum of the comp_unit to use as the dwo_id. */
31405 md5_init_ctx (&ctx
);
31407 die_checksum (comp_unit_die (), &ctx
, &mark
);
31408 unmark_all_dies (comp_unit_die ());
31409 md5_finish_ctx (&ctx
, checksum
);
31411 if (dwarf_version
< 5)
31413 /* Use the first 8 bytes of the checksum as the dwo_id,
31414 and add it to both comp-unit DIEs. */
31415 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
31416 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
31419 /* Add the base offset of the ranges table to the skeleton
31421 if (!vec_safe_is_empty (ranges_table
))
31423 if (dwarf_version
>= 5)
31424 add_AT_lineptr (main_comp_unit_die
, DW_AT_rnglists_base
,
31425 ranges_base_label
);
31427 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
31428 ranges_section_label
);
31431 switch_to_section (debug_addr_section
);
31432 /* GNU DebugFission https://gcc.gnu.org/wiki/DebugFission
31433 which GCC uses to implement -gsplit-dwarf as DWARF GNU extension
31434 before DWARF5, didn't have a header for .debug_addr units.
31435 DWARF5 specifies a small header when address tables are used. */
31436 if (dwarf_version
>= 5)
31438 unsigned int last_idx
= 0;
31439 unsigned long addrs_length
;
31441 addr_index_table
->traverse_noresize
31442 <unsigned int *, count_index_addrs
> (&last_idx
);
31443 addrs_length
= last_idx
* DWARF2_ADDR_SIZE
+ 4;
31445 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
31446 dw2_asm_output_data (4, 0xffffffff,
31447 "Escape value for 64-bit DWARF extension");
31448 dw2_asm_output_data (DWARF_OFFSET_SIZE
, addrs_length
,
31449 "Length of Address Unit");
31450 dw2_asm_output_data (2, 5, "DWARF addr version");
31451 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
31452 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
31454 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
31455 output_addr_table ();
31458 /* Output the main compilation unit if non-empty or if .debug_macinfo
31459 or .debug_macro will be emitted. */
31460 output_comp_unit (comp_unit_die (), have_macinfo
,
31461 dwarf_split_debug_info
? checksum
: NULL
);
31463 if (dwarf_split_debug_info
&& info_section_emitted
)
31464 output_skeleton_debug_sections (main_comp_unit_die
, checksum
);
31466 /* Output the abbreviation table. */
31467 if (vec_safe_length (abbrev_die_table
) != 1)
31469 switch_to_section (debug_abbrev_section
);
31470 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
31471 output_abbrev_section ();
31474 /* Output location list section if necessary. */
31475 if (have_location_lists
)
31477 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
31478 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
31479 /* Output the location lists info. */
31480 switch_to_section (debug_loc_section
);
31481 if (dwarf_version
>= 5)
31483 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_LOC_SECTION_LABEL
, 2);
31484 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_LOC_SECTION_LABEL
, 3);
31485 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
31486 dw2_asm_output_data (4, 0xffffffff,
31487 "Initial length escape value indicating "
31488 "64-bit DWARF extension");
31489 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
31490 "Length of Location Lists");
31491 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
31492 output_dwarf_version ();
31493 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
31494 dw2_asm_output_data (1, 0, "Segment Size");
31495 dw2_asm_output_data (4, dwarf_split_debug_info
? loc_list_idx
: 0,
31496 "Offset Entry Count");
31498 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
31499 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
31501 unsigned int save_loc_list_idx
= loc_list_idx
;
31503 output_loclists_offsets (comp_unit_die ());
31504 gcc_assert (save_loc_list_idx
== loc_list_idx
);
31506 output_location_lists (comp_unit_die ());
31507 if (dwarf_version
>= 5)
31508 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
31511 output_pubtables ();
31513 /* Output the address range information if a CU (.debug_info section)
31514 was emitted. We output an empty table even if we had no functions
31515 to put in it. This because the consumer has no way to tell the
31516 difference between an empty table that we omitted and failure to
31517 generate a table that would have contained data. */
31518 if (info_section_emitted
)
31520 switch_to_section (debug_aranges_section
);
31524 /* Output ranges section if necessary. */
31525 if (!vec_safe_is_empty (ranges_table
))
31527 if (dwarf_version
>= 5)
31528 output_rnglists (generation
);
31533 /* Have to end the macro section. */
31536 switch_to_section (debug_macinfo_section
);
31537 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
31538 output_macinfo (!dwarf_split_debug_info
? debug_line_section_label
31539 : debug_skeleton_line_section_label
, false);
31540 dw2_asm_output_data (1, 0, "End compilation unit");
31543 /* Output the source line correspondence table. We must do this
31544 even if there is no line information. Otherwise, on an empty
31545 translation unit, we will generate a present, but empty,
31546 .debug_info section. IRIX 6.5 `nm' will then complain when
31547 examining the file. This is done late so that any filenames
31548 used by the debug_info section are marked as 'used'. */
31549 switch_to_section (debug_line_section
);
31550 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
31551 if (! output_asm_line_debug_info ())
31552 output_line_info (false);
31554 if (dwarf_split_debug_info
&& info_section_emitted
)
31556 switch_to_section (debug_skeleton_line_section
);
31557 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
31558 output_line_info (true);
31561 /* If we emitted any indirect strings, output the string table too. */
31562 if (debug_str_hash
|| skeleton_debug_str_hash
)
31563 output_indirect_strings ();
31564 if (debug_line_str_hash
)
31566 switch_to_section (debug_line_str_section
);
31567 const enum dwarf_form form
= DW_FORM_line_strp
;
31568 debug_line_str_hash
->traverse
<enum dwarf_form
,
31569 output_indirect_string
> (form
);
31572 /* ??? Move lvugid out of dwarf2out_source_line and reset it too? */
31573 symview_upper_bound
= 0;
31575 bitmap_clear (zero_view_p
);
31578 /* Returns a hash value for X (which really is a variable_value_struct). */
31581 variable_value_hasher::hash (variable_value_struct
*x
)
31583 return (hashval_t
) x
->decl_id
;
31586 /* Return nonzero if decl_id of variable_value_struct X is the same as
31590 variable_value_hasher::equal (variable_value_struct
*x
, tree y
)
31592 return x
->decl_id
== DECL_UID (y
);
31595 /* Helper function for resolve_variable_value, handle
31596 DW_OP_GNU_variable_value in one location expression.
31597 Return true if exprloc has been changed into loclist. */
31600 resolve_variable_value_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
31602 dw_loc_descr_ref next
;
31603 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= next
)
31605 next
= loc
->dw_loc_next
;
31606 if (loc
->dw_loc_opc
!= DW_OP_GNU_variable_value
31607 || loc
->dw_loc_oprnd1
.val_class
!= dw_val_class_decl_ref
)
31610 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
31611 if (DECL_CONTEXT (decl
) != current_function_decl
)
31614 dw_die_ref ref
= lookup_decl_die (decl
);
31617 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31618 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31619 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31622 dw_loc_list_ref l
= loc_list_from_tree (decl
, 0, NULL
);
31625 if (l
->dw_loc_next
)
31627 if (AT_class (a
) != dw_val_class_loc
)
31629 switch (a
->dw_attr
)
31631 /* Following attributes allow both exprloc and loclist
31632 classes, so we can change them into a loclist. */
31633 case DW_AT_location
:
31634 case DW_AT_string_length
:
31635 case DW_AT_return_addr
:
31636 case DW_AT_data_member_location
:
31637 case DW_AT_frame_base
:
31638 case DW_AT_segment
:
31639 case DW_AT_static_link
:
31640 case DW_AT_use_location
:
31641 case DW_AT_vtable_elem_location
:
31644 prev
->dw_loc_next
= NULL
;
31645 prepend_loc_descr_to_each (l
, AT_loc (a
));
31648 add_loc_descr_to_each (l
, next
);
31649 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
31650 a
->dw_attr_val
.val_entry
= NULL
;
31651 a
->dw_attr_val
.v
.val_loc_list
= l
;
31652 have_location_lists
= true;
31654 /* Following attributes allow both exprloc and reference,
31655 so if the whole expression is DW_OP_GNU_variable_value alone
31656 we could transform it into reference. */
31657 case DW_AT_byte_size
:
31658 case DW_AT_bit_size
:
31659 case DW_AT_lower_bound
:
31660 case DW_AT_upper_bound
:
31661 case DW_AT_bit_stride
:
31663 case DW_AT_allocated
:
31664 case DW_AT_associated
:
31665 case DW_AT_byte_stride
:
31666 if (prev
== NULL
&& next
== NULL
)
31674 /* Create DW_TAG_variable that we can refer to. */
31675 gen_decl_die (decl
, NULL_TREE
, NULL
,
31676 lookup_decl_die (current_function_decl
));
31677 ref
= lookup_decl_die (decl
);
31680 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31681 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31682 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31688 prev
->dw_loc_next
= l
->expr
;
31689 add_loc_descr (&prev
->dw_loc_next
, next
);
31690 free_loc_descr (loc
, NULL
);
31691 next
= prev
->dw_loc_next
;
31695 memcpy (loc
, l
->expr
, sizeof (dw_loc_descr_node
));
31696 add_loc_descr (&loc
, next
);
31704 /* Attempt to resolve DW_OP_GNU_variable_value using loc_list_from_tree. */
31707 resolve_variable_value (dw_die_ref die
)
31710 dw_loc_list_ref loc
;
31713 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31714 switch (AT_class (a
))
31716 case dw_val_class_loc
:
31717 if (!resolve_variable_value_in_expr (a
, AT_loc (a
)))
31720 case dw_val_class_loc_list
:
31721 loc
= AT_loc_list (a
);
31723 for (; loc
; loc
= loc
->dw_loc_next
)
31724 resolve_variable_value_in_expr (a
, loc
->expr
);
31731 /* Attempt to optimize DW_OP_GNU_variable_value refering to
31732 temporaries in the current function. */
31735 resolve_variable_values (void)
31737 if (!variable_value_hash
|| !current_function_decl
)
31740 struct variable_value_struct
*node
31741 = variable_value_hash
->find_with_hash (current_function_decl
,
31742 DECL_UID (current_function_decl
));
31749 FOR_EACH_VEC_SAFE_ELT (node
->dies
, i
, die
)
31750 resolve_variable_value (die
);
31753 /* Helper function for note_variable_value, handle one location
31757 note_variable_value_in_expr (dw_die_ref die
, dw_loc_descr_ref loc
)
31759 for (; loc
; loc
= loc
->dw_loc_next
)
31760 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
31761 && loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
31763 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
31764 dw_die_ref ref
= lookup_decl_die (decl
);
31765 if (! ref
&& (flag_generate_lto
|| flag_generate_offload
))
31767 /* ??? This is somewhat a hack because we do not create DIEs
31768 for variables not in BLOCK trees early but when generating
31769 early LTO output we need the dw_val_class_decl_ref to be
31770 fully resolved. For fat LTO objects we'd also like to
31771 undo this after LTO dwarf output. */
31772 gcc_assert (DECL_CONTEXT (decl
));
31773 dw_die_ref ctx
= lookup_decl_die (DECL_CONTEXT (decl
));
31774 gcc_assert (ctx
!= NULL
);
31775 gen_decl_die (decl
, NULL_TREE
, NULL
, ctx
);
31776 ref
= lookup_decl_die (decl
);
31777 gcc_assert (ref
!= NULL
);
31781 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31782 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31783 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31787 && DECL_CONTEXT (decl
)
31788 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
31789 && lookup_decl_die (DECL_CONTEXT (decl
)))
31791 if (!variable_value_hash
)
31792 variable_value_hash
31793 = hash_table
<variable_value_hasher
>::create_ggc (10);
31795 tree fndecl
= DECL_CONTEXT (decl
);
31796 struct variable_value_struct
*node
;
31797 struct variable_value_struct
**slot
31798 = variable_value_hash
->find_slot_with_hash (fndecl
,
31803 node
= ggc_cleared_alloc
<variable_value_struct
> ();
31804 node
->decl_id
= DECL_UID (fndecl
);
31810 vec_safe_push (node
->dies
, die
);
31815 /* Walk the tree DIE and note DIEs with DW_OP_GNU_variable_value still
31816 with dw_val_class_decl_ref operand. */
31819 note_variable_value (dw_die_ref die
)
31823 dw_loc_list_ref loc
;
31826 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31827 switch (AT_class (a
))
31829 case dw_val_class_loc_list
:
31830 loc
= AT_loc_list (a
);
31832 if (!loc
->noted_variable_value
)
31834 loc
->noted_variable_value
= 1;
31835 for (; loc
; loc
= loc
->dw_loc_next
)
31836 note_variable_value_in_expr (die
, loc
->expr
);
31839 case dw_val_class_loc
:
31840 note_variable_value_in_expr (die
, AT_loc (a
));
31846 /* Mark children. */
31847 FOR_EACH_CHILD (die
, c
, note_variable_value (c
));
31850 /* Perform any cleanups needed after the early debug generation pass
31854 dwarf2out_early_finish (const char *filename
)
31857 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
31859 /* PCH might result in DW_AT_producer string being restored from the
31860 header compilation, so always fill it with empty string initially
31861 and overwrite only here. */
31862 dw_attr_node
*producer
= get_AT (comp_unit_die (), DW_AT_producer
);
31863 producer_string
= gen_producer_string ();
31864 producer
->dw_attr_val
.v
.val_str
->refcount
--;
31865 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
31867 /* Add the name for the main input file now. We delayed this from
31868 dwarf2out_init to avoid complications with PCH. */
31869 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
31870 add_comp_dir_attribute (comp_unit_die ());
31872 /* When emitting DWARF5 .debug_line_str, move DW_AT_name and
31873 DW_AT_comp_dir into .debug_line_str section. */
31874 if (!output_asm_line_debug_info ()
31875 && dwarf_version
>= 5
31876 && DWARF5_USE_DEBUG_LINE_STR
)
31878 for (int i
= 0; i
< 2; i
++)
31880 dw_attr_node
*a
= get_AT (comp_unit_die (),
31881 i
? DW_AT_comp_dir
: DW_AT_name
);
31883 || AT_class (a
) != dw_val_class_str
31884 || strlen (AT_string (a
)) + 1 <= DWARF_OFFSET_SIZE
)
31887 if (! debug_line_str_hash
)
31888 debug_line_str_hash
31889 = hash_table
<indirect_string_hasher
>::create_ggc (10);
31891 struct indirect_string_node
*node
31892 = find_AT_string_in_table (AT_string (a
), debug_line_str_hash
);
31893 set_indirect_string (node
);
31894 node
->form
= DW_FORM_line_strp
;
31895 a
->dw_attr_val
.v
.val_str
->refcount
--;
31896 a
->dw_attr_val
.v
.val_str
= node
;
31900 /* With LTO early dwarf was really finished at compile-time, so make
31901 sure to adjust the phase after annotating the LTRANS CU DIE. */
31904 /* Force DW_TAG_imported_unit to be created now, otherwise
31905 we might end up without it or ordered after DW_TAG_inlined_subroutine
31906 referencing DIEs from it. */
31907 if (! flag_wpa
&& flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
31911 if (external_die_map
)
31912 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, tu
)
31913 if (sym_off_pair
*desc
= external_die_map
->get (tu
))
31915 dw_die_ref import
= new_die (DW_TAG_imported_unit
,
31916 comp_unit_die (), NULL_TREE
);
31917 add_AT_external_die_ref (import
, DW_AT_import
,
31918 desc
->sym
, desc
->off
);
31922 early_dwarf_finished
= true;
31925 fprintf (dump_file
, "LTO EARLY DWARF for %s\n", filename
);
31926 print_die (comp_unit_die (), dump_file
);
31931 /* Walk through the list of incomplete types again, trying once more to
31932 emit full debugging info for them. */
31933 retry_incomplete_types ();
31935 /* The point here is to flush out the limbo list so that it is empty
31936 and we don't need to stream it for LTO. */
31937 flush_limbo_die_list ();
31939 gen_scheduled_generic_parms_dies ();
31940 gen_remaining_tmpl_value_param_die_attribute ();
31942 /* Add DW_AT_linkage_name for all deferred DIEs. */
31943 for (limbo_die_node
*node
= deferred_asm_name
; node
; node
= node
->next
)
31945 tree decl
= node
->created_for
;
31946 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
31947 /* A missing DECL_ASSEMBLER_NAME can be a constant DIE that
31948 ended up in deferred_asm_name before we knew it was
31949 constant and never written to disk. */
31950 && DECL_ASSEMBLER_NAME (decl
))
31952 add_linkage_attr (node
->die
, decl
);
31953 move_linkage_attr (node
->die
);
31956 deferred_asm_name
= NULL
;
31958 if (flag_eliminate_unused_debug_types
)
31959 prune_unused_types ();
31961 /* Generate separate COMDAT sections for type DIEs. */
31962 if (use_debug_types
)
31964 break_out_comdat_types (comp_unit_die ());
31966 /* Each new type_unit DIE was added to the limbo die list when created.
31967 Since these have all been added to comdat_type_list, clear the
31969 limbo_die_list
= NULL
;
31971 /* For each new comdat type unit, copy declarations for incomplete
31972 types to make the new unit self-contained (i.e., no direct
31973 references to the main compile unit). */
31974 for (comdat_type_node
*ctnode
= comdat_type_list
;
31975 ctnode
!= NULL
; ctnode
= ctnode
->next
)
31976 copy_decls_for_unworthy_types (ctnode
->root_die
);
31977 copy_decls_for_unworthy_types (comp_unit_die ());
31979 /* In the process of copying declarations from one unit to another,
31980 we may have left some declarations behind that are no longer
31981 referenced. Prune them. */
31982 prune_unused_types ();
31985 /* Traverse the DIE's and note DIEs with DW_OP_GNU_variable_value still
31986 with dw_val_class_decl_ref operand. */
31987 note_variable_value (comp_unit_die ());
31988 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
31989 note_variable_value (node
->die
);
31990 for (comdat_type_node
*ctnode
= comdat_type_list
; ctnode
!= NULL
;
31991 ctnode
= ctnode
->next
)
31992 note_variable_value (ctnode
->root_die
);
31993 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
31994 note_variable_value (node
->die
);
31996 /* The AT_pubnames attribute needs to go in all skeleton dies, including
31997 both the main_cu and all skeleton TUs. Making this call unconditional
31998 would end up either adding a second copy of the AT_pubnames attribute, or
31999 requiring a special case in add_top_level_skeleton_die_attrs. */
32000 if (!dwarf_split_debug_info
)
32001 add_AT_pubnames (comp_unit_die ());
32003 /* The early debug phase is now finished. */
32004 early_dwarf_finished
= true;
32007 fprintf (dump_file
, "EARLY DWARF for %s\n", filename
);
32008 print_die (comp_unit_die (), dump_file
);
32011 /* Do not generate DWARF assembler now when not producing LTO bytecode. */
32012 if ((!flag_generate_lto
&& !flag_generate_offload
)
32013 /* FIXME: Disable debug info generation for (PE-)COFF targets since the
32014 copy_lto_debug_sections operation of the simple object support in
32015 libiberty is not implemented for them yet. */
32016 || TARGET_PECOFF
|| TARGET_COFF
)
32019 /* Now as we are going to output for LTO initialize sections and labels
32020 to the LTO variants. We don't need a random-seed postfix as other
32021 LTO sections as linking the LTO debug sections into one in a partial
32023 init_sections_and_labels (true);
32025 /* The output below is modeled after dwarf2out_finish with all
32026 location related output removed and some LTO specific changes.
32027 Some refactoring might make both smaller and easier to match up. */
32029 /* Traverse the DIE's and add add sibling attributes to those DIE's
32030 that have children. */
32031 add_sibling_attributes (comp_unit_die ());
32032 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
32033 add_sibling_attributes (node
->die
);
32034 for (comdat_type_node
*ctnode
= comdat_type_list
;
32035 ctnode
!= NULL
; ctnode
= ctnode
->next
)
32036 add_sibling_attributes (ctnode
->root_die
);
32038 /* AIX Assembler inserts the length, so adjust the reference to match the
32039 offset expected by debuggers. */
32040 strcpy (dl_section_ref
, debug_line_section_label
);
32041 if (XCOFF_DEBUGGING_INFO
)
32042 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
32044 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32045 add_AT_lineptr (comp_unit_die (), DW_AT_stmt_list
, dl_section_ref
);
32048 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
32049 macinfo_section_label
);
32051 save_macinfo_strings ();
32053 if (dwarf_split_debug_info
)
32055 unsigned int index
= 0;
32056 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
32059 /* Output all of the compilation units. We put the main one last so that
32060 the offsets are available to output_pubnames. */
32061 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
32062 output_comp_unit (node
->die
, 0, NULL
);
32064 hash_table
<comdat_type_hasher
> comdat_type_table (100);
32065 for (comdat_type_node
*ctnode
= comdat_type_list
;
32066 ctnode
!= NULL
; ctnode
= ctnode
->next
)
32068 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
32070 /* Don't output duplicate types. */
32071 if (*slot
!= HTAB_EMPTY_ENTRY
)
32074 /* Add a pointer to the line table for the main compilation unit
32075 so that the debugger can make sense of DW_AT_decl_file
32077 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32078 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
32079 (!dwarf_split_debug_info
32080 ? debug_line_section_label
32081 : debug_skeleton_line_section_label
));
32083 output_comdat_type_unit (ctnode
);
32087 /* Stick a unique symbol to the main debuginfo section. */
32088 compute_comp_unit_symbol (comp_unit_die ());
32090 /* Output the main compilation unit. We always need it if only for
32092 output_comp_unit (comp_unit_die (), true, NULL
);
32094 /* Output the abbreviation table. */
32095 if (vec_safe_length (abbrev_die_table
) != 1)
32097 switch_to_section (debug_abbrev_section
);
32098 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
32099 output_abbrev_section ();
32102 /* Have to end the macro section. */
32105 /* We have to save macinfo state if we need to output it again
32106 for the FAT part of the object. */
32107 vec
<macinfo_entry
, va_gc
> *saved_macinfo_table
= macinfo_table
;
32108 if (flag_fat_lto_objects
)
32109 macinfo_table
= macinfo_table
->copy ();
32111 switch_to_section (debug_macinfo_section
);
32112 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
32113 output_macinfo (debug_line_section_label
, true);
32114 dw2_asm_output_data (1, 0, "End compilation unit");
32116 if (flag_fat_lto_objects
)
32118 vec_free (macinfo_table
);
32119 macinfo_table
= saved_macinfo_table
;
32123 /* Emit a skeleton debug_line section. */
32124 switch_to_section (debug_line_section
);
32125 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
32126 output_line_info (true);
32128 /* If we emitted any indirect strings, output the string table too. */
32129 if (debug_str_hash
|| skeleton_debug_str_hash
)
32130 output_indirect_strings ();
32131 if (debug_line_str_hash
)
32133 switch_to_section (debug_line_str_section
);
32134 const enum dwarf_form form
= DW_FORM_line_strp
;
32135 debug_line_str_hash
->traverse
<enum dwarf_form
,
32136 output_indirect_string
> (form
);
32139 /* Switch back to the text section. */
32140 switch_to_section (text_section
);
32143 /* Reset all state within dwarf2out.c so that we can rerun the compiler
32144 within the same process. For use by toplev::finalize. */
32147 dwarf2out_c_finalize (void)
32149 last_var_location_insn
= NULL
;
32150 cached_next_real_insn
= NULL
;
32151 used_rtx_array
= NULL
;
32152 incomplete_types
= NULL
;
32153 debug_info_section
= NULL
;
32154 debug_skeleton_info_section
= NULL
;
32155 debug_abbrev_section
= NULL
;
32156 debug_skeleton_abbrev_section
= NULL
;
32157 debug_aranges_section
= NULL
;
32158 debug_addr_section
= NULL
;
32159 debug_macinfo_section
= NULL
;
32160 debug_line_section
= NULL
;
32161 debug_skeleton_line_section
= NULL
;
32162 debug_loc_section
= NULL
;
32163 debug_pubnames_section
= NULL
;
32164 debug_pubtypes_section
= NULL
;
32165 debug_str_section
= NULL
;
32166 debug_line_str_section
= NULL
;
32167 debug_str_dwo_section
= NULL
;
32168 debug_str_offsets_section
= NULL
;
32169 debug_ranges_section
= NULL
;
32170 debug_frame_section
= NULL
;
32172 debug_str_hash
= NULL
;
32173 debug_line_str_hash
= NULL
;
32174 skeleton_debug_str_hash
= NULL
;
32175 dw2_string_counter
= 0;
32176 have_multiple_function_sections
= false;
32177 text_section_used
= false;
32178 cold_text_section_used
= false;
32179 cold_text_section
= NULL
;
32180 current_unit_personality
= NULL
;
32182 early_dwarf
= false;
32183 early_dwarf_finished
= false;
32185 next_die_offset
= 0;
32186 single_comp_unit_die
= NULL
;
32187 comdat_type_list
= NULL
;
32188 limbo_die_list
= NULL
;
32190 decl_die_table
= NULL
;
32191 common_block_die_table
= NULL
;
32192 decl_loc_table
= NULL
;
32193 call_arg_locations
= NULL
;
32194 call_arg_loc_last
= NULL
;
32195 call_site_count
= -1;
32196 tail_call_site_count
= -1;
32197 cached_dw_loc_list_table
= NULL
;
32198 abbrev_die_table
= NULL
;
32199 delete dwarf_proc_stack_usage_map
;
32200 dwarf_proc_stack_usage_map
= NULL
;
32201 line_info_label_num
= 0;
32202 cur_line_info_table
= NULL
;
32203 text_section_line_info
= NULL
;
32204 cold_text_section_line_info
= NULL
;
32205 separate_line_info
= NULL
;
32206 info_section_emitted
= false;
32207 pubname_table
= NULL
;
32208 pubtype_table
= NULL
;
32209 macinfo_table
= NULL
;
32210 ranges_table
= NULL
;
32211 ranges_by_label
= NULL
;
32213 have_location_lists
= false;
32216 last_emitted_file
= NULL
;
32218 tmpl_value_parm_die_table
= NULL
;
32219 generic_type_instances
= NULL
;
32220 frame_pointer_fb_offset
= 0;
32221 frame_pointer_fb_offset_valid
= false;
32222 base_types
.release ();
32223 XDELETEVEC (producer_string
);
32224 producer_string
= NULL
;
32227 #include "gt-dwarf2out.h"