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 /* .cfi_personality and .cfi_lsda are only relevant to DWARF2
974 if (targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
)
977 rtx personality
= get_personality_function (current_function_decl
);
981 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
984 /* ??? The GAS support isn't entirely consistent. We have to
985 handle indirect support ourselves, but PC-relative is done
986 in the assembler. Further, the assembler can't handle any
987 of the weirder relocation types. */
988 if (enc
& DW_EH_PE_indirect
)
989 ref
= dw2_force_const_mem (ref
, true);
991 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
992 output_addr_const (asm_out_file
, ref
);
993 fputc ('\n', asm_out_file
);
996 if (crtl
->uses_eh_lsda
)
998 char lab
[MAX_ARTIFICIAL_LABEL_BYTES
];
1000 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1001 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
1002 current_function_funcdef_no
);
1003 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
1004 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
1006 if (enc
& DW_EH_PE_indirect
)
1007 ref
= dw2_force_const_mem (ref
, true);
1009 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
1010 output_addr_const (asm_out_file
, ref
);
1011 fputc ('\n', asm_out_file
);
1015 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
1016 this allocation may be done before pass_final. */
1019 dwarf2out_alloc_current_fde (void)
1023 fde
= ggc_cleared_alloc
<dw_fde_node
> ();
1024 fde
->decl
= current_function_decl
;
1025 fde
->funcdef_number
= current_function_funcdef_no
;
1026 fde
->fde_index
= vec_safe_length (fde_vec
);
1027 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
1028 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
1029 fde
->nothrow
= crtl
->nothrow
;
1030 fde
->drap_reg
= INVALID_REGNUM
;
1031 fde
->vdrap_reg
= INVALID_REGNUM
;
1033 /* Record the FDE associated with this function. */
1035 vec_safe_push (fde_vec
, fde
);
1040 /* Output a marker (i.e. a label) for the beginning of a function, before
1044 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1045 unsigned int column ATTRIBUTE_UNUSED
,
1046 const char *file ATTRIBUTE_UNUSED
)
1048 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1054 current_function_func_begin_label
= NULL
;
1056 do_frame
= dwarf2out_do_frame ();
1058 /* ??? current_function_func_begin_label is also used by except.c for
1059 call-site information. We must emit this label if it might be used. */
1061 && (!flag_exceptions
1062 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1065 fnsec
= function_section (current_function_decl
);
1066 switch_to_section (fnsec
);
1067 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1068 current_function_funcdef_no
);
1069 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1070 current_function_funcdef_no
);
1071 dup_label
= xstrdup (label
);
1072 current_function_func_begin_label
= dup_label
;
1074 /* We can elide FDE allocation if we're not emitting frame unwind info. */
1078 /* Unlike the debug version, the EH version of frame unwind info is a per-
1079 function setting so we need to record whether we need it for the unit. */
1080 do_eh_frame
|= dwarf2out_do_eh_frame ();
1082 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1083 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1084 would include pass_dwarf2_frame. If we've not created the FDE yet,
1088 fde
= dwarf2out_alloc_current_fde ();
1090 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1091 fde
->dw_fde_begin
= dup_label
;
1092 fde
->dw_fde_current_label
= dup_label
;
1093 fde
->in_std_section
= (fnsec
== text_section
1094 || (cold_text_section
&& fnsec
== cold_text_section
));
1096 /* We only want to output line number information for the genuine dwarf2
1097 prologue case, not the eh frame case. */
1098 #ifdef DWARF2_DEBUGGING_INFO
1100 dwarf2out_source_line (line
, column
, file
, 0, true);
1103 if (dwarf2out_do_cfi_asm ())
1104 dwarf2out_do_cfi_startproc (false);
1107 rtx personality
= get_personality_function (current_function_decl
);
1108 if (!current_unit_personality
)
1109 current_unit_personality
= personality
;
1111 /* We cannot keep a current personality per function as without CFI
1112 asm, at the point where we emit the CFI data, there is no current
1113 function anymore. */
1114 if (personality
&& current_unit_personality
!= personality
)
1115 sorry ("multiple EH personalities are supported only with assemblers "
1116 "supporting .cfi_personality directive");
1120 /* Output a marker (i.e. a label) for the end of the generated code
1121 for a function prologue. This gets called *after* the prologue code has
1125 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1126 const char *file ATTRIBUTE_UNUSED
)
1128 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1130 /* Output a label to mark the endpoint of the code generated for this
1132 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1133 current_function_funcdef_no
);
1134 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1135 current_function_funcdef_no
);
1136 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1139 /* Output a marker (i.e. a label) for the beginning of the generated code
1140 for a function epilogue. This gets called *before* the prologue code has
1144 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1145 const char *file ATTRIBUTE_UNUSED
)
1147 dw_fde_ref fde
= cfun
->fde
;
1148 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1150 if (fde
->dw_fde_vms_begin_epilogue
)
1153 /* Output a label to mark the endpoint of the code generated for this
1155 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1156 current_function_funcdef_no
);
1157 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1158 current_function_funcdef_no
);
1159 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1162 /* Output a marker (i.e. a label) for the absolute end of the generated code
1163 for a function definition. This gets called *after* the epilogue code has
1167 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1168 const char *file ATTRIBUTE_UNUSED
)
1171 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1173 last_var_location_insn
= NULL
;
1174 cached_next_real_insn
= NULL
;
1176 if (dwarf2out_do_cfi_asm ())
1177 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1179 /* Output a label to mark the endpoint of the code generated for this
1181 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1182 current_function_funcdef_no
);
1183 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1185 gcc_assert (fde
!= NULL
);
1186 if (fde
->dw_fde_second_begin
== NULL
)
1187 fde
->dw_fde_end
= xstrdup (label
);
1191 dwarf2out_frame_finish (void)
1193 /* Output call frame information. */
1194 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1195 output_call_frame_info (0);
1197 /* Output another copy for the unwinder. */
1199 output_call_frame_info (1);
1202 /* Note that the current function section is being used for code. */
1205 dwarf2out_note_section_used (void)
1207 section
*sec
= current_function_section ();
1208 if (sec
== text_section
)
1209 text_section_used
= true;
1210 else if (sec
== cold_text_section
)
1211 cold_text_section_used
= true;
1214 static void var_location_switch_text_section (void);
1215 static void set_cur_line_info_table (section
*);
1218 dwarf2out_switch_text_section (void)
1220 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1222 dw_fde_ref fde
= cfun
->fde
;
1224 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1226 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_SECOND_SECT_LABEL
,
1227 current_function_funcdef_no
);
1229 fde
->dw_fde_second_begin
= ggc_strdup (label
);
1230 if (!in_cold_section_p
)
1232 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1233 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1237 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1238 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1240 have_multiple_function_sections
= true;
1242 /* There is no need to mark used sections when not debugging. */
1243 if (cold_text_section
!= NULL
)
1244 dwarf2out_note_section_used ();
1246 if (dwarf2out_do_cfi_asm ())
1247 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1249 /* Now do the real section switch. */
1250 sect
= current_function_section ();
1251 switch_to_section (sect
);
1253 fde
->second_in_std_section
1254 = (sect
== text_section
1255 || (cold_text_section
&& sect
== cold_text_section
));
1257 if (dwarf2out_do_cfi_asm ())
1258 dwarf2out_do_cfi_startproc (true);
1260 var_location_switch_text_section ();
1262 if (cold_text_section
!= NULL
)
1263 set_cur_line_info_table (sect
);
1266 /* And now, the subset of the debugging information support code necessary
1267 for emitting location expressions. */
1269 /* Data about a single source file. */
1270 struct GTY((for_user
)) dwarf_file_data
{
1271 const char * filename
;
1275 /* Describe an entry into the .debug_addr section. */
1279 ate_kind_rtx_dtprel
,
1283 struct GTY((for_user
)) addr_table_entry
{
1285 unsigned int refcount
;
1287 union addr_table_entry_struct_union
1289 rtx
GTY ((tag ("0"))) rtl
;
1290 char * GTY ((tag ("1"))) label
;
1292 GTY ((desc ("%1.kind"))) addr
;
1295 typedef unsigned int var_loc_view
;
1297 /* Location lists are ranges + location descriptions for that range,
1298 so you can track variables that are in different places over
1299 their entire life. */
1300 typedef struct GTY(()) dw_loc_list_struct
{
1301 dw_loc_list_ref dw_loc_next
;
1302 const char *begin
; /* Label and addr_entry for start of range */
1303 addr_table_entry
*begin_entry
;
1304 const char *end
; /* Label for end of range */
1305 char *ll_symbol
; /* Label for beginning of location list.
1306 Only on head of list. */
1307 char *vl_symbol
; /* Label for beginning of view list. Ditto. */
1308 const char *section
; /* Section this loclist is relative to */
1309 dw_loc_descr_ref expr
;
1310 var_loc_view vbegin
, vend
;
1312 /* True if all addresses in this and subsequent lists are known to be
1315 /* True if this list has been replaced by dw_loc_next. */
1317 /* True if it has been emitted into .debug_loc* / .debug_loclists*
1319 unsigned char emitted
: 1;
1320 /* True if hash field is index rather than hash value. */
1321 unsigned char num_assigned
: 1;
1322 /* True if .debug_loclists.dwo offset has been emitted for it already. */
1323 unsigned char offset_emitted
: 1;
1324 /* True if note_variable_value_in_expr has been called on it. */
1325 unsigned char noted_variable_value
: 1;
1326 /* True if the range should be emitted even if begin and end
1331 static dw_loc_descr_ref
int_loc_descriptor (poly_int64
);
1332 static dw_loc_descr_ref
uint_loc_descriptor (unsigned HOST_WIDE_INT
);
1334 /* Convert a DWARF stack opcode into its string name. */
1337 dwarf_stack_op_name (unsigned int op
)
1339 const char *name
= get_DW_OP_name (op
);
1344 return "OP_<unknown>";
1347 /* Return TRUE iff we're to output location view lists as a separate
1348 attribute next to the location lists, as an extension compatible
1349 with DWARF 2 and above. */
1352 dwarf2out_locviews_in_attribute ()
1354 return debug_variable_location_views
== 1;
1357 /* Return TRUE iff we're to output location view lists as part of the
1358 location lists, as proposed for standardization after DWARF 5. */
1361 dwarf2out_locviews_in_loclist ()
1363 #ifndef DW_LLE_view_pair
1366 return debug_variable_location_views
== -1;
1370 /* Return a pointer to a newly allocated location description. Location
1371 descriptions are simple expression terms that can be strung
1372 together to form more complicated location (address) descriptions. */
1374 static inline dw_loc_descr_ref
1375 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1376 unsigned HOST_WIDE_INT oprnd2
)
1378 dw_loc_descr_ref descr
= ggc_cleared_alloc
<dw_loc_descr_node
> ();
1380 descr
->dw_loc_opc
= op
;
1381 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1382 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1383 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1384 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1385 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1386 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1391 /* Add a location description term to a location description expression. */
1394 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1396 dw_loc_descr_ref
*d
;
1398 /* Find the end of the chain. */
1399 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1405 /* Compare two location operands for exact equality. */
1408 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1410 if (a
->val_class
!= b
->val_class
)
1412 switch (a
->val_class
)
1414 case dw_val_class_none
:
1416 case dw_val_class_addr
:
1417 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1419 case dw_val_class_offset
:
1420 case dw_val_class_unsigned_const
:
1421 case dw_val_class_const
:
1422 case dw_val_class_unsigned_const_implicit
:
1423 case dw_val_class_const_implicit
:
1424 case dw_val_class_range_list
:
1425 /* These are all HOST_WIDE_INT, signed or unsigned. */
1426 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1428 case dw_val_class_loc
:
1429 return a
->v
.val_loc
== b
->v
.val_loc
;
1430 case dw_val_class_loc_list
:
1431 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1432 case dw_val_class_view_list
:
1433 return a
->v
.val_view_list
== b
->v
.val_view_list
;
1434 case dw_val_class_die_ref
:
1435 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1436 case dw_val_class_fde_ref
:
1437 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1438 case dw_val_class_symview
:
1439 return strcmp (a
->v
.val_symbolic_view
, b
->v
.val_symbolic_view
) == 0;
1440 case dw_val_class_lbl_id
:
1441 case dw_val_class_lineptr
:
1442 case dw_val_class_macptr
:
1443 case dw_val_class_loclistsptr
:
1444 case dw_val_class_high_pc
:
1445 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1446 case dw_val_class_str
:
1447 return a
->v
.val_str
== b
->v
.val_str
;
1448 case dw_val_class_flag
:
1449 return a
->v
.val_flag
== b
->v
.val_flag
;
1450 case dw_val_class_file
:
1451 case dw_val_class_file_implicit
:
1452 return a
->v
.val_file
== b
->v
.val_file
;
1453 case dw_val_class_decl_ref
:
1454 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1456 case dw_val_class_const_double
:
1457 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1458 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1460 case dw_val_class_wide_int
:
1461 return *a
->v
.val_wide
== *b
->v
.val_wide
;
1463 case dw_val_class_vec
:
1465 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1466 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1468 return (a_len
== b_len
1469 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1472 case dw_val_class_data8
:
1473 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1475 case dw_val_class_vms_delta
:
1476 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1477 && !strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
));
1479 case dw_val_class_discr_value
:
1480 return (a
->v
.val_discr_value
.pos
== b
->v
.val_discr_value
.pos
1481 && a
->v
.val_discr_value
.v
.uval
== b
->v
.val_discr_value
.v
.uval
);
1482 case dw_val_class_discr_list
:
1483 /* It makes no sense comparing two discriminant value lists. */
1489 /* Compare two location atoms for exact equality. */
1492 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1494 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1497 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1498 address size, but since we always allocate cleared storage it
1499 should be zero for other types of locations. */
1500 if (a
->dtprel
!= b
->dtprel
)
1503 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1504 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1507 /* Compare two complete location expressions for exact equality. */
1510 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1516 if (a
== NULL
|| b
== NULL
)
1518 if (!loc_descr_equal_p_1 (a
, b
))
1527 /* Add a constant POLY_OFFSET to a location expression. */
1530 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, poly_int64 poly_offset
)
1532 dw_loc_descr_ref loc
;
1535 gcc_assert (*list_head
!= NULL
);
1537 if (known_eq (poly_offset
, 0))
1540 /* Find the end of the chain. */
1541 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1544 HOST_WIDE_INT offset
;
1545 if (!poly_offset
.is_constant (&offset
))
1547 loc
->dw_loc_next
= int_loc_descriptor (poly_offset
);
1548 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_plus
, 0, 0));
1553 if (loc
->dw_loc_opc
== DW_OP_fbreg
1554 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1555 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1556 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1557 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1559 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1560 offset. Don't optimize if an signed integer overflow would happen. */
1562 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1563 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1566 else if (offset
> 0)
1567 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1572 = uint_loc_descriptor (-(unsigned HOST_WIDE_INT
) offset
);
1573 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1577 /* Return a pointer to a newly allocated location description for
1580 static inline dw_loc_descr_ref
1581 new_reg_loc_descr (unsigned int reg
, poly_int64 offset
)
1583 HOST_WIDE_INT const_offset
;
1584 if (offset
.is_constant (&const_offset
))
1587 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1590 return new_loc_descr (DW_OP_bregx
, reg
, const_offset
);
1594 dw_loc_descr_ref ret
= new_reg_loc_descr (reg
, 0);
1595 loc_descr_plus_const (&ret
, offset
);
1600 /* Add a constant OFFSET to a location list. */
1603 loc_list_plus_const (dw_loc_list_ref list_head
, poly_int64 offset
)
1606 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1607 loc_descr_plus_const (&d
->expr
, offset
);
1610 #define DWARF_REF_SIZE \
1611 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1613 /* The number of bits that can be encoded by largest DW_FORM_dataN.
1614 In DWARF4 and earlier it is DW_FORM_data8 with 64 bits, in DWARF5
1615 DW_FORM_data16 with 128 bits. */
1616 #define DWARF_LARGEST_DATA_FORM_BITS \
1617 (dwarf_version >= 5 ? 128 : 64)
1619 /* Utility inline function for construction of ops that were GNU extension
1621 static inline enum dwarf_location_atom
1622 dwarf_OP (enum dwarf_location_atom op
)
1626 case DW_OP_implicit_pointer
:
1627 if (dwarf_version
< 5)
1628 return DW_OP_GNU_implicit_pointer
;
1631 case DW_OP_entry_value
:
1632 if (dwarf_version
< 5)
1633 return DW_OP_GNU_entry_value
;
1636 case DW_OP_const_type
:
1637 if (dwarf_version
< 5)
1638 return DW_OP_GNU_const_type
;
1641 case DW_OP_regval_type
:
1642 if (dwarf_version
< 5)
1643 return DW_OP_GNU_regval_type
;
1646 case DW_OP_deref_type
:
1647 if (dwarf_version
< 5)
1648 return DW_OP_GNU_deref_type
;
1652 if (dwarf_version
< 5)
1653 return DW_OP_GNU_convert
;
1656 case DW_OP_reinterpret
:
1657 if (dwarf_version
< 5)
1658 return DW_OP_GNU_reinterpret
;
1662 if (dwarf_version
< 5)
1663 return DW_OP_GNU_addr_index
;
1667 if (dwarf_version
< 5)
1668 return DW_OP_GNU_const_index
;
1677 /* Similarly for attributes. */
1678 static inline enum dwarf_attribute
1679 dwarf_AT (enum dwarf_attribute at
)
1683 case DW_AT_call_return_pc
:
1684 if (dwarf_version
< 5)
1685 return DW_AT_low_pc
;
1688 case DW_AT_call_tail_call
:
1689 if (dwarf_version
< 5)
1690 return DW_AT_GNU_tail_call
;
1693 case DW_AT_call_origin
:
1694 if (dwarf_version
< 5)
1695 return DW_AT_abstract_origin
;
1698 case DW_AT_call_target
:
1699 if (dwarf_version
< 5)
1700 return DW_AT_GNU_call_site_target
;
1703 case DW_AT_call_target_clobbered
:
1704 if (dwarf_version
< 5)
1705 return DW_AT_GNU_call_site_target_clobbered
;
1708 case DW_AT_call_parameter
:
1709 if (dwarf_version
< 5)
1710 return DW_AT_abstract_origin
;
1713 case DW_AT_call_value
:
1714 if (dwarf_version
< 5)
1715 return DW_AT_GNU_call_site_value
;
1718 case DW_AT_call_data_value
:
1719 if (dwarf_version
< 5)
1720 return DW_AT_GNU_call_site_data_value
;
1723 case DW_AT_call_all_calls
:
1724 if (dwarf_version
< 5)
1725 return DW_AT_GNU_all_call_sites
;
1728 case DW_AT_call_all_tail_calls
:
1729 if (dwarf_version
< 5)
1730 return DW_AT_GNU_all_tail_call_sites
;
1733 case DW_AT_dwo_name
:
1734 if (dwarf_version
< 5)
1735 return DW_AT_GNU_dwo_name
;
1738 case DW_AT_addr_base
:
1739 if (dwarf_version
< 5)
1740 return DW_AT_GNU_addr_base
;
1749 /* And similarly for tags. */
1750 static inline enum dwarf_tag
1751 dwarf_TAG (enum dwarf_tag tag
)
1755 case DW_TAG_call_site
:
1756 if (dwarf_version
< 5)
1757 return DW_TAG_GNU_call_site
;
1760 case DW_TAG_call_site_parameter
:
1761 if (dwarf_version
< 5)
1762 return DW_TAG_GNU_call_site_parameter
;
1771 /* And similarly for forms. */
1772 static inline enum dwarf_form
1773 dwarf_FORM (enum dwarf_form form
)
1778 if (dwarf_version
< 5)
1779 return DW_FORM_GNU_addr_index
;
1783 if (dwarf_version
< 5)
1784 return DW_FORM_GNU_str_index
;
1793 static unsigned long int get_base_type_offset (dw_die_ref
);
1795 /* Return the size of a location descriptor. */
1797 static unsigned long
1798 size_of_loc_descr (dw_loc_descr_ref loc
)
1800 unsigned long size
= 1;
1802 switch (loc
->dw_loc_opc
)
1805 size
+= DWARF2_ADDR_SIZE
;
1807 case DW_OP_GNU_addr_index
:
1809 case DW_OP_GNU_const_index
:
1811 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1812 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1831 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1834 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1839 case DW_OP_plus_uconst
:
1840 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1878 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1881 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1884 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1887 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1888 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1891 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1893 case DW_OP_bit_piece
:
1894 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1895 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1897 case DW_OP_deref_size
:
1898 case DW_OP_xderef_size
:
1907 case DW_OP_call_ref
:
1908 case DW_OP_GNU_variable_value
:
1909 size
+= DWARF_REF_SIZE
;
1911 case DW_OP_implicit_value
:
1912 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1913 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1915 case DW_OP_implicit_pointer
:
1916 case DW_OP_GNU_implicit_pointer
:
1917 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1919 case DW_OP_entry_value
:
1920 case DW_OP_GNU_entry_value
:
1922 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1923 size
+= size_of_uleb128 (op_size
) + op_size
;
1926 case DW_OP_const_type
:
1927 case DW_OP_GNU_const_type
:
1930 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1931 size
+= size_of_uleb128 (o
) + 1;
1932 switch (loc
->dw_loc_oprnd2
.val_class
)
1934 case dw_val_class_vec
:
1935 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1936 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1938 case dw_val_class_const
:
1939 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1941 case dw_val_class_const_double
:
1942 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
1944 case dw_val_class_wide_int
:
1945 size
+= (get_full_len (*loc
->dw_loc_oprnd2
.v
.val_wide
)
1946 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
1953 case DW_OP_regval_type
:
1954 case DW_OP_GNU_regval_type
:
1957 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1958 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1959 + size_of_uleb128 (o
);
1962 case DW_OP_deref_type
:
1963 case DW_OP_GNU_deref_type
:
1966 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1967 size
+= 1 + size_of_uleb128 (o
);
1971 case DW_OP_reinterpret
:
1972 case DW_OP_GNU_convert
:
1973 case DW_OP_GNU_reinterpret
:
1974 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
1975 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1979 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1980 size
+= size_of_uleb128 (o
);
1983 case DW_OP_GNU_parameter_ref
:
1993 /* Return the size of a series of location descriptors. */
1996 size_of_locs (dw_loc_descr_ref loc
)
2001 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
2002 field, to avoid writing to a PCH file. */
2003 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
2005 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
2007 size
+= size_of_loc_descr (l
);
2012 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
2014 l
->dw_loc_addr
= size
;
2015 size
+= size_of_loc_descr (l
);
2021 /* Return the size of the value in a DW_AT_discr_value attribute. */
2024 size_of_discr_value (dw_discr_value
*discr_value
)
2026 if (discr_value
->pos
)
2027 return size_of_uleb128 (discr_value
->v
.uval
);
2029 return size_of_sleb128 (discr_value
->v
.sval
);
2032 /* Return the size of the value in a DW_AT_discr_list attribute. */
2035 size_of_discr_list (dw_discr_list_ref discr_list
)
2039 for (dw_discr_list_ref list
= discr_list
;
2041 list
= list
->dw_discr_next
)
2043 /* One byte for the discriminant value descriptor, and then one or two
2044 LEB128 numbers, depending on whether it's a single case label or a
2047 size
+= size_of_discr_value (&list
->dw_discr_lower_bound
);
2048 if (list
->dw_discr_range
!= 0)
2049 size
+= size_of_discr_value (&list
->dw_discr_upper_bound
);
2054 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
2055 static void get_ref_die_offset_label (char *, dw_die_ref
);
2056 static unsigned long int get_ref_die_offset (dw_die_ref
);
2058 /* Output location description stack opcode's operands (if any).
2059 The for_eh_or_skip parameter controls whether register numbers are
2060 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2061 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2062 info). This should be suppressed for the cases that have not been converted
2063 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2066 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2068 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2069 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2071 switch (loc
->dw_loc_opc
)
2073 #ifdef DWARF2_DEBUGGING_INFO
2076 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
2081 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2082 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
2084 fputc ('\n', asm_out_file
);
2089 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
2094 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2095 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
2097 fputc ('\n', asm_out_file
);
2102 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2103 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
2110 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2111 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2113 dw2_asm_output_data (2, offset
, NULL
);
2116 case DW_OP_implicit_value
:
2117 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2118 switch (val2
->val_class
)
2120 case dw_val_class_const
:
2121 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
2123 case dw_val_class_vec
:
2125 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2126 unsigned int len
= val2
->v
.val_vec
.length
;
2130 if (elt_size
> sizeof (HOST_WIDE_INT
))
2135 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2138 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2139 "fp or vector constant word %u", i
);
2142 case dw_val_class_const_double
:
2144 unsigned HOST_WIDE_INT first
, second
;
2146 if (WORDS_BIG_ENDIAN
)
2148 first
= val2
->v
.val_double
.high
;
2149 second
= val2
->v
.val_double
.low
;
2153 first
= val2
->v
.val_double
.low
;
2154 second
= val2
->v
.val_double
.high
;
2156 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2158 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2162 case dw_val_class_wide_int
:
2165 int len
= get_full_len (*val2
->v
.val_wide
);
2166 if (WORDS_BIG_ENDIAN
)
2167 for (i
= len
- 1; i
>= 0; --i
)
2168 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2169 val2
->v
.val_wide
->elt (i
), NULL
);
2171 for (i
= 0; i
< len
; ++i
)
2172 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2173 val2
->v
.val_wide
->elt (i
), NULL
);
2176 case dw_val_class_addr
:
2177 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
2178 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
2193 case DW_OP_implicit_value
:
2194 /* We currently don't make any attempt to make sure these are
2195 aligned properly like we do for the main unwind info, so
2196 don't support emitting things larger than a byte if we're
2197 only doing unwinding. */
2202 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2205 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2208 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2211 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2213 case DW_OP_plus_uconst
:
2214 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2248 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2252 unsigned r
= val1
->v
.val_unsigned
;
2253 if (for_eh_or_skip
>= 0)
2254 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2255 gcc_assert (size_of_uleb128 (r
)
2256 == size_of_uleb128 (val1
->v
.val_unsigned
));
2257 dw2_asm_output_data_uleb128 (r
, NULL
);
2261 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2265 unsigned r
= val1
->v
.val_unsigned
;
2266 if (for_eh_or_skip
>= 0)
2267 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2268 gcc_assert (size_of_uleb128 (r
)
2269 == size_of_uleb128 (val1
->v
.val_unsigned
));
2270 dw2_asm_output_data_uleb128 (r
, NULL
);
2271 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2275 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2277 case DW_OP_bit_piece
:
2278 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2279 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
2281 case DW_OP_deref_size
:
2282 case DW_OP_xderef_size
:
2283 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2289 if (targetm
.asm_out
.output_dwarf_dtprel
)
2291 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
2294 fputc ('\n', asm_out_file
);
2301 #ifdef DWARF2_DEBUGGING_INFO
2302 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
2309 case DW_OP_GNU_addr_index
:
2311 case DW_OP_GNU_const_index
:
2313 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
2314 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
2315 "(index into .debug_addr)");
2321 unsigned long die_offset
2322 = get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2323 /* Make sure the offset has been computed and that we can encode it as
2325 gcc_assert (die_offset
> 0
2326 && die_offset
<= (loc
->dw_loc_opc
== DW_OP_call2
2329 dw2_asm_output_data ((loc
->dw_loc_opc
== DW_OP_call2
) ? 2 : 4,
2334 case DW_OP_call_ref
:
2335 case DW_OP_GNU_variable_value
:
2337 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2338 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2339 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2340 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2341 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2345 case DW_OP_implicit_pointer
:
2346 case DW_OP_GNU_implicit_pointer
:
2348 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2349 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2350 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2351 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2352 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2353 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2357 case DW_OP_entry_value
:
2358 case DW_OP_GNU_entry_value
:
2359 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
2360 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
2363 case DW_OP_const_type
:
2364 case DW_OP_GNU_const_type
:
2366 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
2368 dw2_asm_output_data_uleb128 (o
, NULL
);
2369 switch (val2
->val_class
)
2371 case dw_val_class_const
:
2372 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2373 dw2_asm_output_data (1, l
, NULL
);
2374 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
2376 case dw_val_class_vec
:
2378 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2379 unsigned int len
= val2
->v
.val_vec
.length
;
2384 dw2_asm_output_data (1, l
, NULL
);
2385 if (elt_size
> sizeof (HOST_WIDE_INT
))
2390 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2393 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2394 "fp or vector constant word %u", i
);
2397 case dw_val_class_const_double
:
2399 unsigned HOST_WIDE_INT first
, second
;
2400 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2402 dw2_asm_output_data (1, 2 * l
, NULL
);
2403 if (WORDS_BIG_ENDIAN
)
2405 first
= val2
->v
.val_double
.high
;
2406 second
= val2
->v
.val_double
.low
;
2410 first
= val2
->v
.val_double
.low
;
2411 second
= val2
->v
.val_double
.high
;
2413 dw2_asm_output_data (l
, first
, NULL
);
2414 dw2_asm_output_data (l
, second
, NULL
);
2417 case dw_val_class_wide_int
:
2420 int len
= get_full_len (*val2
->v
.val_wide
);
2421 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2423 dw2_asm_output_data (1, len
* l
, NULL
);
2424 if (WORDS_BIG_ENDIAN
)
2425 for (i
= len
- 1; i
>= 0; --i
)
2426 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2428 for (i
= 0; i
< len
; ++i
)
2429 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2437 case DW_OP_regval_type
:
2438 case DW_OP_GNU_regval_type
:
2440 unsigned r
= val1
->v
.val_unsigned
;
2441 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2443 if (for_eh_or_skip
>= 0)
2445 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2446 gcc_assert (size_of_uleb128 (r
)
2447 == size_of_uleb128 (val1
->v
.val_unsigned
));
2449 dw2_asm_output_data_uleb128 (r
, NULL
);
2450 dw2_asm_output_data_uleb128 (o
, NULL
);
2453 case DW_OP_deref_type
:
2454 case DW_OP_GNU_deref_type
:
2456 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2458 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2459 dw2_asm_output_data_uleb128 (o
, NULL
);
2463 case DW_OP_reinterpret
:
2464 case DW_OP_GNU_convert
:
2465 case DW_OP_GNU_reinterpret
:
2466 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2467 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2470 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2472 dw2_asm_output_data_uleb128 (o
, NULL
);
2476 case DW_OP_GNU_parameter_ref
:
2479 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2480 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2481 dw2_asm_output_data (4, o
, NULL
);
2486 /* Other codes have no operands. */
2491 /* Output a sequence of location operations.
2492 The for_eh_or_skip parameter controls whether register numbers are
2493 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2494 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2495 info). This should be suppressed for the cases that have not been converted
2496 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2499 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2501 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2503 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2504 /* Output the opcode. */
2505 if (for_eh_or_skip
>= 0
2506 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2508 unsigned r
= (opc
- DW_OP_breg0
);
2509 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2510 gcc_assert (r
<= 31);
2511 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2513 else if (for_eh_or_skip
>= 0
2514 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2516 unsigned r
= (opc
- DW_OP_reg0
);
2517 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2518 gcc_assert (r
<= 31);
2519 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2522 dw2_asm_output_data (1, opc
,
2523 "%s", dwarf_stack_op_name (opc
));
2525 /* Output the operand(s) (if any). */
2526 output_loc_operands (loc
, for_eh_or_skip
);
2530 /* Output location description stack opcode's operands (if any).
2531 The output is single bytes on a line, suitable for .cfi_escape. */
2534 output_loc_operands_raw (dw_loc_descr_ref loc
)
2536 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2537 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2539 switch (loc
->dw_loc_opc
)
2542 case DW_OP_GNU_addr_index
:
2544 case DW_OP_GNU_const_index
:
2546 case DW_OP_implicit_value
:
2547 /* We cannot output addresses in .cfi_escape, only bytes. */
2553 case DW_OP_deref_size
:
2554 case DW_OP_xderef_size
:
2555 fputc (',', asm_out_file
);
2556 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2561 fputc (',', asm_out_file
);
2562 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2567 fputc (',', asm_out_file
);
2568 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2573 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2574 fputc (',', asm_out_file
);
2575 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2583 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2584 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2586 fputc (',', asm_out_file
);
2587 dw2_asm_output_data_raw (2, offset
);
2593 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2594 gcc_assert (size_of_uleb128 (r
)
2595 == size_of_uleb128 (val1
->v
.val_unsigned
));
2596 fputc (',', asm_out_file
);
2597 dw2_asm_output_data_uleb128_raw (r
);
2602 case DW_OP_plus_uconst
:
2604 fputc (',', asm_out_file
);
2605 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2608 case DW_OP_bit_piece
:
2609 fputc (',', asm_out_file
);
2610 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2611 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2648 fputc (',', asm_out_file
);
2649 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2654 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2655 gcc_assert (size_of_uleb128 (r
)
2656 == size_of_uleb128 (val1
->v
.val_unsigned
));
2657 fputc (',', asm_out_file
);
2658 dw2_asm_output_data_uleb128_raw (r
);
2659 fputc (',', asm_out_file
);
2660 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2664 case DW_OP_implicit_pointer
:
2665 case DW_OP_entry_value
:
2666 case DW_OP_const_type
:
2667 case DW_OP_regval_type
:
2668 case DW_OP_deref_type
:
2670 case DW_OP_reinterpret
:
2671 case DW_OP_GNU_implicit_pointer
:
2672 case DW_OP_GNU_entry_value
:
2673 case DW_OP_GNU_const_type
:
2674 case DW_OP_GNU_regval_type
:
2675 case DW_OP_GNU_deref_type
:
2676 case DW_OP_GNU_convert
:
2677 case DW_OP_GNU_reinterpret
:
2678 case DW_OP_GNU_parameter_ref
:
2683 /* Other codes have no operands. */
2689 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2693 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2694 /* Output the opcode. */
2695 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2697 unsigned r
= (opc
- DW_OP_breg0
);
2698 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2699 gcc_assert (r
<= 31);
2700 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2702 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2704 unsigned r
= (opc
- DW_OP_reg0
);
2705 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2706 gcc_assert (r
<= 31);
2707 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2709 /* Output the opcode. */
2710 fprintf (asm_out_file
, "%#x", opc
);
2711 output_loc_operands_raw (loc
);
2713 if (!loc
->dw_loc_next
)
2715 loc
= loc
->dw_loc_next
;
2717 fputc (',', asm_out_file
);
2721 /* This function builds a dwarf location descriptor sequence from a
2722 dw_cfa_location, adding the given OFFSET to the result of the
2725 struct dw_loc_descr_node
*
2726 build_cfa_loc (dw_cfa_location
*cfa
, poly_int64 offset
)
2728 struct dw_loc_descr_node
*head
, *tmp
;
2730 offset
+= cfa
->offset
;
2734 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
2735 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2736 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2737 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2738 add_loc_descr (&head
, tmp
);
2739 loc_descr_plus_const (&head
, offset
);
2742 head
= new_reg_loc_descr (cfa
->reg
, offset
);
2747 /* This function builds a dwarf location descriptor sequence for
2748 the address at OFFSET from the CFA when stack is aligned to
2751 struct dw_loc_descr_node
*
2752 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2753 poly_int64 offset
, HOST_WIDE_INT alignment
)
2755 struct dw_loc_descr_node
*head
;
2756 unsigned int dwarf_fp
2757 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2759 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2760 if (cfa
->reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2762 head
= new_reg_loc_descr (dwarf_fp
, 0);
2763 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2764 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2765 loc_descr_plus_const (&head
, offset
);
2768 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2772 /* And now, the support for symbolic debugging information. */
2774 /* .debug_str support. */
2776 static void dwarf2out_init (const char *);
2777 static void dwarf2out_finish (const char *);
2778 static void dwarf2out_early_finish (const char *);
2779 static void dwarf2out_assembly_start (void);
2780 static void dwarf2out_define (unsigned int, const char *);
2781 static void dwarf2out_undef (unsigned int, const char *);
2782 static void dwarf2out_start_source_file (unsigned, const char *);
2783 static void dwarf2out_end_source_file (unsigned);
2784 static void dwarf2out_function_decl (tree
);
2785 static void dwarf2out_begin_block (unsigned, unsigned);
2786 static void dwarf2out_end_block (unsigned, unsigned);
2787 static bool dwarf2out_ignore_block (const_tree
);
2788 static void dwarf2out_early_global_decl (tree
);
2789 static void dwarf2out_late_global_decl (tree
);
2790 static void dwarf2out_type_decl (tree
, int);
2791 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool, bool);
2792 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2794 static void dwarf2out_abstract_function (tree
);
2795 static void dwarf2out_var_location (rtx_insn
*);
2796 static void dwarf2out_inline_entry (tree
);
2797 static void dwarf2out_size_function (tree
);
2798 static void dwarf2out_begin_function (tree
);
2799 static void dwarf2out_end_function (unsigned int);
2800 static void dwarf2out_register_main_translation_unit (tree unit
);
2801 static void dwarf2out_set_name (tree
, tree
);
2802 static void dwarf2out_register_external_die (tree decl
, const char *sym
,
2803 unsigned HOST_WIDE_INT off
);
2804 static bool dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
2805 unsigned HOST_WIDE_INT
*off
);
2807 /* The debug hooks structure. */
2809 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2813 dwarf2out_early_finish
,
2814 dwarf2out_assembly_start
,
2817 dwarf2out_start_source_file
,
2818 dwarf2out_end_source_file
,
2819 dwarf2out_begin_block
,
2820 dwarf2out_end_block
,
2821 dwarf2out_ignore_block
,
2822 dwarf2out_source_line
,
2823 dwarf2out_begin_prologue
,
2824 #if VMS_DEBUGGING_INFO
2825 dwarf2out_vms_end_prologue
,
2826 dwarf2out_vms_begin_epilogue
,
2828 debug_nothing_int_charstar
,
2829 debug_nothing_int_charstar
,
2831 dwarf2out_end_epilogue
,
2832 dwarf2out_begin_function
,
2833 dwarf2out_end_function
, /* end_function */
2834 dwarf2out_register_main_translation_unit
,
2835 dwarf2out_function_decl
, /* function_decl */
2836 dwarf2out_early_global_decl
,
2837 dwarf2out_late_global_decl
,
2838 dwarf2out_type_decl
, /* type_decl */
2839 dwarf2out_imported_module_or_decl
,
2840 dwarf2out_die_ref_for_decl
,
2841 dwarf2out_register_external_die
,
2842 debug_nothing_tree
, /* deferred_inline_function */
2843 /* The DWARF 2 backend tries to reduce debugging bloat by not
2844 emitting the abstract description of inline functions until
2845 something tries to reference them. */
2846 dwarf2out_abstract_function
, /* outlining_inline_function */
2847 debug_nothing_rtx_code_label
, /* label */
2848 debug_nothing_int
, /* handle_pch */
2849 dwarf2out_var_location
,
2850 dwarf2out_inline_entry
, /* inline_entry */
2851 dwarf2out_size_function
, /* size_function */
2852 dwarf2out_switch_text_section
,
2854 1, /* start_end_main_source_file */
2855 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2858 const struct gcc_debug_hooks dwarf2_lineno_debug_hooks
=
2861 debug_nothing_charstar
,
2862 debug_nothing_charstar
,
2863 dwarf2out_assembly_start
,
2864 debug_nothing_int_charstar
,
2865 debug_nothing_int_charstar
,
2866 debug_nothing_int_charstar
,
2868 debug_nothing_int_int
, /* begin_block */
2869 debug_nothing_int_int
, /* end_block */
2870 debug_true_const_tree
, /* ignore_block */
2871 dwarf2out_source_line
, /* source_line */
2872 debug_nothing_int_int_charstar
, /* begin_prologue */
2873 debug_nothing_int_charstar
, /* end_prologue */
2874 debug_nothing_int_charstar
, /* begin_epilogue */
2875 debug_nothing_int_charstar
, /* end_epilogue */
2876 debug_nothing_tree
, /* begin_function */
2877 debug_nothing_int
, /* end_function */
2878 debug_nothing_tree
, /* register_main_translation_unit */
2879 debug_nothing_tree
, /* function_decl */
2880 debug_nothing_tree
, /* early_global_decl */
2881 debug_nothing_tree
, /* late_global_decl */
2882 debug_nothing_tree_int
, /* type_decl */
2883 debug_nothing_tree_tree_tree_bool_bool
,/* imported_module_or_decl */
2884 debug_false_tree_charstarstar_uhwistar
,/* die_ref_for_decl */
2885 debug_nothing_tree_charstar_uhwi
, /* register_external_die */
2886 debug_nothing_tree
, /* deferred_inline_function */
2887 debug_nothing_tree
, /* outlining_inline_function */
2888 debug_nothing_rtx_code_label
, /* label */
2889 debug_nothing_int
, /* handle_pch */
2890 debug_nothing_rtx_insn
, /* var_location */
2891 debug_nothing_tree
, /* inline_entry */
2892 debug_nothing_tree
, /* size_function */
2893 debug_nothing_void
, /* switch_text_section */
2894 debug_nothing_tree_tree
, /* set_name */
2895 0, /* start_end_main_source_file */
2896 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
2899 /* NOTE: In the comments in this file, many references are made to
2900 "Debugging Information Entries". This term is abbreviated as `DIE'
2901 throughout the remainder of this file. */
2903 /* An internal representation of the DWARF output is built, and then
2904 walked to generate the DWARF debugging info. The walk of the internal
2905 representation is done after the entire program has been compiled.
2906 The types below are used to describe the internal representation. */
2908 /* Whether to put type DIEs into their own section .debug_types instead
2909 of making them part of the .debug_info section. Only supported for
2910 Dwarf V4 or higher and the user didn't disable them through
2911 -fno-debug-types-section. It is more efficient to put them in a
2912 separate comdat sections since the linker will then be able to
2913 remove duplicates. But not all tools support .debug_types sections
2914 yet. For Dwarf V5 or higher .debug_types doesn't exist any more,
2915 it is DW_UT_type unit type in .debug_info section. */
2917 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2919 /* Various DIE's use offsets relative to the beginning of the
2920 .debug_info section to refer to each other. */
2922 typedef long int dw_offset
;
2924 struct comdat_type_node
;
2926 /* The entries in the line_info table more-or-less mirror the opcodes
2927 that are used in the real dwarf line table. Arrays of these entries
2928 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2931 enum dw_line_info_opcode
{
2932 /* Emit DW_LNE_set_address; the operand is the label index. */
2935 /* Emit a row to the matrix with the given line. This may be done
2936 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2940 /* Emit a DW_LNS_set_file. */
2943 /* Emit a DW_LNS_set_column. */
2946 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2949 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2950 LI_set_prologue_end
,
2951 LI_set_epilogue_begin
,
2953 /* Emit a DW_LNE_set_discriminator. */
2954 LI_set_discriminator
,
2956 /* Output a Fixed Advance PC; the target PC is the label index; the
2957 base PC is the previous LI_adv_address or LI_set_address entry.
2958 We only use this when emitting debug views without assembler
2959 support, at explicit user request. Ideally, we should only use
2960 it when the offset might be zero but we can't tell: it's the only
2961 way to maybe change the PC without resetting the view number. */
2965 typedef struct GTY(()) dw_line_info_struct
{
2966 enum dw_line_info_opcode opcode
;
2968 } dw_line_info_entry
;
2971 struct GTY(()) dw_line_info_table
{
2972 /* The label that marks the end of this section. */
2973 const char *end_label
;
2975 /* The values for the last row of the matrix, as collected in the table.
2976 These are used to minimize the changes to the next row. */
2977 unsigned int file_num
;
2978 unsigned int line_num
;
2979 unsigned int column_num
;
2984 /* This denotes the NEXT view number.
2986 If it is 0, it is known that the NEXT view will be the first view
2989 If it is -1, we're forcing the view number to be reset, e.g. at a
2992 The meaning of other nonzero values depends on whether we're
2993 computing views internally or leaving it for the assembler to do
2994 so. If we're emitting them internally, view denotes the view
2995 number since the last known advance of PC. If we're leaving it
2996 for the assembler, it denotes the LVU label number that we're
2997 going to ask the assembler to assign. */
3000 /* This counts the number of symbolic views emitted in this table
3001 since the latest view reset. Its max value, over all tables,
3002 sets symview_upper_bound. */
3003 var_loc_view symviews_since_reset
;
3005 #define FORCE_RESET_NEXT_VIEW(x) ((x) = (var_loc_view)-1)
3006 #define RESET_NEXT_VIEW(x) ((x) = (var_loc_view)0)
3007 #define FORCE_RESETTING_VIEW_P(x) ((x) == (var_loc_view)-1)
3008 #define RESETTING_VIEW_P(x) ((x) == (var_loc_view)0 || FORCE_RESETTING_VIEW_P (x))
3010 vec
<dw_line_info_entry
, va_gc
> *entries
;
3013 /* This is an upper bound for view numbers that the assembler may
3014 assign to symbolic views output in this translation. It is used to
3015 decide how big a field to use to represent view numbers in
3016 symview-classed attributes. */
3018 static var_loc_view symview_upper_bound
;
3020 /* If we're keep track of location views and their reset points, and
3021 INSN is a reset point (i.e., it necessarily advances the PC), mark
3022 the next view in TABLE as reset. */
3025 maybe_reset_location_view (rtx_insn
*insn
, dw_line_info_table
*table
)
3027 if (!debug_internal_reset_location_views
)
3030 /* Maybe turn (part of?) this test into a default target hook. */
3033 if (targetm
.reset_location_view
)
3034 reset
= targetm
.reset_location_view (insn
);
3038 else if (JUMP_TABLE_DATA_P (insn
))
3040 else if (GET_CODE (insn
) == USE
3041 || GET_CODE (insn
) == CLOBBER
3042 || GET_CODE (insn
) == ASM_INPUT
3043 || asm_noperands (insn
) >= 0)
3045 else if (get_attr_min_length (insn
) > 0)
3048 if (reset
> 0 && !RESETTING_VIEW_P (table
->view
))
3049 RESET_NEXT_VIEW (table
->view
);
3052 /* Each DIE attribute has a field specifying the attribute kind,
3053 a link to the next attribute in the chain, and an attribute value.
3054 Attributes are typically linked below the DIE they modify. */
3056 typedef struct GTY(()) dw_attr_struct
{
3057 enum dwarf_attribute dw_attr
;
3058 dw_val_node dw_attr_val
;
3063 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
3064 The children of each node form a circular list linked by
3065 die_sib. die_child points to the node *before* the "first" child node. */
3067 typedef struct GTY((chain_circular ("%h.die_sib"), for_user
)) die_struct
{
3068 union die_symbol_or_type_node
3070 const char * GTY ((tag ("0"))) die_symbol
;
3071 comdat_type_node
*GTY ((tag ("1"))) die_type_node
;
3073 GTY ((desc ("%0.comdat_type_p"))) die_id
;
3074 vec
<dw_attr_node
, va_gc
> *die_attr
;
3075 dw_die_ref die_parent
;
3076 dw_die_ref die_child
;
3078 dw_die_ref die_definition
; /* ref from a specification to its definition */
3079 dw_offset die_offset
;
3080 unsigned long die_abbrev
;
3082 unsigned int decl_id
;
3083 enum dwarf_tag die_tag
;
3084 /* Die is used and must not be pruned as unused. */
3085 BOOL_BITFIELD die_perennial_p
: 1;
3086 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
3087 /* For an external ref to die_symbol if die_offset contains an extra
3088 offset to that symbol. */
3089 BOOL_BITFIELD with_offset
: 1;
3090 /* Whether this DIE was removed from the DIE tree, for example via
3091 prune_unused_types. We don't consider those present from the
3092 DIE lookup routines. */
3093 BOOL_BITFIELD removed
: 1;
3094 /* Lots of spare bits. */
3098 /* Set to TRUE while dwarf2out_early_global_decl is running. */
3099 static bool early_dwarf
;
3100 static bool early_dwarf_finished
;
3101 struct set_early_dwarf
{
3103 set_early_dwarf () : saved(early_dwarf
)
3105 gcc_assert (! early_dwarf_finished
);
3108 ~set_early_dwarf () { early_dwarf
= saved
; }
3111 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
3112 #define FOR_EACH_CHILD(die, c, expr) do { \
3113 c = die->die_child; \
3117 } while (c != die->die_child); \
3120 /* The pubname structure */
3122 typedef struct GTY(()) pubname_struct
{
3129 struct GTY(()) dw_ranges
{
3131 /* If this is positive, it's a block number, otherwise it's a
3132 bitwise-negated index into dw_ranges_by_label. */
3134 /* Index for the range list for DW_FORM_rnglistx. */
3135 unsigned int idx
: 31;
3136 /* True if this range might be possibly in a different section
3137 from previous entry. */
3138 unsigned int maybe_new_sec
: 1;
3141 /* A structure to hold a macinfo entry. */
3143 typedef struct GTY(()) macinfo_struct
{
3145 unsigned HOST_WIDE_INT lineno
;
3151 struct GTY(()) dw_ranges_by_label
{
3156 /* The comdat type node structure. */
3157 struct GTY(()) comdat_type_node
3159 dw_die_ref root_die
;
3160 dw_die_ref type_die
;
3161 dw_die_ref skeleton_die
;
3162 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
3163 comdat_type_node
*next
;
3166 /* A list of DIEs for which we can't determine ancestry (parent_die
3167 field) just yet. Later in dwarf2out_finish we will fill in the
3169 typedef struct GTY(()) limbo_die_struct
{
3171 /* The tree for which this DIE was created. We use this to
3172 determine ancestry later. */
3174 struct limbo_die_struct
*next
;
3178 typedef struct skeleton_chain_struct
3182 struct skeleton_chain_struct
*parent
;
3184 skeleton_chain_node
;
3186 /* Define a macro which returns nonzero for a TYPE_DECL which was
3187 implicitly generated for a type.
3189 Note that, unlike the C front-end (which generates a NULL named
3190 TYPE_DECL node for each complete tagged type, each array type,
3191 and each function type node created) the C++ front-end generates
3192 a _named_ TYPE_DECL node for each tagged type node created.
3193 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3194 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
3195 front-end, but for each type, tagged or not. */
3197 #define TYPE_DECL_IS_STUB(decl) \
3198 (DECL_NAME (decl) == NULL_TREE \
3199 || (DECL_ARTIFICIAL (decl) \
3200 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3201 /* This is necessary for stub decls that \
3202 appear in nested inline functions. */ \
3203 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3204 && (decl_ultimate_origin (decl) \
3205 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3207 /* Information concerning the compilation unit's programming
3208 language, and compiler version. */
3210 /* Fixed size portion of the DWARF compilation unit header. */
3211 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3212 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE \
3213 + (dwarf_version >= 5 ? 4 : 3))
3215 /* Fixed size portion of the DWARF comdat type unit header. */
3216 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
3217 (DWARF_COMPILE_UNIT_HEADER_SIZE \
3218 + DWARF_TYPE_SIGNATURE_SIZE + DWARF_OFFSET_SIZE)
3220 /* Fixed size portion of the DWARF skeleton compilation unit header. */
3221 #define DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE \
3222 (DWARF_COMPILE_UNIT_HEADER_SIZE + (dwarf_version >= 5 ? 8 : 0))
3224 /* Fixed size portion of public names info. */
3225 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3227 /* Fixed size portion of the address range info. */
3228 #define DWARF_ARANGES_HEADER_SIZE \
3229 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3230 DWARF2_ADDR_SIZE * 2) \
3231 - DWARF_INITIAL_LENGTH_SIZE)
3233 /* Size of padding portion in the address range info. It must be
3234 aligned to twice the pointer size. */
3235 #define DWARF_ARANGES_PAD_SIZE \
3236 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3237 DWARF2_ADDR_SIZE * 2) \
3238 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3240 /* Use assembler line directives if available. */
3241 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3242 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3243 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3245 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3249 /* Use assembler views in line directives if available. */
3250 #ifndef DWARF2_ASM_VIEW_DEBUG_INFO
3251 #ifdef HAVE_AS_DWARF2_DEBUG_VIEW
3252 #define DWARF2_ASM_VIEW_DEBUG_INFO 1
3254 #define DWARF2_ASM_VIEW_DEBUG_INFO 0
3258 /* Return true if GCC configure detected assembler support for .loc. */
3261 dwarf2out_default_as_loc_support (void)
3263 return DWARF2_ASM_LINE_DEBUG_INFO
;
3264 #if (GCC_VERSION >= 3000)
3265 # undef DWARF2_ASM_LINE_DEBUG_INFO
3266 # pragma GCC poison DWARF2_ASM_LINE_DEBUG_INFO
3270 /* Return true if GCC configure detected assembler support for views
3271 in .loc directives. */
3274 dwarf2out_default_as_locview_support (void)
3276 return DWARF2_ASM_VIEW_DEBUG_INFO
;
3277 #if (GCC_VERSION >= 3000)
3278 # undef DWARF2_ASM_VIEW_DEBUG_INFO
3279 # pragma GCC poison DWARF2_ASM_VIEW_DEBUG_INFO
3283 /* A bit is set in ZERO_VIEW_P if we are using the assembler-supported
3284 view computation, and it refers to a view identifier for which we
3285 will not emit a label because it is known to map to a view number
3286 zero. We won't allocate the bitmap if we're not using assembler
3287 support for location views, but we have to make the variable
3288 visible for GGC and for code that will be optimized out for lack of
3289 support but that's still parsed and compiled. We could abstract it
3290 out with macros, but it's not worth it. */
3291 static GTY(()) bitmap zero_view_p
;
3293 /* Evaluate to TRUE iff N is known to identify the first location view
3294 at its PC. When not using assembler location view computation,
3295 that must be view number zero. Otherwise, ZERO_VIEW_P is allocated
3296 and views label numbers recorded in it are the ones known to be
3298 #define ZERO_VIEW_P(N) ((N) == (var_loc_view)0 \
3299 || (N) == (var_loc_view)-1 \
3301 && bitmap_bit_p (zero_view_p, (N))))
3303 /* Return true iff we're to emit .loc directives for the assembler to
3304 generate line number sections.
3306 When we're not emitting views, all we need from the assembler is
3307 support for .loc directives.
3309 If we are emitting views, we can only use the assembler's .loc
3310 support if it also supports views.
3312 When the compiler is emitting the line number programs and
3313 computing view numbers itself, it resets view numbers at known PC
3314 changes and counts from that, and then it emits view numbers as
3315 literal constants in locviewlists. There are cases in which the
3316 compiler is not sure about PC changes, e.g. when extra alignment is
3317 requested for a label. In these cases, the compiler may not reset
3318 the view counter, and the potential PC advance in the line number
3319 program will use an opcode that does not reset the view counter
3320 even if the PC actually changes, so that compiler and debug info
3321 consumer can keep view numbers in sync.
3323 When the compiler defers view computation to the assembler, it
3324 emits symbolic view numbers in locviewlists, with the exception of
3325 views known to be zero (forced resets, or reset after
3326 compiler-visible PC changes): instead of emitting symbols for
3327 these, we emit literal zero and assert the assembler agrees with
3328 the compiler's assessment. We could use symbolic views everywhere,
3329 instead of special-casing zero views, but then we'd be unable to
3330 optimize out locviewlists that contain only zeros. */
3333 output_asm_line_debug_info (void)
3335 return (dwarf2out_as_loc_support
3336 && (dwarf2out_as_locview_support
3337 || !debug_variable_location_views
));
3340 /* Minimum line offset in a special line info. opcode.
3341 This value was chosen to give a reasonable range of values. */
3342 #define DWARF_LINE_BASE -10
3344 /* First special line opcode - leave room for the standard opcodes. */
3345 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
3347 /* Range of line offsets in a special line info. opcode. */
3348 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3350 /* Flag that indicates the initial value of the is_stmt_start flag.
3351 In the present implementation, we do not mark any lines as
3352 the beginning of a source statement, because that information
3353 is not made available by the GCC front-end. */
3354 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3356 /* Maximum number of operations per instruction bundle. */
3357 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
3358 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
3361 /* This location is used by calc_die_sizes() to keep track
3362 the offset of each DIE within the .debug_info section. */
3363 static unsigned long next_die_offset
;
3365 /* Record the root of the DIE's built for the current compilation unit. */
3366 static GTY(()) dw_die_ref single_comp_unit_die
;
3368 /* A list of type DIEs that have been separated into comdat sections. */
3369 static GTY(()) comdat_type_node
*comdat_type_list
;
3371 /* A list of CU DIEs that have been separated. */
3372 static GTY(()) limbo_die_node
*cu_die_list
;
3374 /* A list of DIEs with a NULL parent waiting to be relocated. */
3375 static GTY(()) limbo_die_node
*limbo_die_list
;
3377 /* A list of DIEs for which we may have to generate
3378 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
3379 static GTY(()) limbo_die_node
*deferred_asm_name
;
3381 struct dwarf_file_hasher
: ggc_ptr_hash
<dwarf_file_data
>
3383 typedef const char *compare_type
;
3385 static hashval_t
hash (dwarf_file_data
*);
3386 static bool equal (dwarf_file_data
*, const char *);
3389 /* Filenames referenced by this compilation unit. */
3390 static GTY(()) hash_table
<dwarf_file_hasher
> *file_table
;
3392 struct decl_die_hasher
: ggc_ptr_hash
<die_node
>
3394 typedef tree compare_type
;
3396 static hashval_t
hash (die_node
*);
3397 static bool equal (die_node
*, tree
);
3399 /* A hash table of references to DIE's that describe declarations.
3400 The key is a DECL_UID() which is a unique number identifying each decl. */
3401 static GTY (()) hash_table
<decl_die_hasher
> *decl_die_table
;
3403 struct GTY ((for_user
)) variable_value_struct
{
3404 unsigned int decl_id
;
3405 vec
<dw_die_ref
, va_gc
> *dies
;
3408 struct variable_value_hasher
: ggc_ptr_hash
<variable_value_struct
>
3410 typedef tree compare_type
;
3412 static hashval_t
hash (variable_value_struct
*);
3413 static bool equal (variable_value_struct
*, tree
);
3415 /* A hash table of DIEs that contain DW_OP_GNU_variable_value with
3416 dw_val_class_decl_ref class, indexed by FUNCTION_DECLs which is
3417 DECL_CONTEXT of the referenced VAR_DECLs. */
3418 static GTY (()) hash_table
<variable_value_hasher
> *variable_value_hash
;
3420 struct block_die_hasher
: ggc_ptr_hash
<die_struct
>
3422 static hashval_t
hash (die_struct
*);
3423 static bool equal (die_struct
*, die_struct
*);
3426 /* A hash table of references to DIE's that describe COMMON blocks.
3427 The key is DECL_UID() ^ die_parent. */
3428 static GTY (()) hash_table
<block_die_hasher
> *common_block_die_table
;
3430 typedef struct GTY(()) die_arg_entry_struct
{
3436 /* Node of the variable location list. */
3437 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
3438 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
3439 EXPR_LIST chain. For small bitsizes, bitsize is encoded
3440 in mode of the EXPR_LIST node and first EXPR_LIST operand
3441 is either NOTE_INSN_VAR_LOCATION for a piece with a known
3442 location or NULL for padding. For larger bitsizes,
3443 mode is 0 and first operand is a CONCAT with bitsize
3444 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
3445 NULL as second operand. */
3447 const char * GTY (()) label
;
3448 struct var_loc_node
* GTY (()) next
;
3452 /* Variable location list. */
3453 struct GTY ((for_user
)) var_loc_list_def
{
3454 struct var_loc_node
* GTY (()) first
;
3456 /* Pointer to the last but one or last element of the
3457 chained list. If the list is empty, both first and
3458 last are NULL, if the list contains just one node
3459 or the last node certainly is not redundant, it points
3460 to the last node, otherwise points to the last but one.
3461 Do not mark it for GC because it is marked through the chain. */
3462 struct var_loc_node
* GTY ((skip ("%h"))) last
;
3464 /* Pointer to the last element before section switch,
3465 if NULL, either sections weren't switched or first
3466 is after section switch. */
3467 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
3469 /* DECL_UID of the variable decl. */
3470 unsigned int decl_id
;
3472 typedef struct var_loc_list_def var_loc_list
;
3474 /* Call argument location list. */
3475 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
3476 rtx
GTY (()) call_arg_loc_note
;
3477 const char * GTY (()) label
;
3478 tree
GTY (()) block
;
3480 rtx
GTY (()) symbol_ref
;
3481 struct call_arg_loc_node
* GTY (()) next
;
3485 struct decl_loc_hasher
: ggc_ptr_hash
<var_loc_list
>
3487 typedef const_tree compare_type
;
3489 static hashval_t
hash (var_loc_list
*);
3490 static bool equal (var_loc_list
*, const_tree
);
3493 /* Table of decl location linked lists. */
3494 static GTY (()) hash_table
<decl_loc_hasher
> *decl_loc_table
;
3496 /* Head and tail of call_arg_loc chain. */
3497 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
3498 static struct call_arg_loc_node
*call_arg_loc_last
;
3500 /* Number of call sites in the current function. */
3501 static int call_site_count
= -1;
3502 /* Number of tail call sites in the current function. */
3503 static int tail_call_site_count
= -1;
3505 /* A cached location list. */
3506 struct GTY ((for_user
)) cached_dw_loc_list_def
{
3507 /* The DECL_UID of the decl that this entry describes. */
3508 unsigned int decl_id
;
3510 /* The cached location list. */
3511 dw_loc_list_ref loc_list
;
3513 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
3515 struct dw_loc_list_hasher
: ggc_ptr_hash
<cached_dw_loc_list
>
3518 typedef const_tree compare_type
;
3520 static hashval_t
hash (cached_dw_loc_list
*);
3521 static bool equal (cached_dw_loc_list
*, const_tree
);
3524 /* Table of cached location lists. */
3525 static GTY (()) hash_table
<dw_loc_list_hasher
> *cached_dw_loc_list_table
;
3527 /* A vector of references to DIE's that are uniquely identified by their tag,
3528 presence/absence of children DIE's, and list of attribute/value pairs. */
3529 static GTY(()) vec
<dw_die_ref
, va_gc
> *abbrev_die_table
;
3531 /* A hash map to remember the stack usage for DWARF procedures. The value
3532 stored is the stack size difference between before the DWARF procedure
3533 invokation and after it returned. In other words, for a DWARF procedure
3534 that consumes N stack slots and that pushes M ones, this stores M - N. */
3535 static hash_map
<dw_die_ref
, int> *dwarf_proc_stack_usage_map
;
3537 /* A global counter for generating labels for line number data. */
3538 static unsigned int line_info_label_num
;
3540 /* The current table to which we should emit line number information
3541 for the current function. This will be set up at the beginning of
3542 assembly for the function. */
3543 static GTY(()) dw_line_info_table
*cur_line_info_table
;
3545 /* The two default tables of line number info. */
3546 static GTY(()) dw_line_info_table
*text_section_line_info
;
3547 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
3549 /* The set of all non-default tables of line number info. */
3550 static GTY(()) vec
<dw_line_info_table
*, va_gc
> *separate_line_info
;
3552 /* A flag to tell pubnames/types export if there is an info section to
3554 static bool info_section_emitted
;
3556 /* A pointer to the base of a table that contains a list of publicly
3557 accessible names. */
3558 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
3560 /* A pointer to the base of a table that contains a list of publicly
3561 accessible types. */
3562 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
3564 /* A pointer to the base of a table that contains a list of macro
3565 defines/undefines (and file start/end markers). */
3566 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
3568 /* True if .debug_macinfo or .debug_macros section is going to be
3570 #define have_macinfo \
3571 ((!XCOFF_DEBUGGING_INFO || HAVE_XCOFF_DWARF_EXTRAS) \
3572 && debug_info_level >= DINFO_LEVEL_VERBOSE \
3573 && !macinfo_table->is_empty ())
3575 /* Vector of dies for which we should generate .debug_ranges info. */
3576 static GTY (()) vec
<dw_ranges
, va_gc
> *ranges_table
;
3578 /* Vector of pairs of labels referenced in ranges_table. */
3579 static GTY (()) vec
<dw_ranges_by_label
, va_gc
> *ranges_by_label
;
3581 /* Whether we have location lists that need outputting */
3582 static GTY(()) bool have_location_lists
;
3584 /* Unique label counter. */
3585 static GTY(()) unsigned int loclabel_num
;
3587 /* Unique label counter for point-of-call tables. */
3588 static GTY(()) unsigned int poc_label_num
;
3590 /* The last file entry emitted by maybe_emit_file(). */
3591 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
3593 /* Number of internal labels generated by gen_internal_sym(). */
3594 static GTY(()) int label_num
;
3596 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
3598 /* Instances of generic types for which we need to generate debug
3599 info that describe their generic parameters and arguments. That
3600 generation needs to happen once all types are properly laid out so
3601 we do it at the end of compilation. */
3602 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
3604 /* Offset from the "steady-state frame pointer" to the frame base,
3605 within the current function. */
3606 static poly_int64 frame_pointer_fb_offset
;
3607 static bool frame_pointer_fb_offset_valid
;
3609 static vec
<dw_die_ref
> base_types
;
3611 /* Flags to represent a set of attribute classes for attributes that represent
3612 a scalar value (bounds, pointers, ...). */
3615 dw_scalar_form_constant
= 0x01,
3616 dw_scalar_form_exprloc
= 0x02,
3617 dw_scalar_form_reference
= 0x04
3620 /* Forward declarations for functions defined in this file. */
3622 static int is_pseudo_reg (const_rtx
);
3623 static tree
type_main_variant (tree
);
3624 static int is_tagged_type (const_tree
);
3625 static const char *dwarf_tag_name (unsigned);
3626 static const char *dwarf_attr_name (unsigned);
3627 static const char *dwarf_form_name (unsigned);
3628 static tree
decl_ultimate_origin (const_tree
);
3629 static tree
decl_class_context (tree
);
3630 static void add_dwarf_attr (dw_die_ref
, dw_attr_node
*);
3631 static inline enum dw_val_class
AT_class (dw_attr_node
*);
3632 static inline unsigned int AT_index (dw_attr_node
*);
3633 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3634 static inline unsigned AT_flag (dw_attr_node
*);
3635 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3636 static inline HOST_WIDE_INT
AT_int (dw_attr_node
*);
3637 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3638 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_node
*);
3639 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
3640 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
3641 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3642 unsigned int, unsigned char *);
3643 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
3644 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3645 static inline const char *AT_string (dw_attr_node
*);
3646 static enum dwarf_form
AT_string_form (dw_attr_node
*);
3647 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3648 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3649 static inline dw_die_ref
AT_ref (dw_attr_node
*);
3650 static inline int AT_ref_external (dw_attr_node
*);
3651 static inline void set_AT_ref_external (dw_attr_node
*, int);
3652 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
3653 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3654 static inline dw_loc_descr_ref
AT_loc (dw_attr_node
*);
3655 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3657 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3658 static void add_AT_view_list (dw_die_ref
, enum dwarf_attribute
);
3659 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3660 static addr_table_entry
*add_addr_table_entry (void *, enum ate_kind
);
3661 static void remove_addr_table_entry (addr_table_entry
*);
3662 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
, bool);
3663 static inline rtx
AT_addr (dw_attr_node
*);
3664 static void add_AT_symview (dw_die_ref
, enum dwarf_attribute
, const char *);
3665 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3666 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3667 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3668 static void add_AT_loclistsptr (dw_die_ref
, enum dwarf_attribute
,
3670 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
3671 unsigned HOST_WIDE_INT
);
3672 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3673 unsigned long, bool);
3674 static inline const char *AT_lbl (dw_attr_node
*);
3675 static dw_attr_node
*get_AT (dw_die_ref
, enum dwarf_attribute
);
3676 static const char *get_AT_low_pc (dw_die_ref
);
3677 static const char *get_AT_hi_pc (dw_die_ref
);
3678 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
3679 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
3680 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
3681 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
3682 static bool is_cxx (void);
3683 static bool is_cxx (const_tree
);
3684 static bool is_fortran (void);
3685 static bool is_ada (void);
3686 static bool remove_AT (dw_die_ref
, enum dwarf_attribute
);
3687 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3688 static void add_child_die (dw_die_ref
, dw_die_ref
);
3689 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3690 static dw_die_ref
lookup_type_die (tree
);
3691 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3692 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3693 static void equate_type_number_to_die (tree
, dw_die_ref
);
3694 static dw_die_ref
lookup_decl_die (tree
);
3695 static var_loc_list
*lookup_decl_loc (const_tree
);
3696 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3697 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *, var_loc_view
);
3698 static void print_spaces (FILE *);
3699 static void print_die (dw_die_ref
, FILE *);
3700 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3701 static void attr_checksum (dw_attr_node
*, struct md5_ctx
*, int *);
3702 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3703 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3704 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3705 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3706 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_node
*,
3707 struct md5_ctx
*, int *);
3708 struct checksum_attributes
;
3709 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3710 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3711 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3712 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3713 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3714 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3715 static int same_attr_p (dw_attr_node
*, dw_attr_node
*, int *);
3716 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3717 static int is_type_die (dw_die_ref
);
3718 static int is_comdat_die (dw_die_ref
);
3719 static inline bool is_template_instantiation (dw_die_ref
);
3720 static int is_declaration_die (dw_die_ref
);
3721 static int should_move_die_to_comdat (dw_die_ref
);
3722 static dw_die_ref
clone_as_declaration (dw_die_ref
);
3723 static dw_die_ref
clone_die (dw_die_ref
);
3724 static dw_die_ref
clone_tree (dw_die_ref
);
3725 static dw_die_ref
copy_declaration_context (dw_die_ref
, dw_die_ref
);
3726 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
3727 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
3728 static dw_die_ref
generate_skeleton (dw_die_ref
);
3729 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
3732 static void break_out_comdat_types (dw_die_ref
);
3733 static void copy_decls_for_unworthy_types (dw_die_ref
);
3735 static void add_sibling_attributes (dw_die_ref
);
3736 static void output_location_lists (dw_die_ref
);
3737 static int constant_size (unsigned HOST_WIDE_INT
);
3738 static unsigned long size_of_die (dw_die_ref
);
3739 static void calc_die_sizes (dw_die_ref
);
3740 static void calc_base_type_die_sizes (void);
3741 static void mark_dies (dw_die_ref
);
3742 static void unmark_dies (dw_die_ref
);
3743 static void unmark_all_dies (dw_die_ref
);
3744 static unsigned long size_of_pubnames (vec
<pubname_entry
, va_gc
> *);
3745 static unsigned long size_of_aranges (void);
3746 static enum dwarf_form
value_format (dw_attr_node
*);
3747 static void output_value_format (dw_attr_node
*);
3748 static void output_abbrev_section (void);
3749 static void output_die_abbrevs (unsigned long, dw_die_ref
);
3750 static void output_die (dw_die_ref
);
3751 static void output_compilation_unit_header (enum dwarf_unit_type
);
3752 static void output_comp_unit (dw_die_ref
, int, const unsigned char *);
3753 static void output_comdat_type_unit (comdat_type_node
*);
3754 static const char *dwarf2_name (tree
, int);
3755 static void add_pubname (tree
, dw_die_ref
);
3756 static void add_enumerator_pubname (const char *, dw_die_ref
);
3757 static void add_pubname_string (const char *, dw_die_ref
);
3758 static void add_pubtype (tree
, dw_die_ref
);
3759 static void output_pubnames (vec
<pubname_entry
, va_gc
> *);
3760 static void output_aranges (void);
3761 static unsigned int add_ranges (const_tree
, bool = false);
3762 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
3764 static void output_ranges (void);
3765 static dw_line_info_table
*new_line_info_table (void);
3766 static void output_line_info (bool);
3767 static void output_file_names (void);
3768 static dw_die_ref
base_type_die (tree
, bool);
3769 static int is_base_type (tree
);
3770 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, tree
, dw_die_ref
);
3771 static int decl_quals (const_tree
);
3772 static dw_die_ref
modified_type_die (tree
, int, bool, dw_die_ref
);
3773 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
3774 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
3775 static int type_is_enum (const_tree
);
3776 static unsigned int dbx_reg_number (const_rtx
);
3777 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3778 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3779 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3780 enum var_init_status
);
3781 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3782 enum var_init_status
);
3783 static dw_loc_descr_ref
based_loc_descr (rtx
, poly_int64
,
3784 enum var_init_status
);
3785 static int is_based_loc (const_rtx
);
3786 static bool resolve_one_addr (rtx
*);
3787 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3788 enum var_init_status
);
3789 static dw_loc_descr_ref
loc_descriptor (rtx
, machine_mode mode
,
3790 enum var_init_status
);
3791 struct loc_descr_context
;
3792 static void add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
);
3793 static void add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
);
3794 static dw_loc_list_ref
loc_list_from_tree (tree
, int,
3795 struct loc_descr_context
*);
3796 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int,
3797 struct loc_descr_context
*);
3798 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
3799 static tree
field_type (const_tree
);
3800 static unsigned int simple_type_align_in_bits (const_tree
);
3801 static unsigned int simple_decl_align_in_bits (const_tree
);
3802 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3804 static dw_loc_descr_ref
field_byte_offset (const_tree
, struct vlr_context
*,
3806 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3808 static void add_data_member_location_attribute (dw_die_ref
, tree
,
3809 struct vlr_context
*);
3810 static bool add_const_value_attribute (dw_die_ref
, rtx
);
3811 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3812 static void insert_wide_int (const wide_int
&, unsigned char *, int);
3813 static void insert_float (const_rtx
, unsigned char *);
3814 static rtx
rtl_for_decl_location (tree
);
3815 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool);
3816 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3817 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3818 static void add_name_attribute (dw_die_ref
, const char *);
3819 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3820 static void add_comp_dir_attribute (dw_die_ref
);
3821 static void add_scalar_info (dw_die_ref
, enum dwarf_attribute
, tree
, int,
3822 struct loc_descr_context
*);
3823 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
,
3824 struct loc_descr_context
*);
3825 static void add_subscript_info (dw_die_ref
, tree
, bool);
3826 static void add_byte_size_attribute (dw_die_ref
, tree
);
3827 static void add_alignment_attribute (dw_die_ref
, tree
);
3828 static inline void add_bit_offset_attribute (dw_die_ref
, tree
,
3829 struct vlr_context
*);
3830 static void add_bit_size_attribute (dw_die_ref
, tree
);
3831 static void add_prototyped_attribute (dw_die_ref
, tree
);
3832 static dw_die_ref
add_abstract_origin_attribute (dw_die_ref
, tree
);
3833 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3834 static void add_src_coords_attributes (dw_die_ref
, tree
);
3835 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
, bool = false);
3836 static void add_discr_value (dw_die_ref
, dw_discr_value
*);
3837 static void add_discr_list (dw_die_ref
, dw_discr_list_ref
);
3838 static inline dw_discr_list_ref
AT_discr_list (dw_attr_node
*);
3839 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3840 static inline int local_scope_p (dw_die_ref
);
3841 static inline int class_scope_p (dw_die_ref
);
3842 static inline int class_or_namespace_scope_p (dw_die_ref
);
3843 static void add_type_attribute (dw_die_ref
, tree
, int, bool, dw_die_ref
);
3844 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3845 static const char *type_tag (const_tree
);
3846 static tree
member_declared_type (const_tree
);
3848 static const char *decl_start_label (tree
);
3850 static void gen_array_type_die (tree
, dw_die_ref
);
3851 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3853 static void gen_entry_point_die (tree
, dw_die_ref
);
3855 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3856 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3857 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3858 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3859 static void gen_formal_types_die (tree
, dw_die_ref
);
3860 static void gen_subprogram_die (tree
, dw_die_ref
);
3861 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3862 static void gen_const_die (tree
, dw_die_ref
);
3863 static void gen_label_die (tree
, dw_die_ref
);
3864 static void gen_lexical_block_die (tree
, dw_die_ref
);
3865 static void gen_inlined_subroutine_die (tree
, dw_die_ref
);
3866 static void gen_field_die (tree
, struct vlr_context
*, dw_die_ref
);
3867 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3868 static dw_die_ref
gen_compile_unit_die (const char *);
3869 static void gen_inheritance_die (tree
, tree
, tree
, dw_die_ref
);
3870 static void gen_member_die (tree
, dw_die_ref
);
3871 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3872 enum debug_info_usage
);
3873 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3874 static void gen_typedef_die (tree
, dw_die_ref
);
3875 static void gen_type_die (tree
, dw_die_ref
);
3876 static void gen_block_die (tree
, dw_die_ref
);
3877 static void decls_for_scope (tree
, dw_die_ref
);
3878 static bool is_naming_typedef_decl (const_tree
);
3879 static inline dw_die_ref
get_context_die (tree
);
3880 static void gen_namespace_die (tree
, dw_die_ref
);
3881 static dw_die_ref
gen_namelist_decl (tree
, dw_die_ref
, tree
);
3882 static dw_die_ref
gen_decl_die (tree
, tree
, struct vlr_context
*, dw_die_ref
);
3883 static dw_die_ref
force_decl_die (tree
);
3884 static dw_die_ref
force_type_die (tree
);
3885 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3886 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3887 static struct dwarf_file_data
* lookup_filename (const char *);
3888 static void retry_incomplete_types (void);
3889 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3890 static void gen_generic_params_dies (tree
);
3891 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3892 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3893 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3894 static int file_info_cmp (const void *, const void *);
3895 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *, var_loc_view
,
3896 const char *, var_loc_view
, const char *);
3897 static void output_loc_list (dw_loc_list_ref
);
3898 static char *gen_internal_sym (const char *);
3899 static bool want_pubnames (void);
3901 static void prune_unmark_dies (dw_die_ref
);
3902 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3903 static void prune_unused_types_mark (dw_die_ref
, int);
3904 static void prune_unused_types_walk (dw_die_ref
);
3905 static void prune_unused_types_walk_attribs (dw_die_ref
);
3906 static void prune_unused_types_prune (dw_die_ref
);
3907 static void prune_unused_types (void);
3908 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3909 static inline const char *AT_vms_delta1 (dw_attr_node
*);
3910 static inline const char *AT_vms_delta2 (dw_attr_node
*);
3911 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
3912 const char *, const char *);
3913 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
3914 static void gen_remaining_tmpl_value_param_die_attribute (void);
3915 static bool generic_type_p (tree
);
3916 static void schedule_generic_params_dies_gen (tree t
);
3917 static void gen_scheduled_generic_parms_dies (void);
3918 static void resolve_variable_values (void);
3920 static const char *comp_dir_string (void);
3922 static void hash_loc_operands (dw_loc_descr_ref
, inchash::hash
&);
3924 /* enum for tracking thread-local variables whose address is really an offset
3925 relative to the TLS pointer, which will need link-time relocation, but will
3926 not need relocation by the DWARF consumer. */
3934 /* Return the operator to use for an address of a variable. For dtprel_true, we
3935 use DW_OP_const*. For regular variables, which need both link-time
3936 relocation and consumer-level relocation (e.g., to account for shared objects
3937 loaded at a random address), we use DW_OP_addr*. */
3939 static inline enum dwarf_location_atom
3940 dw_addr_op (enum dtprel_bool dtprel
)
3942 if (dtprel
== dtprel_true
)
3943 return (dwarf_split_debug_info
? dwarf_OP (DW_OP_constx
)
3944 : (DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
));
3946 return dwarf_split_debug_info
? dwarf_OP (DW_OP_addrx
) : DW_OP_addr
;
3949 /* Return a pointer to a newly allocated address location description. If
3950 dwarf_split_debug_info is true, then record the address with the appropriate
3952 static inline dw_loc_descr_ref
3953 new_addr_loc_descr (rtx addr
, enum dtprel_bool dtprel
)
3955 dw_loc_descr_ref ref
= new_loc_descr (dw_addr_op (dtprel
), 0, 0);
3957 ref
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
3958 ref
->dw_loc_oprnd1
.v
.val_addr
= addr
;
3959 ref
->dtprel
= dtprel
;
3960 if (dwarf_split_debug_info
)
3961 ref
->dw_loc_oprnd1
.val_entry
3962 = add_addr_table_entry (addr
,
3963 dtprel
? ate_kind_rtx_dtprel
: ate_kind_rtx
);
3965 ref
->dw_loc_oprnd1
.val_entry
= NULL
;
3970 /* Section names used to hold DWARF debugging information. */
3972 #ifndef DEBUG_INFO_SECTION
3973 #define DEBUG_INFO_SECTION ".debug_info"
3975 #ifndef DEBUG_DWO_INFO_SECTION
3976 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3978 #ifndef DEBUG_LTO_INFO_SECTION
3979 #define DEBUG_LTO_INFO_SECTION ".gnu.debuglto_.debug_info"
3981 #ifndef DEBUG_LTO_DWO_INFO_SECTION
3982 #define DEBUG_LTO_DWO_INFO_SECTION ".gnu.debuglto_.debug_info.dwo"
3984 #ifndef DEBUG_ABBREV_SECTION
3985 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3987 #ifndef DEBUG_LTO_ABBREV_SECTION
3988 #define DEBUG_LTO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev"
3990 #ifndef DEBUG_DWO_ABBREV_SECTION
3991 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3993 #ifndef DEBUG_LTO_DWO_ABBREV_SECTION
3994 #define DEBUG_LTO_DWO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev.dwo"
3996 #ifndef DEBUG_ARANGES_SECTION
3997 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3999 #ifndef DEBUG_ADDR_SECTION
4000 #define DEBUG_ADDR_SECTION ".debug_addr"
4002 #ifndef DEBUG_MACINFO_SECTION
4003 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
4005 #ifndef DEBUG_LTO_MACINFO_SECTION
4006 #define DEBUG_LTO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo"
4008 #ifndef DEBUG_DWO_MACINFO_SECTION
4009 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
4011 #ifndef DEBUG_LTO_DWO_MACINFO_SECTION
4012 #define DEBUG_LTO_DWO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo.dwo"
4014 #ifndef DEBUG_MACRO_SECTION
4015 #define DEBUG_MACRO_SECTION ".debug_macro"
4017 #ifndef DEBUG_LTO_MACRO_SECTION
4018 #define DEBUG_LTO_MACRO_SECTION ".gnu.debuglto_.debug_macro"
4020 #ifndef DEBUG_DWO_MACRO_SECTION
4021 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
4023 #ifndef DEBUG_LTO_DWO_MACRO_SECTION
4024 #define DEBUG_LTO_DWO_MACRO_SECTION ".gnu.debuglto_.debug_macro.dwo"
4026 #ifndef DEBUG_LINE_SECTION
4027 #define DEBUG_LINE_SECTION ".debug_line"
4029 #ifndef DEBUG_LTO_LINE_SECTION
4030 #define DEBUG_LTO_LINE_SECTION ".gnu.debuglto_.debug_line"
4032 #ifndef DEBUG_DWO_LINE_SECTION
4033 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
4035 #ifndef DEBUG_LTO_DWO_LINE_SECTION
4036 #define DEBUG_LTO_DWO_LINE_SECTION ".gnu.debuglto_.debug_line.dwo"
4038 #ifndef DEBUG_LOC_SECTION
4039 #define DEBUG_LOC_SECTION ".debug_loc"
4041 #ifndef DEBUG_DWO_LOC_SECTION
4042 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
4044 #ifndef DEBUG_LOCLISTS_SECTION
4045 #define DEBUG_LOCLISTS_SECTION ".debug_loclists"
4047 #ifndef DEBUG_DWO_LOCLISTS_SECTION
4048 #define DEBUG_DWO_LOCLISTS_SECTION ".debug_loclists.dwo"
4050 #ifndef DEBUG_PUBNAMES_SECTION
4051 #define DEBUG_PUBNAMES_SECTION \
4052 ((debug_generate_pub_sections == 2) \
4053 ? ".debug_gnu_pubnames" : ".debug_pubnames")
4055 #ifndef DEBUG_PUBTYPES_SECTION
4056 #define DEBUG_PUBTYPES_SECTION \
4057 ((debug_generate_pub_sections == 2) \
4058 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
4060 #ifndef DEBUG_STR_OFFSETS_SECTION
4061 #define DEBUG_STR_OFFSETS_SECTION ".debug_str_offsets"
4063 #ifndef DEBUG_DWO_STR_OFFSETS_SECTION
4064 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
4066 #ifndef DEBUG_LTO_DWO_STR_OFFSETS_SECTION
4067 #define DEBUG_LTO_DWO_STR_OFFSETS_SECTION ".gnu.debuglto_.debug_str_offsets.dwo"
4069 #ifndef DEBUG_STR_SECTION
4070 #define DEBUG_STR_SECTION ".debug_str"
4072 #ifndef DEBUG_LTO_STR_SECTION
4073 #define DEBUG_LTO_STR_SECTION ".gnu.debuglto_.debug_str"
4075 #ifndef DEBUG_STR_DWO_SECTION
4076 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
4078 #ifndef DEBUG_LTO_STR_DWO_SECTION
4079 #define DEBUG_LTO_STR_DWO_SECTION ".gnu.debuglto_.debug_str.dwo"
4081 #ifndef DEBUG_RANGES_SECTION
4082 #define DEBUG_RANGES_SECTION ".debug_ranges"
4084 #ifndef DEBUG_RNGLISTS_SECTION
4085 #define DEBUG_RNGLISTS_SECTION ".debug_rnglists"
4087 #ifndef DEBUG_LINE_STR_SECTION
4088 #define DEBUG_LINE_STR_SECTION ".debug_line_str"
4090 #ifndef DEBUG_LTO_LINE_STR_SECTION
4091 #define DEBUG_LTO_LINE_STR_SECTION ".gnu.debuglto_.debug_line_str"
4094 /* Standard ELF section names for compiled code and data. */
4095 #ifndef TEXT_SECTION_NAME
4096 #define TEXT_SECTION_NAME ".text"
4099 /* Section flags for .debug_str section. */
4100 #define DEBUG_STR_SECTION_FLAGS \
4101 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
4102 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4105 /* Section flags for .debug_str.dwo section. */
4106 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
4108 /* Attribute used to refer to the macro section. */
4109 #define DEBUG_MACRO_ATTRIBUTE (dwarf_version >= 5 ? DW_AT_macros \
4110 : dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros)
4112 /* Labels we insert at beginning sections we can reference instead of
4113 the section names themselves. */
4115 #ifndef TEXT_SECTION_LABEL
4116 #define TEXT_SECTION_LABEL "Ltext"
4118 #ifndef COLD_TEXT_SECTION_LABEL
4119 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
4121 #ifndef DEBUG_LINE_SECTION_LABEL
4122 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4124 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
4125 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
4127 #ifndef DEBUG_INFO_SECTION_LABEL
4128 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4130 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
4131 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
4133 #ifndef DEBUG_ABBREV_SECTION_LABEL
4134 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4136 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
4137 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
4139 #ifndef DEBUG_ADDR_SECTION_LABEL
4140 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
4142 #ifndef DEBUG_LOC_SECTION_LABEL
4143 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4145 #ifndef DEBUG_RANGES_SECTION_LABEL
4146 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4148 #ifndef DEBUG_MACINFO_SECTION_LABEL
4149 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4151 #ifndef DEBUG_MACRO_SECTION_LABEL
4152 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
4154 #define SKELETON_COMP_DIE_ABBREV 1
4155 #define SKELETON_TYPE_DIE_ABBREV 2
4157 /* Definitions of defaults for formats and names of various special
4158 (artificial) labels which may be generated within this file (when the -g
4159 options is used and DWARF2_DEBUGGING_INFO is in effect.
4160 If necessary, these may be overridden from within the tm.h file, but
4161 typically, overriding these defaults is unnecessary. */
4163 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4164 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4165 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4166 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4167 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4168 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4169 static char debug_skeleton_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4170 static char debug_skeleton_abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4171 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4172 static char debug_addr_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4173 static char debug_skeleton_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4174 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4175 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4176 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4177 static char ranges_base_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4179 #ifndef TEXT_END_LABEL
4180 #define TEXT_END_LABEL "Letext"
4182 #ifndef COLD_END_LABEL
4183 #define COLD_END_LABEL "Letext_cold"
4185 #ifndef BLOCK_BEGIN_LABEL
4186 #define BLOCK_BEGIN_LABEL "LBB"
4188 #ifndef BLOCK_INLINE_ENTRY_LABEL
4189 #define BLOCK_INLINE_ENTRY_LABEL "LBI"
4191 #ifndef BLOCK_END_LABEL
4192 #define BLOCK_END_LABEL "LBE"
4194 #ifndef LINE_CODE_LABEL
4195 #define LINE_CODE_LABEL "LM"
4199 /* Return the root of the DIE's built for the current compilation unit. */
4201 comp_unit_die (void)
4203 if (!single_comp_unit_die
)
4204 single_comp_unit_die
= gen_compile_unit_die (NULL
);
4205 return single_comp_unit_die
;
4208 /* We allow a language front-end to designate a function that is to be
4209 called to "demangle" any name before it is put into a DIE. */
4211 static const char *(*demangle_name_func
) (const char *);
4214 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
4216 demangle_name_func
= func
;
4219 /* Test if rtl node points to a pseudo register. */
4222 is_pseudo_reg (const_rtx rtl
)
4224 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
4225 || (GET_CODE (rtl
) == SUBREG
4226 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
4229 /* Return a reference to a type, with its const and volatile qualifiers
4233 type_main_variant (tree type
)
4235 type
= TYPE_MAIN_VARIANT (type
);
4237 /* ??? There really should be only one main variant among any group of
4238 variants of a given type (and all of the MAIN_VARIANT values for all
4239 members of the group should point to that one type) but sometimes the C
4240 front-end messes this up for array types, so we work around that bug
4242 if (TREE_CODE (type
) == ARRAY_TYPE
)
4243 while (type
!= TYPE_MAIN_VARIANT (type
))
4244 type
= TYPE_MAIN_VARIANT (type
);
4249 /* Return nonzero if the given type node represents a tagged type. */
4252 is_tagged_type (const_tree type
)
4254 enum tree_code code
= TREE_CODE (type
);
4256 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
4257 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
4260 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
4263 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
4265 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
4268 /* Return die_offset of a DIE reference to a base type. */
4270 static unsigned long int
4271 get_base_type_offset (dw_die_ref ref
)
4273 if (ref
->die_offset
)
4274 return ref
->die_offset
;
4275 if (comp_unit_die ()->die_abbrev
)
4277 calc_base_type_die_sizes ();
4278 gcc_assert (ref
->die_offset
);
4280 return ref
->die_offset
;
4283 /* Return die_offset of a DIE reference other than base type. */
4285 static unsigned long int
4286 get_ref_die_offset (dw_die_ref ref
)
4288 gcc_assert (ref
->die_offset
);
4289 return ref
->die_offset
;
4292 /* Convert a DIE tag into its string name. */
4295 dwarf_tag_name (unsigned int tag
)
4297 const char *name
= get_DW_TAG_name (tag
);
4302 return "DW_TAG_<unknown>";
4305 /* Convert a DWARF attribute code into its string name. */
4308 dwarf_attr_name (unsigned int attr
)
4314 #if VMS_DEBUGGING_INFO
4315 case DW_AT_HP_prologue
:
4316 return "DW_AT_HP_prologue";
4318 case DW_AT_MIPS_loop_unroll_factor
:
4319 return "DW_AT_MIPS_loop_unroll_factor";
4322 #if VMS_DEBUGGING_INFO
4323 case DW_AT_HP_epilogue
:
4324 return "DW_AT_HP_epilogue";
4326 case DW_AT_MIPS_stride
:
4327 return "DW_AT_MIPS_stride";
4331 name
= get_DW_AT_name (attr
);
4336 return "DW_AT_<unknown>";
4339 /* Convert a DWARF value form code into its string name. */
4342 dwarf_form_name (unsigned int form
)
4344 const char *name
= get_DW_FORM_name (form
);
4349 return "DW_FORM_<unknown>";
4352 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4353 instance of an inlined instance of a decl which is local to an inline
4354 function, so we have to trace all of the way back through the origin chain
4355 to find out what sort of node actually served as the original seed for the
4359 decl_ultimate_origin (const_tree decl
)
4361 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
4364 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
4365 we're trying to output the abstract instance of this function. */
4366 if (DECL_ABSTRACT_P (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
4369 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4370 most distant ancestor, this should never happen. */
4371 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
4373 return DECL_ABSTRACT_ORIGIN (decl
);
4376 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4377 of a virtual function may refer to a base class, so we check the 'this'
4381 decl_class_context (tree decl
)
4383 tree context
= NULL_TREE
;
4385 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
4386 context
= DECL_CONTEXT (decl
);
4388 context
= TYPE_MAIN_VARIANT
4389 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
4391 if (context
&& !TYPE_P (context
))
4392 context
= NULL_TREE
;
4397 /* Add an attribute/value pair to a DIE. */
4400 add_dwarf_attr (dw_die_ref die
, dw_attr_node
*attr
)
4402 /* Maybe this should be an assert? */
4408 /* Check we do not add duplicate attrs. Can't use get_AT here
4409 because that recurses to the specification/abstract origin DIE. */
4412 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4413 gcc_assert (a
->dw_attr
!= attr
->dw_attr
);
4416 vec_safe_reserve (die
->die_attr
, 1);
4417 vec_safe_push (die
->die_attr
, *attr
);
4420 static inline enum dw_val_class
4421 AT_class (dw_attr_node
*a
)
4423 return a
->dw_attr_val
.val_class
;
4426 /* Return the index for any attribute that will be referenced with a
4427 DW_FORM_addrx/GNU_addr_index or DW_FORM_strx/GNU_str_index. String
4428 indices are stored in dw_attr_val.v.val_str for reference counting
4431 static inline unsigned int
4432 AT_index (dw_attr_node
*a
)
4434 if (AT_class (a
) == dw_val_class_str
)
4435 return a
->dw_attr_val
.v
.val_str
->index
;
4436 else if (a
->dw_attr_val
.val_entry
!= NULL
)
4437 return a
->dw_attr_val
.val_entry
->index
;
4441 /* Add a flag value attribute to a DIE. */
4444 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
4448 attr
.dw_attr
= attr_kind
;
4449 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
4450 attr
.dw_attr_val
.val_entry
= NULL
;
4451 attr
.dw_attr_val
.v
.val_flag
= flag
;
4452 add_dwarf_attr (die
, &attr
);
4455 static inline unsigned
4456 AT_flag (dw_attr_node
*a
)
4458 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
4459 return a
->dw_attr_val
.v
.val_flag
;
4462 /* Add a signed integer attribute value to a DIE. */
4465 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
4469 attr
.dw_attr
= attr_kind
;
4470 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
4471 attr
.dw_attr_val
.val_entry
= NULL
;
4472 attr
.dw_attr_val
.v
.val_int
= int_val
;
4473 add_dwarf_attr (die
, &attr
);
4476 static inline HOST_WIDE_INT
4477 AT_int (dw_attr_node
*a
)
4479 gcc_assert (a
&& (AT_class (a
) == dw_val_class_const
4480 || AT_class (a
) == dw_val_class_const_implicit
));
4481 return a
->dw_attr_val
.v
.val_int
;
4484 /* Add an unsigned integer attribute value to a DIE. */
4487 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4488 unsigned HOST_WIDE_INT unsigned_val
)
4492 attr
.dw_attr
= attr_kind
;
4493 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
4494 attr
.dw_attr_val
.val_entry
= NULL
;
4495 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
4496 add_dwarf_attr (die
, &attr
);
4499 static inline unsigned HOST_WIDE_INT
4500 AT_unsigned (dw_attr_node
*a
)
4502 gcc_assert (a
&& (AT_class (a
) == dw_val_class_unsigned_const
4503 || AT_class (a
) == dw_val_class_unsigned_const_implicit
));
4504 return a
->dw_attr_val
.v
.val_unsigned
;
4507 /* Add an unsigned wide integer attribute value to a DIE. */
4510 add_AT_wide (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4515 attr
.dw_attr
= attr_kind
;
4516 attr
.dw_attr_val
.val_class
= dw_val_class_wide_int
;
4517 attr
.dw_attr_val
.val_entry
= NULL
;
4518 attr
.dw_attr_val
.v
.val_wide
= ggc_alloc
<wide_int
> ();
4519 *attr
.dw_attr_val
.v
.val_wide
= w
;
4520 add_dwarf_attr (die
, &attr
);
4523 /* Add an unsigned double integer attribute value to a DIE. */
4526 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4527 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
4531 attr
.dw_attr
= attr_kind
;
4532 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
4533 attr
.dw_attr_val
.val_entry
= NULL
;
4534 attr
.dw_attr_val
.v
.val_double
.high
= high
;
4535 attr
.dw_attr_val
.v
.val_double
.low
= low
;
4536 add_dwarf_attr (die
, &attr
);
4539 /* Add a floating point attribute value to a DIE and return it. */
4542 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4543 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
4547 attr
.dw_attr
= attr_kind
;
4548 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
4549 attr
.dw_attr_val
.val_entry
= NULL
;
4550 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
4551 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
4552 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
4553 add_dwarf_attr (die
, &attr
);
4556 /* Add an 8-byte data attribute value to a DIE. */
4559 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4560 unsigned char data8
[8])
4564 attr
.dw_attr
= attr_kind
;
4565 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
4566 attr
.dw_attr_val
.val_entry
= NULL
;
4567 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
4568 add_dwarf_attr (die
, &attr
);
4571 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
4572 dwarf_split_debug_info, address attributes in dies destined for the
4573 final executable have force_direct set to avoid using indexed
4577 add_AT_low_high_pc (dw_die_ref die
, const char *lbl_low
, const char *lbl_high
,
4583 lbl_id
= xstrdup (lbl_low
);
4584 attr
.dw_attr
= DW_AT_low_pc
;
4585 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4586 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4587 if (dwarf_split_debug_info
&& !force_direct
)
4588 attr
.dw_attr_val
.val_entry
4589 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4591 attr
.dw_attr_val
.val_entry
= NULL
;
4592 add_dwarf_attr (die
, &attr
);
4594 attr
.dw_attr
= DW_AT_high_pc
;
4595 if (dwarf_version
< 4)
4596 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4598 attr
.dw_attr_val
.val_class
= dw_val_class_high_pc
;
4599 lbl_id
= xstrdup (lbl_high
);
4600 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4601 if (attr
.dw_attr_val
.val_class
== dw_val_class_lbl_id
4602 && dwarf_split_debug_info
&& !force_direct
)
4603 attr
.dw_attr_val
.val_entry
4604 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4606 attr
.dw_attr_val
.val_entry
= NULL
;
4607 add_dwarf_attr (die
, &attr
);
4610 /* Hash and equality functions for debug_str_hash. */
4613 indirect_string_hasher::hash (indirect_string_node
*x
)
4615 return htab_hash_string (x
->str
);
4619 indirect_string_hasher::equal (indirect_string_node
*x1
, const char *x2
)
4621 return strcmp (x1
->str
, x2
) == 0;
4624 /* Add STR to the given string hash table. */
4626 static struct indirect_string_node
*
4627 find_AT_string_in_table (const char *str
,
4628 hash_table
<indirect_string_hasher
> *table
)
4630 struct indirect_string_node
*node
;
4632 indirect_string_node
**slot
4633 = table
->find_slot_with_hash (str
, htab_hash_string (str
), INSERT
);
4636 node
= ggc_cleared_alloc
<indirect_string_node
> ();
4637 node
->str
= ggc_strdup (str
);
4647 /* Add STR to the indirect string hash table. */
4649 static struct indirect_string_node
*
4650 find_AT_string (const char *str
)
4652 if (! debug_str_hash
)
4653 debug_str_hash
= hash_table
<indirect_string_hasher
>::create_ggc (10);
4655 return find_AT_string_in_table (str
, debug_str_hash
);
4658 /* Add a string attribute value to a DIE. */
4661 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
4664 struct indirect_string_node
*node
;
4666 node
= find_AT_string (str
);
4668 attr
.dw_attr
= attr_kind
;
4669 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
4670 attr
.dw_attr_val
.val_entry
= NULL
;
4671 attr
.dw_attr_val
.v
.val_str
= node
;
4672 add_dwarf_attr (die
, &attr
);
4675 static inline const char *
4676 AT_string (dw_attr_node
*a
)
4678 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4679 return a
->dw_attr_val
.v
.val_str
->str
;
4682 /* Call this function directly to bypass AT_string_form's logic to put
4683 the string inline in the die. */
4686 set_indirect_string (struct indirect_string_node
*node
)
4688 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4689 /* Already indirect is a no op. */
4690 if (node
->form
== DW_FORM_strp
4691 || node
->form
== DW_FORM_line_strp
4692 || node
->form
== dwarf_FORM (DW_FORM_strx
))
4694 gcc_assert (node
->label
);
4697 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4698 ++dw2_string_counter
;
4699 node
->label
= xstrdup (label
);
4701 if (!dwarf_split_debug_info
)
4703 node
->form
= DW_FORM_strp
;
4704 node
->index
= NOT_INDEXED
;
4708 node
->form
= dwarf_FORM (DW_FORM_strx
);
4709 node
->index
= NO_INDEX_ASSIGNED
;
4713 /* A helper function for dwarf2out_finish, called to reset indirect
4714 string decisions done for early LTO dwarf output before fat object
4718 reset_indirect_string (indirect_string_node
**h
, void *)
4720 struct indirect_string_node
*node
= *h
;
4721 if (node
->form
== DW_FORM_strp
|| node
->form
== dwarf_FORM (DW_FORM_strx
))
4725 node
->form
= (dwarf_form
) 0;
4731 /* Find out whether a string should be output inline in DIE
4732 or out-of-line in .debug_str section. */
4734 static enum dwarf_form
4735 find_string_form (struct indirect_string_node
*node
)
4742 len
= strlen (node
->str
) + 1;
4744 /* If the string is shorter or equal to the size of the reference, it is
4745 always better to put it inline. */
4746 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
4747 return node
->form
= DW_FORM_string
;
4749 /* If we cannot expect the linker to merge strings in .debug_str
4750 section, only put it into .debug_str if it is worth even in this
4752 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4753 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
4754 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
))
4755 return node
->form
= DW_FORM_string
;
4757 set_indirect_string (node
);
4762 /* Find out whether the string referenced from the attribute should be
4763 output inline in DIE or out-of-line in .debug_str section. */
4765 static enum dwarf_form
4766 AT_string_form (dw_attr_node
*a
)
4768 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4769 return find_string_form (a
->dw_attr_val
.v
.val_str
);
4772 /* Add a DIE reference attribute value to a DIE. */
4775 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4778 gcc_checking_assert (targ_die
!= NULL
);
4780 /* With LTO we can end up trying to reference something we didn't create
4781 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4782 if (targ_die
== NULL
)
4785 attr
.dw_attr
= attr_kind
;
4786 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
4787 attr
.dw_attr_val
.val_entry
= NULL
;
4788 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4789 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
4790 add_dwarf_attr (die
, &attr
);
4793 /* Change DIE reference REF to point to NEW_DIE instead. */
4796 change_AT_die_ref (dw_attr_node
*ref
, dw_die_ref new_die
)
4798 gcc_assert (ref
->dw_attr_val
.val_class
== dw_val_class_die_ref
);
4799 ref
->dw_attr_val
.v
.val_die_ref
.die
= new_die
;
4800 ref
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4803 /* Add an AT_specification attribute to a DIE, and also make the back
4804 pointer from the specification to the definition. */
4807 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4809 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4810 gcc_assert (!targ_die
->die_definition
);
4811 targ_die
->die_definition
= die
;
4814 static inline dw_die_ref
4815 AT_ref (dw_attr_node
*a
)
4817 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4818 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4822 AT_ref_external (dw_attr_node
*a
)
4824 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4825 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4831 set_AT_ref_external (dw_attr_node
*a
, int i
)
4833 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4834 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4837 /* Add an FDE reference attribute value to a DIE. */
4840 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
4844 attr
.dw_attr
= attr_kind
;
4845 attr
.dw_attr_val
.val_class
= dw_val_class_fde_ref
;
4846 attr
.dw_attr_val
.val_entry
= NULL
;
4847 attr
.dw_attr_val
.v
.val_fde_index
= targ_fde
;
4848 add_dwarf_attr (die
, &attr
);
4851 /* Add a location description attribute value to a DIE. */
4854 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4858 attr
.dw_attr
= attr_kind
;
4859 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4860 attr
.dw_attr_val
.val_entry
= NULL
;
4861 attr
.dw_attr_val
.v
.val_loc
= loc
;
4862 add_dwarf_attr (die
, &attr
);
4865 static inline dw_loc_descr_ref
4866 AT_loc (dw_attr_node
*a
)
4868 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4869 return a
->dw_attr_val
.v
.val_loc
;
4873 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4877 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4880 attr
.dw_attr
= attr_kind
;
4881 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
4882 attr
.dw_attr_val
.val_entry
= NULL
;
4883 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
4884 add_dwarf_attr (die
, &attr
);
4885 have_location_lists
= true;
4888 static inline dw_loc_list_ref
4889 AT_loc_list (dw_attr_node
*a
)
4891 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4892 return a
->dw_attr_val
.v
.val_loc_list
;
4895 /* Add a view list attribute to DIE. It must have a DW_AT_location
4896 attribute, because the view list complements the location list. */
4899 add_AT_view_list (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4903 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4906 attr
.dw_attr
= attr_kind
;
4907 attr
.dw_attr_val
.val_class
= dw_val_class_view_list
;
4908 attr
.dw_attr_val
.val_entry
= NULL
;
4909 attr
.dw_attr_val
.v
.val_view_list
= die
;
4910 add_dwarf_attr (die
, &attr
);
4911 gcc_checking_assert (get_AT (die
, DW_AT_location
));
4912 gcc_assert (have_location_lists
);
4915 /* Return a pointer to the location list referenced by the attribute.
4916 If the named attribute is a view list, look up the corresponding
4917 DW_AT_location attribute and return its location list. */
4919 static inline dw_loc_list_ref
*
4920 AT_loc_list_ptr (dw_attr_node
*a
)
4923 switch (AT_class (a
))
4925 case dw_val_class_loc_list
:
4926 return &a
->dw_attr_val
.v
.val_loc_list
;
4927 case dw_val_class_view_list
:
4930 l
= get_AT (a
->dw_attr_val
.v
.val_view_list
, DW_AT_location
);
4933 gcc_checking_assert (l
+ 1 == a
);
4934 return AT_loc_list_ptr (l
);
4941 /* Return the location attribute value associated with a view list
4944 static inline dw_val_node
*
4945 view_list_to_loc_list_val_node (dw_val_node
*val
)
4947 gcc_assert (val
->val_class
== dw_val_class_view_list
);
4948 dw_attr_node
*loc
= get_AT (val
->v
.val_view_list
, DW_AT_location
);
4951 gcc_checking_assert (&(loc
+ 1)->dw_attr_val
== val
);
4952 gcc_assert (AT_class (loc
) == dw_val_class_loc_list
);
4953 return &loc
->dw_attr_val
;
4956 struct addr_hasher
: ggc_ptr_hash
<addr_table_entry
>
4958 static hashval_t
hash (addr_table_entry
*);
4959 static bool equal (addr_table_entry
*, addr_table_entry
*);
4962 /* Table of entries into the .debug_addr section. */
4964 static GTY (()) hash_table
<addr_hasher
> *addr_index_table
;
4966 /* Hash an address_table_entry. */
4969 addr_hasher::hash (addr_table_entry
*a
)
4971 inchash::hash hstate
;
4977 case ate_kind_rtx_dtprel
:
4980 case ate_kind_label
:
4981 return htab_hash_string (a
->addr
.label
);
4985 inchash::add_rtx (a
->addr
.rtl
, hstate
);
4986 return hstate
.end ();
4989 /* Determine equality for two address_table_entries. */
4992 addr_hasher::equal (addr_table_entry
*a1
, addr_table_entry
*a2
)
4994 if (a1
->kind
!= a2
->kind
)
4999 case ate_kind_rtx_dtprel
:
5000 return rtx_equal_p (a1
->addr
.rtl
, a2
->addr
.rtl
);
5001 case ate_kind_label
:
5002 return strcmp (a1
->addr
.label
, a2
->addr
.label
) == 0;
5008 /* Initialize an addr_table_entry. */
5011 init_addr_table_entry (addr_table_entry
*e
, enum ate_kind kind
, void *addr
)
5017 case ate_kind_rtx_dtprel
:
5018 e
->addr
.rtl
= (rtx
) addr
;
5020 case ate_kind_label
:
5021 e
->addr
.label
= (char *) addr
;
5025 e
->index
= NO_INDEX_ASSIGNED
;
5028 /* Add attr to the address table entry to the table. Defer setting an
5029 index until output time. */
5031 static addr_table_entry
*
5032 add_addr_table_entry (void *addr
, enum ate_kind kind
)
5034 addr_table_entry
*node
;
5035 addr_table_entry finder
;
5037 gcc_assert (dwarf_split_debug_info
);
5038 if (! addr_index_table
)
5039 addr_index_table
= hash_table
<addr_hasher
>::create_ggc (10);
5040 init_addr_table_entry (&finder
, kind
, addr
);
5041 addr_table_entry
**slot
= addr_index_table
->find_slot (&finder
, INSERT
);
5043 if (*slot
== HTAB_EMPTY_ENTRY
)
5045 node
= ggc_cleared_alloc
<addr_table_entry
> ();
5046 init_addr_table_entry (node
, kind
, addr
);
5056 /* Remove an entry from the addr table by decrementing its refcount.
5057 Strictly, decrementing the refcount would be enough, but the
5058 assertion that the entry is actually in the table has found
5062 remove_addr_table_entry (addr_table_entry
*entry
)
5064 gcc_assert (dwarf_split_debug_info
&& addr_index_table
);
5065 /* After an index is assigned, the table is frozen. */
5066 gcc_assert (entry
->refcount
> 0 && entry
->index
== NO_INDEX_ASSIGNED
);
5070 /* Given a location list, remove all addresses it refers to from the
5074 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr
)
5076 for (; descr
; descr
= descr
->dw_loc_next
)
5077 if (descr
->dw_loc_oprnd1
.val_entry
!= NULL
)
5079 gcc_assert (descr
->dw_loc_oprnd1
.val_entry
->index
== NO_INDEX_ASSIGNED
);
5080 remove_addr_table_entry (descr
->dw_loc_oprnd1
.val_entry
);
5084 /* A helper function for dwarf2out_finish called through
5085 htab_traverse. Assign an addr_table_entry its index. All entries
5086 must be collected into the table when this function is called,
5087 because the indexing code relies on htab_traverse to traverse nodes
5088 in the same order for each run. */
5091 index_addr_table_entry (addr_table_entry
**h
, unsigned int *index
)
5093 addr_table_entry
*node
= *h
;
5095 /* Don't index unreferenced nodes. */
5096 if (node
->refcount
== 0)
5099 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
5100 node
->index
= *index
;
5106 /* Add an address constant attribute value to a DIE. When using
5107 dwarf_split_debug_info, address attributes in dies destined for the
5108 final executable should be direct references--setting the parameter
5109 force_direct ensures this behavior. */
5112 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
,
5117 attr
.dw_attr
= attr_kind
;
5118 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
5119 attr
.dw_attr_val
.v
.val_addr
= addr
;
5120 if (dwarf_split_debug_info
&& !force_direct
)
5121 attr
.dw_attr_val
.val_entry
= add_addr_table_entry (addr
, ate_kind_rtx
);
5123 attr
.dw_attr_val
.val_entry
= NULL
;
5124 add_dwarf_attr (die
, &attr
);
5127 /* Get the RTX from to an address DIE attribute. */
5130 AT_addr (dw_attr_node
*a
)
5132 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
5133 return a
->dw_attr_val
.v
.val_addr
;
5136 /* Add a file attribute value to a DIE. */
5139 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5140 struct dwarf_file_data
*fd
)
5144 attr
.dw_attr
= attr_kind
;
5145 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
5146 attr
.dw_attr_val
.val_entry
= NULL
;
5147 attr
.dw_attr_val
.v
.val_file
= fd
;
5148 add_dwarf_attr (die
, &attr
);
5151 /* Get the dwarf_file_data from a file DIE attribute. */
5153 static inline struct dwarf_file_data
*
5154 AT_file (dw_attr_node
*a
)
5156 gcc_assert (a
&& (AT_class (a
) == dw_val_class_file
5157 || AT_class (a
) == dw_val_class_file_implicit
));
5158 return a
->dw_attr_val
.v
.val_file
;
5161 /* Add a vms delta attribute value to a DIE. */
5164 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5165 const char *lbl1
, const char *lbl2
)
5169 attr
.dw_attr
= attr_kind
;
5170 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
5171 attr
.dw_attr_val
.val_entry
= NULL
;
5172 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
5173 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
5174 add_dwarf_attr (die
, &attr
);
5177 /* Add a symbolic view identifier attribute value to a DIE. */
5180 add_AT_symview (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5181 const char *view_label
)
5185 attr
.dw_attr
= attr_kind
;
5186 attr
.dw_attr_val
.val_class
= dw_val_class_symview
;
5187 attr
.dw_attr_val
.val_entry
= NULL
;
5188 attr
.dw_attr_val
.v
.val_symbolic_view
= xstrdup (view_label
);
5189 add_dwarf_attr (die
, &attr
);
5192 /* Add a label identifier attribute value to a DIE. */
5195 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5200 attr
.dw_attr
= attr_kind
;
5201 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
5202 attr
.dw_attr_val
.val_entry
= NULL
;
5203 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
5204 if (dwarf_split_debug_info
)
5205 attr
.dw_attr_val
.val_entry
5206 = add_addr_table_entry (attr
.dw_attr_val
.v
.val_lbl_id
,
5208 add_dwarf_attr (die
, &attr
);
5211 /* Add a section offset attribute value to a DIE, an offset into the
5212 debug_line section. */
5215 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5220 attr
.dw_attr
= attr_kind
;
5221 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
5222 attr
.dw_attr_val
.val_entry
= NULL
;
5223 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5224 add_dwarf_attr (die
, &attr
);
5227 /* Add a section offset attribute value to a DIE, an offset into the
5228 debug_loclists section. */
5231 add_AT_loclistsptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5236 attr
.dw_attr
= attr_kind
;
5237 attr
.dw_attr_val
.val_class
= dw_val_class_loclistsptr
;
5238 attr
.dw_attr_val
.val_entry
= NULL
;
5239 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5240 add_dwarf_attr (die
, &attr
);
5243 /* Add a section offset attribute value to a DIE, an offset into the
5244 debug_macinfo section. */
5247 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5252 attr
.dw_attr
= attr_kind
;
5253 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
5254 attr
.dw_attr_val
.val_entry
= NULL
;
5255 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5256 add_dwarf_attr (die
, &attr
);
5259 /* Add an offset attribute value to a DIE. */
5262 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5263 unsigned HOST_WIDE_INT offset
)
5267 attr
.dw_attr
= attr_kind
;
5268 attr
.dw_attr_val
.val_class
= dw_val_class_offset
;
5269 attr
.dw_attr_val
.val_entry
= NULL
;
5270 attr
.dw_attr_val
.v
.val_offset
= offset
;
5271 add_dwarf_attr (die
, &attr
);
5274 /* Add a range_list attribute value to a DIE. When using
5275 dwarf_split_debug_info, address attributes in dies destined for the
5276 final executable should be direct references--setting the parameter
5277 force_direct ensures this behavior. */
5279 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
5280 #define RELOCATED_OFFSET (NULL)
5283 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5284 long unsigned int offset
, bool force_direct
)
5288 attr
.dw_attr
= attr_kind
;
5289 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
5290 /* For the range_list attribute, use val_entry to store whether the
5291 offset should follow split-debug-info or normal semantics. This
5292 value is read in output_range_list_offset. */
5293 if (dwarf_split_debug_info
&& !force_direct
)
5294 attr
.dw_attr_val
.val_entry
= UNRELOCATED_OFFSET
;
5296 attr
.dw_attr_val
.val_entry
= RELOCATED_OFFSET
;
5297 attr
.dw_attr_val
.v
.val_offset
= offset
;
5298 add_dwarf_attr (die
, &attr
);
5301 /* Return the start label of a delta attribute. */
5303 static inline const char *
5304 AT_vms_delta1 (dw_attr_node
*a
)
5306 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5307 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
5310 /* Return the end label of a delta attribute. */
5312 static inline const char *
5313 AT_vms_delta2 (dw_attr_node
*a
)
5315 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5316 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
5319 static inline const char *
5320 AT_lbl (dw_attr_node
*a
)
5322 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
5323 || AT_class (a
) == dw_val_class_lineptr
5324 || AT_class (a
) == dw_val_class_macptr
5325 || AT_class (a
) == dw_val_class_loclistsptr
5326 || AT_class (a
) == dw_val_class_high_pc
));
5327 return a
->dw_attr_val
.v
.val_lbl_id
;
5330 /* Get the attribute of type attr_kind. */
5332 static dw_attr_node
*
5333 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5337 dw_die_ref spec
= NULL
;
5342 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5343 if (a
->dw_attr
== attr_kind
)
5345 else if (a
->dw_attr
== DW_AT_specification
5346 || a
->dw_attr
== DW_AT_abstract_origin
)
5350 return get_AT (spec
, attr_kind
);
5355 /* Returns the parent of the declaration of DIE. */
5358 get_die_parent (dw_die_ref die
)
5365 if ((t
= get_AT_ref (die
, DW_AT_abstract_origin
))
5366 || (t
= get_AT_ref (die
, DW_AT_specification
)))
5369 return die
->die_parent
;
5372 /* Return the "low pc" attribute value, typically associated with a subprogram
5373 DIE. Return null if the "low pc" attribute is either not present, or if it
5374 cannot be represented as an assembler label identifier. */
5376 static inline const char *
5377 get_AT_low_pc (dw_die_ref die
)
5379 dw_attr_node
*a
= get_AT (die
, DW_AT_low_pc
);
5381 return a
? AT_lbl (a
) : NULL
;
5384 /* Return the "high pc" attribute value, typically associated with a subprogram
5385 DIE. Return null if the "high pc" attribute is either not present, or if it
5386 cannot be represented as an assembler label identifier. */
5388 static inline const char *
5389 get_AT_hi_pc (dw_die_ref die
)
5391 dw_attr_node
*a
= get_AT (die
, DW_AT_high_pc
);
5393 return a
? AT_lbl (a
) : NULL
;
5396 /* Return the value of the string attribute designated by ATTR_KIND, or
5397 NULL if it is not present. */
5399 static inline const char *
5400 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5402 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5404 return a
? AT_string (a
) : NULL
;
5407 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5408 if it is not present. */
5411 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5413 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5415 return a
? AT_flag (a
) : 0;
5418 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5419 if it is not present. */
5421 static inline unsigned
5422 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5424 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5426 return a
? AT_unsigned (a
) : 0;
5429 static inline dw_die_ref
5430 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5432 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5434 return a
? AT_ref (a
) : NULL
;
5437 static inline struct dwarf_file_data
*
5438 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5440 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5442 return a
? AT_file (a
) : NULL
;
5445 /* Return TRUE if the language is C++. */
5450 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5452 return (lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
5453 || lang
== DW_LANG_C_plus_plus_11
|| lang
== DW_LANG_C_plus_plus_14
);
5456 /* Return TRUE if DECL was created by the C++ frontend. */
5459 is_cxx (const_tree decl
)
5463 const_tree context
= get_ultimate_context (decl
);
5464 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5465 return strncmp (TRANSLATION_UNIT_LANGUAGE (context
), "GNU C++", 7) == 0;
5470 /* Return TRUE if the language is Fortran. */
5475 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5477 return (lang
== DW_LANG_Fortran77
5478 || lang
== DW_LANG_Fortran90
5479 || lang
== DW_LANG_Fortran95
5480 || lang
== DW_LANG_Fortran03
5481 || lang
== DW_LANG_Fortran08
);
5485 is_fortran (const_tree decl
)
5489 const_tree context
= get_ultimate_context (decl
);
5490 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5491 return (strncmp (TRANSLATION_UNIT_LANGUAGE (context
),
5492 "GNU Fortran", 11) == 0
5493 || strcmp (TRANSLATION_UNIT_LANGUAGE (context
),
5496 return is_fortran ();
5499 /* Return TRUE if the language is Ada. */
5504 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5506 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
5509 /* Remove the specified attribute if present. Return TRUE if removal
5513 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5521 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5522 if (a
->dw_attr
== attr_kind
)
5524 if (AT_class (a
) == dw_val_class_str
)
5525 if (a
->dw_attr_val
.v
.val_str
->refcount
)
5526 a
->dw_attr_val
.v
.val_str
->refcount
--;
5528 /* vec::ordered_remove should help reduce the number of abbrevs
5530 die
->die_attr
->ordered_remove (ix
);
5536 /* Remove CHILD from its parent. PREV must have the property that
5537 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
5540 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
5542 gcc_assert (child
->die_parent
== prev
->die_parent
);
5543 gcc_assert (prev
->die_sib
== child
);
5546 gcc_assert (child
->die_parent
->die_child
== child
);
5550 prev
->die_sib
= child
->die_sib
;
5551 if (child
->die_parent
->die_child
== child
)
5552 child
->die_parent
->die_child
= prev
;
5553 child
->die_sib
= NULL
;
5556 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
5557 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
5560 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
5562 dw_die_ref parent
= old_child
->die_parent
;
5564 gcc_assert (parent
== prev
->die_parent
);
5565 gcc_assert (prev
->die_sib
== old_child
);
5567 new_child
->die_parent
= parent
;
5568 if (prev
== old_child
)
5570 gcc_assert (parent
->die_child
== old_child
);
5571 new_child
->die_sib
= new_child
;
5575 prev
->die_sib
= new_child
;
5576 new_child
->die_sib
= old_child
->die_sib
;
5578 if (old_child
->die_parent
->die_child
== old_child
)
5579 old_child
->die_parent
->die_child
= new_child
;
5580 old_child
->die_sib
= NULL
;
5583 /* Move all children from OLD_PARENT to NEW_PARENT. */
5586 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
5589 new_parent
->die_child
= old_parent
->die_child
;
5590 old_parent
->die_child
= NULL
;
5591 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
5594 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
5598 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
5604 dw_die_ref prev
= c
;
5606 while (c
->die_tag
== tag
)
5608 remove_child_with_prev (c
, prev
);
5609 c
->die_parent
= NULL
;
5610 /* Might have removed every child. */
5611 if (die
->die_child
== NULL
)
5615 } while (c
!= die
->die_child
);
5618 /* Add a CHILD_DIE as the last child of DIE. */
5621 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
5623 /* FIXME this should probably be an assert. */
5624 if (! die
|| ! child_die
)
5626 gcc_assert (die
!= child_die
);
5628 child_die
->die_parent
= die
;
5631 child_die
->die_sib
= die
->die_child
->die_sib
;
5632 die
->die_child
->die_sib
= child_die
;
5635 child_die
->die_sib
= child_die
;
5636 die
->die_child
= child_die
;
5639 /* Like add_child_die, but put CHILD_DIE after AFTER_DIE. */
5642 add_child_die_after (dw_die_ref die
, dw_die_ref child_die
,
5643 dw_die_ref after_die
)
5649 && die
!= child_die
);
5651 child_die
->die_parent
= die
;
5652 child_die
->die_sib
= after_die
->die_sib
;
5653 after_die
->die_sib
= child_die
;
5654 if (die
->die_child
== after_die
)
5655 die
->die_child
= child_die
;
5658 /* Unassociate CHILD from its parent, and make its parent be
5662 reparent_child (dw_die_ref child
, dw_die_ref new_parent
)
5664 for (dw_die_ref p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
5665 if (p
->die_sib
== child
)
5667 remove_child_with_prev (child
, p
);
5670 add_child_die (new_parent
, child
);
5673 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5674 is the specification, to the end of PARENT's list of children.
5675 This is done by removing and re-adding it. */
5678 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
5680 /* We want the declaration DIE from inside the class, not the
5681 specification DIE at toplevel. */
5682 if (child
->die_parent
!= parent
)
5684 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5690 gcc_assert (child
->die_parent
== parent
5691 || (child
->die_parent
5692 == get_AT_ref (parent
, DW_AT_specification
)));
5694 reparent_child (child
, parent
);
5697 /* Create and return a new die with TAG_VALUE as tag. */
5699 static inline dw_die_ref
5700 new_die_raw (enum dwarf_tag tag_value
)
5702 dw_die_ref die
= ggc_cleared_alloc
<die_node
> ();
5703 die
->die_tag
= tag_value
;
5707 /* Create and return a new die with a parent of PARENT_DIE. If
5708 PARENT_DIE is NULL, the new DIE is placed in limbo and an
5709 associated tree T must be supplied to determine parenthood
5712 static inline dw_die_ref
5713 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5715 dw_die_ref die
= new_die_raw (tag_value
);
5717 if (parent_die
!= NULL
)
5718 add_child_die (parent_die
, die
);
5721 limbo_die_node
*limbo_node
;
5723 /* No DIEs created after early dwarf should end up in limbo,
5724 because the limbo list should not persist past LTO
5726 if (tag_value
!= DW_TAG_compile_unit
5727 /* These are allowed because they're generated while
5728 breaking out COMDAT units late. */
5729 && tag_value
!= DW_TAG_type_unit
5730 && tag_value
!= DW_TAG_skeleton_unit
5732 /* Allow nested functions to live in limbo because they will
5733 only temporarily live there, as decls_for_scope will fix
5735 && (TREE_CODE (t
) != FUNCTION_DECL
5736 || !decl_function_context (t
))
5737 /* Same as nested functions above but for types. Types that
5738 are local to a function will be fixed in
5740 && (!RECORD_OR_UNION_TYPE_P (t
)
5741 || !TYPE_CONTEXT (t
)
5742 || TREE_CODE (TYPE_CONTEXT (t
)) != FUNCTION_DECL
)
5743 /* FIXME debug-early: Allow late limbo DIE creation for LTO,
5744 especially in the ltrans stage, but once we implement LTO
5745 dwarf streaming, we should remove this exception. */
5748 fprintf (stderr
, "symbol ended up in limbo too late:");
5749 debug_generic_stmt (t
);
5753 limbo_node
= ggc_cleared_alloc
<limbo_die_node
> ();
5754 limbo_node
->die
= die
;
5755 limbo_node
->created_for
= t
;
5756 limbo_node
->next
= limbo_die_list
;
5757 limbo_die_list
= limbo_node
;
5763 /* Return the DIE associated with the given type specifier. */
5765 static inline dw_die_ref
5766 lookup_type_die (tree type
)
5768 dw_die_ref die
= TYPE_SYMTAB_DIE (type
);
5769 if (die
&& die
->removed
)
5771 TYPE_SYMTAB_DIE (type
) = NULL
;
5777 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
5778 anonymous type named by the typedef TYPE_DIE, return the DIE of the
5779 anonymous type instead the one of the naming typedef. */
5781 static inline dw_die_ref
5782 strip_naming_typedef (tree type
, dw_die_ref type_die
)
5785 && TREE_CODE (type
) == RECORD_TYPE
5787 && type_die
->die_tag
== DW_TAG_typedef
5788 && is_naming_typedef_decl (TYPE_NAME (type
)))
5789 type_die
= get_AT_ref (type_die
, DW_AT_type
);
5793 /* Like lookup_type_die, but if type is an anonymous type named by a
5794 typedef[1], return the DIE of the anonymous type instead the one of
5795 the naming typedef. This is because in gen_typedef_die, we did
5796 equate the anonymous struct named by the typedef with the DIE of
5797 the naming typedef. So by default, lookup_type_die on an anonymous
5798 struct yields the DIE of the naming typedef.
5800 [1]: Read the comment of is_naming_typedef_decl to learn about what
5801 a naming typedef is. */
5803 static inline dw_die_ref
5804 lookup_type_die_strip_naming_typedef (tree type
)
5806 dw_die_ref die
= lookup_type_die (type
);
5807 return strip_naming_typedef (type
, die
);
5810 /* Equate a DIE to a given type specifier. */
5813 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5815 TYPE_SYMTAB_DIE (type
) = type_die
;
5818 /* Returns a hash value for X (which really is a die_struct). */
5821 decl_die_hasher::hash (die_node
*x
)
5823 return (hashval_t
) x
->decl_id
;
5826 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5829 decl_die_hasher::equal (die_node
*x
, tree y
)
5831 return (x
->decl_id
== DECL_UID (y
));
5834 /* Return the DIE associated with a given declaration. */
5836 static inline dw_die_ref
5837 lookup_decl_die (tree decl
)
5839 dw_die_ref
*die
= decl_die_table
->find_slot_with_hash (decl
, DECL_UID (decl
),
5843 if ((*die
)->removed
)
5845 decl_die_table
->clear_slot (die
);
5852 /* For DECL which might have early dwarf output query a SYMBOL + OFFSET
5853 style reference. Return true if we found one refering to a DIE for
5854 DECL, otherwise return false. */
5857 dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
5858 unsigned HOST_WIDE_INT
*off
)
5862 if (in_lto_p
&& !decl_die_table
)
5865 if (TREE_CODE (decl
) == BLOCK
)
5866 die
= BLOCK_DIE (decl
);
5868 die
= lookup_decl_die (decl
);
5872 /* During WPA stage and incremental linking we currently use DIEs
5873 to store the decl <-> label + offset map. That's quite inefficient
5874 but it works for now. */
5877 dw_die_ref ref
= get_AT_ref (die
, DW_AT_abstract_origin
);
5880 gcc_assert (die
== comp_unit_die ());
5883 *off
= ref
->die_offset
;
5884 *sym
= ref
->die_id
.die_symbol
;
5888 /* Similar to get_ref_die_offset_label, but using the "correct"
5890 *off
= die
->die_offset
;
5891 while (die
->die_parent
)
5892 die
= die
->die_parent
;
5893 /* For the containing CU DIE we compute a die_symbol in
5894 compute_comp_unit_symbol. */
5895 gcc_assert (die
->die_tag
== DW_TAG_compile_unit
5896 && die
->die_id
.die_symbol
!= NULL
);
5897 *sym
= die
->die_id
.die_symbol
;
5901 /* Add a reference of kind ATTR_KIND to a DIE at SYMBOL + OFFSET to DIE. */
5904 add_AT_external_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5905 const char *symbol
, HOST_WIDE_INT offset
)
5907 /* Create a fake DIE that contains the reference. Don't use
5908 new_die because we don't want to end up in the limbo list. */
5909 dw_die_ref ref
= new_die_raw (die
->die_tag
);
5910 ref
->die_id
.die_symbol
= IDENTIFIER_POINTER (get_identifier (symbol
));
5911 ref
->die_offset
= offset
;
5912 ref
->with_offset
= 1;
5913 add_AT_die_ref (die
, attr_kind
, ref
);
5916 /* Create a DIE for DECL if required and add a reference to a DIE
5917 at SYMBOL + OFFSET which contains attributes dumped early. */
5920 dwarf2out_register_external_die (tree decl
, const char *sym
,
5921 unsigned HOST_WIDE_INT off
)
5923 if (debug_info_level
== DINFO_LEVEL_NONE
)
5927 || flag_incremental_link
== INCREMENTAL_LINK_LTO
) && !decl_die_table
)
5928 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (1000);
5931 = TREE_CODE (decl
) == BLOCK
? BLOCK_DIE (decl
) : lookup_decl_die (decl
);
5935 dw_die_ref parent
= NULL
;
5936 /* Need to lookup a DIE for the decls context - the containing
5937 function or translation unit. */
5938 if (TREE_CODE (decl
) == BLOCK
)
5940 ctx
= BLOCK_SUPERCONTEXT (decl
);
5941 /* ??? We do not output DIEs for all scopes thus skip as
5942 many DIEs as needed. */
5943 while (TREE_CODE (ctx
) == BLOCK
5944 && !BLOCK_DIE (ctx
))
5945 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5948 ctx
= DECL_CONTEXT (decl
);
5949 /* Peel types in the context stack. */
5950 while (ctx
&& TYPE_P (ctx
))
5951 ctx
= TYPE_CONTEXT (ctx
);
5952 /* Likewise namespaces in case we do not want to emit DIEs for them. */
5953 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
5954 while (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5955 ctx
= DECL_CONTEXT (ctx
);
5958 if (TREE_CODE (ctx
) == BLOCK
)
5959 parent
= BLOCK_DIE (ctx
);
5960 else if (TREE_CODE (ctx
) == TRANSLATION_UNIT_DECL
5961 /* Keep the 1:1 association during WPA. */
5963 && flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
5964 /* Otherwise all late annotations go to the main CU which
5965 imports the original CUs. */
5966 parent
= comp_unit_die ();
5967 else if (TREE_CODE (ctx
) == FUNCTION_DECL
5968 && TREE_CODE (decl
) != FUNCTION_DECL
5969 && TREE_CODE (decl
) != PARM_DECL
5970 && TREE_CODE (decl
) != RESULT_DECL
5971 && TREE_CODE (decl
) != BLOCK
)
5972 /* Leave function local entities parent determination to when
5973 we process scope vars. */
5976 parent
= lookup_decl_die (ctx
);
5979 /* In some cases the FEs fail to set DECL_CONTEXT properly.
5980 Handle this case gracefully by globalizing stuff. */
5981 parent
= comp_unit_die ();
5982 /* Create a DIE "stub". */
5983 switch (TREE_CODE (decl
))
5985 case TRANSLATION_UNIT_DECL
:
5986 if (! flag_wpa
&& flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
5988 die
= comp_unit_die ();
5989 dw_die_ref import
= new_die (DW_TAG_imported_unit
, die
, NULL_TREE
);
5990 add_AT_external_die_ref (import
, DW_AT_import
, sym
, off
);
5991 /* We re-target all CU decls to the LTRANS CU DIE, so no need
5992 to create a DIE for the original CUs. */
5995 /* Keep the 1:1 association during WPA. */
5996 die
= new_die (DW_TAG_compile_unit
, NULL
, decl
);
5998 case NAMESPACE_DECL
:
5999 if (is_fortran (decl
))
6000 die
= new_die (DW_TAG_module
, parent
, decl
);
6002 die
= new_die (DW_TAG_namespace
, parent
, decl
);
6005 die
= new_die (DW_TAG_subprogram
, parent
, decl
);
6008 die
= new_die (DW_TAG_variable
, parent
, decl
);
6011 die
= new_die (DW_TAG_variable
, parent
, decl
);
6014 die
= new_die (DW_TAG_formal_parameter
, parent
, decl
);
6017 die
= new_die (DW_TAG_constant
, parent
, decl
);
6020 die
= new_die (DW_TAG_label
, parent
, decl
);
6023 die
= new_die (DW_TAG_lexical_block
, parent
, decl
);
6028 if (TREE_CODE (decl
) == BLOCK
)
6029 BLOCK_DIE (decl
) = die
;
6031 equate_decl_number_to_die (decl
, die
);
6033 /* Add a reference to the DIE providing early debug at $sym + off. */
6034 add_AT_external_die_ref (die
, DW_AT_abstract_origin
, sym
, off
);
6037 /* Returns a hash value for X (which really is a var_loc_list). */
6040 decl_loc_hasher::hash (var_loc_list
*x
)
6042 return (hashval_t
) x
->decl_id
;
6045 /* Return nonzero if decl_id of var_loc_list X is the same as
6049 decl_loc_hasher::equal (var_loc_list
*x
, const_tree y
)
6051 return (x
->decl_id
== DECL_UID (y
));
6054 /* Return the var_loc list associated with a given declaration. */
6056 static inline var_loc_list
*
6057 lookup_decl_loc (const_tree decl
)
6059 if (!decl_loc_table
)
6061 return decl_loc_table
->find_with_hash (decl
, DECL_UID (decl
));
6064 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
6067 dw_loc_list_hasher::hash (cached_dw_loc_list
*x
)
6069 return (hashval_t
) x
->decl_id
;
6072 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
6076 dw_loc_list_hasher::equal (cached_dw_loc_list
*x
, const_tree y
)
6078 return (x
->decl_id
== DECL_UID (y
));
6081 /* Equate a DIE to a particular declaration. */
6084 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
6086 unsigned int decl_id
= DECL_UID (decl
);
6088 *decl_die_table
->find_slot_with_hash (decl
, decl_id
, INSERT
) = decl_die
;
6089 decl_die
->decl_id
= decl_id
;
6092 /* Return how many bits covers PIECE EXPR_LIST. */
6094 static HOST_WIDE_INT
6095 decl_piece_bitsize (rtx piece
)
6097 int ret
= (int) GET_MODE (piece
);
6100 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
6101 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
6102 return INTVAL (XEXP (XEXP (piece
, 0), 0));
6105 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
6108 decl_piece_varloc_ptr (rtx piece
)
6110 if ((int) GET_MODE (piece
))
6111 return &XEXP (piece
, 0);
6113 return &XEXP (XEXP (piece
, 0), 1);
6116 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
6117 Next is the chain of following piece nodes. */
6119 static rtx_expr_list
*
6120 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
6122 if (bitsize
> 0 && bitsize
<= (int) MAX_MACHINE_MODE
)
6123 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
6125 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
6130 /* Return rtx that should be stored into loc field for
6131 LOC_NOTE and BITPOS/BITSIZE. */
6134 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
6135 HOST_WIDE_INT bitsize
)
6139 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
6141 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
6146 /* This function either modifies location piece list *DEST in
6147 place (if SRC and INNER is NULL), or copies location piece list
6148 *SRC to *DEST while modifying it. Location BITPOS is modified
6149 to contain LOC_NOTE, any pieces overlapping it are removed resp.
6150 not copied and if needed some padding around it is added.
6151 When modifying in place, DEST should point to EXPR_LIST where
6152 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
6153 to the start of the whole list and INNER points to the EXPR_LIST
6154 where earlier pieces cover PIECE_BITPOS bits. */
6157 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
6158 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
6159 HOST_WIDE_INT bitsize
, rtx loc_note
)
6162 bool copy
= inner
!= NULL
;
6166 /* First copy all nodes preceding the current bitpos. */
6167 while (src
!= inner
)
6169 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
6170 decl_piece_bitsize (*src
), NULL_RTX
);
6171 dest
= &XEXP (*dest
, 1);
6172 src
= &XEXP (*src
, 1);
6175 /* Add padding if needed. */
6176 if (bitpos
!= piece_bitpos
)
6178 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
6179 copy
? NULL_RTX
: *dest
);
6180 dest
= &XEXP (*dest
, 1);
6182 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
6185 /* A piece with correct bitpos and bitsize already exist,
6186 just update the location for it and return. */
6187 *decl_piece_varloc_ptr (*dest
) = loc_note
;
6190 /* Add the piece that changed. */
6191 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
6192 dest
= &XEXP (*dest
, 1);
6193 /* Skip over pieces that overlap it. */
6194 diff
= bitpos
- piece_bitpos
+ bitsize
;
6197 while (diff
> 0 && *src
)
6200 diff
-= decl_piece_bitsize (piece
);
6202 src
= &XEXP (piece
, 1);
6205 *src
= XEXP (piece
, 1);
6206 free_EXPR_LIST_node (piece
);
6209 /* Add padding if needed. */
6210 if (diff
< 0 && *src
)
6214 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
6215 dest
= &XEXP (*dest
, 1);
6219 /* Finally copy all nodes following it. */
6222 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
6223 decl_piece_bitsize (*src
), NULL_RTX
);
6224 dest
= &XEXP (*dest
, 1);
6225 src
= &XEXP (*src
, 1);
6229 /* Add a variable location node to the linked list for DECL. */
6231 static struct var_loc_node
*
6232 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
, var_loc_view view
)
6234 unsigned int decl_id
;
6236 struct var_loc_node
*loc
= NULL
;
6237 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
6239 if (VAR_P (decl
) && DECL_HAS_DEBUG_EXPR_P (decl
))
6241 tree realdecl
= DECL_DEBUG_EXPR (decl
);
6242 if (handled_component_p (realdecl
)
6243 || (TREE_CODE (realdecl
) == MEM_REF
6244 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
6247 tree innerdecl
= get_ref_base_and_extent_hwi (realdecl
, &bitpos
,
6248 &bitsize
, &reverse
);
6250 || !DECL_P (innerdecl
)
6251 || DECL_IGNORED_P (innerdecl
)
6252 || TREE_STATIC (innerdecl
)
6254 || bitpos
+ bitsize
> 256)
6260 decl_id
= DECL_UID (decl
);
6262 = decl_loc_table
->find_slot_with_hash (decl
, decl_id
, INSERT
);
6265 temp
= ggc_cleared_alloc
<var_loc_list
> ();
6266 temp
->decl_id
= decl_id
;
6272 /* For PARM_DECLs try to keep around the original incoming value,
6273 even if that means we'll emit a zero-range .debug_loc entry. */
6275 && temp
->first
== temp
->last
6276 && TREE_CODE (decl
) == PARM_DECL
6277 && NOTE_P (temp
->first
->loc
)
6278 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
6279 && DECL_INCOMING_RTL (decl
)
6280 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
6281 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
6282 == GET_CODE (DECL_INCOMING_RTL (decl
))
6283 && prev_real_insn (as_a
<rtx_insn
*> (temp
->first
->loc
)) == NULL_RTX
6285 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
6286 NOTE_VAR_LOCATION_LOC (loc_note
))
6287 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
6288 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
6290 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6291 temp
->first
->next
= loc
;
6293 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6295 else if (temp
->last
)
6297 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
6298 rtx
*piece_loc
= NULL
, last_loc_note
;
6299 HOST_WIDE_INT piece_bitpos
= 0;
6303 gcc_assert (last
->next
== NULL
);
6305 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
6307 piece_loc
= &last
->loc
;
6310 HOST_WIDE_INT cur_bitsize
= decl_piece_bitsize (*piece_loc
);
6311 if (piece_bitpos
+ cur_bitsize
> bitpos
)
6313 piece_bitpos
+= cur_bitsize
;
6314 piece_loc
= &XEXP (*piece_loc
, 1);
6318 /* TEMP->LAST here is either pointer to the last but one or
6319 last element in the chained list, LAST is pointer to the
6321 if (label
&& strcmp (last
->label
, label
) == 0 && last
->view
== view
)
6323 /* For SRA optimized variables if there weren't any real
6324 insns since last note, just modify the last node. */
6325 if (piece_loc
!= NULL
)
6327 adjust_piece_list (piece_loc
, NULL
, NULL
,
6328 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6331 /* If the last note doesn't cover any instructions, remove it. */
6332 if (temp
->last
!= last
)
6334 temp
->last
->next
= NULL
;
6337 gcc_assert (strcmp (last
->label
, label
) != 0 || last
->view
!= view
);
6341 gcc_assert (temp
->first
== temp
->last
6342 || (temp
->first
->next
== temp
->last
6343 && TREE_CODE (decl
) == PARM_DECL
));
6344 memset (temp
->last
, '\0', sizeof (*temp
->last
));
6345 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6349 if (bitsize
== -1 && NOTE_P (last
->loc
))
6350 last_loc_note
= last
->loc
;
6351 else if (piece_loc
!= NULL
6352 && *piece_loc
!= NULL_RTX
6353 && piece_bitpos
== bitpos
6354 && decl_piece_bitsize (*piece_loc
) == bitsize
)
6355 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
6357 last_loc_note
= NULL_RTX
;
6358 /* If the current location is the same as the end of the list,
6359 and either both or neither of the locations is uninitialized,
6360 we have nothing to do. */
6361 if (last_loc_note
== NULL_RTX
6362 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
6363 NOTE_VAR_LOCATION_LOC (loc_note
)))
6364 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6365 != NOTE_VAR_LOCATION_STATUS (loc_note
))
6366 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6367 == VAR_INIT_STATUS_UNINITIALIZED
)
6368 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
6369 == VAR_INIT_STATUS_UNINITIALIZED
))))
6371 /* Add LOC to the end of list and update LAST. If the last
6372 element of the list has been removed above, reuse its
6373 memory for the new node, otherwise allocate a new one. */
6377 memset (loc
, '\0', sizeof (*loc
));
6380 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6381 if (bitsize
== -1 || piece_loc
== NULL
)
6382 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6384 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
6385 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6387 /* Ensure TEMP->LAST will point either to the new last but one
6388 element of the chain, or to the last element in it. */
6389 if (last
!= temp
->last
)
6397 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6400 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6405 /* Keep track of the number of spaces used to indent the
6406 output of the debugging routines that print the structure of
6407 the DIE internal representation. */
6408 static int print_indent
;
6410 /* Indent the line the number of spaces given by print_indent. */
6413 print_spaces (FILE *outfile
)
6415 fprintf (outfile
, "%*s", print_indent
, "");
6418 /* Print a type signature in hex. */
6421 print_signature (FILE *outfile
, char *sig
)
6425 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
6426 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
6430 print_discr_value (FILE *outfile
, dw_discr_value
*discr_value
)
6432 if (discr_value
->pos
)
6433 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, discr_value
->v
.sval
);
6435 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, discr_value
->v
.uval
);
6438 static void print_loc_descr (dw_loc_descr_ref
, FILE *);
6440 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
6441 RECURSE, output location descriptor operations. */
6444 print_dw_val (dw_val_node
*val
, bool recurse
, FILE *outfile
)
6446 switch (val
->val_class
)
6448 case dw_val_class_addr
:
6449 fprintf (outfile
, "address");
6451 case dw_val_class_offset
:
6452 fprintf (outfile
, "offset");
6454 case dw_val_class_loc
:
6455 fprintf (outfile
, "location descriptor");
6456 if (val
->v
.val_loc
== NULL
)
6457 fprintf (outfile
, " -> <null>\n");
6460 fprintf (outfile
, ":\n");
6462 print_loc_descr (val
->v
.val_loc
, outfile
);
6467 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6468 fprintf (outfile
, " #\n");
6470 fprintf (outfile
, " (%p)\n", (void *) val
->v
.val_loc
);
6473 case dw_val_class_loc_list
:
6474 fprintf (outfile
, "location list -> label:%s",
6475 val
->v
.val_loc_list
->ll_symbol
);
6477 case dw_val_class_view_list
:
6478 val
= view_list_to_loc_list_val_node (val
);
6479 fprintf (outfile
, "location list with views -> labels:%s and %s",
6480 val
->v
.val_loc_list
->ll_symbol
,
6481 val
->v
.val_loc_list
->vl_symbol
);
6483 case dw_val_class_range_list
:
6484 fprintf (outfile
, "range list");
6486 case dw_val_class_const
:
6487 case dw_val_class_const_implicit
:
6488 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, val
->v
.val_int
);
6490 case dw_val_class_unsigned_const
:
6491 case dw_val_class_unsigned_const_implicit
:
6492 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, val
->v
.val_unsigned
);
6494 case dw_val_class_const_double
:
6495 fprintf (outfile
, "constant (" HOST_WIDE_INT_PRINT_DEC
","\
6496 HOST_WIDE_INT_PRINT_UNSIGNED
")",
6497 val
->v
.val_double
.high
,
6498 val
->v
.val_double
.low
);
6500 case dw_val_class_wide_int
:
6502 int i
= val
->v
.val_wide
->get_len ();
6503 fprintf (outfile
, "constant (");
6505 if (val
->v
.val_wide
->elt (i
- 1) == 0)
6506 fprintf (outfile
, "0x");
6507 fprintf (outfile
, HOST_WIDE_INT_PRINT_HEX
,
6508 val
->v
.val_wide
->elt (--i
));
6510 fprintf (outfile
, HOST_WIDE_INT_PRINT_PADDED_HEX
,
6511 val
->v
.val_wide
->elt (i
));
6512 fprintf (outfile
, ")");
6515 case dw_val_class_vec
:
6516 fprintf (outfile
, "floating-point or vector constant");
6518 case dw_val_class_flag
:
6519 fprintf (outfile
, "%u", val
->v
.val_flag
);
6521 case dw_val_class_die_ref
:
6522 if (val
->v
.val_die_ref
.die
!= NULL
)
6524 dw_die_ref die
= val
->v
.val_die_ref
.die
;
6526 if (die
->comdat_type_p
)
6528 fprintf (outfile
, "die -> signature: ");
6529 print_signature (outfile
,
6530 die
->die_id
.die_type_node
->signature
);
6532 else if (die
->die_id
.die_symbol
)
6534 fprintf (outfile
, "die -> label: %s", die
->die_id
.die_symbol
);
6535 if (die
->with_offset
)
6536 fprintf (outfile
, " + %ld", die
->die_offset
);
6539 fprintf (outfile
, "die -> %ld", die
->die_offset
);
6540 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6541 fprintf (outfile
, " #");
6543 fprintf (outfile
, " (%p)", (void *) die
);
6546 fprintf (outfile
, "die -> <null>");
6548 case dw_val_class_vms_delta
:
6549 fprintf (outfile
, "delta: @slotcount(%s-%s)",
6550 val
->v
.val_vms_delta
.lbl2
, val
->v
.val_vms_delta
.lbl1
);
6552 case dw_val_class_symview
:
6553 fprintf (outfile
, "view: %s", val
->v
.val_symbolic_view
);
6555 case dw_val_class_lbl_id
:
6556 case dw_val_class_lineptr
:
6557 case dw_val_class_macptr
:
6558 case dw_val_class_loclistsptr
:
6559 case dw_val_class_high_pc
:
6560 fprintf (outfile
, "label: %s", val
->v
.val_lbl_id
);
6562 case dw_val_class_str
:
6563 if (val
->v
.val_str
->str
!= NULL
)
6564 fprintf (outfile
, "\"%s\"", val
->v
.val_str
->str
);
6566 fprintf (outfile
, "<null>");
6568 case dw_val_class_file
:
6569 case dw_val_class_file_implicit
:
6570 fprintf (outfile
, "\"%s\" (%d)", val
->v
.val_file
->filename
,
6571 val
->v
.val_file
->emitted_number
);
6573 case dw_val_class_data8
:
6577 for (i
= 0; i
< 8; i
++)
6578 fprintf (outfile
, "%02x", val
->v
.val_data8
[i
]);
6581 case dw_val_class_discr_value
:
6582 print_discr_value (outfile
, &val
->v
.val_discr_value
);
6584 case dw_val_class_discr_list
:
6585 for (dw_discr_list_ref node
= val
->v
.val_discr_list
;
6587 node
= node
->dw_discr_next
)
6589 if (node
->dw_discr_range
)
6591 fprintf (outfile
, " .. ");
6592 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6593 print_discr_value (outfile
, &node
->dw_discr_upper_bound
);
6596 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6598 if (node
->dw_discr_next
!= NULL
)
6599 fprintf (outfile
, " | ");
6606 /* Likewise, for a DIE attribute. */
6609 print_attribute (dw_attr_node
*a
, bool recurse
, FILE *outfile
)
6611 print_dw_val (&a
->dw_attr_val
, recurse
, outfile
);
6615 /* Print the list of operands in the LOC location description to OUTFILE. This
6616 routine is a debugging aid only. */
6619 print_loc_descr (dw_loc_descr_ref loc
, FILE *outfile
)
6621 dw_loc_descr_ref l
= loc
;
6625 print_spaces (outfile
);
6626 fprintf (outfile
, "<null>\n");
6630 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
6632 print_spaces (outfile
);
6633 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6634 fprintf (outfile
, "#");
6636 fprintf (outfile
, "(%p)", (void *) l
);
6637 fprintf (outfile
, " %s",
6638 dwarf_stack_op_name (l
->dw_loc_opc
));
6639 if (l
->dw_loc_oprnd1
.val_class
!= dw_val_class_none
)
6641 fprintf (outfile
, " ");
6642 print_dw_val (&l
->dw_loc_oprnd1
, false, outfile
);
6644 if (l
->dw_loc_oprnd2
.val_class
!= dw_val_class_none
)
6646 fprintf (outfile
, ", ");
6647 print_dw_val (&l
->dw_loc_oprnd2
, false, outfile
);
6649 fprintf (outfile
, "\n");
6653 /* Print the information associated with a given DIE, and its children.
6654 This routine is a debugging aid only. */
6657 print_die (dw_die_ref die
, FILE *outfile
)
6663 print_spaces (outfile
);
6664 fprintf (outfile
, "DIE %4ld: %s ",
6665 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
6666 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6667 fprintf (outfile
, "#\n");
6669 fprintf (outfile
, "(%p)\n", (void*) die
);
6670 print_spaces (outfile
);
6671 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
6672 fprintf (outfile
, " offset: %ld", die
->die_offset
);
6673 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
6675 if (die
->comdat_type_p
)
6677 print_spaces (outfile
);
6678 fprintf (outfile
, " signature: ");
6679 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
6680 fprintf (outfile
, "\n");
6683 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6685 print_spaces (outfile
);
6686 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
6688 print_attribute (a
, true, outfile
);
6689 fprintf (outfile
, "\n");
6692 if (die
->die_child
!= NULL
)
6695 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
6698 if (print_indent
== 0)
6699 fprintf (outfile
, "\n");
6702 /* Print the list of operations in the LOC location description. */
6705 debug_dwarf_loc_descr (dw_loc_descr_ref loc
)
6707 print_loc_descr (loc
, stderr
);
6710 /* Print the information collected for a given DIE. */
6713 debug_dwarf_die (dw_die_ref die
)
6715 print_die (die
, stderr
);
6719 debug (die_struct
&ref
)
6721 print_die (&ref
, stderr
);
6725 debug (die_struct
*ptr
)
6730 fprintf (stderr
, "<nil>\n");
6734 /* Print all DWARF information collected for the compilation unit.
6735 This routine is a debugging aid only. */
6741 print_die (comp_unit_die (), stderr
);
6744 /* Verify the DIE tree structure. */
6747 verify_die (dw_die_ref die
)
6749 gcc_assert (!die
->die_mark
);
6750 if (die
->die_parent
== NULL
6751 && die
->die_sib
== NULL
)
6753 /* Verify the die_sib list is cyclic. */
6760 while (x
&& !x
->die_mark
);
6761 gcc_assert (x
== die
);
6765 /* Verify all dies have the same parent. */
6766 gcc_assert (x
->die_parent
== die
->die_parent
);
6769 /* Verify the child has the proper parent and recurse. */
6770 gcc_assert (x
->die_child
->die_parent
== x
);
6771 verify_die (x
->die_child
);
6776 while (x
&& x
->die_mark
);
6779 /* Sanity checks on DIEs. */
6782 check_die (dw_die_ref die
)
6786 bool inline_found
= false;
6787 int n_location
= 0, n_low_pc
= 0, n_high_pc
= 0, n_artificial
= 0;
6788 int n_decl_line
= 0, n_decl_column
= 0, n_decl_file
= 0;
6789 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6794 if (a
->dw_attr_val
.v
.val_unsigned
)
6795 inline_found
= true;
6797 case DW_AT_location
:
6806 case DW_AT_artificial
:
6809 case DW_AT_decl_column
:
6812 case DW_AT_decl_line
:
6815 case DW_AT_decl_file
:
6822 if (n_location
> 1 || n_low_pc
> 1 || n_high_pc
> 1 || n_artificial
> 1
6823 || n_decl_column
> 1 || n_decl_line
> 1 || n_decl_file
> 1)
6825 fprintf (stderr
, "Duplicate attributes in DIE:\n");
6826 debug_dwarf_die (die
);
6831 /* A debugging information entry that is a member of an abstract
6832 instance tree [that has DW_AT_inline] should not contain any
6833 attributes which describe aspects of the subroutine which vary
6834 between distinct inlined expansions or distinct out-of-line
6836 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6837 gcc_assert (a
->dw_attr
!= DW_AT_low_pc
6838 && a
->dw_attr
!= DW_AT_high_pc
6839 && a
->dw_attr
!= DW_AT_location
6840 && a
->dw_attr
!= DW_AT_frame_base
6841 && a
->dw_attr
!= DW_AT_call_all_calls
6842 && a
->dw_attr
!= DW_AT_GNU_all_call_sites
);
6846 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6847 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6848 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
6850 /* Calculate the checksum of a location expression. */
6853 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
6856 inchash::hash hstate
;
6859 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
6861 hash_loc_operands (loc
, hstate
);
6862 hash
= hstate
.end();
6866 /* Calculate the checksum of an attribute. */
6869 attr_checksum (dw_attr_node
*at
, struct md5_ctx
*ctx
, int *mark
)
6871 dw_loc_descr_ref loc
;
6874 CHECKSUM (at
->dw_attr
);
6876 /* We don't care that this was compiled with a different compiler
6877 snapshot; if the output is the same, that's what matters. */
6878 if (at
->dw_attr
== DW_AT_producer
)
6881 switch (AT_class (at
))
6883 case dw_val_class_const
:
6884 case dw_val_class_const_implicit
:
6885 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
6887 case dw_val_class_unsigned_const
:
6888 case dw_val_class_unsigned_const_implicit
:
6889 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
6891 case dw_val_class_const_double
:
6892 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
6894 case dw_val_class_wide_int
:
6895 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
6896 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
6897 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
6899 case dw_val_class_vec
:
6900 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
6901 (at
->dw_attr_val
.v
.val_vec
.length
6902 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
6904 case dw_val_class_flag
:
6905 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
6907 case dw_val_class_str
:
6908 CHECKSUM_STRING (AT_string (at
));
6911 case dw_val_class_addr
:
6913 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
6914 CHECKSUM_STRING (XSTR (r
, 0));
6917 case dw_val_class_offset
:
6918 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
6921 case dw_val_class_loc
:
6922 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
6923 loc_checksum (loc
, ctx
);
6926 case dw_val_class_die_ref
:
6927 die_checksum (AT_ref (at
), ctx
, mark
);
6930 case dw_val_class_fde_ref
:
6931 case dw_val_class_vms_delta
:
6932 case dw_val_class_symview
:
6933 case dw_val_class_lbl_id
:
6934 case dw_val_class_lineptr
:
6935 case dw_val_class_macptr
:
6936 case dw_val_class_loclistsptr
:
6937 case dw_val_class_high_pc
:
6940 case dw_val_class_file
:
6941 case dw_val_class_file_implicit
:
6942 CHECKSUM_STRING (AT_file (at
)->filename
);
6945 case dw_val_class_data8
:
6946 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
6954 /* Calculate the checksum of a DIE. */
6957 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6963 /* To avoid infinite recursion. */
6966 CHECKSUM (die
->die_mark
);
6969 die
->die_mark
= ++(*mark
);
6971 CHECKSUM (die
->die_tag
);
6973 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6974 attr_checksum (a
, ctx
, mark
);
6976 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
6980 #undef CHECKSUM_BLOCK
6981 #undef CHECKSUM_STRING
6983 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
6984 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6985 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6986 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
6987 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
6988 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
6989 #define CHECKSUM_ATTR(FOO) \
6990 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
6992 /* Calculate the checksum of a number in signed LEB128 format. */
6995 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
7002 byte
= (value
& 0x7f);
7004 more
= !((value
== 0 && (byte
& 0x40) == 0)
7005 || (value
== -1 && (byte
& 0x40) != 0));
7014 /* Calculate the checksum of a number in unsigned LEB128 format. */
7017 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
7021 unsigned char byte
= (value
& 0x7f);
7024 /* More bytes to follow. */
7032 /* Checksum the context of the DIE. This adds the names of any
7033 surrounding namespaces or structures to the checksum. */
7036 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
7040 int tag
= die
->die_tag
;
7042 if (tag
!= DW_TAG_namespace
7043 && tag
!= DW_TAG_structure_type
7044 && tag
!= DW_TAG_class_type
)
7047 name
= get_AT_string (die
, DW_AT_name
);
7049 spec
= get_AT_ref (die
, DW_AT_specification
);
7053 if (die
->die_parent
!= NULL
)
7054 checksum_die_context (die
->die_parent
, ctx
);
7056 CHECKSUM_ULEB128 ('C');
7057 CHECKSUM_ULEB128 (tag
);
7059 CHECKSUM_STRING (name
);
7062 /* Calculate the checksum of a location expression. */
7065 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
7067 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
7068 were emitted as a DW_FORM_sdata instead of a location expression. */
7069 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
7071 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7072 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
7076 /* Otherwise, just checksum the raw location expression. */
7079 inchash::hash hstate
;
7082 CHECKSUM_ULEB128 (loc
->dtprel
);
7083 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
7084 hash_loc_operands (loc
, hstate
);
7085 hash
= hstate
.end ();
7087 loc
= loc
->dw_loc_next
;
7091 /* Calculate the checksum of an attribute. */
7094 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_node
*at
,
7095 struct md5_ctx
*ctx
, int *mark
)
7097 dw_loc_descr_ref loc
;
7100 if (AT_class (at
) == dw_val_class_die_ref
)
7102 dw_die_ref target_die
= AT_ref (at
);
7104 /* For pointer and reference types, we checksum only the (qualified)
7105 name of the target type (if there is a name). For friend entries,
7106 we checksum only the (qualified) name of the target type or function.
7107 This allows the checksum to remain the same whether the target type
7108 is complete or not. */
7109 if ((at
->dw_attr
== DW_AT_type
7110 && (tag
== DW_TAG_pointer_type
7111 || tag
== DW_TAG_reference_type
7112 || tag
== DW_TAG_rvalue_reference_type
7113 || tag
== DW_TAG_ptr_to_member_type
))
7114 || (at
->dw_attr
== DW_AT_friend
7115 && tag
== DW_TAG_friend
))
7117 dw_attr_node
*name_attr
= get_AT (target_die
, DW_AT_name
);
7119 if (name_attr
!= NULL
)
7121 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
7125 CHECKSUM_ULEB128 ('N');
7126 CHECKSUM_ULEB128 (at
->dw_attr
);
7127 if (decl
->die_parent
!= NULL
)
7128 checksum_die_context (decl
->die_parent
, ctx
);
7129 CHECKSUM_ULEB128 ('E');
7130 CHECKSUM_STRING (AT_string (name_attr
));
7135 /* For all other references to another DIE, we check to see if the
7136 target DIE has already been visited. If it has, we emit a
7137 backward reference; if not, we descend recursively. */
7138 if (target_die
->die_mark
> 0)
7140 CHECKSUM_ULEB128 ('R');
7141 CHECKSUM_ULEB128 (at
->dw_attr
);
7142 CHECKSUM_ULEB128 (target_die
->die_mark
);
7146 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
7150 target_die
->die_mark
= ++(*mark
);
7151 CHECKSUM_ULEB128 ('T');
7152 CHECKSUM_ULEB128 (at
->dw_attr
);
7153 if (decl
->die_parent
!= NULL
)
7154 checksum_die_context (decl
->die_parent
, ctx
);
7155 die_checksum_ordered (target_die
, ctx
, mark
);
7160 CHECKSUM_ULEB128 ('A');
7161 CHECKSUM_ULEB128 (at
->dw_attr
);
7163 switch (AT_class (at
))
7165 case dw_val_class_const
:
7166 case dw_val_class_const_implicit
:
7167 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7168 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
7171 case dw_val_class_unsigned_const
:
7172 case dw_val_class_unsigned_const_implicit
:
7173 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7174 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
7177 case dw_val_class_const_double
:
7178 CHECKSUM_ULEB128 (DW_FORM_block
);
7179 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
7180 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
7183 case dw_val_class_wide_int
:
7184 CHECKSUM_ULEB128 (DW_FORM_block
);
7185 CHECKSUM_ULEB128 (get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7186 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
7187 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
7188 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7189 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
7192 case dw_val_class_vec
:
7193 CHECKSUM_ULEB128 (DW_FORM_block
);
7194 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_vec
.length
7195 * at
->dw_attr_val
.v
.val_vec
.elt_size
);
7196 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
7197 (at
->dw_attr_val
.v
.val_vec
.length
7198 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
7201 case dw_val_class_flag
:
7202 CHECKSUM_ULEB128 (DW_FORM_flag
);
7203 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
7206 case dw_val_class_str
:
7207 CHECKSUM_ULEB128 (DW_FORM_string
);
7208 CHECKSUM_STRING (AT_string (at
));
7211 case dw_val_class_addr
:
7213 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
7214 CHECKSUM_ULEB128 (DW_FORM_string
);
7215 CHECKSUM_STRING (XSTR (r
, 0));
7218 case dw_val_class_offset
:
7219 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7220 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
7223 case dw_val_class_loc
:
7224 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
7225 loc_checksum_ordered (loc
, ctx
);
7228 case dw_val_class_fde_ref
:
7229 case dw_val_class_symview
:
7230 case dw_val_class_lbl_id
:
7231 case dw_val_class_lineptr
:
7232 case dw_val_class_macptr
:
7233 case dw_val_class_loclistsptr
:
7234 case dw_val_class_high_pc
:
7237 case dw_val_class_file
:
7238 case dw_val_class_file_implicit
:
7239 CHECKSUM_ULEB128 (DW_FORM_string
);
7240 CHECKSUM_STRING (AT_file (at
)->filename
);
7243 case dw_val_class_data8
:
7244 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
7252 struct checksum_attributes
7254 dw_attr_node
*at_name
;
7255 dw_attr_node
*at_type
;
7256 dw_attr_node
*at_friend
;
7257 dw_attr_node
*at_accessibility
;
7258 dw_attr_node
*at_address_class
;
7259 dw_attr_node
*at_alignment
;
7260 dw_attr_node
*at_allocated
;
7261 dw_attr_node
*at_artificial
;
7262 dw_attr_node
*at_associated
;
7263 dw_attr_node
*at_binary_scale
;
7264 dw_attr_node
*at_bit_offset
;
7265 dw_attr_node
*at_bit_size
;
7266 dw_attr_node
*at_bit_stride
;
7267 dw_attr_node
*at_byte_size
;
7268 dw_attr_node
*at_byte_stride
;
7269 dw_attr_node
*at_const_value
;
7270 dw_attr_node
*at_containing_type
;
7271 dw_attr_node
*at_count
;
7272 dw_attr_node
*at_data_location
;
7273 dw_attr_node
*at_data_member_location
;
7274 dw_attr_node
*at_decimal_scale
;
7275 dw_attr_node
*at_decimal_sign
;
7276 dw_attr_node
*at_default_value
;
7277 dw_attr_node
*at_digit_count
;
7278 dw_attr_node
*at_discr
;
7279 dw_attr_node
*at_discr_list
;
7280 dw_attr_node
*at_discr_value
;
7281 dw_attr_node
*at_encoding
;
7282 dw_attr_node
*at_endianity
;
7283 dw_attr_node
*at_explicit
;
7284 dw_attr_node
*at_is_optional
;
7285 dw_attr_node
*at_location
;
7286 dw_attr_node
*at_lower_bound
;
7287 dw_attr_node
*at_mutable
;
7288 dw_attr_node
*at_ordering
;
7289 dw_attr_node
*at_picture_string
;
7290 dw_attr_node
*at_prototyped
;
7291 dw_attr_node
*at_small
;
7292 dw_attr_node
*at_segment
;
7293 dw_attr_node
*at_string_length
;
7294 dw_attr_node
*at_string_length_bit_size
;
7295 dw_attr_node
*at_string_length_byte_size
;
7296 dw_attr_node
*at_threads_scaled
;
7297 dw_attr_node
*at_upper_bound
;
7298 dw_attr_node
*at_use_location
;
7299 dw_attr_node
*at_use_UTF8
;
7300 dw_attr_node
*at_variable_parameter
;
7301 dw_attr_node
*at_virtuality
;
7302 dw_attr_node
*at_visibility
;
7303 dw_attr_node
*at_vtable_elem_location
;
7306 /* Collect the attributes that we will want to use for the checksum. */
7309 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
7314 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7325 attrs
->at_friend
= a
;
7327 case DW_AT_accessibility
:
7328 attrs
->at_accessibility
= a
;
7330 case DW_AT_address_class
:
7331 attrs
->at_address_class
= a
;
7333 case DW_AT_alignment
:
7334 attrs
->at_alignment
= a
;
7336 case DW_AT_allocated
:
7337 attrs
->at_allocated
= a
;
7339 case DW_AT_artificial
:
7340 attrs
->at_artificial
= a
;
7342 case DW_AT_associated
:
7343 attrs
->at_associated
= a
;
7345 case DW_AT_binary_scale
:
7346 attrs
->at_binary_scale
= a
;
7348 case DW_AT_bit_offset
:
7349 attrs
->at_bit_offset
= a
;
7351 case DW_AT_bit_size
:
7352 attrs
->at_bit_size
= a
;
7354 case DW_AT_bit_stride
:
7355 attrs
->at_bit_stride
= a
;
7357 case DW_AT_byte_size
:
7358 attrs
->at_byte_size
= a
;
7360 case DW_AT_byte_stride
:
7361 attrs
->at_byte_stride
= a
;
7363 case DW_AT_const_value
:
7364 attrs
->at_const_value
= a
;
7366 case DW_AT_containing_type
:
7367 attrs
->at_containing_type
= a
;
7370 attrs
->at_count
= a
;
7372 case DW_AT_data_location
:
7373 attrs
->at_data_location
= a
;
7375 case DW_AT_data_member_location
:
7376 attrs
->at_data_member_location
= a
;
7378 case DW_AT_decimal_scale
:
7379 attrs
->at_decimal_scale
= a
;
7381 case DW_AT_decimal_sign
:
7382 attrs
->at_decimal_sign
= a
;
7384 case DW_AT_default_value
:
7385 attrs
->at_default_value
= a
;
7387 case DW_AT_digit_count
:
7388 attrs
->at_digit_count
= a
;
7391 attrs
->at_discr
= a
;
7393 case DW_AT_discr_list
:
7394 attrs
->at_discr_list
= a
;
7396 case DW_AT_discr_value
:
7397 attrs
->at_discr_value
= a
;
7399 case DW_AT_encoding
:
7400 attrs
->at_encoding
= a
;
7402 case DW_AT_endianity
:
7403 attrs
->at_endianity
= a
;
7405 case DW_AT_explicit
:
7406 attrs
->at_explicit
= a
;
7408 case DW_AT_is_optional
:
7409 attrs
->at_is_optional
= a
;
7411 case DW_AT_location
:
7412 attrs
->at_location
= a
;
7414 case DW_AT_lower_bound
:
7415 attrs
->at_lower_bound
= a
;
7418 attrs
->at_mutable
= a
;
7420 case DW_AT_ordering
:
7421 attrs
->at_ordering
= a
;
7423 case DW_AT_picture_string
:
7424 attrs
->at_picture_string
= a
;
7426 case DW_AT_prototyped
:
7427 attrs
->at_prototyped
= a
;
7430 attrs
->at_small
= a
;
7433 attrs
->at_segment
= a
;
7435 case DW_AT_string_length
:
7436 attrs
->at_string_length
= a
;
7438 case DW_AT_string_length_bit_size
:
7439 attrs
->at_string_length_bit_size
= a
;
7441 case DW_AT_string_length_byte_size
:
7442 attrs
->at_string_length_byte_size
= a
;
7444 case DW_AT_threads_scaled
:
7445 attrs
->at_threads_scaled
= a
;
7447 case DW_AT_upper_bound
:
7448 attrs
->at_upper_bound
= a
;
7450 case DW_AT_use_location
:
7451 attrs
->at_use_location
= a
;
7453 case DW_AT_use_UTF8
:
7454 attrs
->at_use_UTF8
= a
;
7456 case DW_AT_variable_parameter
:
7457 attrs
->at_variable_parameter
= a
;
7459 case DW_AT_virtuality
:
7460 attrs
->at_virtuality
= a
;
7462 case DW_AT_visibility
:
7463 attrs
->at_visibility
= a
;
7465 case DW_AT_vtable_elem_location
:
7466 attrs
->at_vtable_elem_location
= a
;
7474 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
7477 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
7481 struct checksum_attributes attrs
;
7483 CHECKSUM_ULEB128 ('D');
7484 CHECKSUM_ULEB128 (die
->die_tag
);
7486 memset (&attrs
, 0, sizeof (attrs
));
7488 decl
= get_AT_ref (die
, DW_AT_specification
);
7490 collect_checksum_attributes (&attrs
, decl
);
7491 collect_checksum_attributes (&attrs
, die
);
7493 CHECKSUM_ATTR (attrs
.at_name
);
7494 CHECKSUM_ATTR (attrs
.at_accessibility
);
7495 CHECKSUM_ATTR (attrs
.at_address_class
);
7496 CHECKSUM_ATTR (attrs
.at_allocated
);
7497 CHECKSUM_ATTR (attrs
.at_artificial
);
7498 CHECKSUM_ATTR (attrs
.at_associated
);
7499 CHECKSUM_ATTR (attrs
.at_binary_scale
);
7500 CHECKSUM_ATTR (attrs
.at_bit_offset
);
7501 CHECKSUM_ATTR (attrs
.at_bit_size
);
7502 CHECKSUM_ATTR (attrs
.at_bit_stride
);
7503 CHECKSUM_ATTR (attrs
.at_byte_size
);
7504 CHECKSUM_ATTR (attrs
.at_byte_stride
);
7505 CHECKSUM_ATTR (attrs
.at_const_value
);
7506 CHECKSUM_ATTR (attrs
.at_containing_type
);
7507 CHECKSUM_ATTR (attrs
.at_count
);
7508 CHECKSUM_ATTR (attrs
.at_data_location
);
7509 CHECKSUM_ATTR (attrs
.at_data_member_location
);
7510 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
7511 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
7512 CHECKSUM_ATTR (attrs
.at_default_value
);
7513 CHECKSUM_ATTR (attrs
.at_digit_count
);
7514 CHECKSUM_ATTR (attrs
.at_discr
);
7515 CHECKSUM_ATTR (attrs
.at_discr_list
);
7516 CHECKSUM_ATTR (attrs
.at_discr_value
);
7517 CHECKSUM_ATTR (attrs
.at_encoding
);
7518 CHECKSUM_ATTR (attrs
.at_endianity
);
7519 CHECKSUM_ATTR (attrs
.at_explicit
);
7520 CHECKSUM_ATTR (attrs
.at_is_optional
);
7521 CHECKSUM_ATTR (attrs
.at_location
);
7522 CHECKSUM_ATTR (attrs
.at_lower_bound
);
7523 CHECKSUM_ATTR (attrs
.at_mutable
);
7524 CHECKSUM_ATTR (attrs
.at_ordering
);
7525 CHECKSUM_ATTR (attrs
.at_picture_string
);
7526 CHECKSUM_ATTR (attrs
.at_prototyped
);
7527 CHECKSUM_ATTR (attrs
.at_small
);
7528 CHECKSUM_ATTR (attrs
.at_segment
);
7529 CHECKSUM_ATTR (attrs
.at_string_length
);
7530 CHECKSUM_ATTR (attrs
.at_string_length_bit_size
);
7531 CHECKSUM_ATTR (attrs
.at_string_length_byte_size
);
7532 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
7533 CHECKSUM_ATTR (attrs
.at_upper_bound
);
7534 CHECKSUM_ATTR (attrs
.at_use_location
);
7535 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
7536 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
7537 CHECKSUM_ATTR (attrs
.at_virtuality
);
7538 CHECKSUM_ATTR (attrs
.at_visibility
);
7539 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
7540 CHECKSUM_ATTR (attrs
.at_type
);
7541 CHECKSUM_ATTR (attrs
.at_friend
);
7542 CHECKSUM_ATTR (attrs
.at_alignment
);
7544 /* Checksum the child DIEs. */
7547 dw_attr_node
*name_attr
;
7550 name_attr
= get_AT (c
, DW_AT_name
);
7551 if (is_template_instantiation (c
))
7553 /* Ignore instantiations of member type and function templates. */
7555 else if (name_attr
!= NULL
7556 && (is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
))
7558 /* Use a shallow checksum for named nested types and member
7560 CHECKSUM_ULEB128 ('S');
7561 CHECKSUM_ULEB128 (c
->die_tag
);
7562 CHECKSUM_STRING (AT_string (name_attr
));
7566 /* Use a deep checksum for other children. */
7567 /* Mark this DIE so it gets processed when unmarking. */
7568 if (c
->die_mark
== 0)
7570 die_checksum_ordered (c
, ctx
, mark
);
7572 } while (c
!= die
->die_child
);
7574 CHECKSUM_ULEB128 (0);
7577 /* Add a type name and tag to a hash. */
7579 die_odr_checksum (int tag
, const char *name
, md5_ctx
*ctx
)
7581 CHECKSUM_ULEB128 (tag
);
7582 CHECKSUM_STRING (name
);
7586 #undef CHECKSUM_STRING
7587 #undef CHECKSUM_ATTR
7588 #undef CHECKSUM_LEB128
7589 #undef CHECKSUM_ULEB128
7591 /* Generate the type signature for DIE. This is computed by generating an
7592 MD5 checksum over the DIE's tag, its relevant attributes, and its
7593 children. Attributes that are references to other DIEs are processed
7594 by recursion, using the MARK field to prevent infinite recursion.
7595 If the DIE is nested inside a namespace or another type, we also
7596 need to include that context in the signature. The lower 64 bits
7597 of the resulting MD5 checksum comprise the signature. */
7600 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
7604 unsigned char checksum
[16];
7609 name
= get_AT_string (die
, DW_AT_name
);
7610 decl
= get_AT_ref (die
, DW_AT_specification
);
7611 parent
= get_die_parent (die
);
7613 /* First, compute a signature for just the type name (and its surrounding
7614 context, if any. This is stored in the type unit DIE for link-time
7615 ODR (one-definition rule) checking. */
7617 if (is_cxx () && name
!= NULL
)
7619 md5_init_ctx (&ctx
);
7621 /* Checksum the names of surrounding namespaces and structures. */
7623 checksum_die_context (parent
, &ctx
);
7625 /* Checksum the current DIE. */
7626 die_odr_checksum (die
->die_tag
, name
, &ctx
);
7627 md5_finish_ctx (&ctx
, checksum
);
7629 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
7632 /* Next, compute the complete type signature. */
7634 md5_init_ctx (&ctx
);
7636 die
->die_mark
= mark
;
7638 /* Checksum the names of surrounding namespaces and structures. */
7640 checksum_die_context (parent
, &ctx
);
7642 /* Checksum the DIE and its children. */
7643 die_checksum_ordered (die
, &ctx
, &mark
);
7644 unmark_all_dies (die
);
7645 md5_finish_ctx (&ctx
, checksum
);
7647 /* Store the signature in the type node and link the type DIE and the
7648 type node together. */
7649 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
7650 DWARF_TYPE_SIGNATURE_SIZE
);
7651 die
->comdat_type_p
= true;
7652 die
->die_id
.die_type_node
= type_node
;
7653 type_node
->type_die
= die
;
7655 /* If the DIE is a specification, link its declaration to the type node
7659 decl
->comdat_type_p
= true;
7660 decl
->die_id
.die_type_node
= type_node
;
7664 /* Do the location expressions look same? */
7666 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
7668 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
7669 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
7670 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
7673 /* Do the values look the same? */
7675 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
7677 dw_loc_descr_ref loc1
, loc2
;
7680 if (v1
->val_class
!= v2
->val_class
)
7683 switch (v1
->val_class
)
7685 case dw_val_class_const
:
7686 case dw_val_class_const_implicit
:
7687 return v1
->v
.val_int
== v2
->v
.val_int
;
7688 case dw_val_class_unsigned_const
:
7689 case dw_val_class_unsigned_const_implicit
:
7690 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
7691 case dw_val_class_const_double
:
7692 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
7693 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
7694 case dw_val_class_wide_int
:
7695 return *v1
->v
.val_wide
== *v2
->v
.val_wide
;
7696 case dw_val_class_vec
:
7697 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
7698 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
7700 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
7701 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
7704 case dw_val_class_flag
:
7705 return v1
->v
.val_flag
== v2
->v
.val_flag
;
7706 case dw_val_class_str
:
7707 return !strcmp (v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
7709 case dw_val_class_addr
:
7710 r1
= v1
->v
.val_addr
;
7711 r2
= v2
->v
.val_addr
;
7712 if (GET_CODE (r1
) != GET_CODE (r2
))
7714 return !rtx_equal_p (r1
, r2
);
7716 case dw_val_class_offset
:
7717 return v1
->v
.val_offset
== v2
->v
.val_offset
;
7719 case dw_val_class_loc
:
7720 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
7722 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
7723 if (!same_loc_p (loc1
, loc2
, mark
))
7725 return !loc1
&& !loc2
;
7727 case dw_val_class_die_ref
:
7728 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
7730 case dw_val_class_symview
:
7731 return strcmp (v1
->v
.val_symbolic_view
, v2
->v
.val_symbolic_view
) == 0;
7733 case dw_val_class_fde_ref
:
7734 case dw_val_class_vms_delta
:
7735 case dw_val_class_lbl_id
:
7736 case dw_val_class_lineptr
:
7737 case dw_val_class_macptr
:
7738 case dw_val_class_loclistsptr
:
7739 case dw_val_class_high_pc
:
7742 case dw_val_class_file
:
7743 case dw_val_class_file_implicit
:
7744 return v1
->v
.val_file
== v2
->v
.val_file
;
7746 case dw_val_class_data8
:
7747 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
7754 /* Do the attributes look the same? */
7757 same_attr_p (dw_attr_node
*at1
, dw_attr_node
*at2
, int *mark
)
7759 if (at1
->dw_attr
!= at2
->dw_attr
)
7762 /* We don't care that this was compiled with a different compiler
7763 snapshot; if the output is the same, that's what matters. */
7764 if (at1
->dw_attr
== DW_AT_producer
)
7767 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
7770 /* Do the dies look the same? */
7773 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
7779 /* To avoid infinite recursion. */
7781 return die1
->die_mark
== die2
->die_mark
;
7782 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
7784 if (die1
->die_tag
!= die2
->die_tag
)
7787 if (vec_safe_length (die1
->die_attr
) != vec_safe_length (die2
->die_attr
))
7790 FOR_EACH_VEC_SAFE_ELT (die1
->die_attr
, ix
, a1
)
7791 if (!same_attr_p (a1
, &(*die2
->die_attr
)[ix
], mark
))
7794 c1
= die1
->die_child
;
7795 c2
= die2
->die_child
;
7804 if (!same_die_p (c1
, c2
, mark
))
7808 if (c1
== die1
->die_child
)
7810 if (c2
== die2
->die_child
)
7820 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7821 children, and set die_symbol. */
7824 compute_comp_unit_symbol (dw_die_ref unit_die
)
7826 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
7827 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
7828 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
7831 unsigned char checksum
[16];
7834 /* Compute the checksum of the DIE, then append part of it as hex digits to
7835 the name filename of the unit. */
7837 md5_init_ctx (&ctx
);
7839 die_checksum (unit_die
, &ctx
, &mark
);
7840 unmark_all_dies (unit_die
);
7841 md5_finish_ctx (&ctx
, checksum
);
7843 /* When we this for comp_unit_die () we have a DW_AT_name that might
7844 not start with a letter but with anything valid for filenames and
7845 clean_symbol_name doesn't fix that up. Prepend 'g' if the first
7846 character is not a letter. */
7847 sprintf (name
, "%s%s.", ISALPHA (*base
) ? "" : "g", base
);
7848 clean_symbol_name (name
);
7850 p
= name
+ strlen (name
);
7851 for (i
= 0; i
< 4; i
++)
7853 sprintf (p
, "%.2x", checksum
[i
]);
7857 unit_die
->die_id
.die_symbol
= xstrdup (name
);
7860 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7863 is_type_die (dw_die_ref die
)
7865 switch (die
->die_tag
)
7867 case DW_TAG_array_type
:
7868 case DW_TAG_class_type
:
7869 case DW_TAG_interface_type
:
7870 case DW_TAG_enumeration_type
:
7871 case DW_TAG_pointer_type
:
7872 case DW_TAG_reference_type
:
7873 case DW_TAG_rvalue_reference_type
:
7874 case DW_TAG_string_type
:
7875 case DW_TAG_structure_type
:
7876 case DW_TAG_subroutine_type
:
7877 case DW_TAG_union_type
:
7878 case DW_TAG_ptr_to_member_type
:
7879 case DW_TAG_set_type
:
7880 case DW_TAG_subrange_type
:
7881 case DW_TAG_base_type
:
7882 case DW_TAG_const_type
:
7883 case DW_TAG_file_type
:
7884 case DW_TAG_packed_type
:
7885 case DW_TAG_volatile_type
:
7886 case DW_TAG_typedef
:
7893 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
7894 Basically, we want to choose the bits that are likely to be shared between
7895 compilations (types) and leave out the bits that are specific to individual
7896 compilations (functions). */
7899 is_comdat_die (dw_die_ref c
)
7901 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
7902 we do for stabs. The advantage is a greater likelihood of sharing between
7903 objects that don't include headers in the same order (and therefore would
7904 put the base types in a different comdat). jason 8/28/00 */
7906 if (c
->die_tag
== DW_TAG_base_type
)
7909 if (c
->die_tag
== DW_TAG_pointer_type
7910 || c
->die_tag
== DW_TAG_reference_type
7911 || c
->die_tag
== DW_TAG_rvalue_reference_type
7912 || c
->die_tag
== DW_TAG_const_type
7913 || c
->die_tag
== DW_TAG_volatile_type
)
7915 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
7917 return t
? is_comdat_die (t
) : 0;
7920 return is_type_die (c
);
7923 /* Returns true iff C is a compile-unit DIE. */
7926 is_cu_die (dw_die_ref c
)
7928 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7929 || c
->die_tag
== DW_TAG_skeleton_unit
);
7932 /* Returns true iff C is a unit DIE of some sort. */
7935 is_unit_die (dw_die_ref c
)
7937 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7938 || c
->die_tag
== DW_TAG_partial_unit
7939 || c
->die_tag
== DW_TAG_type_unit
7940 || c
->die_tag
== DW_TAG_skeleton_unit
);
7943 /* Returns true iff C is a namespace DIE. */
7946 is_namespace_die (dw_die_ref c
)
7948 return c
&& c
->die_tag
== DW_TAG_namespace
;
7951 /* Returns true iff C is a class or structure DIE. */
7954 is_class_die (dw_die_ref c
)
7956 return c
&& (c
->die_tag
== DW_TAG_class_type
7957 || c
->die_tag
== DW_TAG_structure_type
);
7960 /* Return non-zero if this DIE is a template parameter. */
7963 is_template_parameter (dw_die_ref die
)
7965 switch (die
->die_tag
)
7967 case DW_TAG_template_type_param
:
7968 case DW_TAG_template_value_param
:
7969 case DW_TAG_GNU_template_template_param
:
7970 case DW_TAG_GNU_template_parameter_pack
:
7977 /* Return non-zero if this DIE represents a template instantiation. */
7980 is_template_instantiation (dw_die_ref die
)
7984 if (!is_type_die (die
) && die
->die_tag
!= DW_TAG_subprogram
)
7986 FOR_EACH_CHILD (die
, c
, if (is_template_parameter (c
)) return true);
7991 gen_internal_sym (const char *prefix
)
7993 char buf
[MAX_ARTIFICIAL_LABEL_BYTES
];
7995 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
7996 return xstrdup (buf
);
7999 /* Return non-zero if this DIE is a declaration. */
8002 is_declaration_die (dw_die_ref die
)
8007 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8008 if (a
->dw_attr
== DW_AT_declaration
)
8014 /* Return non-zero if this DIE is nested inside a subprogram. */
8017 is_nested_in_subprogram (dw_die_ref die
)
8019 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
8023 return local_scope_p (decl
);
8026 /* Return non-zero if this DIE contains a defining declaration of a
8030 contains_subprogram_definition (dw_die_ref die
)
8034 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
8036 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
8040 /* Return non-zero if this is a type DIE that should be moved to a
8041 COMDAT .debug_types section or .debug_info section with DW_UT_*type
8045 should_move_die_to_comdat (dw_die_ref die
)
8047 switch (die
->die_tag
)
8049 case DW_TAG_class_type
:
8050 case DW_TAG_structure_type
:
8051 case DW_TAG_enumeration_type
:
8052 case DW_TAG_union_type
:
8053 /* Don't move declarations, inlined instances, types nested in a
8054 subprogram, or types that contain subprogram definitions. */
8055 if (is_declaration_die (die
)
8056 || get_AT (die
, DW_AT_abstract_origin
)
8057 || is_nested_in_subprogram (die
)
8058 || contains_subprogram_definition (die
))
8061 case DW_TAG_array_type
:
8062 case DW_TAG_interface_type
:
8063 case DW_TAG_pointer_type
:
8064 case DW_TAG_reference_type
:
8065 case DW_TAG_rvalue_reference_type
:
8066 case DW_TAG_string_type
:
8067 case DW_TAG_subroutine_type
:
8068 case DW_TAG_ptr_to_member_type
:
8069 case DW_TAG_set_type
:
8070 case DW_TAG_subrange_type
:
8071 case DW_TAG_base_type
:
8072 case DW_TAG_const_type
:
8073 case DW_TAG_file_type
:
8074 case DW_TAG_packed_type
:
8075 case DW_TAG_volatile_type
:
8076 case DW_TAG_typedef
:
8082 /* Make a clone of DIE. */
8085 clone_die (dw_die_ref die
)
8087 dw_die_ref clone
= new_die_raw (die
->die_tag
);
8091 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8092 add_dwarf_attr (clone
, a
);
8097 /* Make a clone of the tree rooted at DIE. */
8100 clone_tree (dw_die_ref die
)
8103 dw_die_ref clone
= clone_die (die
);
8105 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
8110 /* Make a clone of DIE as a declaration. */
8113 clone_as_declaration (dw_die_ref die
)
8120 /* If the DIE is already a declaration, just clone it. */
8121 if (is_declaration_die (die
))
8122 return clone_die (die
);
8124 /* If the DIE is a specification, just clone its declaration DIE. */
8125 decl
= get_AT_ref (die
, DW_AT_specification
);
8128 clone
= clone_die (decl
);
8129 if (die
->comdat_type_p
)
8130 add_AT_die_ref (clone
, DW_AT_signature
, die
);
8134 clone
= new_die_raw (die
->die_tag
);
8136 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8138 /* We don't want to copy over all attributes.
8139 For example we don't want DW_AT_byte_size because otherwise we will no
8140 longer have a declaration and GDB will treat it as a definition. */
8144 case DW_AT_abstract_origin
:
8145 case DW_AT_artificial
:
8146 case DW_AT_containing_type
:
8147 case DW_AT_external
:
8150 case DW_AT_virtuality
:
8151 case DW_AT_linkage_name
:
8152 case DW_AT_MIPS_linkage_name
:
8153 add_dwarf_attr (clone
, a
);
8155 case DW_AT_byte_size
:
8156 case DW_AT_alignment
:
8162 if (die
->comdat_type_p
)
8163 add_AT_die_ref (clone
, DW_AT_signature
, die
);
8165 add_AT_flag (clone
, DW_AT_declaration
, 1);
8170 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
8172 struct decl_table_entry
8178 /* Helpers to manipulate hash table of copied declarations. */
8180 /* Hashtable helpers. */
8182 struct decl_table_entry_hasher
: free_ptr_hash
<decl_table_entry
>
8184 typedef die_struct
*compare_type
;
8185 static inline hashval_t
hash (const decl_table_entry
*);
8186 static inline bool equal (const decl_table_entry
*, const die_struct
*);
8190 decl_table_entry_hasher::hash (const decl_table_entry
*entry
)
8192 return htab_hash_pointer (entry
->orig
);
8196 decl_table_entry_hasher::equal (const decl_table_entry
*entry1
,
8197 const die_struct
*entry2
)
8199 return entry1
->orig
== entry2
;
8202 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
8204 /* Copy DIE and its ancestors, up to, but not including, the compile unit
8205 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
8206 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
8207 to check if the ancestor has already been copied into UNIT. */
8210 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
,
8211 decl_hash_type
*decl_table
)
8213 dw_die_ref parent
= die
->die_parent
;
8214 dw_die_ref new_parent
= unit
;
8216 decl_table_entry
**slot
= NULL
;
8217 struct decl_table_entry
*entry
= NULL
;
8221 /* Check if the entry has already been copied to UNIT. */
8222 slot
= decl_table
->find_slot_with_hash (die
, htab_hash_pointer (die
),
8224 if (*slot
!= HTAB_EMPTY_ENTRY
)
8230 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
8231 entry
= XCNEW (struct decl_table_entry
);
8239 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
8242 if (!is_unit_die (parent
))
8243 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
8246 copy
= clone_as_declaration (die
);
8247 add_child_die (new_parent
, copy
);
8251 /* Record the pointer to the copy. */
8257 /* Copy the declaration context to the new type unit DIE. This includes
8258 any surrounding namespace or type declarations. If the DIE has an
8259 AT_specification attribute, it also includes attributes and children
8260 attached to the specification, and returns a pointer to the original
8261 parent of the declaration DIE. Returns NULL otherwise. */
8264 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
8267 dw_die_ref new_decl
;
8268 dw_die_ref orig_parent
= NULL
;
8270 decl
= get_AT_ref (die
, DW_AT_specification
);
8279 /* The original DIE will be changed to a declaration, and must
8280 be moved to be a child of the original declaration DIE. */
8281 orig_parent
= decl
->die_parent
;
8283 /* Copy the type node pointer from the new DIE to the original
8284 declaration DIE so we can forward references later. */
8285 decl
->comdat_type_p
= true;
8286 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
8288 remove_AT (die
, DW_AT_specification
);
8290 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
8292 if (a
->dw_attr
!= DW_AT_name
8293 && a
->dw_attr
!= DW_AT_declaration
8294 && a
->dw_attr
!= DW_AT_external
)
8295 add_dwarf_attr (die
, a
);
8298 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
8301 if (decl
->die_parent
!= NULL
8302 && !is_unit_die (decl
->die_parent
))
8304 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
8305 if (new_decl
!= NULL
)
8307 remove_AT (new_decl
, DW_AT_signature
);
8308 add_AT_specification (die
, new_decl
);
8315 /* Generate the skeleton ancestor tree for the given NODE, then clone
8316 the DIE and add the clone into the tree. */
8319 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
8321 if (node
->new_die
!= NULL
)
8324 node
->new_die
= clone_as_declaration (node
->old_die
);
8326 if (node
->parent
!= NULL
)
8328 generate_skeleton_ancestor_tree (node
->parent
);
8329 add_child_die (node
->parent
->new_die
, node
->new_die
);
8333 /* Generate a skeleton tree of DIEs containing any declarations that are
8334 found in the original tree. We traverse the tree looking for declaration
8335 DIEs, and construct the skeleton from the bottom up whenever we find one. */
8338 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
8340 skeleton_chain_node node
;
8343 dw_die_ref prev
= NULL
;
8344 dw_die_ref next
= NULL
;
8346 node
.parent
= parent
;
8348 first
= c
= parent
->old_die
->die_child
;
8352 if (prev
== NULL
|| prev
->die_sib
== c
)
8355 next
= (c
== first
? NULL
: c
->die_sib
);
8357 node
.new_die
= NULL
;
8358 if (is_declaration_die (c
))
8360 if (is_template_instantiation (c
))
8362 /* Instantiated templates do not need to be cloned into the
8363 type unit. Just move the DIE and its children back to
8364 the skeleton tree (in the main CU). */
8365 remove_child_with_prev (c
, prev
);
8366 add_child_die (parent
->new_die
, c
);
8369 else if (c
->comdat_type_p
)
8371 /* This is the skeleton of earlier break_out_comdat_types
8372 type. Clone the existing DIE, but keep the children
8373 under the original (which is in the main CU). */
8374 dw_die_ref clone
= clone_die (c
);
8376 replace_child (c
, clone
, prev
);
8377 generate_skeleton_ancestor_tree (parent
);
8378 add_child_die (parent
->new_die
, c
);
8384 /* Clone the existing DIE, move the original to the skeleton
8385 tree (which is in the main CU), and put the clone, with
8386 all the original's children, where the original came from
8387 (which is about to be moved to the type unit). */
8388 dw_die_ref clone
= clone_die (c
);
8389 move_all_children (c
, clone
);
8391 /* If the original has a DW_AT_object_pointer attribute,
8392 it would now point to a child DIE just moved to the
8393 cloned tree, so we need to remove that attribute from
8395 remove_AT (c
, DW_AT_object_pointer
);
8397 replace_child (c
, clone
, prev
);
8398 generate_skeleton_ancestor_tree (parent
);
8399 add_child_die (parent
->new_die
, c
);
8400 node
.old_die
= clone
;
8405 generate_skeleton_bottom_up (&node
);
8406 } while (next
!= NULL
);
8409 /* Wrapper function for generate_skeleton_bottom_up. */
8412 generate_skeleton (dw_die_ref die
)
8414 skeleton_chain_node node
;
8417 node
.new_die
= NULL
;
8420 /* If this type definition is nested inside another type,
8421 and is not an instantiation of a template, always leave
8422 at least a declaration in its place. */
8423 if (die
->die_parent
!= NULL
8424 && is_type_die (die
->die_parent
)
8425 && !is_template_instantiation (die
))
8426 node
.new_die
= clone_as_declaration (die
);
8428 generate_skeleton_bottom_up (&node
);
8429 return node
.new_die
;
8432 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
8433 declaration. The original DIE is moved to a new compile unit so that
8434 existing references to it follow it to the new location. If any of the
8435 original DIE's descendants is a declaration, we need to replace the
8436 original DIE with a skeleton tree and move the declarations back into the
8440 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
8443 dw_die_ref skeleton
, orig_parent
;
8445 /* Copy the declaration context to the type unit DIE. If the returned
8446 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
8448 orig_parent
= copy_declaration_context (unit
, child
);
8450 skeleton
= generate_skeleton (child
);
8451 if (skeleton
== NULL
)
8452 remove_child_with_prev (child
, prev
);
8455 skeleton
->comdat_type_p
= true;
8456 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
8458 /* If the original DIE was a specification, we need to put
8459 the skeleton under the parent DIE of the declaration.
8460 This leaves the original declaration in the tree, but
8461 it will be pruned later since there are no longer any
8462 references to it. */
8463 if (orig_parent
!= NULL
)
8465 remove_child_with_prev (child
, prev
);
8466 add_child_die (orig_parent
, skeleton
);
8469 replace_child (child
, skeleton
, prev
);
8476 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8477 comdat_type_node
*type_node
,
8478 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
);
8480 /* Helper for copy_dwarf_procs_ref_in_dies. Make a copy of the DIE DWARF
8481 procedure, put it under TYPE_NODE and return the copy. Continue looking for
8482 DWARF procedure references in the DW_AT_location attribute. */
8485 copy_dwarf_procedure (dw_die_ref die
,
8486 comdat_type_node
*type_node
,
8487 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8489 gcc_assert (die
->die_tag
== DW_TAG_dwarf_procedure
);
8491 /* DWARF procedures are not supposed to have children... */
8492 gcc_assert (die
->die_child
== NULL
);
8494 /* ... and they are supposed to have only one attribute: DW_AT_location. */
8495 gcc_assert (vec_safe_length (die
->die_attr
) == 1
8496 && ((*die
->die_attr
)[0].dw_attr
== DW_AT_location
));
8498 /* Do not copy more than once DWARF procedures. */
8500 dw_die_ref
&die_copy
= copied_dwarf_procs
.get_or_insert (die
, &existed
);
8504 die_copy
= clone_die (die
);
8505 add_child_die (type_node
->root_die
, die_copy
);
8506 copy_dwarf_procs_ref_in_attrs (die_copy
, type_node
, copied_dwarf_procs
);
8510 /* Helper for copy_dwarf_procs_ref_in_dies. Look for references to DWARF
8511 procedures in DIE's attributes. */
8514 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8515 comdat_type_node
*type_node
,
8516 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8521 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, i
, a
)
8523 dw_loc_descr_ref loc
;
8525 if (a
->dw_attr_val
.val_class
!= dw_val_class_loc
)
8528 for (loc
= a
->dw_attr_val
.v
.val_loc
; loc
!= NULL
; loc
= loc
->dw_loc_next
)
8530 switch (loc
->dw_loc_opc
)
8534 case DW_OP_call_ref
:
8535 gcc_assert (loc
->dw_loc_oprnd1
.val_class
8536 == dw_val_class_die_ref
);
8537 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
8538 = copy_dwarf_procedure (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
,
8540 copied_dwarf_procs
);
8549 /* Copy DWARF procedures that are referenced by the DIE tree to TREE_NODE and
8550 rewrite references to point to the copies.
8552 References are looked for in DIE's attributes and recursively in all its
8553 children attributes that are location descriptions. COPIED_DWARF_PROCS is a
8554 mapping from old DWARF procedures to their copy. It is used not to copy
8555 twice the same DWARF procedure under TYPE_NODE. */
8558 copy_dwarf_procs_ref_in_dies (dw_die_ref die
,
8559 comdat_type_node
*type_node
,
8560 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8564 copy_dwarf_procs_ref_in_attrs (die
, type_node
, copied_dwarf_procs
);
8565 FOR_EACH_CHILD (die
, c
, copy_dwarf_procs_ref_in_dies (c
,
8567 copied_dwarf_procs
));
8570 /* Traverse the DIE and set up additional .debug_types or .debug_info
8571 DW_UT_*type sections for each type worthy of being placed in a COMDAT
8575 break_out_comdat_types (dw_die_ref die
)
8579 dw_die_ref prev
= NULL
;
8580 dw_die_ref next
= NULL
;
8581 dw_die_ref unit
= NULL
;
8583 first
= c
= die
->die_child
;
8587 if (prev
== NULL
|| prev
->die_sib
== c
)
8590 next
= (c
== first
? NULL
: c
->die_sib
);
8591 if (should_move_die_to_comdat (c
))
8593 dw_die_ref replacement
;
8594 comdat_type_node
*type_node
;
8596 /* Break out nested types into their own type units. */
8597 break_out_comdat_types (c
);
8599 /* Create a new type unit DIE as the root for the new tree, and
8600 add it to the list of comdat types. */
8601 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
8602 add_AT_unsigned (unit
, DW_AT_language
,
8603 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
8604 type_node
= ggc_cleared_alloc
<comdat_type_node
> ();
8605 type_node
->root_die
= unit
;
8606 type_node
->next
= comdat_type_list
;
8607 comdat_type_list
= type_node
;
8609 /* Generate the type signature. */
8610 generate_type_signature (c
, type_node
);
8612 /* Copy the declaration context, attributes, and children of the
8613 declaration into the new type unit DIE, then remove this DIE
8614 from the main CU (or replace it with a skeleton if necessary). */
8615 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
8616 type_node
->skeleton_die
= replacement
;
8618 /* Add the DIE to the new compunit. */
8619 add_child_die (unit
, c
);
8621 /* Types can reference DWARF procedures for type size or data location
8622 expressions. Calls in DWARF expressions cannot target procedures
8623 that are not in the same section. So we must copy DWARF procedures
8624 along with this type and then rewrite references to them. */
8625 hash_map
<dw_die_ref
, dw_die_ref
> copied_dwarf_procs
;
8626 copy_dwarf_procs_ref_in_dies (c
, type_node
, copied_dwarf_procs
);
8628 if (replacement
!= NULL
)
8631 else if (c
->die_tag
== DW_TAG_namespace
8632 || c
->die_tag
== DW_TAG_class_type
8633 || c
->die_tag
== DW_TAG_structure_type
8634 || c
->die_tag
== DW_TAG_union_type
)
8636 /* Look for nested types that can be broken out. */
8637 break_out_comdat_types (c
);
8639 } while (next
!= NULL
);
8642 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
8643 Enter all the cloned children into the hash table decl_table. */
8646 clone_tree_partial (dw_die_ref die
, decl_hash_type
*decl_table
)
8650 struct decl_table_entry
*entry
;
8651 decl_table_entry
**slot
;
8653 if (die
->die_tag
== DW_TAG_subprogram
)
8654 clone
= clone_as_declaration (die
);
8656 clone
= clone_die (die
);
8658 slot
= decl_table
->find_slot_with_hash (die
,
8659 htab_hash_pointer (die
), INSERT
);
8661 /* Assert that DIE isn't in the hash table yet. If it would be there
8662 before, the ancestors would be necessarily there as well, therefore
8663 clone_tree_partial wouldn't be called. */
8664 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
8666 entry
= XCNEW (struct decl_table_entry
);
8668 entry
->copy
= clone
;
8671 if (die
->die_tag
!= DW_TAG_subprogram
)
8672 FOR_EACH_CHILD (die
, c
,
8673 add_child_die (clone
, clone_tree_partial (c
, decl_table
)));
8678 /* Walk the DIE and its children, looking for references to incomplete
8679 or trivial types that are unmarked (i.e., that are not in the current
8683 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type
*decl_table
)
8689 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8691 if (AT_class (a
) == dw_val_class_die_ref
)
8693 dw_die_ref targ
= AT_ref (a
);
8694 decl_table_entry
**slot
;
8695 struct decl_table_entry
*entry
;
8697 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
8700 slot
= decl_table
->find_slot_with_hash (targ
,
8701 htab_hash_pointer (targ
),
8704 if (*slot
!= HTAB_EMPTY_ENTRY
)
8706 /* TARG has already been copied, so we just need to
8707 modify the reference to point to the copy. */
8709 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
8713 dw_die_ref parent
= unit
;
8714 dw_die_ref copy
= clone_die (targ
);
8716 /* Record in DECL_TABLE that TARG has been copied.
8717 Need to do this now, before the recursive call,
8718 because DECL_TABLE may be expanded and SLOT
8719 would no longer be a valid pointer. */
8720 entry
= XCNEW (struct decl_table_entry
);
8725 /* If TARG is not a declaration DIE, we need to copy its
8727 if (!is_declaration_die (targ
))
8731 add_child_die (copy
,
8732 clone_tree_partial (c
, decl_table
)));
8735 /* Make sure the cloned tree is marked as part of the
8739 /* If TARG has surrounding context, copy its ancestor tree
8740 into the new type unit. */
8741 if (targ
->die_parent
!= NULL
8742 && !is_unit_die (targ
->die_parent
))
8743 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
8746 add_child_die (parent
, copy
);
8747 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
8749 /* Make sure the newly-copied DIE is walked. If it was
8750 installed in a previously-added context, it won't
8751 get visited otherwise. */
8754 /* Find the highest point of the newly-added tree,
8755 mark each node along the way, and walk from there. */
8756 parent
->die_mark
= 1;
8757 while (parent
->die_parent
8758 && parent
->die_parent
->die_mark
== 0)
8760 parent
= parent
->die_parent
;
8761 parent
->die_mark
= 1;
8763 copy_decls_walk (unit
, parent
, decl_table
);
8769 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
8772 /* Copy declarations for "unworthy" types into the new comdat section.
8773 Incomplete types, modified types, and certain other types aren't broken
8774 out into comdat sections of their own, so they don't have a signature,
8775 and we need to copy the declaration into the same section so that we
8776 don't have an external reference. */
8779 copy_decls_for_unworthy_types (dw_die_ref unit
)
8782 decl_hash_type
decl_table (10);
8783 copy_decls_walk (unit
, unit
, &decl_table
);
8787 /* Traverse the DIE and add a sibling attribute if it may have the
8788 effect of speeding up access to siblings. To save some space,
8789 avoid generating sibling attributes for DIE's without children. */
8792 add_sibling_attributes (dw_die_ref die
)
8796 if (! die
->die_child
)
8799 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
8800 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
8802 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
8805 /* Output all location lists for the DIE and its children. */
8808 output_location_lists (dw_die_ref die
)
8814 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8815 if (AT_class (a
) == dw_val_class_loc_list
)
8816 output_loc_list (AT_loc_list (a
));
8818 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
8821 /* During assign_location_list_indexes and output_loclists_offset the
8822 current index, after it the number of assigned indexes (i.e. how
8823 large the .debug_loclists* offset table should be). */
8824 static unsigned int loc_list_idx
;
8826 /* Output all location list offsets for the DIE and its children. */
8829 output_loclists_offsets (dw_die_ref die
)
8835 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8836 if (AT_class (a
) == dw_val_class_loc_list
)
8838 dw_loc_list_ref l
= AT_loc_list (a
);
8839 if (l
->offset_emitted
)
8841 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l
->ll_symbol
,
8842 loc_section_label
, NULL
);
8843 gcc_assert (l
->hash
== loc_list_idx
);
8845 l
->offset_emitted
= true;
8848 FOR_EACH_CHILD (die
, c
, output_loclists_offsets (c
));
8851 /* Recursively set indexes of location lists. */
8854 assign_location_list_indexes (dw_die_ref die
)
8860 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8861 if (AT_class (a
) == dw_val_class_loc_list
)
8863 dw_loc_list_ref list
= AT_loc_list (a
);
8864 if (!list
->num_assigned
)
8866 list
->num_assigned
= true;
8867 list
->hash
= loc_list_idx
++;
8871 FOR_EACH_CHILD (die
, c
, assign_location_list_indexes (c
));
8874 /* We want to limit the number of external references, because they are
8875 larger than local references: a relocation takes multiple words, and
8876 even a sig8 reference is always eight bytes, whereas a local reference
8877 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
8878 So if we encounter multiple external references to the same type DIE, we
8879 make a local typedef stub for it and redirect all references there.
8881 This is the element of the hash table for keeping track of these
8891 /* Hashtable helpers. */
8893 struct external_ref_hasher
: free_ptr_hash
<external_ref
>
8895 static inline hashval_t
hash (const external_ref
*);
8896 static inline bool equal (const external_ref
*, const external_ref
*);
8900 external_ref_hasher::hash (const external_ref
*r
)
8902 dw_die_ref die
= r
->type
;
8905 /* We can't use the address of the DIE for hashing, because
8906 that will make the order of the stub DIEs non-deterministic. */
8907 if (! die
->comdat_type_p
)
8908 /* We have a symbol; use it to compute a hash. */
8909 h
= htab_hash_string (die
->die_id
.die_symbol
);
8912 /* We have a type signature; use a subset of the bits as the hash.
8913 The 8-byte signature is at least as large as hashval_t. */
8914 comdat_type_node
*type_node
= die
->die_id
.die_type_node
;
8915 memcpy (&h
, type_node
->signature
, sizeof (h
));
8921 external_ref_hasher::equal (const external_ref
*r1
, const external_ref
*r2
)
8923 return r1
->type
== r2
->type
;
8926 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
8928 /* Return a pointer to the external_ref for references to DIE. */
8930 static struct external_ref
*
8931 lookup_external_ref (external_ref_hash_type
*map
, dw_die_ref die
)
8933 struct external_ref ref
, *ref_p
;
8934 external_ref
**slot
;
8937 slot
= map
->find_slot (&ref
, INSERT
);
8938 if (*slot
!= HTAB_EMPTY_ENTRY
)
8941 ref_p
= XCNEW (struct external_ref
);
8947 /* Subroutine of optimize_external_refs, below.
8949 If we see a type skeleton, record it as our stub. If we see external
8950 references, remember how many we've seen. */
8953 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type
*map
)
8958 struct external_ref
*ref_p
;
8960 if (is_type_die (die
)
8961 && (c
= get_AT_ref (die
, DW_AT_signature
)))
8963 /* This is a local skeleton; use it for local references. */
8964 ref_p
= lookup_external_ref (map
, c
);
8968 /* Scan the DIE references, and remember any that refer to DIEs from
8969 other CUs (i.e. those which are not marked). */
8970 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8971 if (AT_class (a
) == dw_val_class_die_ref
8972 && (c
= AT_ref (a
))->die_mark
== 0
8975 ref_p
= lookup_external_ref (map
, c
);
8979 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
8982 /* htab_traverse callback function for optimize_external_refs, below. SLOT
8983 points to an external_ref, DATA is the CU we're processing. If we don't
8984 already have a local stub, and we have multiple refs, build a stub. */
8987 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
8989 struct external_ref
*ref_p
= *slot
;
8991 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
8993 /* We have multiple references to this type, so build a small stub.
8994 Both of these forms are a bit dodgy from the perspective of the
8995 DWARF standard, since technically they should have names. */
8996 dw_die_ref cu
= data
;
8997 dw_die_ref type
= ref_p
->type
;
8998 dw_die_ref stub
= NULL
;
9000 if (type
->comdat_type_p
)
9002 /* If we refer to this type via sig8, use AT_signature. */
9003 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
9004 add_AT_die_ref (stub
, DW_AT_signature
, type
);
9008 /* Otherwise, use a typedef with no name. */
9009 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
9010 add_AT_die_ref (stub
, DW_AT_type
, type
);
9019 /* DIE is a unit; look through all the DIE references to see if there are
9020 any external references to types, and if so, create local stubs for
9021 them which will be applied in build_abbrev_table. This is useful because
9022 references to local DIEs are smaller. */
9024 static external_ref_hash_type
*
9025 optimize_external_refs (dw_die_ref die
)
9027 external_ref_hash_type
*map
= new external_ref_hash_type (10);
9028 optimize_external_refs_1 (die
, map
);
9029 map
->traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
9033 /* The following 3 variables are temporaries that are computed only during the
9034 build_abbrev_table call and used and released during the following
9035 optimize_abbrev_table call. */
9037 /* First abbrev_id that can be optimized based on usage. */
9038 static unsigned int abbrev_opt_start
;
9040 /* Maximum abbrev_id of a base type plus one (we can't optimize DIEs with
9041 abbrev_id smaller than this, because they must be already sized
9042 during build_abbrev_table). */
9043 static unsigned int abbrev_opt_base_type_end
;
9045 /* Vector of usage counts during build_abbrev_table. Indexed by
9046 abbrev_id - abbrev_opt_start. */
9047 static vec
<unsigned int> abbrev_usage_count
;
9049 /* Vector of all DIEs added with die_abbrev >= abbrev_opt_start. */
9050 static vec
<dw_die_ref
> sorted_abbrev_dies
;
9052 /* The format of each DIE (and its attribute value pairs) is encoded in an
9053 abbreviation table. This routine builds the abbreviation table and assigns
9054 a unique abbreviation id for each abbreviation entry. The children of each
9055 die are visited recursively. */
9058 build_abbrev_table (dw_die_ref die
, external_ref_hash_type
*extern_map
)
9060 unsigned int abbrev_id
= 0;
9066 /* Scan the DIE references, and replace any that refer to
9067 DIEs from other CUs (i.e. those which are not marked) with
9068 the local stubs we built in optimize_external_refs. */
9069 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9070 if (AT_class (a
) == dw_val_class_die_ref
9071 && (c
= AT_ref (a
))->die_mark
== 0)
9073 struct external_ref
*ref_p
;
9074 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
9076 ref_p
= lookup_external_ref (extern_map
, c
);
9077 if (ref_p
->stub
&& ref_p
->stub
!= die
)
9078 change_AT_die_ref (a
, ref_p
->stub
);
9080 /* We aren't changing this reference, so mark it external. */
9081 set_AT_ref_external (a
, 1);
9084 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
9086 dw_attr_node
*die_a
, *abbrev_a
;
9092 if (abbrev
->die_tag
!= die
->die_tag
)
9094 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
9097 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
9100 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
9102 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
9103 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
9104 || (value_format (abbrev_a
) != value_format (die_a
)))
9114 if (abbrev_id
>= vec_safe_length (abbrev_die_table
))
9116 vec_safe_push (abbrev_die_table
, die
);
9117 if (abbrev_opt_start
)
9118 abbrev_usage_count
.safe_push (0);
9120 if (abbrev_opt_start
&& abbrev_id
>= abbrev_opt_start
)
9122 abbrev_usage_count
[abbrev_id
- abbrev_opt_start
]++;
9123 sorted_abbrev_dies
.safe_push (die
);
9126 die
->die_abbrev
= abbrev_id
;
9127 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
9130 /* Callback function for sorted_abbrev_dies vector sorting. We sort
9131 by die_abbrev's usage count, from the most commonly used
9132 abbreviation to the least. */
9135 die_abbrev_cmp (const void *p1
, const void *p2
)
9137 dw_die_ref die1
= *(const dw_die_ref
*) p1
;
9138 dw_die_ref die2
= *(const dw_die_ref
*) p2
;
9140 gcc_checking_assert (die1
->die_abbrev
>= abbrev_opt_start
);
9141 gcc_checking_assert (die2
->die_abbrev
>= abbrev_opt_start
);
9143 if (die1
->die_abbrev
>= abbrev_opt_base_type_end
9144 && die2
->die_abbrev
>= abbrev_opt_base_type_end
)
9146 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
9147 > abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
9149 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
9150 < abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
9154 /* Stabilize the sort. */
9155 if (die1
->die_abbrev
< die2
->die_abbrev
)
9157 if (die1
->die_abbrev
> die2
->die_abbrev
)
9163 /* Convert dw_val_class_const and dw_val_class_unsigned_const class attributes
9164 of DIEs in between sorted_abbrev_dies[first_id] and abbrev_dies[end_id - 1]
9165 into dw_val_class_const_implicit or
9166 dw_val_class_unsigned_const_implicit. */
9169 optimize_implicit_const (unsigned int first_id
, unsigned int end
,
9170 vec
<bool> &implicit_consts
)
9172 /* It never makes sense if there is just one DIE using the abbreviation. */
9173 if (end
< first_id
+ 2)
9178 dw_die_ref die
= sorted_abbrev_dies
[first_id
];
9179 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9180 if (implicit_consts
[ix
])
9182 enum dw_val_class new_class
= dw_val_class_none
;
9183 switch (AT_class (a
))
9185 case dw_val_class_unsigned_const
:
9186 if ((HOST_WIDE_INT
) AT_unsigned (a
) < 0)
9189 /* The .debug_abbrev section will grow by
9190 size_of_sleb128 (AT_unsigned (a)) and we avoid the constants
9191 in all the DIEs using that abbreviation. */
9192 if (constant_size (AT_unsigned (a
)) * (end
- first_id
)
9193 <= (unsigned) size_of_sleb128 (AT_unsigned (a
)))
9196 new_class
= dw_val_class_unsigned_const_implicit
;
9199 case dw_val_class_const
:
9200 new_class
= dw_val_class_const_implicit
;
9203 case dw_val_class_file
:
9204 new_class
= dw_val_class_file_implicit
;
9210 for (i
= first_id
; i
< end
; i
++)
9211 (*sorted_abbrev_dies
[i
]->die_attr
)[ix
].dw_attr_val
.val_class
9216 /* Attempt to optimize abbreviation table from abbrev_opt_start
9217 abbreviation above. */
9220 optimize_abbrev_table (void)
9222 if (abbrev_opt_start
9223 && vec_safe_length (abbrev_die_table
) > abbrev_opt_start
9224 && (dwarf_version
>= 5 || vec_safe_length (abbrev_die_table
) > 127))
9226 auto_vec
<bool, 32> implicit_consts
;
9227 sorted_abbrev_dies
.qsort (die_abbrev_cmp
);
9229 unsigned int abbrev_id
= abbrev_opt_start
- 1;
9230 unsigned int first_id
= ~0U;
9231 unsigned int last_abbrev_id
= 0;
9234 if (abbrev_opt_base_type_end
> abbrev_opt_start
)
9235 abbrev_id
= abbrev_opt_base_type_end
- 1;
9236 /* Reassign abbreviation ids from abbrev_opt_start above, so that
9237 most commonly used abbreviations come first. */
9238 FOR_EACH_VEC_ELT (sorted_abbrev_dies
, i
, die
)
9243 /* If calc_base_type_die_sizes has been called, the CU and
9244 base types after it can't be optimized, because we've already
9245 calculated their DIE offsets. We've sorted them first. */
9246 if (die
->die_abbrev
< abbrev_opt_base_type_end
)
9248 if (die
->die_abbrev
!= last_abbrev_id
)
9250 last_abbrev_id
= die
->die_abbrev
;
9251 if (dwarf_version
>= 5 && first_id
!= ~0U)
9252 optimize_implicit_const (first_id
, i
, implicit_consts
);
9254 (*abbrev_die_table
)[abbrev_id
] = die
;
9255 if (dwarf_version
>= 5)
9258 implicit_consts
.truncate (0);
9260 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9261 switch (AT_class (a
))
9263 case dw_val_class_const
:
9264 case dw_val_class_unsigned_const
:
9265 case dw_val_class_file
:
9266 implicit_consts
.safe_push (true);
9269 implicit_consts
.safe_push (false);
9274 else if (dwarf_version
>= 5)
9276 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9277 if (!implicit_consts
[ix
])
9281 dw_attr_node
*other_a
9282 = &(*(*abbrev_die_table
)[abbrev_id
]->die_attr
)[ix
];
9283 if (!dw_val_equal_p (&a
->dw_attr_val
,
9284 &other_a
->dw_attr_val
))
9285 implicit_consts
[ix
] = false;
9288 die
->die_abbrev
= abbrev_id
;
9290 gcc_assert (abbrev_id
== vec_safe_length (abbrev_die_table
) - 1);
9291 if (dwarf_version
>= 5 && first_id
!= ~0U)
9292 optimize_implicit_const (first_id
, i
, implicit_consts
);
9295 abbrev_opt_start
= 0;
9296 abbrev_opt_base_type_end
= 0;
9297 abbrev_usage_count
.release ();
9298 sorted_abbrev_dies
.release ();
9301 /* Return the power-of-two number of bytes necessary to represent VALUE. */
9304 constant_size (unsigned HOST_WIDE_INT value
)
9311 log
= floor_log2 (value
);
9314 log
= 1 << (floor_log2 (log
) + 1);
9319 /* Return the size of a DIE as it is represented in the
9320 .debug_info section. */
9322 static unsigned long
9323 size_of_die (dw_die_ref die
)
9325 unsigned long size
= 0;
9328 enum dwarf_form form
;
9330 size
+= size_of_uleb128 (die
->die_abbrev
);
9331 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9333 switch (AT_class (a
))
9335 case dw_val_class_addr
:
9336 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9338 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9339 size
+= size_of_uleb128 (AT_index (a
));
9342 size
+= DWARF2_ADDR_SIZE
;
9344 case dw_val_class_offset
:
9345 size
+= DWARF_OFFSET_SIZE
;
9347 case dw_val_class_loc
:
9349 unsigned long lsize
= size_of_locs (AT_loc (a
));
9352 if (dwarf_version
>= 4)
9353 size
+= size_of_uleb128 (lsize
);
9355 size
+= constant_size (lsize
);
9359 case dw_val_class_loc_list
:
9360 case dw_val_class_view_list
:
9361 if (dwarf_split_debug_info
&& dwarf_version
>= 5)
9363 gcc_assert (AT_loc_list (a
)->num_assigned
);
9364 size
+= size_of_uleb128 (AT_loc_list (a
)->hash
);
9367 size
+= DWARF_OFFSET_SIZE
;
9369 case dw_val_class_range_list
:
9370 if (value_format (a
) == DW_FORM_rnglistx
)
9372 gcc_assert (rnglist_idx
);
9373 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
9374 size
+= size_of_uleb128 (r
->idx
);
9377 size
+= DWARF_OFFSET_SIZE
;
9379 case dw_val_class_const
:
9380 size
+= size_of_sleb128 (AT_int (a
));
9382 case dw_val_class_unsigned_const
:
9384 int csize
= constant_size (AT_unsigned (a
));
9385 if (dwarf_version
== 3
9386 && a
->dw_attr
== DW_AT_data_member_location
9388 size
+= size_of_uleb128 (AT_unsigned (a
));
9393 case dw_val_class_symview
:
9394 if (symview_upper_bound
<= 0xff)
9396 else if (symview_upper_bound
<= 0xffff)
9398 else if (symview_upper_bound
<= 0xffffffff)
9403 case dw_val_class_const_implicit
:
9404 case dw_val_class_unsigned_const_implicit
:
9405 case dw_val_class_file_implicit
:
9406 /* These occupy no size in the DIE, just an extra sleb128 in
9409 case dw_val_class_const_double
:
9410 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
9411 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
9414 case dw_val_class_wide_int
:
9415 size
+= (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9416 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
9417 if (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9418 * HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
9421 case dw_val_class_vec
:
9422 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
9423 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
9424 + a
->dw_attr_val
.v
.val_vec
.length
9425 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
9427 case dw_val_class_flag
:
9428 if (dwarf_version
>= 4)
9429 /* Currently all add_AT_flag calls pass in 1 as last argument,
9430 so DW_FORM_flag_present can be used. If that ever changes,
9431 we'll need to use DW_FORM_flag and have some optimization
9432 in build_abbrev_table that will change those to
9433 DW_FORM_flag_present if it is set to 1 in all DIEs using
9434 the same abbrev entry. */
9435 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9439 case dw_val_class_die_ref
:
9440 if (AT_ref_external (a
))
9442 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
9443 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
9444 is sized by target address length, whereas in DWARF3
9445 it's always sized as an offset. */
9446 if (use_debug_types
)
9447 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
9448 else if (dwarf_version
== 2)
9449 size
+= DWARF2_ADDR_SIZE
;
9451 size
+= DWARF_OFFSET_SIZE
;
9454 size
+= DWARF_OFFSET_SIZE
;
9456 case dw_val_class_fde_ref
:
9457 size
+= DWARF_OFFSET_SIZE
;
9459 case dw_val_class_lbl_id
:
9460 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9462 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9463 size
+= size_of_uleb128 (AT_index (a
));
9466 size
+= DWARF2_ADDR_SIZE
;
9468 case dw_val_class_lineptr
:
9469 case dw_val_class_macptr
:
9470 case dw_val_class_loclistsptr
:
9471 size
+= DWARF_OFFSET_SIZE
;
9473 case dw_val_class_str
:
9474 form
= AT_string_form (a
);
9475 if (form
== DW_FORM_strp
|| form
== DW_FORM_line_strp
)
9476 size
+= DWARF_OFFSET_SIZE
;
9477 else if (form
== dwarf_FORM (DW_FORM_strx
))
9478 size
+= size_of_uleb128 (AT_index (a
));
9480 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
9482 case dw_val_class_file
:
9483 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
9485 case dw_val_class_data8
:
9488 case dw_val_class_vms_delta
:
9489 size
+= DWARF_OFFSET_SIZE
;
9491 case dw_val_class_high_pc
:
9492 size
+= DWARF2_ADDR_SIZE
;
9494 case dw_val_class_discr_value
:
9495 size
+= size_of_discr_value (&a
->dw_attr_val
.v
.val_discr_value
);
9497 case dw_val_class_discr_list
:
9499 unsigned block_size
= size_of_discr_list (AT_discr_list (a
));
9501 /* This is a block, so we have the block length and then its
9503 size
+= constant_size (block_size
) + block_size
;
9514 /* Size the debugging information associated with a given DIE. Visits the
9515 DIE's children recursively. Updates the global variable next_die_offset, on
9516 each time through. Uses the current value of next_die_offset to update the
9517 die_offset field in each DIE. */
9520 calc_die_sizes (dw_die_ref die
)
9524 gcc_assert (die
->die_offset
== 0
9525 || (unsigned long int) die
->die_offset
== next_die_offset
);
9526 die
->die_offset
= next_die_offset
;
9527 next_die_offset
+= size_of_die (die
);
9529 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
9531 if (die
->die_child
!= NULL
)
9532 /* Count the null byte used to terminate sibling lists. */
9533 next_die_offset
+= 1;
9536 /* Size just the base type children at the start of the CU.
9537 This is needed because build_abbrev needs to size locs
9538 and sizing of type based stack ops needs to know die_offset
9539 values for the base types. */
9542 calc_base_type_die_sizes (void)
9544 unsigned long die_offset
= (dwarf_split_debug_info
9545 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
9546 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
9548 dw_die_ref base_type
;
9549 #if ENABLE_ASSERT_CHECKING
9550 dw_die_ref prev
= comp_unit_die ()->die_child
;
9553 die_offset
+= size_of_die (comp_unit_die ());
9554 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
9556 #if ENABLE_ASSERT_CHECKING
9557 gcc_assert (base_type
->die_offset
== 0
9558 && prev
->die_sib
== base_type
9559 && base_type
->die_child
== NULL
9560 && base_type
->die_abbrev
);
9563 if (abbrev_opt_start
9564 && base_type
->die_abbrev
>= abbrev_opt_base_type_end
)
9565 abbrev_opt_base_type_end
= base_type
->die_abbrev
+ 1;
9566 base_type
->die_offset
= die_offset
;
9567 die_offset
+= size_of_die (base_type
);
9571 /* Set the marks for a die and its children. We do this so
9572 that we know whether or not a reference needs to use FORM_ref_addr; only
9573 DIEs in the same CU will be marked. We used to clear out the offset
9574 and use that as the flag, but ran into ordering problems. */
9577 mark_dies (dw_die_ref die
)
9581 gcc_assert (!die
->die_mark
);
9584 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
9587 /* Clear the marks for a die and its children. */
9590 unmark_dies (dw_die_ref die
)
9594 if (! use_debug_types
)
9595 gcc_assert (die
->die_mark
);
9598 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
9601 /* Clear the marks for a die, its children and referred dies. */
9604 unmark_all_dies (dw_die_ref die
)
9614 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
9616 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9617 if (AT_class (a
) == dw_val_class_die_ref
)
9618 unmark_all_dies (AT_ref (a
));
9621 /* Calculate if the entry should appear in the final output file. It may be
9622 from a pruned a type. */
9625 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
9627 /* By limiting gnu pubnames to definitions only, gold can generate a
9628 gdb index without entries for declarations, which don't include
9629 enough information to be useful. */
9630 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
9633 if (table
== pubname_table
)
9635 /* Enumerator names are part of the pubname table, but the
9636 parent DW_TAG_enumeration_type die may have been pruned.
9637 Don't output them if that is the case. */
9638 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
9639 (p
->die
->die_parent
== NULL
9640 || !p
->die
->die_parent
->die_perennial_p
))
9643 /* Everything else in the pubname table is included. */
9647 /* The pubtypes table shouldn't include types that have been
9649 return (p
->die
->die_offset
!= 0
9650 || !flag_eliminate_unused_debug_types
);
9653 /* Return the size of the .debug_pubnames or .debug_pubtypes table
9654 generated for the compilation unit. */
9656 static unsigned long
9657 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9662 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
9664 size
= DWARF_PUBNAMES_HEADER_SIZE
;
9665 FOR_EACH_VEC_ELT (*names
, i
, p
)
9666 if (include_pubname_in_output (names
, p
))
9667 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1 + space_for_flags
;
9669 size
+= DWARF_OFFSET_SIZE
;
9673 /* Return the size of the information in the .debug_aranges section. */
9675 static unsigned long
9676 size_of_aranges (void)
9680 size
= DWARF_ARANGES_HEADER_SIZE
;
9682 /* Count the address/length pair for this compilation unit. */
9683 if (text_section_used
)
9684 size
+= 2 * DWARF2_ADDR_SIZE
;
9685 if (cold_text_section_used
)
9686 size
+= 2 * DWARF2_ADDR_SIZE
;
9687 if (have_multiple_function_sections
)
9692 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
9694 if (DECL_IGNORED_P (fde
->decl
))
9696 if (!fde
->in_std_section
)
9697 size
+= 2 * DWARF2_ADDR_SIZE
;
9698 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
9699 size
+= 2 * DWARF2_ADDR_SIZE
;
9703 /* Count the two zero words used to terminated the address range table. */
9704 size
+= 2 * DWARF2_ADDR_SIZE
;
9708 /* Select the encoding of an attribute value. */
9710 static enum dwarf_form
9711 value_format (dw_attr_node
*a
)
9713 switch (AT_class (a
))
9715 case dw_val_class_addr
:
9716 /* Only very few attributes allow DW_FORM_addr. */
9721 case DW_AT_entry_pc
:
9722 case DW_AT_trampoline
:
9723 return (AT_index (a
) == NOT_INDEXED
9724 ? DW_FORM_addr
: dwarf_FORM (DW_FORM_addrx
));
9728 switch (DWARF2_ADDR_SIZE
)
9731 return DW_FORM_data1
;
9733 return DW_FORM_data2
;
9735 return DW_FORM_data4
;
9737 return DW_FORM_data8
;
9741 case dw_val_class_loc_list
:
9742 case dw_val_class_view_list
:
9743 if (dwarf_split_debug_info
9744 && dwarf_version
>= 5
9745 && AT_loc_list (a
)->num_assigned
)
9746 return DW_FORM_loclistx
;
9748 case dw_val_class_range_list
:
9749 /* For range lists in DWARF 5, use DW_FORM_rnglistx from .debug_info.dwo
9750 but in .debug_info use DW_FORM_sec_offset, which is shorter if we
9751 care about sizes of .debug* sections in shared libraries and
9752 executables and don't take into account relocations that affect just
9753 relocatable objects - for DW_FORM_rnglistx we'd have to emit offset
9754 table in the .debug_rnglists section. */
9755 if (dwarf_split_debug_info
9756 && dwarf_version
>= 5
9757 && AT_class (a
) == dw_val_class_range_list
9759 && a
->dw_attr_val
.val_entry
!= RELOCATED_OFFSET
)
9760 return DW_FORM_rnglistx
;
9761 if (dwarf_version
>= 4)
9762 return DW_FORM_sec_offset
;
9764 case dw_val_class_vms_delta
:
9765 case dw_val_class_offset
:
9766 switch (DWARF_OFFSET_SIZE
)
9769 return DW_FORM_data4
;
9771 return DW_FORM_data8
;
9775 case dw_val_class_loc
:
9776 if (dwarf_version
>= 4)
9777 return DW_FORM_exprloc
;
9778 switch (constant_size (size_of_locs (AT_loc (a
))))
9781 return DW_FORM_block1
;
9783 return DW_FORM_block2
;
9785 return DW_FORM_block4
;
9789 case dw_val_class_const
:
9790 return DW_FORM_sdata
;
9791 case dw_val_class_unsigned_const
:
9792 switch (constant_size (AT_unsigned (a
)))
9795 return DW_FORM_data1
;
9797 return DW_FORM_data2
;
9799 /* In DWARF3 DW_AT_data_member_location with
9800 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
9801 constant, so we need to use DW_FORM_udata if we need
9802 a large constant. */
9803 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9804 return DW_FORM_udata
;
9805 return DW_FORM_data4
;
9807 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9808 return DW_FORM_udata
;
9809 return DW_FORM_data8
;
9813 case dw_val_class_const_implicit
:
9814 case dw_val_class_unsigned_const_implicit
:
9815 case dw_val_class_file_implicit
:
9816 return DW_FORM_implicit_const
;
9817 case dw_val_class_const_double
:
9818 switch (HOST_BITS_PER_WIDE_INT
)
9821 return DW_FORM_data2
;
9823 return DW_FORM_data4
;
9825 return DW_FORM_data8
;
9827 if (dwarf_version
>= 5)
9828 return DW_FORM_data16
;
9831 return DW_FORM_block1
;
9833 case dw_val_class_wide_int
:
9834 switch (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
)
9837 return DW_FORM_data1
;
9839 return DW_FORM_data2
;
9841 return DW_FORM_data4
;
9843 return DW_FORM_data8
;
9845 if (dwarf_version
>= 5)
9846 return DW_FORM_data16
;
9849 return DW_FORM_block1
;
9851 case dw_val_class_symview
:
9852 /* ??? We might use uleb128, but then we'd have to compute
9853 .debug_info offsets in the assembler. */
9854 if (symview_upper_bound
<= 0xff)
9855 return DW_FORM_data1
;
9856 else if (symview_upper_bound
<= 0xffff)
9857 return DW_FORM_data2
;
9858 else if (symview_upper_bound
<= 0xffffffff)
9859 return DW_FORM_data4
;
9861 return DW_FORM_data8
;
9862 case dw_val_class_vec
:
9863 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
9864 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
9867 return DW_FORM_block1
;
9869 return DW_FORM_block2
;
9871 return DW_FORM_block4
;
9875 case dw_val_class_flag
:
9876 if (dwarf_version
>= 4)
9878 /* Currently all add_AT_flag calls pass in 1 as last argument,
9879 so DW_FORM_flag_present can be used. If that ever changes,
9880 we'll need to use DW_FORM_flag and have some optimization
9881 in build_abbrev_table that will change those to
9882 DW_FORM_flag_present if it is set to 1 in all DIEs using
9883 the same abbrev entry. */
9884 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9885 return DW_FORM_flag_present
;
9887 return DW_FORM_flag
;
9888 case dw_val_class_die_ref
:
9889 if (AT_ref_external (a
))
9890 return use_debug_types
? DW_FORM_ref_sig8
: DW_FORM_ref_addr
;
9893 case dw_val_class_fde_ref
:
9894 return DW_FORM_data
;
9895 case dw_val_class_lbl_id
:
9896 return (AT_index (a
) == NOT_INDEXED
9897 ? DW_FORM_addr
: dwarf_FORM (DW_FORM_addrx
));
9898 case dw_val_class_lineptr
:
9899 case dw_val_class_macptr
:
9900 case dw_val_class_loclistsptr
:
9901 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
9902 case dw_val_class_str
:
9903 return AT_string_form (a
);
9904 case dw_val_class_file
:
9905 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
9908 return DW_FORM_data1
;
9910 return DW_FORM_data2
;
9912 return DW_FORM_data4
;
9917 case dw_val_class_data8
:
9918 return DW_FORM_data8
;
9920 case dw_val_class_high_pc
:
9921 switch (DWARF2_ADDR_SIZE
)
9924 return DW_FORM_data1
;
9926 return DW_FORM_data2
;
9928 return DW_FORM_data4
;
9930 return DW_FORM_data8
;
9935 case dw_val_class_discr_value
:
9936 return (a
->dw_attr_val
.v
.val_discr_value
.pos
9939 case dw_val_class_discr_list
:
9940 switch (constant_size (size_of_discr_list (AT_discr_list (a
))))
9943 return DW_FORM_block1
;
9945 return DW_FORM_block2
;
9947 return DW_FORM_block4
;
9957 /* Output the encoding of an attribute value. */
9960 output_value_format (dw_attr_node
*a
)
9962 enum dwarf_form form
= value_format (a
);
9964 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
9967 /* Given a die and id, produce the appropriate abbreviations. */
9970 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
9973 dw_attr_node
*a_attr
;
9975 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
9976 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
9977 dwarf_tag_name (abbrev
->die_tag
));
9979 if (abbrev
->die_child
!= NULL
)
9980 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
9982 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
9984 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
9986 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
9987 dwarf_attr_name (a_attr
->dw_attr
));
9988 output_value_format (a_attr
);
9989 if (value_format (a_attr
) == DW_FORM_implicit_const
)
9991 if (AT_class (a_attr
) == dw_val_class_file_implicit
)
9993 int f
= maybe_emit_file (a_attr
->dw_attr_val
.v
.val_file
);
9994 const char *filename
= a_attr
->dw_attr_val
.v
.val_file
->filename
;
9995 dw2_asm_output_data_sleb128 (f
, "(%s)", filename
);
9998 dw2_asm_output_data_sleb128 (a_attr
->dw_attr_val
.v
.val_int
, NULL
);
10002 dw2_asm_output_data (1, 0, NULL
);
10003 dw2_asm_output_data (1, 0, NULL
);
10007 /* Output the .debug_abbrev section which defines the DIE abbreviation
10011 output_abbrev_section (void)
10013 unsigned int abbrev_id
;
10016 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
10017 if (abbrev_id
!= 0)
10018 output_die_abbrevs (abbrev_id
, abbrev
);
10020 /* Terminate the table. */
10021 dw2_asm_output_data (1, 0, NULL
);
10024 /* Return a new location list, given the begin and end range, and the
10027 static inline dw_loc_list_ref
10028 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, var_loc_view vbegin
,
10029 const char *end
, var_loc_view vend
,
10030 const char *section
)
10032 dw_loc_list_ref retlist
= ggc_cleared_alloc
<dw_loc_list_node
> ();
10034 retlist
->begin
= begin
;
10035 retlist
->begin_entry
= NULL
;
10036 retlist
->end
= end
;
10037 retlist
->expr
= expr
;
10038 retlist
->section
= section
;
10039 retlist
->vbegin
= vbegin
;
10040 retlist
->vend
= vend
;
10045 /* Return true iff there's any nonzero view number in the loc list.
10047 ??? When views are not enabled, we'll often extend a single range
10048 to the entire function, so that we emit a single location
10049 expression rather than a location list. With views, even with a
10050 single range, we'll output a list if start or end have a nonzero
10051 view. If we change this, we may want to stop splitting a single
10052 range in dw_loc_list just because of a nonzero view, even if it
10053 straddles across hot/cold partitions. */
10056 loc_list_has_views (dw_loc_list_ref list
)
10058 if (!debug_variable_location_views
)
10061 for (dw_loc_list_ref loc
= list
;
10062 loc
!= NULL
; loc
= loc
->dw_loc_next
)
10063 if (!ZERO_VIEW_P (loc
->vbegin
) || !ZERO_VIEW_P (loc
->vend
))
10069 /* Generate a new internal symbol for this location list node, if it
10070 hasn't got one yet. */
10073 gen_llsym (dw_loc_list_ref list
)
10075 gcc_assert (!list
->ll_symbol
);
10076 list
->ll_symbol
= gen_internal_sym ("LLST");
10078 if (!loc_list_has_views (list
))
10081 if (dwarf2out_locviews_in_attribute ())
10083 /* Use the same label_num for the view list. */
10085 list
->vl_symbol
= gen_internal_sym ("LVUS");
10088 list
->vl_symbol
= list
->ll_symbol
;
10091 /* Generate a symbol for the list, but only if we really want to emit
10095 maybe_gen_llsym (dw_loc_list_ref list
)
10097 if (!list
|| (!list
->dw_loc_next
&& !loc_list_has_views (list
)))
10103 /* Determine whether or not to skip loc_list entry CURR. If SIZEP is
10104 NULL, don't consider size of the location expression. If we're not
10105 to skip it, and SIZEP is non-null, store the size of CURR->expr's
10106 representation in *SIZEP. */
10109 skip_loc_list_entry (dw_loc_list_ref curr
, unsigned long *sizep
= NULL
)
10111 /* Don't output an entry that starts and ends at the same address. */
10112 if (strcmp (curr
->begin
, curr
->end
) == 0
10113 && curr
->vbegin
== curr
->vend
&& !curr
->force
)
10119 unsigned long size
= size_of_locs (curr
->expr
);
10121 /* If the expression is too large, drop it on the floor. We could
10122 perhaps put it into DW_TAG_dwarf_procedure and refer to that
10123 in the expression, but >= 64KB expressions for a single value
10124 in a single range are unlikely very useful. */
10125 if (dwarf_version
< 5 && size
> 0xffff)
10133 /* Output a view pair loclist entry for CURR, if it requires one. */
10136 dwarf2out_maybe_output_loclist_view_pair (dw_loc_list_ref curr
)
10138 if (!dwarf2out_locviews_in_loclist ())
10141 if (ZERO_VIEW_P (curr
->vbegin
) && ZERO_VIEW_P (curr
->vend
))
10144 #ifdef DW_LLE_view_pair
10145 dw2_asm_output_data (1, DW_LLE_view_pair
, "DW_LLE_view_pair");
10147 if (dwarf2out_as_locview_support
)
10149 if (ZERO_VIEW_P (curr
->vbegin
))
10150 dw2_asm_output_data_uleb128 (0, "Location view begin");
10153 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10154 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vbegin
);
10155 dw2_asm_output_symname_uleb128 (label
, "Location view begin");
10158 if (ZERO_VIEW_P (curr
->vend
))
10159 dw2_asm_output_data_uleb128 (0, "Location view end");
10162 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10163 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vend
);
10164 dw2_asm_output_symname_uleb128 (label
, "Location view end");
10169 dw2_asm_output_data_uleb128 (curr
->vbegin
, "Location view begin");
10170 dw2_asm_output_data_uleb128 (curr
->vend
, "Location view end");
10172 #endif /* DW_LLE_view_pair */
10177 /* Output the location list given to us. */
10180 output_loc_list (dw_loc_list_ref list_head
)
10182 int vcount
= 0, lcount
= 0;
10184 if (list_head
->emitted
)
10186 list_head
->emitted
= true;
10188 if (list_head
->vl_symbol
&& dwarf2out_locviews_in_attribute ())
10190 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->vl_symbol
);
10192 for (dw_loc_list_ref curr
= list_head
; curr
!= NULL
;
10193 curr
= curr
->dw_loc_next
)
10195 unsigned long size
;
10197 if (skip_loc_list_entry (curr
, &size
))
10202 /* ?? dwarf_split_debug_info? */
10203 if (dwarf2out_as_locview_support
)
10205 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10207 if (!ZERO_VIEW_P (curr
->vbegin
))
10209 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vbegin
);
10210 dw2_asm_output_symname_uleb128 (label
,
10211 "View list begin (%s)",
10212 list_head
->vl_symbol
);
10215 dw2_asm_output_data_uleb128 (0,
10216 "View list begin (%s)",
10217 list_head
->vl_symbol
);
10219 if (!ZERO_VIEW_P (curr
->vend
))
10221 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vend
);
10222 dw2_asm_output_symname_uleb128 (label
,
10223 "View list end (%s)",
10224 list_head
->vl_symbol
);
10227 dw2_asm_output_data_uleb128 (0,
10228 "View list end (%s)",
10229 list_head
->vl_symbol
);
10233 dw2_asm_output_data_uleb128 (curr
->vbegin
,
10234 "View list begin (%s)",
10235 list_head
->vl_symbol
);
10236 dw2_asm_output_data_uleb128 (curr
->vend
,
10237 "View list end (%s)",
10238 list_head
->vl_symbol
);
10243 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
10245 const char *last_section
= NULL
;
10246 const char *base_label
= NULL
;
10248 /* Walk the location list, and output each range + expression. */
10249 for (dw_loc_list_ref curr
= list_head
; curr
!= NULL
;
10250 curr
= curr
->dw_loc_next
)
10252 unsigned long size
;
10254 /* Skip this entry? If we skip it here, we must skip it in the
10255 view list above as well. */
10256 if (skip_loc_list_entry (curr
, &size
))
10261 if (dwarf_version
>= 5)
10263 if (dwarf_split_debug_info
)
10265 dwarf2out_maybe_output_loclist_view_pair (curr
);
10266 /* For -gsplit-dwarf, emit DW_LLE_starx_length, which has
10267 uleb128 index into .debug_addr and uleb128 length. */
10268 dw2_asm_output_data (1, DW_LLE_startx_length
,
10269 "DW_LLE_startx_length (%s)",
10270 list_head
->ll_symbol
);
10271 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10272 "Location list range start index "
10273 "(%s)", curr
->begin
);
10274 /* FIXME: This will ICE ifndef HAVE_AS_LEB128.
10275 For that case we probably need to emit DW_LLE_startx_endx,
10276 but we'd need 2 .debug_addr entries rather than just one. */
10277 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
10278 "Location list length (%s)",
10279 list_head
->ll_symbol
);
10281 else if (!have_multiple_function_sections
&& HAVE_AS_LEB128
)
10283 dwarf2out_maybe_output_loclist_view_pair (curr
);
10284 /* If all code is in .text section, the base address is
10285 already provided by the CU attributes. Use
10286 DW_LLE_offset_pair where both addresses are uleb128 encoded
10287 offsets against that base. */
10288 dw2_asm_output_data (1, DW_LLE_offset_pair
,
10289 "DW_LLE_offset_pair (%s)",
10290 list_head
->ll_symbol
);
10291 dw2_asm_output_delta_uleb128 (curr
->begin
, curr
->section
,
10292 "Location list begin address (%s)",
10293 list_head
->ll_symbol
);
10294 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->section
,
10295 "Location list end address (%s)",
10296 list_head
->ll_symbol
);
10298 else if (HAVE_AS_LEB128
)
10300 /* Otherwise, find out how many consecutive entries could share
10301 the same base entry. If just one, emit DW_LLE_start_length,
10302 otherwise emit DW_LLE_base_address for the base address
10303 followed by a series of DW_LLE_offset_pair. */
10304 if (last_section
== NULL
|| curr
->section
!= last_section
)
10306 dw_loc_list_ref curr2
;
10307 for (curr2
= curr
->dw_loc_next
; curr2
!= NULL
;
10308 curr2
= curr2
->dw_loc_next
)
10310 if (strcmp (curr2
->begin
, curr2
->end
) == 0
10315 if (curr2
== NULL
|| curr
->section
!= curr2
->section
)
10316 last_section
= NULL
;
10319 last_section
= curr
->section
;
10320 base_label
= curr
->begin
;
10321 dw2_asm_output_data (1, DW_LLE_base_address
,
10322 "DW_LLE_base_address (%s)",
10323 list_head
->ll_symbol
);
10324 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, base_label
,
10325 "Base address (%s)",
10326 list_head
->ll_symbol
);
10329 /* Only one entry with the same base address. Use
10330 DW_LLE_start_length with absolute address and uleb128
10332 if (last_section
== NULL
)
10334 dwarf2out_maybe_output_loclist_view_pair (curr
);
10335 dw2_asm_output_data (1, DW_LLE_start_length
,
10336 "DW_LLE_start_length (%s)",
10337 list_head
->ll_symbol
);
10338 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10339 "Location list begin address (%s)",
10340 list_head
->ll_symbol
);
10341 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
10342 "Location list length "
10343 "(%s)", list_head
->ll_symbol
);
10345 /* Otherwise emit DW_LLE_offset_pair, relative to above emitted
10346 DW_LLE_base_address. */
10349 dwarf2out_maybe_output_loclist_view_pair (curr
);
10350 dw2_asm_output_data (1, DW_LLE_offset_pair
,
10351 "DW_LLE_offset_pair (%s)",
10352 list_head
->ll_symbol
);
10353 dw2_asm_output_delta_uleb128 (curr
->begin
, base_label
,
10354 "Location list begin address "
10355 "(%s)", list_head
->ll_symbol
);
10356 dw2_asm_output_delta_uleb128 (curr
->end
, base_label
,
10357 "Location list end address "
10358 "(%s)", list_head
->ll_symbol
);
10361 /* The assembler does not support .uleb128 directive. Emit
10362 DW_LLE_start_end with a pair of absolute addresses. */
10365 dwarf2out_maybe_output_loclist_view_pair (curr
);
10366 dw2_asm_output_data (1, DW_LLE_start_end
,
10367 "DW_LLE_start_end (%s)",
10368 list_head
->ll_symbol
);
10369 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10370 "Location list begin address (%s)",
10371 list_head
->ll_symbol
);
10372 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10373 "Location list end address (%s)",
10374 list_head
->ll_symbol
);
10377 else if (dwarf_split_debug_info
)
10379 /* For -gsplit-dwarf -gdwarf-{2,3,4} emit index into .debug_addr
10380 and 4 byte length. */
10381 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
10382 "Location list start/length entry (%s)",
10383 list_head
->ll_symbol
);
10384 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10385 "Location list range start index (%s)",
10387 /* The length field is 4 bytes. If we ever need to support
10388 an 8-byte length, we can add a new DW_LLE code or fall back
10389 to DW_LLE_GNU_start_end_entry. */
10390 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
10391 "Location list range length (%s)",
10392 list_head
->ll_symbol
);
10394 else if (!have_multiple_function_sections
)
10396 /* Pair of relative addresses against start of text section. */
10397 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
10398 "Location list begin address (%s)",
10399 list_head
->ll_symbol
);
10400 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
10401 "Location list end address (%s)",
10402 list_head
->ll_symbol
);
10406 /* Pair of absolute addresses. */
10407 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10408 "Location list begin address (%s)",
10409 list_head
->ll_symbol
);
10410 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10411 "Location list end address (%s)",
10412 list_head
->ll_symbol
);
10415 /* Output the block length for this list of location operations. */
10416 if (dwarf_version
>= 5)
10417 dw2_asm_output_data_uleb128 (size
, "Location expression size");
10420 gcc_assert (size
<= 0xffff);
10421 dw2_asm_output_data (2, size
, "Location expression size");
10424 output_loc_sequence (curr
->expr
, -1);
10427 /* And finally list termination. */
10428 if (dwarf_version
>= 5)
10429 dw2_asm_output_data (1, DW_LLE_end_of_list
,
10430 "DW_LLE_end_of_list (%s)", list_head
->ll_symbol
);
10431 else if (dwarf_split_debug_info
)
10432 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
10433 "Location list terminator (%s)",
10434 list_head
->ll_symbol
);
10437 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10438 "Location list terminator begin (%s)",
10439 list_head
->ll_symbol
);
10440 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10441 "Location list terminator end (%s)",
10442 list_head
->ll_symbol
);
10445 gcc_assert (!list_head
->vl_symbol
10446 || vcount
== lcount
* (dwarf2out_locviews_in_attribute () ? 1 : 0));
10449 /* Output a range_list offset into the .debug_ranges or .debug_rnglists
10450 section. Emit a relocated reference if val_entry is NULL, otherwise,
10451 emit an indirect reference. */
10454 output_range_list_offset (dw_attr_node
*a
)
10456 const char *name
= dwarf_attr_name (a
->dw_attr
);
10458 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
10460 if (dwarf_version
>= 5)
10462 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
10463 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, r
->label
,
10464 debug_ranges_section
, "%s", name
);
10468 char *p
= strchr (ranges_section_label
, '\0');
10469 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
10470 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
);
10471 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
10472 debug_ranges_section
, "%s", name
);
10476 else if (dwarf_version
>= 5)
10478 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
10479 gcc_assert (rnglist_idx
);
10480 dw2_asm_output_data_uleb128 (r
->idx
, "%s", name
);
10483 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
10484 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
,
10485 "%s (offset from %s)", name
, ranges_section_label
);
10488 /* Output the offset into the debug_loc section. */
10491 output_loc_list_offset (dw_attr_node
*a
)
10493 char *sym
= AT_loc_list (a
)->ll_symbol
;
10496 if (!dwarf_split_debug_info
)
10497 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
10498 "%s", dwarf_attr_name (a
->dw_attr
));
10499 else if (dwarf_version
>= 5)
10501 gcc_assert (AT_loc_list (a
)->num_assigned
);
10502 dw2_asm_output_data_uleb128 (AT_loc_list (a
)->hash
, "%s (%s)",
10503 dwarf_attr_name (a
->dw_attr
),
10507 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
10508 "%s", dwarf_attr_name (a
->dw_attr
));
10511 /* Output the offset into the debug_loc section. */
10514 output_view_list_offset (dw_attr_node
*a
)
10516 char *sym
= (*AT_loc_list_ptr (a
))->vl_symbol
;
10519 if (dwarf_split_debug_info
)
10520 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
10521 "%s", dwarf_attr_name (a
->dw_attr
));
10523 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
10524 "%s", dwarf_attr_name (a
->dw_attr
));
10527 /* Output an attribute's index or value appropriately. */
10530 output_attr_index_or_value (dw_attr_node
*a
)
10532 const char *name
= dwarf_attr_name (a
->dw_attr
);
10534 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
10536 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
10539 switch (AT_class (a
))
10541 case dw_val_class_addr
:
10542 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
10544 case dw_val_class_high_pc
:
10545 case dw_val_class_lbl_id
:
10546 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
10549 gcc_unreachable ();
10553 /* Output a type signature. */
10556 output_signature (const char *sig
, const char *name
)
10560 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
10561 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
10564 /* Output a discriminant value. */
10567 output_discr_value (dw_discr_value
*discr_value
, const char *name
)
10569 if (discr_value
->pos
)
10570 dw2_asm_output_data_uleb128 (discr_value
->v
.uval
, "%s", name
);
10572 dw2_asm_output_data_sleb128 (discr_value
->v
.sval
, "%s", name
);
10575 /* Output the DIE and its attributes. Called recursively to generate
10576 the definitions of each child DIE. */
10579 output_die (dw_die_ref die
)
10583 unsigned long size
;
10586 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
10587 (unsigned long)die
->die_offset
,
10588 dwarf_tag_name (die
->die_tag
));
10590 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
10592 const char *name
= dwarf_attr_name (a
->dw_attr
);
10594 switch (AT_class (a
))
10596 case dw_val_class_addr
:
10597 output_attr_index_or_value (a
);
10600 case dw_val_class_offset
:
10601 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
10605 case dw_val_class_range_list
:
10606 output_range_list_offset (a
);
10609 case dw_val_class_loc
:
10610 size
= size_of_locs (AT_loc (a
));
10612 /* Output the block length for this list of location operations. */
10613 if (dwarf_version
>= 4)
10614 dw2_asm_output_data_uleb128 (size
, "%s", name
);
10616 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
10618 output_loc_sequence (AT_loc (a
), -1);
10621 case dw_val_class_const
:
10622 /* ??? It would be slightly more efficient to use a scheme like is
10623 used for unsigned constants below, but gdb 4.x does not sign
10624 extend. Gdb 5.x does sign extend. */
10625 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
10628 case dw_val_class_unsigned_const
:
10630 int csize
= constant_size (AT_unsigned (a
));
10631 if (dwarf_version
== 3
10632 && a
->dw_attr
== DW_AT_data_member_location
10634 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
10636 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
10640 case dw_val_class_symview
:
10643 if (symview_upper_bound
<= 0xff)
10645 else if (symview_upper_bound
<= 0xffff)
10647 else if (symview_upper_bound
<= 0xffffffff)
10651 dw2_asm_output_addr (vsize
, a
->dw_attr_val
.v
.val_symbolic_view
,
10656 case dw_val_class_const_implicit
:
10657 if (flag_debug_asm
)
10658 fprintf (asm_out_file
, "\t\t\t%s %s ("
10659 HOST_WIDE_INT_PRINT_DEC
")\n",
10660 ASM_COMMENT_START
, name
, AT_int (a
));
10663 case dw_val_class_unsigned_const_implicit
:
10664 if (flag_debug_asm
)
10665 fprintf (asm_out_file
, "\t\t\t%s %s ("
10666 HOST_WIDE_INT_PRINT_HEX
")\n",
10667 ASM_COMMENT_START
, name
, AT_unsigned (a
));
10670 case dw_val_class_const_double
:
10672 unsigned HOST_WIDE_INT first
, second
;
10674 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
10675 dw2_asm_output_data (1,
10676 HOST_BITS_PER_DOUBLE_INT
10677 / HOST_BITS_PER_CHAR
,
10680 if (WORDS_BIG_ENDIAN
)
10682 first
= a
->dw_attr_val
.v
.val_double
.high
;
10683 second
= a
->dw_attr_val
.v
.val_double
.low
;
10687 first
= a
->dw_attr_val
.v
.val_double
.low
;
10688 second
= a
->dw_attr_val
.v
.val_double
.high
;
10691 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10692 first
, "%s", name
);
10693 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10698 case dw_val_class_wide_int
:
10701 int len
= get_full_len (*a
->dw_attr_val
.v
.val_wide
);
10702 int l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
10703 if (len
* HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
10704 dw2_asm_output_data (1, get_full_len (*a
->dw_attr_val
.v
.val_wide
)
10707 if (WORDS_BIG_ENDIAN
)
10708 for (i
= len
- 1; i
>= 0; --i
)
10710 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10715 for (i
= 0; i
< len
; ++i
)
10717 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10724 case dw_val_class_vec
:
10726 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
10727 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
10731 dw2_asm_output_data (constant_size (len
* elt_size
),
10732 len
* elt_size
, "%s", name
);
10733 if (elt_size
> sizeof (HOST_WIDE_INT
))
10738 for (i
= 0, p
= (unsigned char *) a
->dw_attr_val
.v
.val_vec
.array
;
10740 i
++, p
+= elt_size
)
10741 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
10742 "fp or vector constant word %u", i
);
10746 case dw_val_class_flag
:
10747 if (dwarf_version
>= 4)
10749 /* Currently all add_AT_flag calls pass in 1 as last argument,
10750 so DW_FORM_flag_present can be used. If that ever changes,
10751 we'll need to use DW_FORM_flag and have some optimization
10752 in build_abbrev_table that will change those to
10753 DW_FORM_flag_present if it is set to 1 in all DIEs using
10754 the same abbrev entry. */
10755 gcc_assert (AT_flag (a
) == 1);
10756 if (flag_debug_asm
)
10757 fprintf (asm_out_file
, "\t\t\t%s %s\n",
10758 ASM_COMMENT_START
, name
);
10761 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
10764 case dw_val_class_loc_list
:
10765 output_loc_list_offset (a
);
10768 case dw_val_class_view_list
:
10769 output_view_list_offset (a
);
10772 case dw_val_class_die_ref
:
10773 if (AT_ref_external (a
))
10775 if (AT_ref (a
)->comdat_type_p
)
10777 comdat_type_node
*type_node
10778 = AT_ref (a
)->die_id
.die_type_node
;
10780 gcc_assert (type_node
);
10781 output_signature (type_node
->signature
, name
);
10785 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
10789 /* In DWARF2, DW_FORM_ref_addr is sized by target address
10790 length, whereas in DWARF3 it's always sized as an
10792 if (dwarf_version
== 2)
10793 size
= DWARF2_ADDR_SIZE
;
10795 size
= DWARF_OFFSET_SIZE
;
10796 /* ??? We cannot unconditionally output die_offset if
10797 non-zero - others might create references to those
10799 And we do not clear its DIE offset after outputting it
10800 (and the label refers to the actual DIEs, not the
10801 DWARF CU unit header which is when using label + offset
10802 would be the correct thing to do).
10803 ??? This is the reason for the with_offset flag. */
10804 if (AT_ref (a
)->with_offset
)
10805 dw2_asm_output_offset (size
, sym
, AT_ref (a
)->die_offset
,
10806 debug_info_section
, "%s", name
);
10808 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
10814 gcc_assert (AT_ref (a
)->die_offset
);
10815 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
10820 case dw_val_class_fde_ref
:
10822 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
10824 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
10825 a
->dw_attr_val
.v
.val_fde_index
* 2);
10826 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
10831 case dw_val_class_vms_delta
:
10832 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
10833 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
10834 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
10837 dw2_asm_output_delta (DWARF_OFFSET_SIZE
,
10838 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
10843 case dw_val_class_lbl_id
:
10844 output_attr_index_or_value (a
);
10847 case dw_val_class_lineptr
:
10848 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10849 debug_line_section
, "%s", name
);
10852 case dw_val_class_macptr
:
10853 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10854 debug_macinfo_section
, "%s", name
);
10857 case dw_val_class_loclistsptr
:
10858 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10859 debug_loc_section
, "%s", name
);
10862 case dw_val_class_str
:
10863 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
10864 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
10865 a
->dw_attr_val
.v
.val_str
->label
,
10867 "%s: \"%s\"", name
, AT_string (a
));
10868 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_line_strp
)
10869 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
10870 a
->dw_attr_val
.v
.val_str
->label
,
10871 debug_line_str_section
,
10872 "%s: \"%s\"", name
, AT_string (a
));
10873 else if (a
->dw_attr_val
.v
.val_str
->form
== dwarf_FORM (DW_FORM_strx
))
10874 dw2_asm_output_data_uleb128 (AT_index (a
),
10875 "%s: \"%s\"", name
, AT_string (a
));
10877 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
10880 case dw_val_class_file
:
10882 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
10884 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
10885 a
->dw_attr_val
.v
.val_file
->filename
);
10889 case dw_val_class_file_implicit
:
10890 if (flag_debug_asm
)
10891 fprintf (asm_out_file
, "\t\t\t%s %s (%d, %s)\n",
10892 ASM_COMMENT_START
, name
,
10893 maybe_emit_file (a
->dw_attr_val
.v
.val_file
),
10894 a
->dw_attr_val
.v
.val_file
->filename
);
10897 case dw_val_class_data8
:
10901 for (i
= 0; i
< 8; i
++)
10902 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
10903 i
== 0 ? "%s" : NULL
, name
);
10907 case dw_val_class_high_pc
:
10908 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
10909 get_AT_low_pc (die
), "DW_AT_high_pc");
10912 case dw_val_class_discr_value
:
10913 output_discr_value (&a
->dw_attr_val
.v
.val_discr_value
, name
);
10916 case dw_val_class_discr_list
:
10918 dw_discr_list_ref list
= AT_discr_list (a
);
10919 const int size
= size_of_discr_list (list
);
10921 /* This is a block, so output its length first. */
10922 dw2_asm_output_data (constant_size (size
), size
,
10923 "%s: block size", name
);
10925 for (; list
!= NULL
; list
= list
->dw_discr_next
)
10927 /* One byte for the discriminant value descriptor, and then as
10928 many LEB128 numbers as required. */
10929 if (list
->dw_discr_range
)
10930 dw2_asm_output_data (1, DW_DSC_range
,
10931 "%s: DW_DSC_range", name
);
10933 dw2_asm_output_data (1, DW_DSC_label
,
10934 "%s: DW_DSC_label", name
);
10936 output_discr_value (&list
->dw_discr_lower_bound
, name
);
10937 if (list
->dw_discr_range
)
10938 output_discr_value (&list
->dw_discr_upper_bound
, name
);
10944 gcc_unreachable ();
10948 FOR_EACH_CHILD (die
, c
, output_die (c
));
10950 /* Add null byte to terminate sibling list. */
10951 if (die
->die_child
!= NULL
)
10952 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
10953 (unsigned long) die
->die_offset
);
10956 /* Output the dwarf version number. */
10959 output_dwarf_version ()
10961 /* ??? For now, if -gdwarf-6 is specified, we output version 5 with
10962 views in loclist. That will change eventually. */
10963 if (dwarf_version
== 6)
10969 "-gdwarf-6 is output as version 5 with incompatibilities");
10972 dw2_asm_output_data (2, 5, "DWARF version number");
10975 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
10978 /* Output the compilation unit that appears at the beginning of the
10979 .debug_info section, and precedes the DIE descriptions. */
10982 output_compilation_unit_header (enum dwarf_unit_type ut
)
10984 if (!XCOFF_DEBUGGING_INFO
)
10986 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10987 dw2_asm_output_data (4, 0xffffffff,
10988 "Initial length escape value indicating 64-bit DWARF extension");
10989 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
10990 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
10991 "Length of Compilation Unit Info");
10994 output_dwarf_version ();
10995 if (dwarf_version
>= 5)
11000 case DW_UT_compile
: name
= "DW_UT_compile"; break;
11001 case DW_UT_type
: name
= "DW_UT_type"; break;
11002 case DW_UT_split_compile
: name
= "DW_UT_split_compile"; break;
11003 case DW_UT_split_type
: name
= "DW_UT_split_type"; break;
11004 default: gcc_unreachable ();
11006 dw2_asm_output_data (1, ut
, "%s", name
);
11007 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11009 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
11010 debug_abbrev_section
,
11011 "Offset Into Abbrev. Section");
11012 if (dwarf_version
< 5)
11013 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11016 /* Output the compilation unit DIE and its children. */
11019 output_comp_unit (dw_die_ref die
, int output_if_empty
,
11020 const unsigned char *dwo_id
)
11022 const char *secname
, *oldsym
;
11025 /* Unless we are outputting main CU, we may throw away empty ones. */
11026 if (!output_if_empty
&& die
->die_child
== NULL
)
11029 /* Even if there are no children of this DIE, we must output the information
11030 about the compilation unit. Otherwise, on an empty translation unit, we
11031 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
11032 will then complain when examining the file. First mark all the DIEs in
11033 this CU so we know which get local refs. */
11036 external_ref_hash_type
*extern_map
= optimize_external_refs (die
);
11038 /* For now, optimize only the main CU, in order to optimize the rest
11039 we'd need to see all of them earlier. Leave the rest for post-linking
11041 if (die
== comp_unit_die ())
11042 abbrev_opt_start
= vec_safe_length (abbrev_die_table
);
11044 build_abbrev_table (die
, extern_map
);
11046 optimize_abbrev_table ();
11050 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11051 next_die_offset
= (dwo_id
11052 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11053 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
11054 calc_die_sizes (die
);
11056 oldsym
= die
->die_id
.die_symbol
;
11057 if (oldsym
&& die
->comdat_type_p
)
11059 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
11061 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
11063 die
->die_id
.die_symbol
= NULL
;
11064 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11068 switch_to_section (debug_info_section
);
11069 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
11070 info_section_emitted
= true;
11073 /* For LTO cross unit DIE refs we want a symbol on the start of the
11074 debuginfo section, not on the CU DIE. */
11075 if ((flag_generate_lto
|| flag_generate_offload
) && oldsym
)
11077 /* ??? No way to get visibility assembled without a decl. */
11078 tree decl
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
11079 get_identifier (oldsym
), char_type_node
);
11080 TREE_PUBLIC (decl
) = true;
11081 TREE_STATIC (decl
) = true;
11082 DECL_ARTIFICIAL (decl
) = true;
11083 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
11084 DECL_VISIBILITY_SPECIFIED (decl
) = true;
11085 targetm
.asm_out
.assemble_visibility (decl
, VISIBILITY_HIDDEN
);
11086 #ifdef ASM_WEAKEN_LABEL
11087 /* We prefer a .weak because that handles duplicates from duplicate
11088 archive members in a graceful way. */
11089 ASM_WEAKEN_LABEL (asm_out_file
, oldsym
);
11091 targetm
.asm_out
.globalize_label (asm_out_file
, oldsym
);
11093 ASM_OUTPUT_LABEL (asm_out_file
, oldsym
);
11096 /* Output debugging information. */
11097 output_compilation_unit_header (dwo_id
11098 ? DW_UT_split_compile
: DW_UT_compile
);
11099 if (dwarf_version
>= 5)
11101 if (dwo_id
!= NULL
)
11102 for (int i
= 0; i
< 8; i
++)
11103 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
11107 /* Leave the marks on the main CU, so we can check them in
11108 output_pubnames. */
11112 die
->die_id
.die_symbol
= oldsym
;
11116 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
11117 and .debug_pubtypes. This is configured per-target, but can be
11118 overridden by the -gpubnames or -gno-pubnames options. */
11121 want_pubnames (void)
11123 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
11125 if (debug_generate_pub_sections
!= -1)
11126 return debug_generate_pub_sections
;
11127 return targetm
.want_debug_pub_sections
;
11130 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
11133 add_AT_pubnames (dw_die_ref die
)
11135 if (want_pubnames ())
11136 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
11139 /* Add a string attribute value to a skeleton DIE. */
11142 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
11146 struct indirect_string_node
*node
;
11148 if (! skeleton_debug_str_hash
)
11149 skeleton_debug_str_hash
11150 = hash_table
<indirect_string_hasher
>::create_ggc (10);
11152 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
11153 find_string_form (node
);
11154 if (node
->form
== dwarf_FORM (DW_FORM_strx
))
11155 node
->form
= DW_FORM_strp
;
11157 attr
.dw_attr
= attr_kind
;
11158 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
11159 attr
.dw_attr_val
.val_entry
= NULL
;
11160 attr
.dw_attr_val
.v
.val_str
= node
;
11161 add_dwarf_attr (die
, &attr
);
11164 /* Helper function to generate top-level dies for skeleton debug_info and
11168 add_top_level_skeleton_die_attrs (dw_die_ref die
)
11170 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
11171 const char *comp_dir
= comp_dir_string ();
11173 add_skeleton_AT_string (die
, dwarf_AT (DW_AT_dwo_name
), dwo_file_name
);
11174 if (comp_dir
!= NULL
)
11175 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
11176 add_AT_pubnames (die
);
11177 add_AT_lineptr (die
, dwarf_AT (DW_AT_addr_base
), debug_addr_section_label
);
11180 /* Output skeleton debug sections that point to the dwo file. */
11183 output_skeleton_debug_sections (dw_die_ref comp_unit
,
11184 const unsigned char *dwo_id
)
11186 /* These attributes will be found in the full debug_info section. */
11187 remove_AT (comp_unit
, DW_AT_producer
);
11188 remove_AT (comp_unit
, DW_AT_language
);
11190 switch_to_section (debug_skeleton_info_section
);
11191 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
11193 /* Produce the skeleton compilation-unit header. This one differs enough from
11194 a normal CU header that it's better not to call output_compilation_unit
11196 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11197 dw2_asm_output_data (4, 0xffffffff,
11198 "Initial length escape value indicating 64-bit "
11199 "DWARF extension");
11201 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
11202 DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11203 - DWARF_INITIAL_LENGTH_SIZE
11204 + size_of_die (comp_unit
),
11205 "Length of Compilation Unit Info");
11206 output_dwarf_version ();
11207 if (dwarf_version
>= 5)
11209 dw2_asm_output_data (1, DW_UT_skeleton
, "DW_UT_skeleton");
11210 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11212 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_abbrev_section_label
,
11213 debug_skeleton_abbrev_section
,
11214 "Offset Into Abbrev. Section");
11215 if (dwarf_version
< 5)
11216 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11218 for (int i
= 0; i
< 8; i
++)
11219 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
11221 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
11222 output_die (comp_unit
);
11224 /* Build the skeleton debug_abbrev section. */
11225 switch_to_section (debug_skeleton_abbrev_section
);
11226 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
11228 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
11230 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
11233 /* Output a comdat type unit DIE and its children. */
11236 output_comdat_type_unit (comdat_type_node
*node
)
11238 const char *secname
;
11241 #if defined (OBJECT_FORMAT_ELF)
11245 /* First mark all the DIEs in this CU so we know which get local refs. */
11246 mark_dies (node
->root_die
);
11248 external_ref_hash_type
*extern_map
= optimize_external_refs (node
->root_die
);
11250 build_abbrev_table (node
->root_die
, extern_map
);
11255 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11256 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
11257 calc_die_sizes (node
->root_die
);
11259 #if defined (OBJECT_FORMAT_ELF)
11260 if (dwarf_version
>= 5)
11262 if (!dwarf_split_debug_info
)
11263 secname
= ".debug_info";
11265 secname
= ".debug_info.dwo";
11267 else if (!dwarf_split_debug_info
)
11268 secname
= ".debug_types";
11270 secname
= ".debug_types.dwo";
11272 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11273 sprintf (tmp
, dwarf_version
>= 5 ? "wi." : "wt.");
11274 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11275 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11276 comdat_key
= get_identifier (tmp
);
11277 targetm
.asm_out
.named_section (secname
,
11278 SECTION_DEBUG
| SECTION_LINKONCE
,
11281 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11282 sprintf (tmp
, (dwarf_version
>= 5
11283 ? ".gnu.linkonce.wi." : ".gnu.linkonce.wt."));
11284 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11285 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11287 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11290 /* Output debugging information. */
11291 output_compilation_unit_header (dwarf_split_debug_info
11292 ? DW_UT_split_type
: DW_UT_type
);
11293 output_signature (node
->signature
, "Type Signature");
11294 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
11295 "Offset to Type DIE");
11296 output_die (node
->root_die
);
11298 unmark_dies (node
->root_die
);
11301 /* Return the DWARF2/3 pubname associated with a decl. */
11303 static const char *
11304 dwarf2_name (tree decl
, int scope
)
11306 if (DECL_NAMELESS (decl
))
11308 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
11311 /* Add a new entry to .debug_pubnames if appropriate. */
11314 add_pubname_string (const char *str
, dw_die_ref die
)
11319 e
.name
= xstrdup (str
);
11320 vec_safe_push (pubname_table
, e
);
11324 add_pubname (tree decl
, dw_die_ref die
)
11326 if (!want_pubnames ())
11329 /* Don't add items to the table when we expect that the consumer will have
11330 just read the enclosing die. For example, if the consumer is looking at a
11331 class_member, it will either be inside the class already, or will have just
11332 looked up the class to find the member. Either way, searching the class is
11333 faster than searching the index. */
11334 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
11335 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
11337 const char *name
= dwarf2_name (decl
, 1);
11340 add_pubname_string (name
, die
);
11344 /* Add an enumerator to the pubnames section. */
11347 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
11351 gcc_assert (scope_name
);
11352 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
11354 vec_safe_push (pubname_table
, e
);
11357 /* Add a new entry to .debug_pubtypes if appropriate. */
11360 add_pubtype (tree decl
, dw_die_ref die
)
11364 if (!want_pubnames ())
11367 if ((TREE_PUBLIC (decl
)
11368 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
11369 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
11372 const char *scope_name
= "";
11373 const char *sep
= is_cxx () ? "::" : ".";
11376 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
11377 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
11379 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
11380 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
11381 scope_name
= concat (scope_name
, sep
, NULL
);
11387 name
= type_tag (decl
);
11389 name
= lang_hooks
.dwarf_name (decl
, 1);
11391 /* If we don't have a name for the type, there's no point in adding
11392 it to the table. */
11393 if (name
!= NULL
&& name
[0] != '\0')
11396 e
.name
= concat (scope_name
, name
, NULL
);
11397 vec_safe_push (pubtype_table
, e
);
11400 /* Although it might be more consistent to add the pubinfo for the
11401 enumerators as their dies are created, they should only be added if the
11402 enum type meets the criteria above. So rather than re-check the parent
11403 enum type whenever an enumerator die is created, just output them all
11404 here. This isn't protected by the name conditional because anonymous
11405 enums don't have names. */
11406 if (die
->die_tag
== DW_TAG_enumeration_type
)
11410 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
11415 /* Output a single entry in the pubnames table. */
11418 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
11420 dw_die_ref die
= entry
->die
;
11421 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
11423 dw2_asm_output_data (DWARF_OFFSET_SIZE
, die_offset
, "DIE offset");
11425 if (debug_generate_pub_sections
== 2)
11427 /* This logic follows gdb's method for determining the value of the flag
11429 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
11430 switch (die
->die_tag
)
11432 case DW_TAG_typedef
:
11433 case DW_TAG_base_type
:
11434 case DW_TAG_subrange_type
:
11435 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11436 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11438 case DW_TAG_enumerator
:
11439 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11440 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11442 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11444 case DW_TAG_subprogram
:
11445 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11446 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
11448 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11450 case DW_TAG_constant
:
11451 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11452 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11453 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11455 case DW_TAG_variable
:
11456 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11457 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11458 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11460 case DW_TAG_namespace
:
11461 case DW_TAG_imported_declaration
:
11462 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11464 case DW_TAG_class_type
:
11465 case DW_TAG_interface_type
:
11466 case DW_TAG_structure_type
:
11467 case DW_TAG_union_type
:
11468 case DW_TAG_enumeration_type
:
11469 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11471 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11474 /* An unusual tag. Leave the flag-byte empty. */
11477 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
11478 "GDB-index flags");
11481 dw2_asm_output_nstring (entry
->name
, -1, "external name");
11485 /* Output the public names table used to speed up access to externally
11486 visible names; or the public types table used to find type definitions. */
11489 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
11492 unsigned long pubnames_length
= size_of_pubnames (names
);
11493 pubname_entry
*pub
;
11495 if (!XCOFF_DEBUGGING_INFO
)
11497 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11498 dw2_asm_output_data (4, 0xffffffff,
11499 "Initial length escape value indicating 64-bit DWARF extension");
11500 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
11501 "Pub Info Length");
11504 /* Version number for pubnames/pubtypes is independent of dwarf version. */
11505 dw2_asm_output_data (2, 2, "DWARF pubnames/pubtypes version");
11507 if (dwarf_split_debug_info
)
11508 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
11509 debug_skeleton_info_section
,
11510 "Offset of Compilation Unit Info");
11512 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
11513 debug_info_section
,
11514 "Offset of Compilation Unit Info");
11515 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
11516 "Compilation Unit Length");
11518 FOR_EACH_VEC_ELT (*names
, i
, pub
)
11520 if (include_pubname_in_output (names
, pub
))
11522 dw_offset die_offset
= pub
->die
->die_offset
;
11524 /* We shouldn't see pubnames for DIEs outside of the main CU. */
11525 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
11526 gcc_assert (pub
->die
->die_mark
);
11528 /* If we're putting types in their own .debug_types sections,
11529 the .debug_pubtypes table will still point to the compile
11530 unit (not the type unit), so we want to use the offset of
11531 the skeleton DIE (if there is one). */
11532 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
11534 comdat_type_node
*type_node
= pub
->die
->die_id
.die_type_node
;
11536 if (type_node
!= NULL
)
11537 die_offset
= (type_node
->skeleton_die
!= NULL
11538 ? type_node
->skeleton_die
->die_offset
11539 : comp_unit_die ()->die_offset
);
11542 output_pubname (die_offset
, pub
);
11546 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
11549 /* Output public names and types tables if necessary. */
11552 output_pubtables (void)
11554 if (!want_pubnames () || !info_section_emitted
)
11557 switch_to_section (debug_pubnames_section
);
11558 output_pubnames (pubname_table
);
11559 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
11560 It shouldn't hurt to emit it always, since pure DWARF2 consumers
11561 simply won't look for the section. */
11562 switch_to_section (debug_pubtypes_section
);
11563 output_pubnames (pubtype_table
);
11567 /* Output the information that goes into the .debug_aranges table.
11568 Namely, define the beginning and ending address range of the
11569 text section generated for this compilation unit. */
11572 output_aranges (void)
11575 unsigned long aranges_length
= size_of_aranges ();
11577 if (!XCOFF_DEBUGGING_INFO
)
11579 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11580 dw2_asm_output_data (4, 0xffffffff,
11581 "Initial length escape value indicating 64-bit DWARF extension");
11582 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
11583 "Length of Address Ranges Info");
11586 /* Version number for aranges is still 2, even up to DWARF5. */
11587 dw2_asm_output_data (2, 2, "DWARF aranges version");
11588 if (dwarf_split_debug_info
)
11589 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
11590 debug_skeleton_info_section
,
11591 "Offset of Compilation Unit Info");
11593 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
11594 debug_info_section
,
11595 "Offset of Compilation Unit Info");
11596 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
11597 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
11599 /* We need to align to twice the pointer size here. */
11600 if (DWARF_ARANGES_PAD_SIZE
)
11602 /* Pad using a 2 byte words so that padding is correct for any
11604 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
11605 2 * DWARF2_ADDR_SIZE
);
11606 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
11607 dw2_asm_output_data (2, 0, NULL
);
11610 /* It is necessary not to output these entries if the sections were
11611 not used; if the sections were not used, the length will be 0 and
11612 the address may end up as 0 if the section is discarded by ld
11613 --gc-sections, leaving an invalid (0, 0) entry that can be
11614 confused with the terminator. */
11615 if (text_section_used
)
11617 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
11618 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
11619 text_section_label
, "Length");
11621 if (cold_text_section_used
)
11623 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
11625 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
11626 cold_text_section_label
, "Length");
11629 if (have_multiple_function_sections
)
11634 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
11636 if (DECL_IGNORED_P (fde
->decl
))
11638 if (!fde
->in_std_section
)
11640 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
11642 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
11643 fde
->dw_fde_begin
, "Length");
11645 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
11647 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
11649 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
11650 fde
->dw_fde_second_begin
, "Length");
11655 /* Output the terminator words. */
11656 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11657 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11660 /* Add a new entry to .debug_ranges. Return its index into
11661 ranges_table vector. */
11663 static unsigned int
11664 add_ranges_num (int num
, bool maybe_new_sec
)
11666 dw_ranges r
= { NULL
, num
, 0, maybe_new_sec
};
11667 vec_safe_push (ranges_table
, r
);
11668 return vec_safe_length (ranges_table
) - 1;
11671 /* Add a new entry to .debug_ranges corresponding to a block, or a
11672 range terminator if BLOCK is NULL. MAYBE_NEW_SEC is true if
11673 this entry might be in a different section from previous range. */
11675 static unsigned int
11676 add_ranges (const_tree block
, bool maybe_new_sec
)
11678 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0, maybe_new_sec
);
11681 /* Note that (*rnglist_table)[offset] is either a head of a rnglist
11682 chain, or middle entry of a chain that will be directly referred to. */
11685 note_rnglist_head (unsigned int offset
)
11687 if (dwarf_version
< 5 || (*ranges_table
)[offset
].label
)
11689 (*ranges_table
)[offset
].label
= gen_internal_sym ("LLRL");
11692 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
11693 When using dwarf_split_debug_info, address attributes in dies destined
11694 for the final executable should be direct references--setting the
11695 parameter force_direct ensures this behavior. */
11698 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
11699 bool *added
, bool force_direct
)
11701 unsigned int in_use
= vec_safe_length (ranges_by_label
);
11702 unsigned int offset
;
11703 dw_ranges_by_label rbl
= { begin
, end
};
11704 vec_safe_push (ranges_by_label
, rbl
);
11705 offset
= add_ranges_num (-(int)in_use
- 1, true);
11708 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
11710 note_rnglist_head (offset
);
11714 /* Emit .debug_ranges section. */
11717 output_ranges (void)
11720 static const char *const start_fmt
= "Offset %#x";
11721 const char *fmt
= start_fmt
;
11724 switch_to_section (debug_ranges_section
);
11725 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11726 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11728 int block_num
= r
->num
;
11732 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11733 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11735 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11736 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11738 /* If all code is in the text section, then the compilation
11739 unit base address defaults to DW_AT_low_pc, which is the
11740 base of the text section. */
11741 if (!have_multiple_function_sections
)
11743 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
11744 text_section_label
,
11745 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11746 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
11747 text_section_label
, NULL
);
11750 /* Otherwise, the compilation unit base address is zero,
11751 which allows us to use absolute addresses, and not worry
11752 about whether the target supports cross-section
11756 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11757 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11758 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
11764 /* Negative block_num stands for an index into ranges_by_label. */
11765 else if (block_num
< 0)
11767 int lab_idx
= - block_num
- 1;
11769 if (!have_multiple_function_sections
)
11771 gcc_unreachable ();
11773 /* If we ever use add_ranges_by_labels () for a single
11774 function section, all we have to do is to take out
11775 the #if 0 above. */
11776 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11777 (*ranges_by_label
)[lab_idx
].begin
,
11778 text_section_label
,
11779 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11780 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11781 (*ranges_by_label
)[lab_idx
].end
,
11782 text_section_label
, NULL
);
11787 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11788 (*ranges_by_label
)[lab_idx
].begin
,
11789 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11790 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11791 (*ranges_by_label
)[lab_idx
].end
,
11797 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11798 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11804 /* Non-zero if .debug_line_str should be used for .debug_line section
11805 strings or strings that are likely shareable with those. */
11806 #define DWARF5_USE_DEBUG_LINE_STR \
11807 (!DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET \
11808 && (DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) != 0 \
11809 /* FIXME: there is no .debug_line_str.dwo section, \
11810 for -gsplit-dwarf we should use DW_FORM_strx instead. */ \
11811 && !dwarf_split_debug_info)
11813 /* Assign .debug_rnglists indexes. */
11816 index_rnglists (void)
11821 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11823 r
->idx
= rnglist_idx
++;
11826 /* Emit .debug_rnglists section. */
11829 output_rnglists (unsigned generation
)
11833 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
11834 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
11835 char basebuf
[MAX_ARTIFICIAL_LABEL_BYTES
];
11837 switch_to_section (debug_ranges_section
);
11838 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11839 /* There are up to 4 unique ranges labels per generation.
11840 See also init_sections_and_labels. */
11841 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_RANGES_SECTION_LABEL
,
11842 2 + generation
* 4);
11843 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_RANGES_SECTION_LABEL
,
11844 3 + generation
* 4);
11845 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11846 dw2_asm_output_data (4, 0xffffffff,
11847 "Initial length escape value indicating "
11848 "64-bit DWARF extension");
11849 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
11850 "Length of Range Lists");
11851 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
11852 output_dwarf_version ();
11853 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
11854 dw2_asm_output_data (1, 0, "Segment Size");
11855 /* Emit the offset table only for -gsplit-dwarf. If we don't care
11856 about relocation sizes and primarily care about the size of .debug*
11857 sections in linked shared libraries and executables, then
11858 the offset table plus corresponding DW_FORM_rnglistx uleb128 indexes
11859 into it are usually larger than just DW_FORM_sec_offset offsets
11860 into the .debug_rnglists section. */
11861 dw2_asm_output_data (4, dwarf_split_debug_info
? rnglist_idx
: 0,
11862 "Offset Entry Count");
11863 if (dwarf_split_debug_info
)
11865 ASM_OUTPUT_LABEL (asm_out_file
, ranges_base_label
);
11866 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11868 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, r
->label
,
11869 ranges_base_label
, NULL
);
11872 const char *lab
= "";
11873 unsigned int len
= vec_safe_length (ranges_table
);
11874 const char *base
= NULL
;
11875 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11877 int block_num
= r
->num
;
11881 ASM_OUTPUT_LABEL (asm_out_file
, r
->label
);
11884 if (HAVE_AS_LEB128
&& (r
->label
|| r
->maybe_new_sec
))
11888 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11889 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11891 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11892 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11894 if (HAVE_AS_LEB128
)
11896 /* If all code is in the text section, then the compilation
11897 unit base address defaults to DW_AT_low_pc, which is the
11898 base of the text section. */
11899 if (!have_multiple_function_sections
)
11901 dw2_asm_output_data (1, DW_RLE_offset_pair
,
11902 "DW_RLE_offset_pair (%s)", lab
);
11903 dw2_asm_output_delta_uleb128 (blabel
, text_section_label
,
11904 "Range begin address (%s)", lab
);
11905 dw2_asm_output_delta_uleb128 (elabel
, text_section_label
,
11906 "Range end address (%s)", lab
);
11911 dw_ranges
*r2
= NULL
;
11913 r2
= &(*ranges_table
)[i
+ 1];
11916 && r2
->label
== NULL
11917 && !r2
->maybe_new_sec
)
11919 dw2_asm_output_data (1, DW_RLE_base_address
,
11920 "DW_RLE_base_address (%s)", lab
);
11921 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11922 "Base address (%s)", lab
);
11923 strcpy (basebuf
, blabel
);
11929 dw2_asm_output_data (1, DW_RLE_offset_pair
,
11930 "DW_RLE_offset_pair (%s)", lab
);
11931 dw2_asm_output_delta_uleb128 (blabel
, base
,
11932 "Range begin address (%s)", lab
);
11933 dw2_asm_output_delta_uleb128 (elabel
, base
,
11934 "Range end address (%s)", lab
);
11937 dw2_asm_output_data (1, DW_RLE_start_length
,
11938 "DW_RLE_start_length (%s)", lab
);
11939 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11940 "Range begin address (%s)", lab
);
11941 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
11942 "Range length (%s)", lab
);
11946 dw2_asm_output_data (1, DW_RLE_start_end
,
11947 "DW_RLE_start_end (%s)", lab
);
11948 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11949 "Range begin address (%s)", lab
);
11950 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
11951 "Range end address (%s)", lab
);
11955 /* Negative block_num stands for an index into ranges_by_label. */
11956 else if (block_num
< 0)
11958 int lab_idx
= - block_num
- 1;
11959 const char *blabel
= (*ranges_by_label
)[lab_idx
].begin
;
11960 const char *elabel
= (*ranges_by_label
)[lab_idx
].end
;
11962 if (!have_multiple_function_sections
)
11963 gcc_unreachable ();
11964 if (HAVE_AS_LEB128
)
11966 dw2_asm_output_data (1, DW_RLE_start_length
,
11967 "DW_RLE_start_length (%s)", lab
);
11968 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11969 "Range begin address (%s)", lab
);
11970 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
11971 "Range length (%s)", lab
);
11975 dw2_asm_output_data (1, DW_RLE_start_end
,
11976 "DW_RLE_start_end (%s)", lab
);
11977 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11978 "Range begin address (%s)", lab
);
11979 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
11980 "Range end address (%s)", lab
);
11984 dw2_asm_output_data (1, DW_RLE_end_of_list
,
11985 "DW_RLE_end_of_list (%s)", lab
);
11987 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
11990 /* Data structure containing information about input files. */
11993 const char *path
; /* Complete file name. */
11994 const char *fname
; /* File name part. */
11995 int length
; /* Length of entire string. */
11996 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
11997 int dir_idx
; /* Index in directory table. */
12000 /* Data structure containing information about directories with source
12004 const char *path
; /* Path including directory name. */
12005 int length
; /* Path length. */
12006 int prefix
; /* Index of directory entry which is a prefix. */
12007 int count
; /* Number of files in this directory. */
12008 int dir_idx
; /* Index of directory used as base. */
12011 /* Callback function for file_info comparison. We sort by looking at
12012 the directories in the path. */
12015 file_info_cmp (const void *p1
, const void *p2
)
12017 const struct file_info
*const s1
= (const struct file_info
*) p1
;
12018 const struct file_info
*const s2
= (const struct file_info
*) p2
;
12019 const unsigned char *cp1
;
12020 const unsigned char *cp2
;
12022 /* Take care of file names without directories. We need to make sure that
12023 we return consistent values to qsort since some will get confused if
12024 we return the same value when identical operands are passed in opposite
12025 orders. So if neither has a directory, return 0 and otherwise return
12026 1 or -1 depending on which one has the directory. We want the one with
12027 the directory to sort after the one without, so all no directory files
12028 are at the start (normally only the compilation unit file). */
12029 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
12030 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
12032 cp1
= (const unsigned char *) s1
->path
;
12033 cp2
= (const unsigned char *) s2
->path
;
12039 /* Reached the end of the first path? If so, handle like above,
12040 but now we want longer directory prefixes before shorter ones. */
12041 if ((cp1
== (const unsigned char *) s1
->fname
)
12042 || (cp2
== (const unsigned char *) s2
->fname
))
12043 return ((cp1
== (const unsigned char *) s1
->fname
)
12044 - (cp2
== (const unsigned char *) s2
->fname
));
12046 /* Character of current path component the same? */
12047 else if (*cp1
!= *cp2
)
12048 return *cp1
- *cp2
;
12052 struct file_name_acquire_data
12054 struct file_info
*files
;
12059 /* Traversal function for the hash table. */
12062 file_name_acquire (dwarf_file_data
**slot
, file_name_acquire_data
*fnad
)
12064 struct dwarf_file_data
*d
= *slot
;
12065 struct file_info
*fi
;
12068 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
12070 if (! d
->emitted_number
)
12073 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
12075 fi
= fnad
->files
+ fnad
->used_files
++;
12077 /* Skip all leading "./". */
12079 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
12082 /* Create a new array entry. */
12084 fi
->length
= strlen (f
);
12087 /* Search for the file name part. */
12088 f
= strrchr (f
, DIR_SEPARATOR
);
12089 #if defined (DIR_SEPARATOR_2)
12091 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
12095 if (f
== NULL
|| f
< g
)
12101 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
12105 /* Helper function for output_file_names. Emit a FORM encoded
12106 string STR, with assembly comment start ENTRY_KIND and
12110 output_line_string (enum dwarf_form form
, const char *str
,
12111 const char *entry_kind
, unsigned int idx
)
12115 case DW_FORM_string
:
12116 dw2_asm_output_nstring (str
, -1, "%s: %#x", entry_kind
, idx
);
12118 case DW_FORM_line_strp
:
12119 if (!debug_line_str_hash
)
12120 debug_line_str_hash
12121 = hash_table
<indirect_string_hasher
>::create_ggc (10);
12123 struct indirect_string_node
*node
;
12124 node
= find_AT_string_in_table (str
, debug_line_str_hash
);
12125 set_indirect_string (node
);
12127 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
12128 debug_line_str_section
, "%s: %#x: \"%s\"",
12129 entry_kind
, 0, node
->str
);
12132 gcc_unreachable ();
12136 /* Output the directory table and the file name table. We try to minimize
12137 the total amount of memory needed. A heuristic is used to avoid large
12138 slowdowns with many input files. */
12141 output_file_names (void)
12143 struct file_name_acquire_data fnad
;
12145 struct file_info
*files
;
12146 struct dir_info
*dirs
;
12154 if (!last_emitted_file
)
12156 if (dwarf_version
>= 5)
12158 dw2_asm_output_data (1, 0, "Directory entry format count");
12159 dw2_asm_output_data_uleb128 (0, "Directories count");
12160 dw2_asm_output_data (1, 0, "File name entry format count");
12161 dw2_asm_output_data_uleb128 (0, "File names count");
12165 dw2_asm_output_data (1, 0, "End directory table");
12166 dw2_asm_output_data (1, 0, "End file name table");
12171 numfiles
= last_emitted_file
->emitted_number
;
12173 /* Allocate the various arrays we need. */
12174 files
= XALLOCAVEC (struct file_info
, numfiles
);
12175 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
12177 fnad
.files
= files
;
12178 fnad
.used_files
= 0;
12179 fnad
.max_files
= numfiles
;
12180 file_table
->traverse
<file_name_acquire_data
*, file_name_acquire
> (&fnad
);
12181 gcc_assert (fnad
.used_files
== fnad
.max_files
);
12183 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
12185 /* Find all the different directories used. */
12186 dirs
[0].path
= files
[0].path
;
12187 dirs
[0].length
= files
[0].fname
- files
[0].path
;
12188 dirs
[0].prefix
= -1;
12190 dirs
[0].dir_idx
= 0;
12191 files
[0].dir_idx
= 0;
12194 for (i
= 1; i
< numfiles
; i
++)
12195 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
12196 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
12197 dirs
[ndirs
- 1].length
) == 0)
12199 /* Same directory as last entry. */
12200 files
[i
].dir_idx
= ndirs
- 1;
12201 ++dirs
[ndirs
- 1].count
;
12207 /* This is a new directory. */
12208 dirs
[ndirs
].path
= files
[i
].path
;
12209 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
12210 dirs
[ndirs
].count
= 1;
12211 dirs
[ndirs
].dir_idx
= ndirs
;
12212 files
[i
].dir_idx
= ndirs
;
12214 /* Search for a prefix. */
12215 dirs
[ndirs
].prefix
= -1;
12216 for (j
= 0; j
< ndirs
; j
++)
12217 if (dirs
[j
].length
< dirs
[ndirs
].length
12218 && dirs
[j
].length
> 1
12219 && (dirs
[ndirs
].prefix
== -1
12220 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
12221 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
12222 dirs
[ndirs
].prefix
= j
;
12227 /* Now to the actual work. We have to find a subset of the directories which
12228 allow expressing the file name using references to the directory table
12229 with the least amount of characters. We do not do an exhaustive search
12230 where we would have to check out every combination of every single
12231 possible prefix. Instead we use a heuristic which provides nearly optimal
12232 results in most cases and never is much off. */
12233 saved
= XALLOCAVEC (int, ndirs
);
12234 savehere
= XALLOCAVEC (int, ndirs
);
12236 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
12237 for (i
= 0; i
< ndirs
; i
++)
12242 /* We can always save some space for the current directory. But this
12243 does not mean it will be enough to justify adding the directory. */
12244 savehere
[i
] = dirs
[i
].length
;
12245 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
12247 for (j
= i
+ 1; j
< ndirs
; j
++)
12250 if (saved
[j
] < dirs
[i
].length
)
12252 /* Determine whether the dirs[i] path is a prefix of the
12256 k
= dirs
[j
].prefix
;
12257 while (k
!= -1 && k
!= (int) i
)
12258 k
= dirs
[k
].prefix
;
12262 /* Yes it is. We can possibly save some memory by
12263 writing the filenames in dirs[j] relative to
12265 savehere
[j
] = dirs
[i
].length
;
12266 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
12271 /* Check whether we can save enough to justify adding the dirs[i]
12273 if (total
> dirs
[i
].length
+ 1)
12275 /* It's worthwhile adding. */
12276 for (j
= i
; j
< ndirs
; j
++)
12277 if (savehere
[j
] > 0)
12279 /* Remember how much we saved for this directory so far. */
12280 saved
[j
] = savehere
[j
];
12282 /* Remember the prefix directory. */
12283 dirs
[j
].dir_idx
= i
;
12288 /* Emit the directory name table. */
12289 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
12290 enum dwarf_form str_form
= DW_FORM_string
;
12291 enum dwarf_form idx_form
= DW_FORM_udata
;
12292 if (dwarf_version
>= 5)
12294 const char *comp_dir
= comp_dir_string ();
12295 if (comp_dir
== NULL
)
12297 dw2_asm_output_data (1, 1, "Directory entry format count");
12298 if (DWARF5_USE_DEBUG_LINE_STR
)
12299 str_form
= DW_FORM_line_strp
;
12300 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12301 dw2_asm_output_data_uleb128 (str_form
, "%s",
12302 get_DW_FORM_name (str_form
));
12303 dw2_asm_output_data_uleb128 (ndirs
+ idx_offset
, "Directories count");
12304 if (str_form
== DW_FORM_string
)
12306 dw2_asm_output_nstring (comp_dir
, -1, "Directory Entry: %#x", 0);
12307 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12308 dw2_asm_output_nstring (dirs
[i
].path
,
12310 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
12311 "Directory Entry: %#x", i
+ idx_offset
);
12315 output_line_string (str_form
, comp_dir
, "Directory Entry", 0);
12316 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12319 = ggc_alloc_string (dirs
[i
].path
,
12321 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
);
12322 output_line_string (str_form
, str
, "Directory Entry",
12323 (unsigned) i
+ idx_offset
);
12329 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12330 dw2_asm_output_nstring (dirs
[i
].path
,
12332 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
12333 "Directory Entry: %#x", i
+ idx_offset
);
12335 dw2_asm_output_data (1, 0, "End directory table");
12338 /* We have to emit them in the order of emitted_number since that's
12339 used in the debug info generation. To do this efficiently we
12340 generate a back-mapping of the indices first. */
12341 backmap
= XALLOCAVEC (int, numfiles
);
12342 for (i
= 0; i
< numfiles
; i
++)
12343 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
12345 if (dwarf_version
>= 5)
12347 const char *filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
12348 if (filename0
== NULL
)
12350 /* DW_LNCT_directory_index can use DW_FORM_udata, DW_FORM_data1 and
12351 DW_FORM_data2. Choose one based on the number of directories
12352 and how much space would they occupy in each encoding.
12353 If we have at most 256 directories, all indexes fit into
12354 a single byte, so DW_FORM_data1 is most compact (if there
12355 are at most 128 directories, DW_FORM_udata would be as
12356 compact as that, but not shorter and slower to decode). */
12357 if (ndirs
+ idx_offset
<= 256)
12358 idx_form
= DW_FORM_data1
;
12359 /* If there are more than 65536 directories, we have to use
12360 DW_FORM_udata, DW_FORM_data2 can't refer to them.
12361 Otherwise, compute what space would occupy if all the indexes
12362 used DW_FORM_udata - sum - and compare that to how large would
12363 be DW_FORM_data2 encoding, and pick the more efficient one. */
12364 else if (ndirs
+ idx_offset
<= 65536)
12366 unsigned HOST_WIDE_INT sum
= 1;
12367 for (i
= 0; i
< numfiles
; i
++)
12369 int file_idx
= backmap
[i
];
12370 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
12371 sum
+= size_of_uleb128 (dir_idx
);
12373 if (sum
>= HOST_WIDE_INT_UC (2) * (numfiles
+ 1))
12374 idx_form
= DW_FORM_data2
;
12376 #ifdef VMS_DEBUGGING_INFO
12377 dw2_asm_output_data (1, 4, "File name entry format count");
12379 dw2_asm_output_data (1, 2, "File name entry format count");
12381 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12382 dw2_asm_output_data_uleb128 (str_form
, "%s",
12383 get_DW_FORM_name (str_form
));
12384 dw2_asm_output_data_uleb128 (DW_LNCT_directory_index
,
12385 "DW_LNCT_directory_index");
12386 dw2_asm_output_data_uleb128 (idx_form
, "%s",
12387 get_DW_FORM_name (idx_form
));
12388 #ifdef VMS_DEBUGGING_INFO
12389 dw2_asm_output_data_uleb128 (DW_LNCT_timestamp
, "DW_LNCT_timestamp");
12390 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12391 dw2_asm_output_data_uleb128 (DW_LNCT_size
, "DW_LNCT_size");
12392 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12394 dw2_asm_output_data_uleb128 (numfiles
+ 1, "File names count");
12396 output_line_string (str_form
, filename0
, "File Entry", 0);
12398 /* Include directory index. */
12399 if (idx_form
!= DW_FORM_udata
)
12400 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12403 dw2_asm_output_data_uleb128 (0, NULL
);
12405 #ifdef VMS_DEBUGGING_INFO
12406 dw2_asm_output_data_uleb128 (0, NULL
);
12407 dw2_asm_output_data_uleb128 (0, NULL
);
12411 /* Now write all the file names. */
12412 for (i
= 0; i
< numfiles
; i
++)
12414 int file_idx
= backmap
[i
];
12415 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
12417 #ifdef VMS_DEBUGGING_INFO
12418 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
12420 /* Setting these fields can lead to debugger miscomparisons,
12421 but VMS Debug requires them to be set correctly. */
12426 int maxfilelen
= (strlen (files
[file_idx
].path
)
12427 + dirs
[dir_idx
].length
12428 + MAX_VMS_VERSION_LEN
+ 1);
12429 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
12431 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
12432 snprintf (filebuf
, maxfilelen
, "%s;%d",
12433 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
12435 output_line_string (str_form
, filebuf
, "File Entry", (unsigned) i
+ 1);
12437 /* Include directory index. */
12438 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
12439 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12440 dir_idx
+ idx_offset
, NULL
);
12442 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
12444 /* Modification time. */
12445 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
12446 &cdt
, 0, 0, 0) == 0)
12449 /* File length in bytes. */
12450 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
12451 0, &siz
, 0, 0) == 0)
12454 output_line_string (str_form
,
12455 files
[file_idx
].path
+ dirs
[dir_idx
].length
,
12456 "File Entry", (unsigned) i
+ 1);
12458 /* Include directory index. */
12459 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
12460 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12461 dir_idx
+ idx_offset
, NULL
);
12463 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
12465 if (dwarf_version
>= 5)
12468 /* Modification time. */
12469 dw2_asm_output_data_uleb128 (0, NULL
);
12471 /* File length in bytes. */
12472 dw2_asm_output_data_uleb128 (0, NULL
);
12473 #endif /* VMS_DEBUGGING_INFO */
12476 if (dwarf_version
< 5)
12477 dw2_asm_output_data (1, 0, "End file name table");
12481 /* Output one line number table into the .debug_line section. */
12484 output_one_line_info_table (dw_line_info_table
*table
)
12486 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12487 unsigned int current_line
= 1;
12488 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
12489 dw_line_info_entry
*ent
, *prev_addr
;
12495 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
12497 switch (ent
->opcode
)
12499 case LI_set_address
:
12500 /* ??? Unfortunately, we have little choice here currently, and
12501 must always use the most general form. GCC does not know the
12502 address delta itself, so we can't use DW_LNS_advance_pc. Many
12503 ports do have length attributes which will give an upper bound
12504 on the address range. We could perhaps use length attributes
12505 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
12506 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
12510 /* This can handle any delta. This takes
12511 4+DWARF2_ADDR_SIZE bytes. */
12512 dw2_asm_output_data (1, 0, "set address %s%s", line_label
,
12513 debug_variable_location_views
12514 ? ", reset view to 0" : "");
12515 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12516 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12517 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
12522 case LI_adv_address
:
12524 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
12525 char prev_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12526 ASM_GENERATE_INTERNAL_LABEL (prev_label
, LINE_CODE_LABEL
, prev_addr
->val
);
12530 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
, "fixed advance PC, increment view to %i", view
);
12531 dw2_asm_output_delta (2, line_label
, prev_label
,
12532 "from %s to %s", prev_label
, line_label
);
12539 if (ent
->val
== current_line
)
12541 /* We still need to start a new row, so output a copy insn. */
12542 dw2_asm_output_data (1, DW_LNS_copy
,
12543 "copy line %u", current_line
);
12547 int line_offset
= ent
->val
- current_line
;
12548 int line_delta
= line_offset
- DWARF_LINE_BASE
;
12550 current_line
= ent
->val
;
12551 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
12553 /* This can handle deltas from -10 to 234, using the current
12554 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
12555 This takes 1 byte. */
12556 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
12557 "line %u", current_line
);
12561 /* This can handle any delta. This takes at least 4 bytes,
12562 depending on the value being encoded. */
12563 dw2_asm_output_data (1, DW_LNS_advance_line
,
12564 "advance to line %u", current_line
);
12565 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
12566 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
12572 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
12573 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
12576 case LI_set_column
:
12577 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
12578 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
12581 case LI_negate_stmt
:
12582 current_is_stmt
= !current_is_stmt
;
12583 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
12584 "is_stmt %d", current_is_stmt
);
12587 case LI_set_prologue_end
:
12588 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
12589 "set prologue end");
12592 case LI_set_epilogue_begin
:
12593 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
12594 "set epilogue begin");
12597 case LI_set_discriminator
:
12598 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
12599 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
12600 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
12601 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
12606 /* Emit debug info for the address of the end of the table. */
12607 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
12608 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12609 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12610 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
12612 dw2_asm_output_data (1, 0, "end sequence");
12613 dw2_asm_output_data_uleb128 (1, NULL
);
12614 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
12617 /* Output the source line number correspondence information. This
12618 information goes into the .debug_line section. */
12621 output_line_info (bool prologue_only
)
12623 static unsigned int generation
;
12624 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
12625 char p1
[MAX_ARTIFICIAL_LABEL_BYTES
], p2
[MAX_ARTIFICIAL_LABEL_BYTES
];
12626 bool saw_one
= false;
12629 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, generation
);
12630 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, generation
);
12631 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, generation
);
12632 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, generation
++);
12634 if (!XCOFF_DEBUGGING_INFO
)
12636 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
12637 dw2_asm_output_data (4, 0xffffffff,
12638 "Initial length escape value indicating 64-bit DWARF extension");
12639 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
12640 "Length of Source Line Info");
12643 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
12645 output_dwarf_version ();
12646 if (dwarf_version
>= 5)
12648 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
12649 dw2_asm_output_data (1, 0, "Segment Size");
12651 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
12652 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
12654 /* Define the architecture-dependent minimum instruction length (in bytes).
12655 In this implementation of DWARF, this field is used for information
12656 purposes only. Since GCC generates assembly language, we have no
12657 a priori knowledge of how many instruction bytes are generated for each
12658 source line, and therefore can use only the DW_LNE_set_address and
12659 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
12660 this as '1', which is "correct enough" for all architectures,
12661 and don't let the target override. */
12662 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
12664 if (dwarf_version
>= 4)
12665 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
12666 "Maximum Operations Per Instruction");
12667 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
12668 "Default is_stmt_start flag");
12669 dw2_asm_output_data (1, DWARF_LINE_BASE
,
12670 "Line Base Value (Special Opcodes)");
12671 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
12672 "Line Range Value (Special Opcodes)");
12673 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
12674 "Special Opcode Base");
12676 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
12681 case DW_LNS_advance_pc
:
12682 case DW_LNS_advance_line
:
12683 case DW_LNS_set_file
:
12684 case DW_LNS_set_column
:
12685 case DW_LNS_fixed_advance_pc
:
12686 case DW_LNS_set_isa
:
12694 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
12698 /* Write out the information about the files we use. */
12699 output_file_names ();
12700 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
12703 /* Output the marker for the end of the line number info. */
12704 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12708 if (separate_line_info
)
12710 dw_line_info_table
*table
;
12713 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
12716 output_one_line_info_table (table
);
12720 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
12722 output_one_line_info_table (cold_text_section_line_info
);
12726 /* ??? Some Darwin linkers crash on a .debug_line section with no
12727 sequences. Further, merely a DW_LNE_end_sequence entry is not
12728 sufficient -- the address column must also be initialized.
12729 Make sure to output at least one set_address/end_sequence pair,
12730 choosing .text since that section is always present. */
12731 if (text_section_line_info
->in_use
|| !saw_one
)
12732 output_one_line_info_table (text_section_line_info
);
12734 /* Output the marker for the end of the line number info. */
12735 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12738 /* Return true if DW_AT_endianity should be emitted according to REVERSE. */
12741 need_endianity_attribute_p (bool reverse
)
12743 return reverse
&& (dwarf_version
>= 3 || !dwarf_strict
);
12746 /* Given a pointer to a tree node for some base type, return a pointer to
12747 a DIE that describes the given type. REVERSE is true if the type is
12748 to be interpreted in the reverse storage order wrt the target order.
12750 This routine must only be called for GCC type nodes that correspond to
12751 Dwarf base (fundamental) types. */
12754 base_type_die (tree type
, bool reverse
)
12756 dw_die_ref base_type_result
;
12757 enum dwarf_type encoding
;
12758 bool fpt_used
= false;
12759 struct fixed_point_type_info fpt_info
;
12760 tree type_bias
= NULL_TREE
;
12762 /* If this is a subtype that should not be emitted as a subrange type,
12763 use the base type. See subrange_type_for_debug_p. */
12764 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
12765 type
= TREE_TYPE (type
);
12767 switch (TREE_CODE (type
))
12770 if ((dwarf_version
>= 4 || !dwarf_strict
)
12771 && TYPE_NAME (type
)
12772 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
12773 && DECL_IS_BUILTIN (TYPE_NAME (type
))
12774 && DECL_NAME (TYPE_NAME (type
)))
12776 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
12777 if (strcmp (name
, "char16_t") == 0
12778 || strcmp (name
, "char32_t") == 0)
12780 encoding
= DW_ATE_UTF
;
12784 if ((dwarf_version
>= 3 || !dwarf_strict
)
12785 && lang_hooks
.types
.get_fixed_point_type_info
)
12787 memset (&fpt_info
, 0, sizeof (fpt_info
));
12788 if (lang_hooks
.types
.get_fixed_point_type_info (type
, &fpt_info
))
12791 encoding
= ((TYPE_UNSIGNED (type
))
12792 ? DW_ATE_unsigned_fixed
12793 : DW_ATE_signed_fixed
);
12797 if (TYPE_STRING_FLAG (type
))
12799 if (TYPE_UNSIGNED (type
))
12800 encoding
= DW_ATE_unsigned_char
;
12802 encoding
= DW_ATE_signed_char
;
12804 else if (TYPE_UNSIGNED (type
))
12805 encoding
= DW_ATE_unsigned
;
12807 encoding
= DW_ATE_signed
;
12810 && lang_hooks
.types
.get_type_bias
)
12811 type_bias
= lang_hooks
.types
.get_type_bias (type
);
12815 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
12817 if (dwarf_version
>= 3 || !dwarf_strict
)
12818 encoding
= DW_ATE_decimal_float
;
12820 encoding
= DW_ATE_lo_user
;
12823 encoding
= DW_ATE_float
;
12826 case FIXED_POINT_TYPE
:
12827 if (!(dwarf_version
>= 3 || !dwarf_strict
))
12828 encoding
= DW_ATE_lo_user
;
12829 else if (TYPE_UNSIGNED (type
))
12830 encoding
= DW_ATE_unsigned_fixed
;
12832 encoding
= DW_ATE_signed_fixed
;
12835 /* Dwarf2 doesn't know anything about complex ints, so use
12836 a user defined type for it. */
12838 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
12839 encoding
= DW_ATE_complex_float
;
12841 encoding
= DW_ATE_lo_user
;
12845 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
12846 encoding
= DW_ATE_boolean
;
12850 /* No other TREE_CODEs are Dwarf fundamental types. */
12851 gcc_unreachable ();
12854 base_type_result
= new_die_raw (DW_TAG_base_type
);
12856 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
12857 int_size_in_bytes (type
));
12858 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
12860 if (need_endianity_attribute_p (reverse
))
12861 add_AT_unsigned (base_type_result
, DW_AT_endianity
,
12862 BYTES_BIG_ENDIAN
? DW_END_little
: DW_END_big
);
12864 add_alignment_attribute (base_type_result
, type
);
12868 switch (fpt_info
.scale_factor_kind
)
12870 case fixed_point_scale_factor_binary
:
12871 add_AT_int (base_type_result
, DW_AT_binary_scale
,
12872 fpt_info
.scale_factor
.binary
);
12875 case fixed_point_scale_factor_decimal
:
12876 add_AT_int (base_type_result
, DW_AT_decimal_scale
,
12877 fpt_info
.scale_factor
.decimal
);
12880 case fixed_point_scale_factor_arbitrary
:
12881 /* Arbitrary scale factors cannot be described in standard DWARF,
12885 /* Describe the scale factor as a rational constant. */
12886 const dw_die_ref scale_factor
12887 = new_die (DW_TAG_constant
, comp_unit_die (), type
);
12889 add_AT_unsigned (scale_factor
, DW_AT_GNU_numerator
,
12890 fpt_info
.scale_factor
.arbitrary
.numerator
);
12891 add_AT_int (scale_factor
, DW_AT_GNU_denominator
,
12892 fpt_info
.scale_factor
.arbitrary
.denominator
);
12894 add_AT_die_ref (base_type_result
, DW_AT_small
, scale_factor
);
12899 gcc_unreachable ();
12904 add_scalar_info (base_type_result
, DW_AT_GNU_bias
, type_bias
,
12905 dw_scalar_form_constant
12906 | dw_scalar_form_exprloc
12907 | dw_scalar_form_reference
,
12910 return base_type_result
;
12913 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
12914 named 'auto' in its type: return true for it, false otherwise. */
12917 is_cxx_auto (tree type
)
12921 tree name
= TYPE_IDENTIFIER (type
);
12922 if (name
== get_identifier ("auto")
12923 || name
== get_identifier ("decltype(auto)"))
12929 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
12930 given input type is a Dwarf "fundamental" type. Otherwise return null. */
12933 is_base_type (tree type
)
12935 switch (TREE_CODE (type
))
12939 case FIXED_POINT_TYPE
:
12948 case QUAL_UNION_TYPE
:
12949 case ENUMERAL_TYPE
:
12950 case FUNCTION_TYPE
:
12953 case REFERENCE_TYPE
:
12961 if (is_cxx_auto (type
))
12963 gcc_unreachable ();
12969 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
12970 node, return the size in bits for the type if it is a constant, or else
12971 return the alignment for the type if the type's size is not constant, or
12972 else return BITS_PER_WORD if the type actually turns out to be an
12973 ERROR_MARK node. */
12975 static inline unsigned HOST_WIDE_INT
12976 simple_type_size_in_bits (const_tree type
)
12978 if (TREE_CODE (type
) == ERROR_MARK
)
12979 return BITS_PER_WORD
;
12980 else if (TYPE_SIZE (type
) == NULL_TREE
)
12982 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
12983 return tree_to_uhwi (TYPE_SIZE (type
));
12985 return TYPE_ALIGN (type
);
12988 /* Similarly, but return an offset_int instead of UHWI. */
12990 static inline offset_int
12991 offset_int_type_size_in_bits (const_tree type
)
12993 if (TREE_CODE (type
) == ERROR_MARK
)
12994 return BITS_PER_WORD
;
12995 else if (TYPE_SIZE (type
) == NULL_TREE
)
12997 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
12998 return wi::to_offset (TYPE_SIZE (type
));
13000 return TYPE_ALIGN (type
);
13003 /* Given a pointer to a tree node for a subrange type, return a pointer
13004 to a DIE that describes the given type. */
13007 subrange_type_die (tree type
, tree low
, tree high
, tree bias
,
13008 dw_die_ref context_die
)
13010 dw_die_ref subrange_die
;
13011 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
13013 if (context_die
== NULL
)
13014 context_die
= comp_unit_die ();
13016 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
13018 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
13020 /* The size of the subrange type and its base type do not match,
13021 so we need to generate a size attribute for the subrange type. */
13022 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
13025 add_alignment_attribute (subrange_die
, type
);
13028 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
, NULL
);
13030 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
, NULL
);
13031 if (bias
&& !dwarf_strict
)
13032 add_scalar_info (subrange_die
, DW_AT_GNU_bias
, bias
,
13033 dw_scalar_form_constant
13034 | dw_scalar_form_exprloc
13035 | dw_scalar_form_reference
,
13038 return subrange_die
;
13041 /* Returns the (const and/or volatile) cv_qualifiers associated with
13042 the decl node. This will normally be augmented with the
13043 cv_qualifiers of the underlying type in add_type_attribute. */
13046 decl_quals (const_tree decl
)
13048 return ((TREE_READONLY (decl
)
13049 /* The C++ front-end correctly marks reference-typed
13050 variables as readonly, but from a language (and debug
13051 info) standpoint they are not const-qualified. */
13052 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
13053 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
)
13054 | (TREE_THIS_VOLATILE (decl
)
13055 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
));
13058 /* Determine the TYPE whose qualifiers match the largest strict subset
13059 of the given TYPE_QUALS, and return its qualifiers. Ignore all
13060 qualifiers outside QUAL_MASK. */
13063 get_nearest_type_subqualifiers (tree type
, int type_quals
, int qual_mask
)
13066 int best_rank
= 0, best_qual
= 0, max_rank
;
13068 type_quals
&= qual_mask
;
13069 max_rank
= popcount_hwi (type_quals
) - 1;
13071 for (t
= TYPE_MAIN_VARIANT (type
); t
&& best_rank
< max_rank
;
13072 t
= TYPE_NEXT_VARIANT (t
))
13074 int q
= TYPE_QUALS (t
) & qual_mask
;
13076 if ((q
& type_quals
) == q
&& q
!= type_quals
13077 && check_base_type (t
, type
))
13079 int rank
= popcount_hwi (q
);
13081 if (rank
> best_rank
)
13092 struct dwarf_qual_info_t
{ int q
; enum dwarf_tag t
; };
13093 static const dwarf_qual_info_t dwarf_qual_info
[] =
13095 { TYPE_QUAL_CONST
, DW_TAG_const_type
},
13096 { TYPE_QUAL_VOLATILE
, DW_TAG_volatile_type
},
13097 { TYPE_QUAL_RESTRICT
, DW_TAG_restrict_type
},
13098 { TYPE_QUAL_ATOMIC
, DW_TAG_atomic_type
}
13100 static const unsigned int dwarf_qual_info_size
13101 = sizeof (dwarf_qual_info
) / sizeof (dwarf_qual_info
[0]);
13103 /* If DIE is a qualified DIE of some base DIE with the same parent,
13104 return the base DIE, otherwise return NULL. Set MASK to the
13105 qualifiers added compared to the returned DIE. */
13108 qualified_die_p (dw_die_ref die
, int *mask
, unsigned int depth
)
13111 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13112 if (die
->die_tag
== dwarf_qual_info
[i
].t
)
13114 if (i
== dwarf_qual_info_size
)
13116 if (vec_safe_length (die
->die_attr
) != 1)
13118 dw_die_ref type
= get_AT_ref (die
, DW_AT_type
);
13119 if (type
== NULL
|| type
->die_parent
!= die
->die_parent
)
13121 *mask
|= dwarf_qual_info
[i
].q
;
13124 dw_die_ref ret
= qualified_die_p (type
, mask
, depth
- 1);
13131 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
13132 entry that chains the modifiers specified by CV_QUALS in front of the
13133 given type. REVERSE is true if the type is to be interpreted in the
13134 reverse storage order wrt the target order. */
13137 modified_type_die (tree type
, int cv_quals
, bool reverse
,
13138 dw_die_ref context_die
)
13140 enum tree_code code
= TREE_CODE (type
);
13141 dw_die_ref mod_type_die
;
13142 dw_die_ref sub_die
= NULL
;
13143 tree item_type
= NULL
;
13144 tree qualified_type
;
13145 tree name
, low
, high
;
13146 dw_die_ref mod_scope
;
13147 /* Only these cv-qualifiers are currently handled. */
13148 const int cv_qual_mask
= (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
13149 | TYPE_QUAL_RESTRICT
| TYPE_QUAL_ATOMIC
|
13150 ENCODE_QUAL_ADDR_SPACE(~0U));
13151 const bool reverse_base_type
13152 = need_endianity_attribute_p (reverse
) && is_base_type (type
);
13154 if (code
== ERROR_MARK
)
13157 if (lang_hooks
.types
.get_debug_type
)
13159 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
13161 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
13162 return modified_type_die (debug_type
, cv_quals
, reverse
, context_die
);
13165 cv_quals
&= cv_qual_mask
;
13167 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
13168 tag modifier (and not an attribute) old consumers won't be able
13170 if (dwarf_version
< 3)
13171 cv_quals
&= ~TYPE_QUAL_RESTRICT
;
13173 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
13174 if (dwarf_version
< 5)
13175 cv_quals
&= ~TYPE_QUAL_ATOMIC
;
13177 /* See if we already have the appropriately qualified variant of
13179 qualified_type
= get_qualified_type (type
, cv_quals
);
13181 if (qualified_type
== sizetype
)
13183 /* Try not to expose the internal sizetype type's name. */
13184 if (TYPE_NAME (qualified_type
)
13185 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
13187 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
13189 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
13190 && (TYPE_PRECISION (t
)
13191 == TYPE_PRECISION (qualified_type
))
13192 && (TYPE_UNSIGNED (t
)
13193 == TYPE_UNSIGNED (qualified_type
)));
13194 qualified_type
= t
;
13196 else if (qualified_type
== sizetype
13197 && TREE_CODE (sizetype
) == TREE_CODE (size_type_node
)
13198 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (size_type_node
)
13199 && TYPE_UNSIGNED (sizetype
) == TYPE_UNSIGNED (size_type_node
))
13200 qualified_type
= size_type_node
;
13203 /* If we do, then we can just use its DIE, if it exists. */
13204 if (qualified_type
)
13206 mod_type_die
= lookup_type_die (qualified_type
);
13208 /* DW_AT_endianity doesn't come from a qualifier on the type, so it is
13209 dealt with specially: the DIE with the attribute, if it exists, is
13210 placed immediately after the regular DIE for the same base type. */
13212 && (!reverse_base_type
13213 || ((mod_type_die
= mod_type_die
->die_sib
) != NULL
13214 && get_AT_unsigned (mod_type_die
, DW_AT_endianity
))))
13215 return mod_type_die
;
13218 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
13220 /* Handle C typedef types. */
13222 && TREE_CODE (name
) == TYPE_DECL
13223 && DECL_ORIGINAL_TYPE (name
)
13224 && !DECL_ARTIFICIAL (name
))
13226 tree dtype
= TREE_TYPE (name
);
13228 /* Skip the typedef for base types with DW_AT_endianity, no big deal. */
13229 if (qualified_type
== dtype
&& !reverse_base_type
)
13231 tree origin
= decl_ultimate_origin (name
);
13233 /* Typedef variants that have an abstract origin don't get their own
13234 type DIE (see gen_typedef_die), so fall back on the ultimate
13235 abstract origin instead. */
13236 if (origin
!= NULL
&& origin
!= name
)
13237 return modified_type_die (TREE_TYPE (origin
), cv_quals
, reverse
,
13240 /* For a named type, use the typedef. */
13241 gen_type_die (qualified_type
, context_die
);
13242 return lookup_type_die (qualified_type
);
13246 int dquals
= TYPE_QUALS_NO_ADDR_SPACE (dtype
);
13247 dquals
&= cv_qual_mask
;
13248 if ((dquals
& ~cv_quals
) != TYPE_UNQUALIFIED
13249 || (cv_quals
== dquals
&& DECL_ORIGINAL_TYPE (name
) != type
))
13250 /* cv-unqualified version of named type. Just use
13251 the unnamed type to which it refers. */
13252 return modified_type_die (DECL_ORIGINAL_TYPE (name
), cv_quals
,
13253 reverse
, context_die
);
13254 /* Else cv-qualified version of named type; fall through. */
13258 mod_scope
= scope_die_for (type
, context_die
);
13262 int sub_quals
= 0, first_quals
= 0;
13264 dw_die_ref first
= NULL
, last
= NULL
;
13266 /* Determine a lesser qualified type that most closely matches
13267 this one. Then generate DW_TAG_* entries for the remaining
13269 sub_quals
= get_nearest_type_subqualifiers (type
, cv_quals
,
13271 if (sub_quals
&& use_debug_types
)
13273 bool needed
= false;
13274 /* If emitting type units, make sure the order of qualifiers
13275 is canonical. Thus, start from unqualified type if
13276 an earlier qualifier is missing in sub_quals, but some later
13277 one is present there. */
13278 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13279 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
13281 else if (needed
&& (dwarf_qual_info
[i
].q
& cv_quals
))
13287 mod_type_die
= modified_type_die (type
, sub_quals
, reverse
, context_die
);
13288 if (mod_scope
&& mod_type_die
&& mod_type_die
->die_parent
== mod_scope
)
13290 /* As not all intermediate qualified DIEs have corresponding
13291 tree types, ensure that qualified DIEs in the same scope
13292 as their DW_AT_type are emitted after their DW_AT_type,
13293 only with other qualified DIEs for the same type possibly
13294 in between them. Determine the range of such qualified
13295 DIEs now (first being the base type, last being corresponding
13296 last qualified DIE for it). */
13297 unsigned int count
= 0;
13298 first
= qualified_die_p (mod_type_die
, &first_quals
,
13299 dwarf_qual_info_size
);
13301 first
= mod_type_die
;
13302 gcc_assert ((first_quals
& ~sub_quals
) == 0);
13303 for (count
= 0, last
= first
;
13304 count
< (1U << dwarf_qual_info_size
);
13305 count
++, last
= last
->die_sib
)
13308 if (last
== mod_scope
->die_child
)
13310 if (qualified_die_p (last
->die_sib
, &quals
, dwarf_qual_info_size
)
13316 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13317 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
13320 if (first
&& first
!= last
)
13322 for (d
= first
->die_sib
; ; d
= d
->die_sib
)
13325 qualified_die_p (d
, &quals
, dwarf_qual_info_size
);
13326 if (quals
== (first_quals
| dwarf_qual_info
[i
].q
))
13342 d
= new_die_raw (dwarf_qual_info
[i
].t
);
13343 add_child_die_after (mod_scope
, d
, last
);
13347 d
= new_die (dwarf_qual_info
[i
].t
, mod_scope
, type
);
13349 add_AT_die_ref (d
, DW_AT_type
, mod_type_die
);
13351 first_quals
|= dwarf_qual_info
[i
].q
;
13354 else if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
)
13356 dwarf_tag tag
= DW_TAG_pointer_type
;
13357 if (code
== REFERENCE_TYPE
)
13359 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
13360 tag
= DW_TAG_rvalue_reference_type
;
13362 tag
= DW_TAG_reference_type
;
13364 mod_type_die
= new_die (tag
, mod_scope
, type
);
13366 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
13367 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
13368 add_alignment_attribute (mod_type_die
, type
);
13369 item_type
= TREE_TYPE (type
);
13371 addr_space_t as
= TYPE_ADDR_SPACE (item_type
);
13372 if (!ADDR_SPACE_GENERIC_P (as
))
13374 int action
= targetm
.addr_space
.debug (as
);
13377 /* Positive values indicate an address_class. */
13378 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, action
);
13382 /* Negative values indicate an (inverted) segment base reg. */
13384 = one_reg_loc_descriptor (~action
, VAR_INIT_STATUS_INITIALIZED
);
13385 add_AT_loc (mod_type_die
, DW_AT_segment
, d
);
13389 else if (code
== INTEGER_TYPE
13390 && TREE_TYPE (type
) != NULL_TREE
13391 && subrange_type_for_debug_p (type
, &low
, &high
))
13393 tree bias
= NULL_TREE
;
13394 if (lang_hooks
.types
.get_type_bias
)
13395 bias
= lang_hooks
.types
.get_type_bias (type
);
13396 mod_type_die
= subrange_type_die (type
, low
, high
, bias
, context_die
);
13397 item_type
= TREE_TYPE (type
);
13399 else if (is_base_type (type
))
13401 mod_type_die
= base_type_die (type
, reverse
);
13403 /* The DIE with DW_AT_endianity is placed right after the naked DIE. */
13404 if (reverse_base_type
)
13406 dw_die_ref after_die
13407 = modified_type_die (type
, cv_quals
, false, context_die
);
13408 add_child_die_after (comp_unit_die (), mod_type_die
, after_die
);
13411 add_child_die (comp_unit_die (), mod_type_die
);
13413 add_pubtype (type
, mod_type_die
);
13417 gen_type_die (type
, context_die
);
13419 /* We have to get the type_main_variant here (and pass that to the
13420 `lookup_type_die' routine) because the ..._TYPE node we have
13421 might simply be a *copy* of some original type node (where the
13422 copy was created to help us keep track of typedef names) and
13423 that copy might have a different TYPE_UID from the original
13425 if (TREE_CODE (type
) == FUNCTION_TYPE
13426 || TREE_CODE (type
) == METHOD_TYPE
)
13428 /* For function/method types, can't just use type_main_variant here,
13429 because that can have different ref-qualifiers for C++,
13430 but try to canonicalize. */
13431 tree main
= TYPE_MAIN_VARIANT (type
);
13432 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
13433 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
13434 && check_base_type (t
, main
)
13435 && check_lang_type (t
, type
))
13436 return lookup_type_die (t
);
13437 return lookup_type_die (type
);
13439 else if (TREE_CODE (type
) != VECTOR_TYPE
13440 && TREE_CODE (type
) != ARRAY_TYPE
)
13441 return lookup_type_die (type_main_variant (type
));
13443 /* Vectors have the debugging information in the type,
13444 not the main variant. */
13445 return lookup_type_die (type
);
13448 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
13449 don't output a DW_TAG_typedef, since there isn't one in the
13450 user's program; just attach a DW_AT_name to the type.
13451 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
13452 if the base type already has the same name. */
13454 && ((TREE_CODE (name
) != TYPE_DECL
13455 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
13456 || (cv_quals
== TYPE_UNQUALIFIED
)))
13457 || (TREE_CODE (name
) == TYPE_DECL
13458 && TREE_TYPE (name
) == qualified_type
13459 && DECL_NAME (name
))))
13461 if (TREE_CODE (name
) == TYPE_DECL
)
13462 /* Could just call add_name_and_src_coords_attributes here,
13463 but since this is a builtin type it doesn't have any
13464 useful source coordinates anyway. */
13465 name
= DECL_NAME (name
);
13466 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
13468 /* This probably indicates a bug. */
13469 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
13471 name
= TYPE_IDENTIFIER (type
);
13472 add_name_attribute (mod_type_die
,
13473 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
13476 if (qualified_type
&& !reverse_base_type
)
13477 equate_type_number_to_die (qualified_type
, mod_type_die
);
13480 /* We must do this after the equate_type_number_to_die call, in case
13481 this is a recursive type. This ensures that the modified_type_die
13482 recursion will terminate even if the type is recursive. Recursive
13483 types are possible in Ada. */
13484 sub_die
= modified_type_die (item_type
,
13485 TYPE_QUALS_NO_ADDR_SPACE (item_type
),
13489 if (sub_die
!= NULL
)
13490 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
13492 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
13493 if (TYPE_ARTIFICIAL (type
))
13494 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
13496 return mod_type_die
;
13499 /* Generate DIEs for the generic parameters of T.
13500 T must be either a generic type or a generic function.
13501 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
13504 gen_generic_params_dies (tree t
)
13508 dw_die_ref die
= NULL
;
13511 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
13515 die
= lookup_type_die (t
);
13516 else if (DECL_P (t
))
13517 die
= lookup_decl_die (t
);
13521 parms
= lang_hooks
.get_innermost_generic_parms (t
);
13523 /* T has no generic parameter. It means T is neither a generic type
13524 or function. End of story. */
13527 parms_num
= TREE_VEC_LENGTH (parms
);
13528 args
= lang_hooks
.get_innermost_generic_args (t
);
13529 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
13530 non_default
= int_cst_value (TREE_CHAIN (args
));
13532 non_default
= TREE_VEC_LENGTH (args
);
13533 for (i
= 0; i
< parms_num
; i
++)
13535 tree parm
, arg
, arg_pack_elems
;
13536 dw_die_ref parm_die
;
13538 parm
= TREE_VEC_ELT (parms
, i
);
13539 arg
= TREE_VEC_ELT (args
, i
);
13540 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
13541 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
13543 if (parm
&& TREE_VALUE (parm
) && arg
)
13545 /* If PARM represents a template parameter pack,
13546 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
13547 by DW_TAG_template_*_parameter DIEs for the argument
13548 pack elements of ARG. Note that ARG would then be
13549 an argument pack. */
13550 if (arg_pack_elems
)
13551 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
13555 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
13556 true /* emit name */, die
);
13557 if (i
>= non_default
)
13558 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
13563 /* Create and return a DIE for PARM which should be
13564 the representation of a generic type parameter.
13565 For instance, in the C++ front end, PARM would be a template parameter.
13566 ARG is the argument to PARM.
13567 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
13569 PARENT_DIE is the parent DIE which the new created DIE should be added to,
13570 as a child node. */
13573 generic_parameter_die (tree parm
, tree arg
,
13575 dw_die_ref parent_die
)
13577 dw_die_ref tmpl_die
= NULL
;
13578 const char *name
= NULL
;
13580 if (!parm
|| !DECL_NAME (parm
) || !arg
)
13583 /* We support non-type generic parameters and arguments,
13584 type generic parameters and arguments, as well as
13585 generic generic parameters (a.k.a. template template parameters in C++)
13587 if (TREE_CODE (parm
) == PARM_DECL
)
13588 /* PARM is a nontype generic parameter */
13589 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
13590 else if (TREE_CODE (parm
) == TYPE_DECL
)
13591 /* PARM is a type generic parameter. */
13592 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
13593 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
13594 /* PARM is a generic generic parameter.
13595 Its DIE is a GNU extension. It shall have a
13596 DW_AT_name attribute to represent the name of the template template
13597 parameter, and a DW_AT_GNU_template_name attribute to represent the
13598 name of the template template argument. */
13599 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
13602 gcc_unreachable ();
13608 /* If PARM is a generic parameter pack, it means we are
13609 emitting debug info for a template argument pack element.
13610 In other terms, ARG is a template argument pack element.
13611 In that case, we don't emit any DW_AT_name attribute for
13615 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
13617 add_AT_string (tmpl_die
, DW_AT_name
, name
);
13620 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
13622 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
13623 TMPL_DIE should have a child DW_AT_type attribute that is set
13624 to the type of the argument to PARM, which is ARG.
13625 If PARM is a type generic parameter, TMPL_DIE should have a
13626 child DW_AT_type that is set to ARG. */
13627 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
13628 add_type_attribute (tmpl_die
, tmpl_type
,
13629 (TREE_THIS_VOLATILE (tmpl_type
)
13630 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
),
13631 false, parent_die
);
13635 /* So TMPL_DIE is a DIE representing a
13636 a generic generic template parameter, a.k.a template template
13637 parameter in C++ and arg is a template. */
13639 /* The DW_AT_GNU_template_name attribute of the DIE must be set
13640 to the name of the argument. */
13641 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
13643 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
13646 if (TREE_CODE (parm
) == PARM_DECL
)
13647 /* So PARM is a non-type generic parameter.
13648 DWARF3 5.6.8 says we must set a DW_AT_const_value child
13649 attribute of TMPL_DIE which value represents the value
13651 We must be careful here:
13652 The value of ARG might reference some function decls.
13653 We might currently be emitting debug info for a generic
13654 type and types are emitted before function decls, we don't
13655 know if the function decls referenced by ARG will actually be
13656 emitted after cgraph computations.
13657 So must defer the generation of the DW_AT_const_value to
13658 after cgraph is ready. */
13659 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
13665 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
13666 PARM_PACK must be a template parameter pack. The returned DIE
13667 will be child DIE of PARENT_DIE. */
13670 template_parameter_pack_die (tree parm_pack
,
13671 tree parm_pack_args
,
13672 dw_die_ref parent_die
)
13677 gcc_assert (parent_die
&& parm_pack
);
13679 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
13680 add_name_and_src_coords_attributes (die
, parm_pack
);
13681 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
13682 generic_parameter_die (parm_pack
,
13683 TREE_VEC_ELT (parm_pack_args
, j
),
13684 false /* Don't emit DW_AT_name */,
13689 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
13690 an enumerated type. */
13693 type_is_enum (const_tree type
)
13695 return TREE_CODE (type
) == ENUMERAL_TYPE
;
13698 /* Return the DBX register number described by a given RTL node. */
13700 static unsigned int
13701 dbx_reg_number (const_rtx rtl
)
13703 unsigned regno
= REGNO (rtl
);
13705 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
13707 #ifdef LEAF_REG_REMAP
13708 if (crtl
->uses_only_leaf_regs
)
13710 int leaf_reg
= LEAF_REG_REMAP (regno
);
13711 if (leaf_reg
!= -1)
13712 regno
= (unsigned) leaf_reg
;
13716 regno
= DBX_REGISTER_NUMBER (regno
);
13717 gcc_assert (regno
!= INVALID_REGNUM
);
13721 /* Optionally add a DW_OP_piece term to a location description expression.
13722 DW_OP_piece is only added if the location description expression already
13723 doesn't end with DW_OP_piece. */
13726 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
13728 dw_loc_descr_ref loc
;
13730 if (*list_head
!= NULL
)
13732 /* Find the end of the chain. */
13733 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
13736 if (loc
->dw_loc_opc
!= DW_OP_piece
)
13737 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
13741 /* Return a location descriptor that designates a machine register or
13742 zero if there is none. */
13744 static dw_loc_descr_ref
13745 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
13749 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
13752 /* We only use "frame base" when we're sure we're talking about the
13753 post-prologue local stack frame. We do this by *not* running
13754 register elimination until this point, and recognizing the special
13755 argument pointer and soft frame pointer rtx's.
13756 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
13757 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
13758 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
13760 dw_loc_descr_ref result
= NULL
;
13762 if (dwarf_version
>= 4 || !dwarf_strict
)
13764 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
13767 add_loc_descr (&result
,
13768 new_loc_descr (DW_OP_stack_value
, 0, 0));
13773 regs
= targetm
.dwarf_register_span (rtl
);
13775 if (REG_NREGS (rtl
) > 1 || regs
)
13776 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
13779 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
13780 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
13782 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
13786 /* Return a location descriptor that designates a machine register for
13787 a given hard register number. */
13789 static dw_loc_descr_ref
13790 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
13792 dw_loc_descr_ref reg_loc_descr
;
13796 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
13798 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
13800 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13801 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13803 return reg_loc_descr
;
13806 /* Given an RTL of a register, return a location descriptor that
13807 designates a value that spans more than one register. */
13809 static dw_loc_descr_ref
13810 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
13811 enum var_init_status initialized
)
13814 dw_loc_descr_ref loc_result
= NULL
;
13816 /* Simple, contiguous registers. */
13817 if (regs
== NULL_RTX
)
13819 unsigned reg
= REGNO (rtl
);
13822 #ifdef LEAF_REG_REMAP
13823 if (crtl
->uses_only_leaf_regs
)
13825 int leaf_reg
= LEAF_REG_REMAP (reg
);
13826 if (leaf_reg
!= -1)
13827 reg
= (unsigned) leaf_reg
;
13831 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
13832 nregs
= REG_NREGS (rtl
);
13834 /* At present we only track constant-sized pieces. */
13835 if (!GET_MODE_SIZE (GET_MODE (rtl
)).is_constant (&size
))
13842 dw_loc_descr_ref t
;
13844 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
13845 VAR_INIT_STATUS_INITIALIZED
);
13846 add_loc_descr (&loc_result
, t
);
13847 add_loc_descr_op_piece (&loc_result
, size
);
13853 /* Now onto stupid register sets in non contiguous locations. */
13855 gcc_assert (GET_CODE (regs
) == PARALLEL
);
13857 /* At present we only track constant-sized pieces. */
13858 if (!GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0))).is_constant (&size
))
13862 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
13864 dw_loc_descr_ref t
;
13866 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
13867 VAR_INIT_STATUS_INITIALIZED
);
13868 add_loc_descr (&loc_result
, t
);
13869 add_loc_descr_op_piece (&loc_result
, size
);
13872 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13873 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13877 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
13879 /* Return a location descriptor that designates a constant i,
13880 as a compound operation from constant (i >> shift), constant shift
13883 static dw_loc_descr_ref
13884 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
13886 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
13887 add_loc_descr (&ret
, int_loc_descriptor (shift
));
13888 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
13892 /* Return a location descriptor that designates constant POLY_I. */
13894 static dw_loc_descr_ref
13895 int_loc_descriptor (poly_int64 poly_i
)
13897 enum dwarf_location_atom op
;
13900 if (!poly_i
.is_constant (&i
))
13902 /* Create location descriptions for the non-constant part and
13903 add any constant offset at the end. */
13904 dw_loc_descr_ref ret
= NULL
;
13905 HOST_WIDE_INT constant
= poly_i
.coeffs
[0];
13906 for (unsigned int j
= 1; j
< NUM_POLY_INT_COEFFS
; ++j
)
13908 HOST_WIDE_INT coeff
= poly_i
.coeffs
[j
];
13911 dw_loc_descr_ref start
= ret
;
13912 unsigned int factor
;
13914 unsigned int regno
= targetm
.dwarf_poly_indeterminate_value
13915 (j
, &factor
, &bias
);
13917 /* Add COEFF * ((REGNO / FACTOR) - BIAS) to the value:
13918 add COEFF * (REGNO / FACTOR) now and subtract
13919 COEFF * BIAS from the final constant part. */
13920 constant
-= coeff
* bias
;
13921 add_loc_descr (&ret
, new_reg_loc_descr (regno
, 0));
13922 if (coeff
% factor
== 0)
13926 int amount
= exact_log2 (factor
);
13927 gcc_assert (amount
>= 0);
13928 add_loc_descr (&ret
, int_loc_descriptor (amount
));
13929 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
13933 add_loc_descr (&ret
, int_loc_descriptor (coeff
));
13934 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
13937 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
13940 loc_descr_plus_const (&ret
, constant
);
13944 /* Pick the smallest representation of a constant, rather than just
13945 defaulting to the LEB encoding. */
13948 int clz
= clz_hwi (i
);
13949 int ctz
= ctz_hwi (i
);
13951 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
13952 else if (i
<= 0xff)
13953 op
= DW_OP_const1u
;
13954 else if (i
<= 0xffff)
13955 op
= DW_OP_const2u
;
13956 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
13957 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
13958 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
13959 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
13960 while DW_OP_const4u is 5 bytes. */
13961 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
13962 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13963 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
13964 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
13965 while DW_OP_const4u is 5 bytes. */
13966 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
13968 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
13969 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
13972 /* As i >= 2**31, the double cast above will yield a negative number.
13973 Since wrapping is defined in DWARF expressions we can output big
13974 positive integers as small negative ones, regardless of the size
13977 Here, since the evaluator will handle 32-bit values and since i >=
13978 2**31, we know it's going to be interpreted as a negative literal:
13979 store it this way if we can do better than 5 bytes this way. */
13980 return int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
13982 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
13983 op
= DW_OP_const4u
;
13985 /* Past this point, i >= 0x100000000 and thus DW_OP_constu will take at
13986 least 6 bytes: see if we can do better before falling back to it. */
13987 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13988 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
13989 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes. */
13990 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
13991 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
13992 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
13993 >= HOST_BITS_PER_WIDE_INT
)
13994 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
13995 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes. */
13996 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
13997 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
13998 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
13999 && size_of_uleb128 (i
) > 6)
14000 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
14001 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
14008 op
= DW_OP_const1s
;
14009 else if (i
>= -0x8000)
14010 op
= DW_OP_const2s
;
14011 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
14013 if (size_of_int_loc_descriptor (i
) < 5)
14015 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
14016 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14019 op
= DW_OP_const4s
;
14023 if (size_of_int_loc_descriptor (i
)
14024 < (unsigned long) 1 + size_of_sleb128 (i
))
14026 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
14027 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14034 return new_loc_descr (op
, i
, 0);
14037 /* Likewise, for unsigned constants. */
14039 static dw_loc_descr_ref
14040 uint_loc_descriptor (unsigned HOST_WIDE_INT i
)
14042 const unsigned HOST_WIDE_INT max_int
= INTTYPE_MAXIMUM (HOST_WIDE_INT
);
14043 const unsigned HOST_WIDE_INT max_uint
14044 = INTTYPE_MAXIMUM (unsigned HOST_WIDE_INT
);
14046 /* If possible, use the clever signed constants handling. */
14048 return int_loc_descriptor ((HOST_WIDE_INT
) i
);
14050 /* Here, we are left with positive numbers that cannot be represented as
14051 HOST_WIDE_INT, i.e.:
14052 max (HOST_WIDE_INT) < i <= max (unsigned HOST_WIDE_INT)
14054 Using DW_OP_const4/8/./u operation to encode them consumes a lot of bytes
14055 whereas may be better to output a negative integer: thanks to integer
14056 wrapping, we know that:
14057 x = x - 2 ** DWARF2_ADDR_SIZE
14058 = x - 2 * (max (HOST_WIDE_INT) + 1)
14059 So numbers close to max (unsigned HOST_WIDE_INT) could be represented as
14060 small negative integers. Let's try that in cases it will clearly improve
14061 the encoding: there is no gain turning DW_OP_const4u into
14063 if (DWARF2_ADDR_SIZE
* 8 == HOST_BITS_PER_WIDE_INT
14064 && ((DWARF2_ADDR_SIZE
== 4 && i
> max_uint
- 0x8000)
14065 || (DWARF2_ADDR_SIZE
== 8 && i
> max_uint
- 0x80000000)))
14067 const unsigned HOST_WIDE_INT first_shift
= i
- max_int
- 1;
14069 /* Now, -1 < first_shift <= max (HOST_WIDE_INT)
14070 i.e. 0 <= first_shift <= max (HOST_WIDE_INT). */
14071 const HOST_WIDE_INT second_shift
14072 = (HOST_WIDE_INT
) first_shift
- (HOST_WIDE_INT
) max_int
- 1;
14074 /* So we finally have:
14075 -max (HOST_WIDE_INT) - 1 <= second_shift <= -1.
14076 i.e. min (HOST_WIDE_INT) <= second_shift < 0. */
14077 return int_loc_descriptor (second_shift
);
14080 /* Last chance: fallback to a simple constant operation. */
14081 return new_loc_descr
14082 ((HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14088 /* Generate and return a location description that computes the unsigned
14089 comparison of the two stack top entries (a OP b where b is the top-most
14090 entry and a is the second one). The KIND of comparison can be LT_EXPR,
14091 LE_EXPR, GT_EXPR or GE_EXPR. */
14093 static dw_loc_descr_ref
14094 uint_comparison_loc_list (enum tree_code kind
)
14096 enum dwarf_location_atom op
, flip_op
;
14097 dw_loc_descr_ref ret
, bra_node
, jmp_node
, tmp
;
14114 gcc_unreachable ();
14117 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14118 jmp_node
= new_loc_descr (DW_OP_skip
, 0, 0);
14120 /* Until DWARFv4, operations all work on signed integers. It is nevertheless
14121 possible to perform unsigned comparisons: we just have to distinguish
14124 1. when a and b have the same sign (as signed integers); then we should
14125 return: a OP(signed) b;
14127 2. when a is a negative signed integer while b is a positive one, then a
14128 is a greater unsigned integer than b; likewise when a and b's roles
14131 So first, compare the sign of the two operands. */
14132 ret
= new_loc_descr (DW_OP_over
, 0, 0);
14133 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
14134 add_loc_descr (&ret
, new_loc_descr (DW_OP_xor
, 0, 0));
14135 /* If they have different signs (i.e. they have different sign bits), then
14136 the stack top value has now the sign bit set and thus it's smaller than
14138 add_loc_descr (&ret
, new_loc_descr (DW_OP_lit0
, 0, 0));
14139 add_loc_descr (&ret
, new_loc_descr (DW_OP_lt
, 0, 0));
14140 add_loc_descr (&ret
, bra_node
);
14142 /* We are in case 1. At this point, we know both operands have the same
14143 sign, to it's safe to use the built-in signed comparison. */
14144 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14145 add_loc_descr (&ret
, jmp_node
);
14147 /* We are in case 2. Here, we know both operands do not have the same sign,
14148 so we have to flip the signed comparison. */
14149 flip_op
= (kind
== LT_EXPR
|| kind
== LE_EXPR
) ? DW_OP_gt
: DW_OP_lt
;
14150 tmp
= new_loc_descr (flip_op
, 0, 0);
14151 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14152 bra_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14153 add_loc_descr (&ret
, tmp
);
14155 /* This dummy operation is necessary to make the two branches join. */
14156 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
14157 jmp_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14158 jmp_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14159 add_loc_descr (&ret
, tmp
);
14164 /* Likewise, but takes the location description lists (might be destructive on
14165 them). Return NULL if either is NULL or if concatenation fails. */
14167 static dw_loc_list_ref
14168 loc_list_from_uint_comparison (dw_loc_list_ref left
, dw_loc_list_ref right
,
14169 enum tree_code kind
)
14171 if (left
== NULL
|| right
== NULL
)
14174 add_loc_list (&left
, right
);
14178 add_loc_descr_to_each (left
, uint_comparison_loc_list (kind
));
14182 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
14183 without actually allocating it. */
14185 static unsigned long
14186 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
14188 return size_of_int_loc_descriptor (i
>> shift
)
14189 + size_of_int_loc_descriptor (shift
)
14193 /* Return size_of_locs (int_loc_descriptor (i)) without
14194 actually allocating it. */
14196 static unsigned long
14197 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
14206 else if (i
<= 0xff)
14208 else if (i
<= 0xffff)
14212 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
14213 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
14214 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14216 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14217 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
14218 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14220 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
14221 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
14223 return size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
14224 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14226 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
14227 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14228 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
14229 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14231 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
14232 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
14233 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14235 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
14236 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
14238 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14247 else if (i
>= -0x8000)
14249 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
14251 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
14253 s
= size_of_int_loc_descriptor (-i
) + 1;
14261 unsigned long r
= 1 + size_of_sleb128 (i
);
14262 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
14264 s
= size_of_int_loc_descriptor (-i
) + 1;
14273 /* Return loc description representing "address" of integer value.
14274 This can appear only as toplevel expression. */
14276 static dw_loc_descr_ref
14277 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
14280 dw_loc_descr_ref loc_result
= NULL
;
14282 if (!(dwarf_version
>= 4 || !dwarf_strict
))
14285 litsize
= size_of_int_loc_descriptor (i
);
14286 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
14287 is more compact. For DW_OP_stack_value we need:
14288 litsize + 1 (DW_OP_stack_value)
14289 and for DW_OP_implicit_value:
14290 1 (DW_OP_implicit_value) + 1 (length) + size. */
14291 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
14293 loc_result
= int_loc_descriptor (i
);
14294 add_loc_descr (&loc_result
,
14295 new_loc_descr (DW_OP_stack_value
, 0, 0));
14299 loc_result
= new_loc_descr (DW_OP_implicit_value
,
14301 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
14302 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
14306 /* Return a location descriptor that designates a base+offset location. */
14308 static dw_loc_descr_ref
14309 based_loc_descr (rtx reg
, poly_int64 offset
,
14310 enum var_init_status initialized
)
14312 unsigned int regno
;
14313 dw_loc_descr_ref result
;
14314 dw_fde_ref fde
= cfun
->fde
;
14316 /* We only use "frame base" when we're sure we're talking about the
14317 post-prologue local stack frame. We do this by *not* running
14318 register elimination until this point, and recognizing the special
14319 argument pointer and soft frame pointer rtx's. */
14320 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
14322 rtx elim
= (ira_use_lra_p
14323 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
14324 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
14328 /* Allow hard frame pointer here even if frame pointer
14329 isn't used since hard frame pointer is encoded with
14330 DW_OP_fbreg which uses the DW_AT_frame_base attribute,
14331 not hard frame pointer directly. */
14332 elim
= strip_offset_and_add (elim
, &offset
);
14333 gcc_assert (elim
== hard_frame_pointer_rtx
14334 || elim
== stack_pointer_rtx
);
14336 /* If drap register is used to align stack, use frame
14337 pointer + offset to access stack variables. If stack
14338 is aligned without drap, use stack pointer + offset to
14339 access stack variables. */
14340 if (crtl
->stack_realign_tried
14341 && reg
== frame_pointer_rtx
)
14344 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
14345 ? HARD_FRAME_POINTER_REGNUM
14347 return new_reg_loc_descr (base_reg
, offset
);
14350 gcc_assert (frame_pointer_fb_offset_valid
);
14351 offset
+= frame_pointer_fb_offset
;
14352 HOST_WIDE_INT const_offset
;
14353 if (offset
.is_constant (&const_offset
))
14354 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
14357 dw_loc_descr_ref ret
= new_loc_descr (DW_OP_fbreg
, 0, 0);
14358 loc_descr_plus_const (&ret
, offset
);
14364 regno
= REGNO (reg
);
14365 #ifdef LEAF_REG_REMAP
14366 if (crtl
->uses_only_leaf_regs
)
14368 int leaf_reg
= LEAF_REG_REMAP (regno
);
14369 if (leaf_reg
!= -1)
14370 regno
= (unsigned) leaf_reg
;
14373 regno
= DWARF_FRAME_REGNUM (regno
);
14375 HOST_WIDE_INT const_offset
;
14376 if (!optimize
&& fde
14377 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
)
14378 && offset
.is_constant (&const_offset
))
14380 /* Use cfa+offset to represent the location of arguments passed
14381 on the stack when drap is used to align stack.
14382 Only do this when not optimizing, for optimized code var-tracking
14383 is supposed to track where the arguments live and the register
14384 used as vdrap or drap in some spot might be used for something
14385 else in other part of the routine. */
14386 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
14389 result
= new_reg_loc_descr (regno
, offset
);
14391 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14392 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14397 /* Return true if this RTL expression describes a base+offset calculation. */
14400 is_based_loc (const_rtx rtl
)
14402 return (GET_CODE (rtl
) == PLUS
14403 && ((REG_P (XEXP (rtl
, 0))
14404 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
14405 && CONST_INT_P (XEXP (rtl
, 1)))));
14408 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
14411 static dw_loc_descr_ref
14412 tls_mem_loc_descriptor (rtx mem
)
14415 dw_loc_descr_ref loc_result
;
14417 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
14420 base
= get_base_address (MEM_EXPR (mem
));
14423 || !DECL_THREAD_LOCAL_P (base
))
14426 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1, NULL
);
14427 if (loc_result
== NULL
)
14430 if (maybe_ne (MEM_OFFSET (mem
), 0))
14431 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
14436 /* Output debug info about reason why we failed to expand expression as dwarf
14440 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
14442 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
14444 fprintf (dump_file
, "Failed to expand as dwarf: ");
14446 print_generic_expr (dump_file
, expr
, dump_flags
);
14449 fprintf (dump_file
, "\n");
14450 print_rtl (dump_file
, rtl
);
14452 fprintf (dump_file
, "\nReason: %s\n", reason
);
14456 /* Helper function for const_ok_for_output. */
14459 const_ok_for_output_1 (rtx rtl
)
14461 if (targetm
.const_not_ok_for_debug_p (rtl
))
14463 if (GET_CODE (rtl
) != UNSPEC
)
14465 expansion_failed (NULL_TREE
, rtl
,
14466 "Expression rejected for debug by the backend.\n");
14470 /* If delegitimize_address couldn't do anything with the UNSPEC, and
14471 the target hook doesn't explicitly allow it in debug info, assume
14472 we can't express it in the debug info. */
14473 /* Don't complain about TLS UNSPECs, those are just too hard to
14474 delegitimize. Note this could be a non-decl SYMBOL_REF such as
14475 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
14476 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
14478 && (XVECLEN (rtl
, 0) == 0
14479 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
14480 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
))
14481 inform (current_function_decl
14482 ? DECL_SOURCE_LOCATION (current_function_decl
)
14483 : UNKNOWN_LOCATION
,
14484 #if NUM_UNSPEC_VALUES > 0
14485 "non-delegitimized UNSPEC %s (%d) found in variable location",
14486 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
14487 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
14490 "non-delegitimized UNSPEC %d found in variable location",
14493 expansion_failed (NULL_TREE
, rtl
,
14494 "UNSPEC hasn't been delegitimized.\n");
14498 if (CONST_POLY_INT_P (rtl
))
14501 if (targetm
.const_not_ok_for_debug_p (rtl
))
14503 expansion_failed (NULL_TREE
, rtl
,
14504 "Expression rejected for debug by the backend.\n");
14508 /* FIXME: Refer to PR60655. It is possible for simplification
14509 of rtl expressions in var tracking to produce such expressions.
14510 We should really identify / validate expressions
14511 enclosed in CONST that can be handled by assemblers on various
14512 targets and only handle legitimate cases here. */
14513 switch (GET_CODE (rtl
))
14524 if (CONSTANT_POOL_ADDRESS_P (rtl
))
14527 get_pool_constant_mark (rtl
, &marked
);
14528 /* If all references to this pool constant were optimized away,
14529 it was not output and thus we can't represent it. */
14532 expansion_failed (NULL_TREE
, rtl
,
14533 "Constant was removed from constant pool.\n");
14538 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
14541 /* Avoid references to external symbols in debug info, on several targets
14542 the linker might even refuse to link when linking a shared library,
14543 and in many other cases the relocations for .debug_info/.debug_loc are
14544 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
14545 to be defined within the same shared library or executable are fine. */
14546 if (SYMBOL_REF_EXTERNAL_P (rtl
))
14548 tree decl
= SYMBOL_REF_DECL (rtl
);
14550 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
14552 expansion_failed (NULL_TREE
, rtl
,
14553 "Symbol not defined in current TU.\n");
14561 /* Return true if constant RTL can be emitted in DW_OP_addr or
14562 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
14563 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
14566 const_ok_for_output (rtx rtl
)
14568 if (GET_CODE (rtl
) == SYMBOL_REF
)
14569 return const_ok_for_output_1 (rtl
);
14571 if (GET_CODE (rtl
) == CONST
)
14573 subrtx_var_iterator::array_type array
;
14574 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
14575 if (!const_ok_for_output_1 (*iter
))
14583 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
14584 if possible, NULL otherwise. */
14587 base_type_for_mode (machine_mode mode
, bool unsignedp
)
14589 dw_die_ref type_die
;
14590 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
14594 switch (TREE_CODE (type
))
14602 type_die
= lookup_type_die (type
);
14604 type_die
= modified_type_die (type
, TYPE_UNQUALIFIED
, false,
14606 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
14611 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
14612 type matching MODE, or, if MODE is narrower than or as wide as
14613 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
14616 static dw_loc_descr_ref
14617 convert_descriptor_to_mode (scalar_int_mode mode
, dw_loc_descr_ref op
)
14619 machine_mode outer_mode
= mode
;
14620 dw_die_ref type_die
;
14621 dw_loc_descr_ref cvt
;
14623 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
14625 add_loc_descr (&op
, new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0));
14628 type_die
= base_type_for_mode (outer_mode
, 1);
14629 if (type_die
== NULL
)
14631 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14632 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14633 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14634 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14635 add_loc_descr (&op
, cvt
);
14639 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
14641 static dw_loc_descr_ref
14642 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
14643 dw_loc_descr_ref op1
)
14645 dw_loc_descr_ref ret
= op0
;
14646 add_loc_descr (&ret
, op1
);
14647 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14648 if (STORE_FLAG_VALUE
!= 1)
14650 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
14651 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
14656 /* Subroutine of scompare_loc_descriptor for the case in which we're
14657 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
14658 and in which OP_MODE is bigger than DWARF2_ADDR_SIZE. */
14660 static dw_loc_descr_ref
14661 scompare_loc_descriptor_wide (enum dwarf_location_atom op
,
14662 scalar_int_mode op_mode
,
14663 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
14665 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
14666 dw_loc_descr_ref cvt
;
14668 if (type_die
== NULL
)
14670 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14671 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14672 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14673 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14674 add_loc_descr (&op0
, cvt
);
14675 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14676 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14677 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14678 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14679 add_loc_descr (&op1
, cvt
);
14680 return compare_loc_descriptor (op
, op0
, op1
);
14683 /* Subroutine of scompare_loc_descriptor for the case in which we're
14684 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
14685 and in which OP_MODE is smaller than DWARF2_ADDR_SIZE. */
14687 static dw_loc_descr_ref
14688 scompare_loc_descriptor_narrow (enum dwarf_location_atom op
, rtx rtl
,
14689 scalar_int_mode op_mode
,
14690 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
14692 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
14693 /* For eq/ne, if the operands are known to be zero-extended,
14694 there is no need to do the fancy shifting up. */
14695 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
14697 dw_loc_descr_ref last0
, last1
;
14698 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
14700 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
14702 /* deref_size zero extends, and for constants we can check
14703 whether they are zero extended or not. */
14704 if (((last0
->dw_loc_opc
== DW_OP_deref_size
14705 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
14706 || (CONST_INT_P (XEXP (rtl
, 0))
14707 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
14708 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
14709 && ((last1
->dw_loc_opc
== DW_OP_deref_size
14710 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
14711 || (CONST_INT_P (XEXP (rtl
, 1))
14712 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
14713 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
14714 return compare_loc_descriptor (op
, op0
, op1
);
14716 /* EQ/NE comparison against constant in narrower type than
14717 DWARF2_ADDR_SIZE can be performed either as
14718 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
14721 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
14722 DW_OP_{eq,ne}. Pick whatever is shorter. */
14723 if (CONST_INT_P (XEXP (rtl
, 1))
14724 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
14725 && (size_of_int_loc_descriptor (shift
) + 1
14726 + size_of_int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
)
14727 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
14728 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
14729 & GET_MODE_MASK (op_mode
))))
14731 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
14732 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14733 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
14734 & GET_MODE_MASK (op_mode
));
14735 return compare_loc_descriptor (op
, op0
, op1
);
14738 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14739 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14740 if (CONST_INT_P (XEXP (rtl
, 1)))
14741 op1
= int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
);
14744 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14745 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14747 return compare_loc_descriptor (op
, op0
, op1
);
14750 /* Return location descriptor for unsigned comparison OP RTL. */
14752 static dw_loc_descr_ref
14753 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
14754 machine_mode mem_mode
)
14756 machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
14757 dw_loc_descr_ref op0
, op1
;
14759 if (op_mode
== VOIDmode
)
14760 op_mode
= GET_MODE (XEXP (rtl
, 1));
14761 if (op_mode
== VOIDmode
)
14764 scalar_int_mode int_op_mode
;
14766 && dwarf_version
< 5
14767 && (!is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
)
14768 || GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
))
14771 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
14772 VAR_INIT_STATUS_INITIALIZED
);
14773 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
14774 VAR_INIT_STATUS_INITIALIZED
);
14776 if (op0
== NULL
|| op1
== NULL
)
14779 if (is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
))
14781 if (GET_MODE_SIZE (int_op_mode
) < DWARF2_ADDR_SIZE
)
14782 return scompare_loc_descriptor_narrow (op
, rtl
, int_op_mode
, op0
, op1
);
14784 if (GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
)
14785 return scompare_loc_descriptor_wide (op
, int_op_mode
, op0
, op1
);
14787 return compare_loc_descriptor (op
, op0
, op1
);
14790 /* Return location descriptor for unsigned comparison OP RTL. */
14792 static dw_loc_descr_ref
14793 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
14794 machine_mode mem_mode
)
14796 dw_loc_descr_ref op0
, op1
;
14798 machine_mode test_op_mode
= GET_MODE (XEXP (rtl
, 0));
14799 if (test_op_mode
== VOIDmode
)
14800 test_op_mode
= GET_MODE (XEXP (rtl
, 1));
14802 scalar_int_mode op_mode
;
14803 if (!is_a
<scalar_int_mode
> (test_op_mode
, &op_mode
))
14807 && dwarf_version
< 5
14808 && GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
14811 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
14812 VAR_INIT_STATUS_INITIALIZED
);
14813 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
14814 VAR_INIT_STATUS_INITIALIZED
);
14816 if (op0
== NULL
|| op1
== NULL
)
14819 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
14821 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
14822 dw_loc_descr_ref last0
, last1
;
14823 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
14825 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
14827 if (CONST_INT_P (XEXP (rtl
, 0)))
14828 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
14829 /* deref_size zero extends, so no need to mask it again. */
14830 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
14831 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
14833 add_loc_descr (&op0
, int_loc_descriptor (mask
));
14834 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14836 if (CONST_INT_P (XEXP (rtl
, 1)))
14837 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
14838 /* deref_size zero extends, so no need to mask it again. */
14839 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
14840 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
14842 add_loc_descr (&op1
, int_loc_descriptor (mask
));
14843 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
14846 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
14848 HOST_WIDE_INT bias
= 1;
14849 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
14850 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14851 if (CONST_INT_P (XEXP (rtl
, 1)))
14852 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
14853 + INTVAL (XEXP (rtl
, 1)));
14855 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
14858 return compare_loc_descriptor (op
, op0
, op1
);
14861 /* Return location descriptor for {U,S}{MIN,MAX}. */
14863 static dw_loc_descr_ref
14864 minmax_loc_descriptor (rtx rtl
, machine_mode mode
,
14865 machine_mode mem_mode
)
14867 enum dwarf_location_atom op
;
14868 dw_loc_descr_ref op0
, op1
, ret
;
14869 dw_loc_descr_ref bra_node
, drop_node
;
14871 scalar_int_mode int_mode
;
14873 && dwarf_version
< 5
14874 && (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
14875 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
))
14878 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14879 VAR_INIT_STATUS_INITIALIZED
);
14880 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
14881 VAR_INIT_STATUS_INITIALIZED
);
14883 if (op0
== NULL
|| op1
== NULL
)
14886 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
14887 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
14888 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
14889 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
14891 /* Checked by the caller. */
14892 int_mode
= as_a
<scalar_int_mode
> (mode
);
14893 if (GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
14895 HOST_WIDE_INT mask
= GET_MODE_MASK (int_mode
);
14896 add_loc_descr (&op0
, int_loc_descriptor (mask
));
14897 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14898 add_loc_descr (&op1
, int_loc_descriptor (mask
));
14899 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
14901 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
14903 HOST_WIDE_INT bias
= 1;
14904 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
14905 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14906 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14909 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14910 && GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
14912 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (int_mode
)) * BITS_PER_UNIT
;
14913 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14914 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14915 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14916 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14918 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14919 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
14921 dw_die_ref type_die
= base_type_for_mode (int_mode
, 0);
14922 dw_loc_descr_ref cvt
;
14923 if (type_die
== NULL
)
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 (&op0
, cvt
);
14930 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14931 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14932 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14933 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14934 add_loc_descr (&op1
, cvt
);
14937 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
14942 add_loc_descr (&ret
, op1
);
14943 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14944 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14945 add_loc_descr (&ret
, bra_node
);
14946 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14947 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
14948 add_loc_descr (&ret
, drop_node
);
14949 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14950 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
14951 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
14952 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
14953 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
14954 ret
= convert_descriptor_to_mode (int_mode
, ret
);
14958 /* Helper function for mem_loc_descriptor. Perform OP binary op,
14959 but after converting arguments to type_die, afterwards
14960 convert back to unsigned. */
14962 static dw_loc_descr_ref
14963 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
14964 scalar_int_mode mode
, machine_mode mem_mode
)
14966 dw_loc_descr_ref cvt
, op0
, op1
;
14968 if (type_die
== NULL
)
14970 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14971 VAR_INIT_STATUS_INITIALIZED
);
14972 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
14973 VAR_INIT_STATUS_INITIALIZED
);
14974 if (op0
== NULL
|| op1
== NULL
)
14976 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14977 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14978 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14979 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14980 add_loc_descr (&op0
, cvt
);
14981 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14982 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14983 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14984 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14985 add_loc_descr (&op1
, cvt
);
14986 add_loc_descr (&op0
, op1
);
14987 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
14988 return convert_descriptor_to_mode (mode
, op0
);
14991 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
14992 const0 is DW_OP_lit0 or corresponding typed constant,
14993 const1 is DW_OP_lit1 or corresponding typed constant
14994 and constMSB is constant with just the MSB bit set
14996 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
14997 L1: const0 DW_OP_swap
14998 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
14999 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15004 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
15005 L1: const0 DW_OP_swap
15006 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
15007 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15012 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
15013 L1: const1 DW_OP_swap
15014 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
15015 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15019 static dw_loc_descr_ref
15020 clz_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15021 machine_mode mem_mode
)
15023 dw_loc_descr_ref op0
, ret
, tmp
;
15024 HOST_WIDE_INT valv
;
15025 dw_loc_descr_ref l1jump
, l1label
;
15026 dw_loc_descr_ref l2jump
, l2label
;
15027 dw_loc_descr_ref l3jump
, l3label
;
15028 dw_loc_descr_ref l4jump
, l4label
;
15031 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
15034 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15035 VAR_INIT_STATUS_INITIALIZED
);
15039 if (GET_CODE (rtl
) == CLZ
)
15041 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
15042 valv
= GET_MODE_BITSIZE (mode
);
15044 else if (GET_CODE (rtl
) == FFS
)
15046 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
15047 valv
= GET_MODE_BITSIZE (mode
);
15048 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15049 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15050 add_loc_descr (&ret
, l1jump
);
15051 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
15052 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
15053 VAR_INIT_STATUS_INITIALIZED
);
15056 add_loc_descr (&ret
, tmp
);
15057 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15058 add_loc_descr (&ret
, l4jump
);
15059 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
15060 ? const1_rtx
: const0_rtx
,
15062 VAR_INIT_STATUS_INITIALIZED
);
15063 if (l1label
== NULL
)
15065 add_loc_descr (&ret
, l1label
);
15066 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15067 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
15068 add_loc_descr (&ret
, l2label
);
15069 if (GET_CODE (rtl
) != CLZ
)
15071 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
15072 msb
= GEN_INT (HOST_WIDE_INT_1U
15073 << (GET_MODE_BITSIZE (mode
) - 1));
15075 msb
= immed_wide_int_const
15076 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode
) - 1,
15077 GET_MODE_PRECISION (mode
)), mode
);
15078 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
15079 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
15080 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
15081 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
15083 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
15084 VAR_INIT_STATUS_INITIALIZED
);
15087 add_loc_descr (&ret
, tmp
);
15088 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15089 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15090 add_loc_descr (&ret
, l3jump
);
15091 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15092 VAR_INIT_STATUS_INITIALIZED
);
15095 add_loc_descr (&ret
, tmp
);
15096 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
15097 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
15098 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15099 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
15100 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15101 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15102 add_loc_descr (&ret
, l2jump
);
15103 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
15104 add_loc_descr (&ret
, l3label
);
15105 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
15106 add_loc_descr (&ret
, l4label
);
15107 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15108 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15109 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15110 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15111 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15112 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
15113 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15114 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
15118 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
15119 const1 is DW_OP_lit1 or corresponding typed constant):
15121 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15122 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15126 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15127 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15130 static dw_loc_descr_ref
15131 popcount_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15132 machine_mode mem_mode
)
15134 dw_loc_descr_ref op0
, ret
, tmp
;
15135 dw_loc_descr_ref l1jump
, l1label
;
15136 dw_loc_descr_ref l2jump
, l2label
;
15138 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
15141 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15142 VAR_INIT_STATUS_INITIALIZED
);
15146 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15147 VAR_INIT_STATUS_INITIALIZED
);
15150 add_loc_descr (&ret
, tmp
);
15151 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15152 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
15153 add_loc_descr (&ret
, l1label
);
15154 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15155 add_loc_descr (&ret
, l2jump
);
15156 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15157 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
15158 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15159 VAR_INIT_STATUS_INITIALIZED
);
15162 add_loc_descr (&ret
, tmp
);
15163 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15164 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
15165 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
15166 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15167 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15168 VAR_INIT_STATUS_INITIALIZED
);
15169 add_loc_descr (&ret
, tmp
);
15170 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15171 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15172 add_loc_descr (&ret
, l1jump
);
15173 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
15174 add_loc_descr (&ret
, l2label
);
15175 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15176 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15177 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15178 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15182 /* BSWAP (constS is initial shift count, either 56 or 24):
15184 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
15185 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
15186 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
15187 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
15188 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
15190 static dw_loc_descr_ref
15191 bswap_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15192 machine_mode mem_mode
)
15194 dw_loc_descr_ref op0
, ret
, tmp
;
15195 dw_loc_descr_ref l1jump
, l1label
;
15196 dw_loc_descr_ref l2jump
, l2label
;
15198 if (BITS_PER_UNIT
!= 8
15199 || (GET_MODE_BITSIZE (mode
) != 32
15200 && GET_MODE_BITSIZE (mode
) != 64))
15203 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15204 VAR_INIT_STATUS_INITIALIZED
);
15209 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
15211 VAR_INIT_STATUS_INITIALIZED
);
15214 add_loc_descr (&ret
, tmp
);
15215 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15216 VAR_INIT_STATUS_INITIALIZED
);
15219 add_loc_descr (&ret
, tmp
);
15220 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
15221 add_loc_descr (&ret
, l1label
);
15222 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
15224 VAR_INIT_STATUS_INITIALIZED
);
15225 add_loc_descr (&ret
, tmp
);
15226 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
15227 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15228 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15229 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
15230 VAR_INIT_STATUS_INITIALIZED
);
15233 add_loc_descr (&ret
, tmp
);
15234 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15235 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
15236 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
15237 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
15238 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15239 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15240 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15241 VAR_INIT_STATUS_INITIALIZED
);
15242 add_loc_descr (&ret
, tmp
);
15243 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
15244 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15245 add_loc_descr (&ret
, l2jump
);
15246 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
15247 VAR_INIT_STATUS_INITIALIZED
);
15248 add_loc_descr (&ret
, tmp
);
15249 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15250 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15251 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15252 add_loc_descr (&ret
, l1jump
);
15253 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
15254 add_loc_descr (&ret
, l2label
);
15255 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15256 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
15257 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15258 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15259 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15260 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15264 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
15265 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15266 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
15267 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
15269 ROTATERT is similar:
15270 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
15271 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15272 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
15274 static dw_loc_descr_ref
15275 rotate_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15276 machine_mode mem_mode
)
15278 rtx rtlop1
= XEXP (rtl
, 1);
15279 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
15282 if (is_narrower_int_mode (GET_MODE (rtlop1
), mode
))
15283 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
15284 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15285 VAR_INIT_STATUS_INITIALIZED
);
15286 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
15287 VAR_INIT_STATUS_INITIALIZED
);
15288 if (op0
== NULL
|| op1
== NULL
)
15290 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
15291 for (i
= 0; i
< 2; i
++)
15293 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
15294 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
15296 VAR_INIT_STATUS_INITIALIZED
);
15297 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
15298 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
15300 : HOST_BITS_PER_WIDE_INT
== 64
15301 ? DW_OP_const8u
: DW_OP_constu
,
15302 GET_MODE_MASK (mode
), 0);
15305 if (mask
[i
] == NULL
)
15307 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
15310 add_loc_descr (&ret
, op1
);
15311 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
15312 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
15313 if (GET_CODE (rtl
) == ROTATERT
)
15315 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
15316 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
15317 GET_MODE_BITSIZE (mode
), 0));
15319 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
15320 if (mask
[0] != NULL
)
15321 add_loc_descr (&ret
, mask
[0]);
15322 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
15323 if (mask
[1] != NULL
)
15325 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15326 add_loc_descr (&ret
, mask
[1]);
15327 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15329 if (GET_CODE (rtl
) == ROTATE
)
15331 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
15332 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
15333 GET_MODE_BITSIZE (mode
), 0));
15335 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15336 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
15340 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
15341 for DEBUG_PARAMETER_REF RTL. */
15343 static dw_loc_descr_ref
15344 parameter_ref_descriptor (rtx rtl
)
15346 dw_loc_descr_ref ret
;
15351 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
15352 /* With LTO during LTRANS we get the late DIE that refers to the early
15353 DIE, thus we add another indirection here. This seems to confuse
15354 gdb enough to make gcc.dg/guality/pr68860-1.c FAIL with LTO. */
15355 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
15356 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
15359 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15360 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
15361 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15365 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
15366 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
15371 /* The following routine converts the RTL for a variable or parameter
15372 (resident in memory) into an equivalent Dwarf representation of a
15373 mechanism for getting the address of that same variable onto the top of a
15374 hypothetical "address evaluation" stack.
15376 When creating memory location descriptors, we are effectively transforming
15377 the RTL for a memory-resident object into its Dwarf postfix expression
15378 equivalent. This routine recursively descends an RTL tree, turning
15379 it into Dwarf postfix code as it goes.
15381 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
15383 MEM_MODE is the mode of the memory reference, needed to handle some
15384 autoincrement addressing modes.
15386 Return 0 if we can't represent the location. */
15389 mem_loc_descriptor (rtx rtl
, machine_mode mode
,
15390 machine_mode mem_mode
,
15391 enum var_init_status initialized
)
15393 dw_loc_descr_ref mem_loc_result
= NULL
;
15394 enum dwarf_location_atom op
;
15395 dw_loc_descr_ref op0
, op1
;
15396 rtx inner
= NULL_RTX
;
15399 if (mode
== VOIDmode
)
15400 mode
= GET_MODE (rtl
);
15402 /* Note that for a dynamically sized array, the location we will generate a
15403 description of here will be the lowest numbered location which is
15404 actually within the array. That's *not* necessarily the same as the
15405 zeroth element of the array. */
15407 rtl
= targetm
.delegitimize_address (rtl
);
15409 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
15412 scalar_int_mode int_mode
, inner_mode
, op1_mode
;
15413 switch (GET_CODE (rtl
))
15418 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
15421 /* The case of a subreg may arise when we have a local (register)
15422 variable or a formal (register) parameter which doesn't quite fill
15423 up an entire register. For now, just assume that it is
15424 legitimate to make the Dwarf info refer to the whole register which
15425 contains the given subreg. */
15426 if (!subreg_lowpart_p (rtl
))
15428 inner
= SUBREG_REG (rtl
);
15431 if (inner
== NULL_RTX
)
15432 inner
= XEXP (rtl
, 0);
15433 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15434 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
15435 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15436 #ifdef POINTERS_EXTEND_UNSIGNED
15437 || (int_mode
== Pmode
&& mem_mode
!= VOIDmode
)
15440 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
)
15442 mem_loc_result
= mem_loc_descriptor (inner
,
15444 mem_mode
, initialized
);
15447 if (dwarf_strict
&& dwarf_version
< 5)
15449 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15450 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
15451 ? GET_MODE_SIZE (int_mode
) <= GET_MODE_SIZE (inner_mode
)
15452 : known_eq (GET_MODE_SIZE (mode
), GET_MODE_SIZE (GET_MODE (inner
))))
15454 dw_die_ref type_die
;
15455 dw_loc_descr_ref cvt
;
15457 mem_loc_result
= mem_loc_descriptor (inner
,
15459 mem_mode
, initialized
);
15460 if (mem_loc_result
== NULL
)
15462 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15463 if (type_die
== NULL
)
15465 mem_loc_result
= NULL
;
15468 if (maybe_ne (GET_MODE_SIZE (mode
), GET_MODE_SIZE (GET_MODE (inner
))))
15469 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15471 cvt
= new_loc_descr (dwarf_OP (DW_OP_reinterpret
), 0, 0);
15472 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15473 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15474 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15475 add_loc_descr (&mem_loc_result
, cvt
);
15476 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15477 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
15479 /* Convert it to untyped afterwards. */
15480 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15481 add_loc_descr (&mem_loc_result
, cvt
);
15487 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15488 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
15489 && rtl
!= arg_pointer_rtx
15490 && rtl
!= frame_pointer_rtx
15491 #ifdef POINTERS_EXTEND_UNSIGNED
15492 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
15496 dw_die_ref type_die
;
15497 unsigned int dbx_regnum
;
15499 if (dwarf_strict
&& dwarf_version
< 5)
15501 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
15503 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15504 if (type_die
== NULL
)
15507 dbx_regnum
= dbx_reg_number (rtl
);
15508 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
15510 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_regval_type
),
15512 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
15513 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
15514 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
15517 /* Whenever a register number forms a part of the description of the
15518 method for calculating the (dynamic) address of a memory resident
15519 object, DWARF rules require the register number be referred to as
15520 a "base register". This distinction is not based in any way upon
15521 what category of register the hardware believes the given register
15522 belongs to. This is strictly DWARF terminology we're dealing with
15523 here. Note that in cases where the location of a memory-resident
15524 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
15525 OP_CONST (0)) the actual DWARF location descriptor that we generate
15526 may just be OP_BASEREG (basereg). This may look deceptively like
15527 the object in question was allocated to a register (rather than in
15528 memory) so DWARF consumers need to be aware of the subtle
15529 distinction between OP_REG and OP_BASEREG. */
15530 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
15531 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
15532 else if (stack_realign_drap
15534 && crtl
->args
.internal_arg_pointer
== rtl
15535 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
15537 /* If RTL is internal_arg_pointer, which has been optimized
15538 out, use DRAP instead. */
15539 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
15540 VAR_INIT_STATUS_INITIALIZED
);
15546 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15547 || !is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
))
15549 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
15550 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
15553 else if (GET_CODE (rtl
) == ZERO_EXTEND
15554 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15555 && GET_MODE_BITSIZE (inner_mode
) < HOST_BITS_PER_WIDE_INT
15556 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
15557 to expand zero extend as two shifts instead of
15559 && GET_MODE_SIZE (inner_mode
) <= 4)
15561 mem_loc_result
= op0
;
15562 add_loc_descr (&mem_loc_result
,
15563 int_loc_descriptor (GET_MODE_MASK (inner_mode
)));
15564 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
15566 else if (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
15568 int shift
= DWARF2_ADDR_SIZE
- GET_MODE_SIZE (inner_mode
);
15569 shift
*= BITS_PER_UNIT
;
15570 if (GET_CODE (rtl
) == SIGN_EXTEND
)
15574 mem_loc_result
= op0
;
15575 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
15576 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
15577 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
15578 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15580 else if (!dwarf_strict
|| dwarf_version
>= 5)
15582 dw_die_ref type_die1
, type_die2
;
15583 dw_loc_descr_ref cvt
;
15585 type_die1
= base_type_for_mode (inner_mode
,
15586 GET_CODE (rtl
) == ZERO_EXTEND
);
15587 if (type_die1
== NULL
)
15589 type_die2
= base_type_for_mode (int_mode
, 1);
15590 if (type_die2
== NULL
)
15592 mem_loc_result
= op0
;
15593 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15594 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15595 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
15596 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15597 add_loc_descr (&mem_loc_result
, cvt
);
15598 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15599 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15600 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
15601 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15602 add_loc_descr (&mem_loc_result
, cvt
);
15608 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
15609 if (new_rtl
!= rtl
)
15611 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
15613 if (mem_loc_result
!= NULL
)
15614 return mem_loc_result
;
15617 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
15618 get_address_mode (rtl
), mode
,
15619 VAR_INIT_STATUS_INITIALIZED
);
15620 if (mem_loc_result
== NULL
)
15621 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
15622 if (mem_loc_result
!= NULL
)
15624 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15625 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15627 dw_die_ref type_die
;
15628 dw_loc_descr_ref deref
;
15629 HOST_WIDE_INT size
;
15631 if (dwarf_strict
&& dwarf_version
< 5)
15633 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
15636 = base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15637 if (type_die
== NULL
)
15639 deref
= new_loc_descr (dwarf_OP (DW_OP_deref_type
), size
, 0);
15640 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
15641 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
15642 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
15643 add_loc_descr (&mem_loc_result
, deref
);
15645 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
15646 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
15648 add_loc_descr (&mem_loc_result
,
15649 new_loc_descr (DW_OP_deref_size
,
15650 GET_MODE_SIZE (int_mode
), 0));
15655 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
15658 /* Some ports can transform a symbol ref into a label ref, because
15659 the symbol ref is too far away and has to be dumped into a constant
15663 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15664 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
15665 #ifdef POINTERS_EXTEND_UNSIGNED
15666 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
15670 if (GET_CODE (rtl
) == SYMBOL_REF
15671 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
15673 dw_loc_descr_ref temp
;
15675 /* If this is not defined, we have no way to emit the data. */
15676 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
15679 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
15681 /* We check for DWARF 5 here because gdb did not implement
15682 DW_OP_form_tls_address until after 7.12. */
15683 mem_loc_result
= new_loc_descr ((dwarf_version
>= 5
15684 ? DW_OP_form_tls_address
15685 : DW_OP_GNU_push_tls_address
),
15687 add_loc_descr (&mem_loc_result
, temp
);
15692 if (!const_ok_for_output (rtl
))
15694 if (GET_CODE (rtl
) == CONST
)
15695 switch (GET_CODE (XEXP (rtl
, 0)))
15699 goto try_const_unop
;
15702 goto try_const_unop
;
15705 arg
= XEXP (XEXP (rtl
, 0), 0);
15706 if (!CONSTANT_P (arg
))
15707 arg
= gen_rtx_CONST (int_mode
, arg
);
15708 op0
= mem_loc_descriptor (arg
, int_mode
, mem_mode
,
15712 mem_loc_result
= op0
;
15713 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15717 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
,
15718 mem_mode
, initialized
);
15725 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
15726 vec_safe_push (used_rtx_array
, rtl
);
15732 case DEBUG_IMPLICIT_PTR
:
15733 expansion_failed (NULL_TREE
, rtl
,
15734 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
15738 if (dwarf_strict
&& dwarf_version
< 5)
15740 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
15742 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15743 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15744 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
15745 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15748 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
15749 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
15751 op0
= one_reg_loc_descriptor (dbx_regnum
,
15752 VAR_INIT_STATUS_INITIALIZED
);
15755 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
15756 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
15758 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
15759 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15760 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
15764 gcc_unreachable ();
15767 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_entry_value
), 0, 0);
15768 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15769 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
15772 case DEBUG_PARAMETER_REF
:
15773 mem_loc_result
= parameter_ref_descriptor (rtl
);
15777 /* Extract the PLUS expression nested inside and fall into
15778 PLUS code below. */
15779 rtl
= XEXP (rtl
, 1);
15784 /* Turn these into a PLUS expression and fall into the PLUS code
15786 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
15787 gen_int_mode (GET_CODE (rtl
) == PRE_INC
15788 ? GET_MODE_UNIT_SIZE (mem_mode
)
15789 : -GET_MODE_UNIT_SIZE (mem_mode
),
15796 if (is_based_loc (rtl
)
15797 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15798 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15799 || XEXP (rtl
, 0) == arg_pointer_rtx
15800 || XEXP (rtl
, 0) == frame_pointer_rtx
))
15801 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
15802 INTVAL (XEXP (rtl
, 1)),
15803 VAR_INIT_STATUS_INITIALIZED
);
15806 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15807 VAR_INIT_STATUS_INITIALIZED
);
15808 if (mem_loc_result
== 0)
15811 if (CONST_INT_P (XEXP (rtl
, 1))
15812 && (GET_MODE_SIZE (as_a
<scalar_int_mode
> (mode
))
15813 <= DWARF2_ADDR_SIZE
))
15814 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
15817 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15818 VAR_INIT_STATUS_INITIALIZED
);
15821 add_loc_descr (&mem_loc_result
, op1
);
15822 add_loc_descr (&mem_loc_result
,
15823 new_loc_descr (DW_OP_plus
, 0, 0));
15828 /* If a pseudo-reg is optimized away, it is possible for it to
15829 be replaced with a MEM containing a multiply or shift. */
15839 if ((!dwarf_strict
|| dwarf_version
>= 5)
15840 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15841 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15843 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
15844 base_type_for_mode (mode
, 0),
15845 int_mode
, mem_mode
);
15868 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
))
15870 op0
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
, mem_mode
,
15871 VAR_INIT_STATUS_INITIALIZED
);
15873 rtx rtlop1
= XEXP (rtl
, 1);
15874 if (is_a
<scalar_int_mode
> (GET_MODE (rtlop1
), &op1_mode
)
15875 && GET_MODE_BITSIZE (op1_mode
) < GET_MODE_BITSIZE (int_mode
))
15876 rtlop1
= gen_rtx_ZERO_EXTEND (int_mode
, rtlop1
);
15877 op1
= mem_loc_descriptor (rtlop1
, int_mode
, mem_mode
,
15878 VAR_INIT_STATUS_INITIALIZED
);
15881 if (op0
== 0 || op1
== 0)
15884 mem_loc_result
= op0
;
15885 add_loc_descr (&mem_loc_result
, op1
);
15886 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15902 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15903 VAR_INIT_STATUS_INITIALIZED
);
15904 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15905 VAR_INIT_STATUS_INITIALIZED
);
15907 if (op0
== 0 || op1
== 0)
15910 mem_loc_result
= op0
;
15911 add_loc_descr (&mem_loc_result
, op1
);
15912 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15916 if ((!dwarf_strict
|| dwarf_version
>= 5)
15917 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15918 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15920 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
15921 base_type_for_mode (mode
, 0),
15922 int_mode
, mem_mode
);
15926 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15927 VAR_INIT_STATUS_INITIALIZED
);
15928 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15929 VAR_INIT_STATUS_INITIALIZED
);
15931 if (op0
== 0 || op1
== 0)
15934 mem_loc_result
= op0
;
15935 add_loc_descr (&mem_loc_result
, op1
);
15936 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
15937 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
15938 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
15939 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
15940 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
15944 if ((!dwarf_strict
|| dwarf_version
>= 5)
15945 && is_a
<scalar_int_mode
> (mode
, &int_mode
))
15947 if (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15952 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
15953 base_type_for_mode (int_mode
, 1),
15954 int_mode
, mem_mode
);
15971 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15972 VAR_INIT_STATUS_INITIALIZED
);
15977 mem_loc_result
= op0
;
15978 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15982 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15983 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15984 #ifdef POINTERS_EXTEND_UNSIGNED
15985 || (int_mode
== Pmode
15986 && mem_mode
!= VOIDmode
15987 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
15991 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
15994 if ((!dwarf_strict
|| dwarf_version
>= 5)
15995 && (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
15996 || GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_DOUBLE_INT
))
15998 dw_die_ref type_die
= base_type_for_mode (int_mode
, 1);
15999 scalar_int_mode amode
;
16000 if (type_die
== NULL
)
16002 if (INTVAL (rtl
) >= 0
16003 && (int_mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
, 0)
16005 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
16006 /* const DW_OP_convert <XXX> vs.
16007 DW_OP_const_type <XXX, 1, const>. */
16008 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
16009 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (int_mode
))
16011 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
16012 op0
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16013 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16014 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16015 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16016 add_loc_descr (&mem_loc_result
, op0
);
16017 return mem_loc_result
;
16019 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0,
16021 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16022 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16023 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16024 if (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
)
16025 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
16028 mem_loc_result
->dw_loc_oprnd2
.val_class
16029 = dw_val_class_const_double
;
16030 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
16031 = double_int::from_shwi (INTVAL (rtl
));
16037 if (!dwarf_strict
|| dwarf_version
>= 5)
16039 dw_die_ref type_die
;
16041 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
16042 CONST_DOUBLE rtx could represent either a large integer
16043 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
16044 the value is always a floating point constant.
16046 When it is an integer, a CONST_DOUBLE is used whenever
16047 the constant requires 2 HWIs to be adequately represented.
16048 We output CONST_DOUBLEs as blocks. */
16049 if (mode
== VOIDmode
16050 || (GET_MODE (rtl
) == VOIDmode
16051 && maybe_ne (GET_MODE_BITSIZE (mode
),
16052 HOST_BITS_PER_DOUBLE_INT
)))
16054 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16055 if (type_die
== NULL
)
16057 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
16058 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16059 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16060 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16061 #if TARGET_SUPPORTS_WIDE_INT == 0
16062 if (!SCALAR_FLOAT_MODE_P (mode
))
16064 mem_loc_result
->dw_loc_oprnd2
.val_class
16065 = dw_val_class_const_double
;
16066 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
16067 = rtx_to_double_int (rtl
);
16072 scalar_float_mode float_mode
= as_a
<scalar_float_mode
> (mode
);
16073 unsigned int length
= GET_MODE_SIZE (float_mode
);
16074 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
16076 insert_float (rtl
, array
);
16077 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16078 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
16079 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
16080 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16085 case CONST_WIDE_INT
:
16086 if (!dwarf_strict
|| dwarf_version
>= 5)
16088 dw_die_ref type_die
;
16090 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16091 if (type_die
== NULL
)
16093 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
16094 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16095 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16096 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16097 mem_loc_result
->dw_loc_oprnd2
.val_class
16098 = dw_val_class_wide_int
;
16099 mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
16100 *mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, mode
);
16104 case CONST_POLY_INT
:
16105 mem_loc_result
= int_loc_descriptor (rtx_to_poly_int64 (rtl
));
16109 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
16113 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
16117 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
16121 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
16125 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
16129 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
16133 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
16137 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
16141 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
16145 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
16150 if (!SCALAR_INT_MODE_P (mode
))
16155 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
16160 if (CONST_INT_P (XEXP (rtl
, 1))
16161 && CONST_INT_P (XEXP (rtl
, 2))
16162 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16163 && is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
)
16164 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16165 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
16166 && ((unsigned) INTVAL (XEXP (rtl
, 1))
16167 + (unsigned) INTVAL (XEXP (rtl
, 2))
16168 <= GET_MODE_BITSIZE (int_mode
)))
16171 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
16172 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16175 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
16179 mem_loc_result
= op0
;
16180 size
= INTVAL (XEXP (rtl
, 1));
16181 shift
= INTVAL (XEXP (rtl
, 2));
16182 if (BITS_BIG_ENDIAN
)
16183 shift
= GET_MODE_BITSIZE (inner_mode
) - shift
- size
;
16184 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
16186 add_loc_descr (&mem_loc_result
,
16187 int_loc_descriptor (DWARF2_ADDR_SIZE
16189 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
16191 if (size
!= (int) DWARF2_ADDR_SIZE
)
16193 add_loc_descr (&mem_loc_result
,
16194 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
16195 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16202 dw_loc_descr_ref op2
, bra_node
, drop_node
;
16203 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
16204 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
16205 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
16206 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16207 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16208 VAR_INIT_STATUS_INITIALIZED
);
16209 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
16210 VAR_INIT_STATUS_INITIALIZED
);
16211 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
16214 mem_loc_result
= op1
;
16215 add_loc_descr (&mem_loc_result
, op2
);
16216 add_loc_descr (&mem_loc_result
, op0
);
16217 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
16218 add_loc_descr (&mem_loc_result
, bra_node
);
16219 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
16220 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
16221 add_loc_descr (&mem_loc_result
, drop_node
);
16222 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
16223 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
16228 case FLOAT_TRUNCATE
:
16230 case UNSIGNED_FLOAT
:
16233 if (!dwarf_strict
|| dwarf_version
>= 5)
16235 dw_die_ref type_die
;
16236 dw_loc_descr_ref cvt
;
16238 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
16239 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16242 if (is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &int_mode
)
16243 && (GET_CODE (rtl
) == FLOAT
16244 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
))
16246 type_die
= base_type_for_mode (int_mode
,
16247 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
16248 if (type_die
== NULL
)
16250 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16251 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16252 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16253 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16254 add_loc_descr (&op0
, cvt
);
16256 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
16257 if (type_die
== NULL
)
16259 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16260 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16261 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16262 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16263 add_loc_descr (&op0
, cvt
);
16264 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16265 && (GET_CODE (rtl
) == FIX
16266 || GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
))
16268 op0
= convert_descriptor_to_mode (int_mode
, op0
);
16272 mem_loc_result
= op0
;
16279 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16280 mem_loc_result
= clz_loc_descriptor (rtl
, int_mode
, mem_mode
);
16285 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16286 mem_loc_result
= popcount_loc_descriptor (rtl
, int_mode
, mem_mode
);
16290 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16291 mem_loc_result
= bswap_loc_descriptor (rtl
, int_mode
, mem_mode
);
16296 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16297 mem_loc_result
= rotate_loc_descriptor (rtl
, int_mode
, mem_mode
);
16301 /* In theory, we could implement the above. */
16302 /* DWARF cannot represent the unsigned compare operations
16327 case FRACT_CONVERT
:
16328 case UNSIGNED_FRACT_CONVERT
:
16330 case UNSIGNED_SAT_FRACT
:
16336 case VEC_DUPLICATE
:
16341 case STRICT_LOW_PART
:
16347 /* If delegitimize_address couldn't do anything with the UNSPEC, we
16348 can't express it in the debug info. This can happen e.g. with some
16353 resolve_one_addr (&rtl
);
16356 /* RTL sequences inside PARALLEL record a series of DWARF operations for
16357 the expression. An UNSPEC rtx represents a raw DWARF operation,
16358 new_loc_descr is called for it to build the operation directly.
16359 Otherwise mem_loc_descriptor is called recursively. */
16363 dw_loc_descr_ref exp_result
= NULL
;
16365 for (; index
< XVECLEN (rtl
, 0); index
++)
16367 rtx elem
= XVECEXP (rtl
, 0, index
);
16368 if (GET_CODE (elem
) == UNSPEC
)
16370 /* Each DWARF operation UNSPEC contain two operands, if
16371 one operand is not used for the operation, const0_rtx is
16373 gcc_assert (XVECLEN (elem
, 0) == 2);
16375 HOST_WIDE_INT dw_op
= XINT (elem
, 1);
16376 HOST_WIDE_INT oprnd1
= INTVAL (XVECEXP (elem
, 0, 0));
16377 HOST_WIDE_INT oprnd2
= INTVAL (XVECEXP (elem
, 0, 1));
16379 = new_loc_descr ((enum dwarf_location_atom
) dw_op
, oprnd1
,
16384 = mem_loc_descriptor (elem
, mode
, mem_mode
,
16385 VAR_INIT_STATUS_INITIALIZED
);
16387 if (!mem_loc_result
)
16388 mem_loc_result
= exp_result
;
16390 add_loc_descr (&mem_loc_result
, exp_result
);
16399 print_rtl (stderr
, rtl
);
16400 gcc_unreachable ();
16405 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
16406 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
16408 return mem_loc_result
;
16411 /* Return a descriptor that describes the concatenation of two locations.
16412 This is typically a complex variable. */
16414 static dw_loc_descr_ref
16415 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
16417 /* At present we only track constant-sized pieces. */
16418 unsigned int size0
, size1
;
16419 if (!GET_MODE_SIZE (GET_MODE (x0
)).is_constant (&size0
)
16420 || !GET_MODE_SIZE (GET_MODE (x1
)).is_constant (&size1
))
16423 dw_loc_descr_ref cc_loc_result
= NULL
;
16424 dw_loc_descr_ref x0_ref
16425 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16426 dw_loc_descr_ref x1_ref
16427 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16429 if (x0_ref
== 0 || x1_ref
== 0)
16432 cc_loc_result
= x0_ref
;
16433 add_loc_descr_op_piece (&cc_loc_result
, size0
);
16435 add_loc_descr (&cc_loc_result
, x1_ref
);
16436 add_loc_descr_op_piece (&cc_loc_result
, size1
);
16438 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
16439 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
16441 return cc_loc_result
;
16444 /* Return a descriptor that describes the concatenation of N
16447 static dw_loc_descr_ref
16448 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
16451 dw_loc_descr_ref cc_loc_result
= NULL
;
16452 unsigned int n
= XVECLEN (concatn
, 0);
16455 for (i
= 0; i
< n
; ++i
)
16457 dw_loc_descr_ref ref
;
16458 rtx x
= XVECEXP (concatn
, 0, i
);
16460 /* At present we only track constant-sized pieces. */
16461 if (!GET_MODE_SIZE (GET_MODE (x
)).is_constant (&size
))
16464 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16468 add_loc_descr (&cc_loc_result
, ref
);
16469 add_loc_descr_op_piece (&cc_loc_result
, size
);
16472 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
16473 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
16475 return cc_loc_result
;
16478 /* Helper function for loc_descriptor. Return DW_OP_implicit_pointer
16479 for DEBUG_IMPLICIT_PTR RTL. */
16481 static dw_loc_descr_ref
16482 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
16484 dw_loc_descr_ref ret
;
16487 if (dwarf_strict
&& dwarf_version
< 5)
16489 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
16490 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
16491 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
16492 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
16493 ret
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
16494 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
16497 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16498 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
16499 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16503 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
16504 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
16509 /* Output a proper Dwarf location descriptor for a variable or parameter
16510 which is either allocated in a register or in a memory location. For a
16511 register, we just generate an OP_REG and the register number. For a
16512 memory location we provide a Dwarf postfix expression describing how to
16513 generate the (dynamic) address of the object onto the address stack.
16515 MODE is mode of the decl if this loc_descriptor is going to be used in
16516 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
16517 allowed, VOIDmode otherwise.
16519 If we don't know how to describe it, return 0. */
16521 static dw_loc_descr_ref
16522 loc_descriptor (rtx rtl
, machine_mode mode
,
16523 enum var_init_status initialized
)
16525 dw_loc_descr_ref loc_result
= NULL
;
16526 scalar_int_mode int_mode
;
16528 switch (GET_CODE (rtl
))
16531 /* The case of a subreg may arise when we have a local (register)
16532 variable or a formal (register) parameter which doesn't quite fill
16533 up an entire register. For now, just assume that it is
16534 legitimate to make the Dwarf info refer to the whole register which
16535 contains the given subreg. */
16536 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
16537 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
16538 GET_MODE (SUBREG_REG (rtl
)), initialized
);
16544 loc_result
= reg_loc_descriptor (rtl
, initialized
);
16548 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
16549 GET_MODE (rtl
), initialized
);
16550 if (loc_result
== NULL
)
16551 loc_result
= tls_mem_loc_descriptor (rtl
);
16552 if (loc_result
== NULL
)
16554 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
16555 if (new_rtl
!= rtl
)
16556 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
16561 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
16566 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
16571 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
16573 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
16574 if (GET_CODE (loc
) == EXPR_LIST
)
16575 loc
= XEXP (loc
, 0);
16576 loc_result
= loc_descriptor (loc
, mode
, initialized
);
16580 rtl
= XEXP (rtl
, 1);
16585 rtvec par_elems
= XVEC (rtl
, 0);
16586 int num_elem
= GET_NUM_ELEM (par_elems
);
16590 /* Create the first one, so we have something to add to. */
16591 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
16592 VOIDmode
, initialized
);
16593 if (loc_result
== NULL
)
16595 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
16596 /* At present we only track constant-sized pieces. */
16597 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
16599 add_loc_descr_op_piece (&loc_result
, size
);
16600 for (i
= 1; i
< num_elem
; i
++)
16602 dw_loc_descr_ref temp
;
16604 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
16605 VOIDmode
, initialized
);
16608 add_loc_descr (&loc_result
, temp
);
16609 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
16610 /* At present we only track constant-sized pieces. */
16611 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
16613 add_loc_descr_op_piece (&loc_result
, size
);
16619 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
16621 int_mode
= as_a
<scalar_int_mode
> (mode
);
16622 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (int_mode
),
16628 if (mode
== VOIDmode
)
16629 mode
= GET_MODE (rtl
);
16631 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16633 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
16635 /* Note that a CONST_DOUBLE rtx could represent either an integer
16636 or a floating-point constant. A CONST_DOUBLE is used whenever
16637 the constant requires more than one word in order to be
16638 adequately represented. We output CONST_DOUBLEs as blocks. */
16639 scalar_mode smode
= as_a
<scalar_mode
> (mode
);
16640 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16641 GET_MODE_SIZE (smode
), 0);
16642 #if TARGET_SUPPORTS_WIDE_INT == 0
16643 if (!SCALAR_FLOAT_MODE_P (smode
))
16645 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
16646 loc_result
->dw_loc_oprnd2
.v
.val_double
16647 = rtx_to_double_int (rtl
);
16652 unsigned int length
= GET_MODE_SIZE (smode
);
16653 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
16655 insert_float (rtl
, array
);
16656 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16657 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
16658 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
16659 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16664 case CONST_WIDE_INT
:
16665 if (mode
== VOIDmode
)
16666 mode
= GET_MODE (rtl
);
16668 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16670 int_mode
= as_a
<scalar_int_mode
> (mode
);
16671 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16672 GET_MODE_SIZE (int_mode
), 0);
16673 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_wide_int
;
16674 loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
16675 *loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, int_mode
);
16680 if (mode
== VOIDmode
)
16681 mode
= GET_MODE (rtl
);
16683 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16685 unsigned int length
;
16686 if (!CONST_VECTOR_NUNITS (rtl
).is_constant (&length
))
16689 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
16690 unsigned char *array
16691 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
16694 machine_mode imode
= GET_MODE_INNER (mode
);
16696 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
16697 switch (GET_MODE_CLASS (mode
))
16699 case MODE_VECTOR_INT
:
16700 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
16702 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
16703 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
16707 case MODE_VECTOR_FLOAT
:
16708 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
16710 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
16711 insert_float (elt
, p
);
16716 gcc_unreachable ();
16719 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16720 length
* elt_size
, 0);
16721 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16722 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
16723 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
16724 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16729 if (mode
== VOIDmode
16730 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
16731 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
16732 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
16734 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
16739 if (!const_ok_for_output (rtl
))
16743 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16744 && GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
16745 && (dwarf_version
>= 4 || !dwarf_strict
))
16747 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
16748 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16749 vec_safe_push (used_rtx_array
, rtl
);
16753 case DEBUG_IMPLICIT_PTR
:
16754 loc_result
= implicit_ptr_descriptor (rtl
, 0);
16758 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
16759 && CONST_INT_P (XEXP (rtl
, 1)))
16762 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
16768 if ((is_a
<scalar_int_mode
> (mode
, &int_mode
)
16769 && GET_MODE (rtl
) == int_mode
16770 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16771 && dwarf_version
>= 4)
16772 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
16774 /* Value expression. */
16775 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
16777 add_loc_descr (&loc_result
,
16778 new_loc_descr (DW_OP_stack_value
, 0, 0));
16786 /* We need to figure out what section we should use as the base for the
16787 address ranges where a given location is valid.
16788 1. If this particular DECL has a section associated with it, use that.
16789 2. If this function has a section associated with it, use that.
16790 3. Otherwise, use the text section.
16791 XXX: If you split a variable across multiple sections, we won't notice. */
16793 static const char *
16794 secname_for_decl (const_tree decl
)
16796 const char *secname
;
16798 if (VAR_OR_FUNCTION_DECL_P (decl
)
16799 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
) || TREE_STATIC (decl
))
16800 && DECL_SECTION_NAME (decl
))
16801 secname
= DECL_SECTION_NAME (decl
);
16802 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
16803 secname
= DECL_SECTION_NAME (current_function_decl
);
16804 else if (cfun
&& in_cold_section_p
)
16805 secname
= crtl
->subsections
.cold_section_label
;
16807 secname
= text_section_label
;
16812 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
16815 decl_by_reference_p (tree decl
)
16817 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
16819 && DECL_BY_REFERENCE (decl
));
16822 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
16825 static dw_loc_descr_ref
16826 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
16827 enum var_init_status initialized
)
16829 int have_address
= 0;
16830 dw_loc_descr_ref descr
;
16833 if (want_address
!= 2)
16835 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
16837 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
16839 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
16840 if (GET_CODE (varloc
) == EXPR_LIST
)
16841 varloc
= XEXP (varloc
, 0);
16842 mode
= GET_MODE (varloc
);
16843 if (MEM_P (varloc
))
16845 rtx addr
= XEXP (varloc
, 0);
16846 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
16847 mode
, initialized
);
16852 rtx x
= avoid_constant_pool_reference (varloc
);
16854 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
16859 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
16866 if (GET_CODE (varloc
) == VAR_LOCATION
)
16867 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
16869 mode
= DECL_MODE (loc
);
16870 descr
= loc_descriptor (varloc
, mode
, initialized
);
16877 if (want_address
== 2 && !have_address
16878 && (dwarf_version
>= 4 || !dwarf_strict
))
16880 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
16882 expansion_failed (loc
, NULL_RTX
,
16883 "DWARF address size mismatch");
16886 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16889 /* Show if we can't fill the request for an address. */
16890 if (want_address
&& !have_address
)
16892 expansion_failed (loc
, NULL_RTX
,
16893 "Want address and only have value");
16897 /* If we've got an address and don't want one, dereference. */
16898 if (!want_address
&& have_address
)
16900 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
16901 enum dwarf_location_atom op
;
16903 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
16905 expansion_failed (loc
, NULL_RTX
,
16906 "DWARF address size mismatch");
16909 else if (size
== DWARF2_ADDR_SIZE
)
16912 op
= DW_OP_deref_size
;
16914 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
16920 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
16921 if it is not possible. */
16923 static dw_loc_descr_ref
16924 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
16926 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
16927 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
16928 else if (dwarf_version
>= 3 || !dwarf_strict
)
16929 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
16934 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
16935 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
16937 static dw_loc_descr_ref
16938 dw_sra_loc_expr (tree decl
, rtx loc
)
16941 unsigned HOST_WIDE_INT padsize
= 0;
16942 dw_loc_descr_ref descr
, *descr_tail
;
16943 unsigned HOST_WIDE_INT decl_size
;
16945 enum var_init_status initialized
;
16947 if (DECL_SIZE (decl
) == NULL
16948 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
16951 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
16953 descr_tail
= &descr
;
16955 for (p
= loc
; p
; p
= XEXP (p
, 1))
16957 unsigned HOST_WIDE_INT bitsize
= decl_piece_bitsize (p
);
16958 rtx loc_note
= *decl_piece_varloc_ptr (p
);
16959 dw_loc_descr_ref cur_descr
;
16960 dw_loc_descr_ref
*tail
, last
= NULL
;
16961 unsigned HOST_WIDE_INT opsize
= 0;
16963 if (loc_note
== NULL_RTX
16964 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
16966 padsize
+= bitsize
;
16969 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
16970 varloc
= NOTE_VAR_LOCATION (loc_note
);
16971 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
16972 if (cur_descr
== NULL
)
16974 padsize
+= bitsize
;
16978 /* Check that cur_descr either doesn't use
16979 DW_OP_*piece operations, or their sum is equal
16980 to bitsize. Otherwise we can't embed it. */
16981 for (tail
= &cur_descr
; *tail
!= NULL
;
16982 tail
= &(*tail
)->dw_loc_next
)
16983 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
16985 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
16989 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
16991 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
16995 if (last
!= NULL
&& opsize
!= bitsize
)
16997 padsize
+= bitsize
;
16998 /* Discard the current piece of the descriptor and release any
16999 addr_table entries it uses. */
17000 remove_loc_list_addr_table_entries (cur_descr
);
17004 /* If there is a hole, add DW_OP_*piece after empty DWARF
17005 expression, which means that those bits are optimized out. */
17008 if (padsize
> decl_size
)
17010 remove_loc_list_addr_table_entries (cur_descr
);
17011 goto discard_descr
;
17013 decl_size
-= padsize
;
17014 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
17015 if (*descr_tail
== NULL
)
17017 remove_loc_list_addr_table_entries (cur_descr
);
17018 goto discard_descr
;
17020 descr_tail
= &(*descr_tail
)->dw_loc_next
;
17023 *descr_tail
= cur_descr
;
17025 if (bitsize
> decl_size
)
17026 goto discard_descr
;
17027 decl_size
-= bitsize
;
17030 HOST_WIDE_INT offset
= 0;
17031 if (GET_CODE (varloc
) == VAR_LOCATION
17032 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
17034 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
17035 if (GET_CODE (varloc
) == EXPR_LIST
)
17036 varloc
= XEXP (varloc
, 0);
17040 if (GET_CODE (varloc
) == CONST
17041 || GET_CODE (varloc
) == SIGN_EXTEND
17042 || GET_CODE (varloc
) == ZERO_EXTEND
)
17043 varloc
= XEXP (varloc
, 0);
17044 else if (GET_CODE (varloc
) == SUBREG
)
17045 varloc
= SUBREG_REG (varloc
);
17050 /* DW_OP_bit_size offset should be zero for register
17051 or implicit location descriptions and empty location
17052 descriptions, but for memory addresses needs big endian
17054 if (MEM_P (varloc
))
17056 unsigned HOST_WIDE_INT memsize
;
17057 if (!poly_uint64 (MEM_SIZE (varloc
)).is_constant (&memsize
))
17058 goto discard_descr
;
17059 memsize
*= BITS_PER_UNIT
;
17060 if (memsize
!= bitsize
)
17062 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
17063 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
17064 goto discard_descr
;
17065 if (memsize
< bitsize
)
17066 goto discard_descr
;
17067 if (BITS_BIG_ENDIAN
)
17068 offset
= memsize
- bitsize
;
17072 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
17073 if (*descr_tail
== NULL
)
17074 goto discard_descr
;
17075 descr_tail
= &(*descr_tail
)->dw_loc_next
;
17079 /* If there were any non-empty expressions, add padding till the end of
17081 if (descr
!= NULL
&& decl_size
!= 0)
17083 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
17084 if (*descr_tail
== NULL
)
17085 goto discard_descr
;
17090 /* Discard the descriptor and release any addr_table entries it uses. */
17091 remove_loc_list_addr_table_entries (descr
);
17095 /* Return the dwarf representation of the location list LOC_LIST of
17096 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
17099 static dw_loc_list_ref
17100 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
17102 const char *endname
, *secname
;
17103 var_loc_view endview
;
17105 enum var_init_status initialized
;
17106 struct var_loc_node
*node
;
17107 dw_loc_descr_ref descr
;
17108 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
17109 dw_loc_list_ref list
= NULL
;
17110 dw_loc_list_ref
*listp
= &list
;
17112 /* Now that we know what section we are using for a base,
17113 actually construct the list of locations.
17114 The first location information is what is passed to the
17115 function that creates the location list, and the remaining
17116 locations just get added on to that list.
17117 Note that we only know the start address for a location
17118 (IE location changes), so to build the range, we use
17119 the range [current location start, next location start].
17120 This means we have to special case the last node, and generate
17121 a range of [last location start, end of function label]. */
17123 if (cfun
&& crtl
->has_bb_partition
)
17125 bool save_in_cold_section_p
= in_cold_section_p
;
17126 in_cold_section_p
= first_function_block_is_cold
;
17127 if (loc_list
->last_before_switch
== NULL
)
17128 in_cold_section_p
= !in_cold_section_p
;
17129 secname
= secname_for_decl (decl
);
17130 in_cold_section_p
= save_in_cold_section_p
;
17133 secname
= secname_for_decl (decl
);
17135 for (node
= loc_list
->first
; node
; node
= node
->next
)
17137 bool range_across_switch
= false;
17138 if (GET_CODE (node
->loc
) == EXPR_LIST
17139 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
17141 if (GET_CODE (node
->loc
) == EXPR_LIST
)
17144 /* This requires DW_OP_{,bit_}piece, which is not usable
17145 inside DWARF expressions. */
17146 if (want_address
== 2)
17147 descr
= dw_sra_loc_expr (decl
, node
->loc
);
17151 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
17152 varloc
= NOTE_VAR_LOCATION (node
->loc
);
17153 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
17157 /* If section switch happens in between node->label
17158 and node->next->label (or end of function) and
17159 we can't emit it as a single entry list,
17160 emit two ranges, first one ending at the end
17161 of first partition and second one starting at the
17162 beginning of second partition. */
17163 if (node
== loc_list
->last_before_switch
17164 && (node
!= loc_list
->first
|| loc_list
->first
->next
17165 /* If we are to emit a view number, we will emit
17166 a loclist rather than a single location
17167 expression for the entire function (see
17168 loc_list_has_views), so we have to split the
17169 range that straddles across partitions. */
17170 || !ZERO_VIEW_P (node
->view
))
17171 && current_function_decl
)
17173 endname
= cfun
->fde
->dw_fde_end
;
17175 range_across_switch
= true;
17177 /* The variable has a location between NODE->LABEL and
17178 NODE->NEXT->LABEL. */
17179 else if (node
->next
)
17180 endname
= node
->next
->label
, endview
= node
->next
->view
;
17181 /* If the variable has a location at the last label
17182 it keeps its location until the end of function. */
17183 else if (!current_function_decl
)
17184 endname
= text_end_label
, endview
= 0;
17187 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
17188 current_function_funcdef_no
);
17189 endname
= ggc_strdup (label_id
);
17193 *listp
= new_loc_list (descr
, node
->label
, node
->view
,
17194 endname
, endview
, secname
);
17195 if (TREE_CODE (decl
) == PARM_DECL
17196 && node
== loc_list
->first
17197 && NOTE_P (node
->loc
)
17198 && strcmp (node
->label
, endname
) == 0)
17199 (*listp
)->force
= true;
17200 listp
= &(*listp
)->dw_loc_next
;
17205 && crtl
->has_bb_partition
17206 && node
== loc_list
->last_before_switch
)
17208 bool save_in_cold_section_p
= in_cold_section_p
;
17209 in_cold_section_p
= !first_function_block_is_cold
;
17210 secname
= secname_for_decl (decl
);
17211 in_cold_section_p
= save_in_cold_section_p
;
17214 if (range_across_switch
)
17216 if (GET_CODE (node
->loc
) == EXPR_LIST
)
17217 descr
= dw_sra_loc_expr (decl
, node
->loc
);
17220 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
17221 varloc
= NOTE_VAR_LOCATION (node
->loc
);
17222 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
17225 gcc_assert (descr
);
17226 /* The variable has a location between NODE->LABEL and
17227 NODE->NEXT->LABEL. */
17229 endname
= node
->next
->label
, endview
= node
->next
->view
;
17231 endname
= cfun
->fde
->dw_fde_second_end
, endview
= 0;
17232 *listp
= new_loc_list (descr
, cfun
->fde
->dw_fde_second_begin
, 0,
17233 endname
, endview
, secname
);
17234 listp
= &(*listp
)->dw_loc_next
;
17238 /* Try to avoid the overhead of a location list emitting a location
17239 expression instead, but only if we didn't have more than one
17240 location entry in the first place. If some entries were not
17241 representable, we don't want to pretend a single entry that was
17242 applies to the entire scope in which the variable is
17244 if (list
&& loc_list
->first
->next
)
17247 maybe_gen_llsym (list
);
17252 /* Return if the loc_list has only single element and thus can be represented
17253 as location description. */
17256 single_element_loc_list_p (dw_loc_list_ref list
)
17258 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
17259 return !list
->ll_symbol
;
17262 /* Duplicate a single element of location list. */
17264 static inline dw_loc_descr_ref
17265 copy_loc_descr (dw_loc_descr_ref ref
)
17267 dw_loc_descr_ref copy
= ggc_alloc
<dw_loc_descr_node
> ();
17268 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
17272 /* To each location in list LIST append loc descr REF. */
17275 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
17277 dw_loc_descr_ref copy
;
17278 add_loc_descr (&list
->expr
, ref
);
17279 list
= list
->dw_loc_next
;
17282 copy
= copy_loc_descr (ref
);
17283 add_loc_descr (&list
->expr
, copy
);
17284 while (copy
->dw_loc_next
)
17285 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
17286 list
= list
->dw_loc_next
;
17290 /* To each location in list LIST prepend loc descr REF. */
17293 prepend_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
17295 dw_loc_descr_ref copy
;
17296 dw_loc_descr_ref ref_end
= list
->expr
;
17297 add_loc_descr (&ref
, list
->expr
);
17299 list
= list
->dw_loc_next
;
17302 dw_loc_descr_ref end
= list
->expr
;
17303 list
->expr
= copy
= copy_loc_descr (ref
);
17304 while (copy
->dw_loc_next
!= ref_end
)
17305 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
17306 copy
->dw_loc_next
= end
;
17307 list
= list
->dw_loc_next
;
17311 /* Given two lists RET and LIST
17312 produce location list that is result of adding expression in LIST
17313 to expression in RET on each position in program.
17314 Might be destructive on both RET and LIST.
17316 TODO: We handle only simple cases of RET or LIST having at most one
17317 element. General case would involve sorting the lists in program order
17318 and merging them that will need some additional work.
17319 Adding that will improve quality of debug info especially for SRA-ed
17323 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
17332 if (!list
->dw_loc_next
)
17334 add_loc_descr_to_each (*ret
, list
->expr
);
17337 if (!(*ret
)->dw_loc_next
)
17339 prepend_loc_descr_to_each (list
, (*ret
)->expr
);
17343 expansion_failed (NULL_TREE
, NULL_RTX
,
17344 "Don't know how to merge two non-trivial"
17345 " location lists.\n");
17350 /* LOC is constant expression. Try a luck, look it up in constant
17351 pool and return its loc_descr of its address. */
17353 static dw_loc_descr_ref
17354 cst_pool_loc_descr (tree loc
)
17356 /* Get an RTL for this, if something has been emitted. */
17357 rtx rtl
= lookup_constant_def (loc
);
17359 if (!rtl
|| !MEM_P (rtl
))
17364 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
17366 /* TODO: We might get more coverage if we was actually delaying expansion
17367 of all expressions till end of compilation when constant pools are fully
17369 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
17371 expansion_failed (loc
, NULL_RTX
,
17372 "CST value in contant pool but not marked.");
17375 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
17376 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
17379 /* Return dw_loc_list representing address of addr_expr LOC
17380 by looking for inner INDIRECT_REF expression and turning
17381 it into simple arithmetics.
17383 See loc_list_from_tree for the meaning of CONTEXT. */
17385 static dw_loc_list_ref
17386 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
,
17387 loc_descr_context
*context
)
17390 poly_int64 bitsize
, bitpos
, bytepos
;
17392 int unsignedp
, reversep
, volatilep
= 0;
17393 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
17395 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
17396 &bitsize
, &bitpos
, &offset
, &mode
,
17397 &unsignedp
, &reversep
, &volatilep
);
17399 if (!multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
))
17401 expansion_failed (loc
, NULL_RTX
, "bitfield access");
17404 if (!INDIRECT_REF_P (obj
))
17406 expansion_failed (obj
,
17407 NULL_RTX
, "no indirect ref in inner refrence");
17410 if (!offset
&& known_eq (bitpos
, 0))
17411 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1,
17414 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
17415 && (dwarf_version
>= 4 || !dwarf_strict
))
17417 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0, context
);
17422 /* Variable offset. */
17423 list_ret1
= loc_list_from_tree (offset
, 0, context
);
17424 if (list_ret1
== 0)
17426 add_loc_list (&list_ret
, list_ret1
);
17429 add_loc_descr_to_each (list_ret
,
17430 new_loc_descr (DW_OP_plus
, 0, 0));
17432 HOST_WIDE_INT value
;
17433 if (bytepos
.is_constant (&value
) && value
> 0)
17434 add_loc_descr_to_each (list_ret
,
17435 new_loc_descr (DW_OP_plus_uconst
, value
, 0));
17436 else if (maybe_ne (bytepos
, 0))
17437 loc_list_plus_const (list_ret
, bytepos
);
17438 add_loc_descr_to_each (list_ret
,
17439 new_loc_descr (DW_OP_stack_value
, 0, 0));
17444 /* Set LOC to the next operation that is not a DW_OP_nop operation. In the case
17445 all operations from LOC are nops, move to the last one. Insert in NOPS all
17446 operations that are skipped. */
17449 loc_descr_to_next_no_nop (dw_loc_descr_ref
&loc
,
17450 hash_set
<dw_loc_descr_ref
> &nops
)
17452 while (loc
->dw_loc_next
!= NULL
&& loc
->dw_loc_opc
== DW_OP_nop
)
17455 loc
= loc
->dw_loc_next
;
17459 /* Helper for loc_descr_without_nops: free the location description operation
17463 free_loc_descr (const dw_loc_descr_ref
&loc
, void *data ATTRIBUTE_UNUSED
)
17469 /* Remove all DW_OP_nop operations from LOC except, if it exists, the one that
17473 loc_descr_without_nops (dw_loc_descr_ref
&loc
)
17475 if (loc
->dw_loc_opc
== DW_OP_nop
&& loc
->dw_loc_next
== NULL
)
17478 /* Set of all DW_OP_nop operations we remove. */
17479 hash_set
<dw_loc_descr_ref
> nops
;
17481 /* First, strip all prefix NOP operations in order to keep the head of the
17482 operations list. */
17483 loc_descr_to_next_no_nop (loc
, nops
);
17485 for (dw_loc_descr_ref cur
= loc
; cur
!= NULL
;)
17487 /* For control flow operations: strip "prefix" nops in destination
17489 if (cur
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
)
17490 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd1
.v
.val_loc
, nops
);
17491 if (cur
->dw_loc_oprnd2
.val_class
== dw_val_class_loc
)
17492 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd2
.v
.val_loc
, nops
);
17494 /* Do the same for the operations that follow, then move to the next
17496 if (cur
->dw_loc_next
!= NULL
)
17497 loc_descr_to_next_no_nop (cur
->dw_loc_next
, nops
);
17498 cur
= cur
->dw_loc_next
;
17501 nops
.traverse
<void *, free_loc_descr
> (NULL
);
17505 struct dwarf_procedure_info
;
17507 /* Helper structure for location descriptions generation. */
17508 struct loc_descr_context
17510 /* The type that is implicitly referenced by DW_OP_push_object_address, or
17511 NULL_TREE if DW_OP_push_object_address in invalid for this location
17512 description. This is used when processing PLACEHOLDER_EXPR nodes. */
17514 /* The ..._DECL node that should be translated as a
17515 DW_OP_push_object_address operation. */
17517 /* Information about the DWARF procedure we are currently generating. NULL if
17518 we are not generating a DWARF procedure. */
17519 struct dwarf_procedure_info
*dpi
;
17520 /* True if integral PLACEHOLDER_EXPR stands for the first argument passed
17521 by consumer. Used for DW_TAG_generic_subrange attributes. */
17522 bool placeholder_arg
;
17523 /* True if PLACEHOLDER_EXPR has been seen. */
17524 bool placeholder_seen
;
17527 /* DWARF procedures generation
17529 DWARF expressions (aka. location descriptions) are used to encode variable
17530 things such as sizes or offsets. Such computations can have redundant parts
17531 that can be factorized in order to reduce the size of the output debug
17532 information. This is the whole point of DWARF procedures.
17534 Thanks to stor-layout.c, size and offset expressions in GENERIC trees are
17535 already factorized into functions ("size functions") in order to handle very
17536 big and complex types. Such functions are quite simple: they have integral
17537 arguments, they return an integral result and their body contains only a
17538 return statement with arithmetic expressions. This is the only kind of
17539 function we are interested in translating into DWARF procedures, here.
17541 DWARF expressions and DWARF procedure are executed using a stack, so we have
17542 to define some calling convention for them to interact. Let's say that:
17544 - Before calling a DWARF procedure, DWARF expressions must push on the stack
17545 all arguments in reverse order (right-to-left) so that when the DWARF
17546 procedure execution starts, the first argument is the top of the stack.
17548 - Then, when returning, the DWARF procedure must have consumed all arguments
17549 on the stack, must have pushed the result and touched nothing else.
17551 - Each integral argument and the result are integral types can be hold in a
17554 - We call "frame offset" the number of stack slots that are "under DWARF
17555 procedure control": it includes the arguments slots, the temporaries and
17556 the result slot. Thus, it is equal to the number of arguments when the
17557 procedure execution starts and must be equal to one (the result) when it
17560 /* Helper structure used when generating operations for a DWARF procedure. */
17561 struct dwarf_procedure_info
17563 /* The FUNCTION_DECL node corresponding to the DWARF procedure that is
17564 currently translated. */
17566 /* The number of arguments FNDECL takes. */
17567 unsigned args_count
;
17570 /* Return a pointer to a newly created DIE node for a DWARF procedure. Add
17571 LOCATION as its DW_AT_location attribute. If FNDECL is not NULL_TREE,
17572 equate it to this DIE. */
17575 new_dwarf_proc_die (dw_loc_descr_ref location
, tree fndecl
,
17576 dw_die_ref parent_die
)
17578 dw_die_ref dwarf_proc_die
;
17580 if ((dwarf_version
< 3 && dwarf_strict
)
17581 || location
== NULL
)
17584 dwarf_proc_die
= new_die (DW_TAG_dwarf_procedure
, parent_die
, fndecl
);
17586 equate_decl_number_to_die (fndecl
, dwarf_proc_die
);
17587 add_AT_loc (dwarf_proc_die
, DW_AT_location
, location
);
17588 return dwarf_proc_die
;
17591 /* Return whether TYPE is a supported type as a DWARF procedure argument
17592 type or return type (we handle only scalar types and pointer types that
17593 aren't wider than the DWARF expression evaluation stack. */
17596 is_handled_procedure_type (tree type
)
17598 return ((INTEGRAL_TYPE_P (type
)
17599 || TREE_CODE (type
) == OFFSET_TYPE
17600 || TREE_CODE (type
) == POINTER_TYPE
)
17601 && int_size_in_bytes (type
) <= DWARF2_ADDR_SIZE
);
17604 /* Helper for resolve_args_picking: do the same but stop when coming across
17605 visited nodes. For each node we visit, register in FRAME_OFFSETS the frame
17606 offset *before* evaluating the corresponding operation. */
17609 resolve_args_picking_1 (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
17610 struct dwarf_procedure_info
*dpi
,
17611 hash_map
<dw_loc_descr_ref
, unsigned> &frame_offsets
)
17613 /* The "frame_offset" identifier is already used to name a macro... */
17614 unsigned frame_offset_
= initial_frame_offset
;
17615 dw_loc_descr_ref l
;
17617 for (l
= loc
; l
!= NULL
;)
17620 unsigned &l_frame_offset
= frame_offsets
.get_or_insert (l
, &existed
);
17622 /* If we already met this node, there is nothing to compute anymore. */
17625 /* Make sure that the stack size is consistent wherever the execution
17626 flow comes from. */
17627 gcc_assert ((unsigned) l_frame_offset
== frame_offset_
);
17630 l_frame_offset
= frame_offset_
;
17632 /* If needed, relocate the picking offset with respect to the frame
17634 if (l
->frame_offset_rel
)
17636 unsigned HOST_WIDE_INT off
;
17637 switch (l
->dw_loc_opc
)
17640 off
= l
->dw_loc_oprnd1
.v
.val_unsigned
;
17649 gcc_unreachable ();
17651 /* frame_offset_ is the size of the current stack frame, including
17652 incoming arguments. Besides, the arguments are pushed
17653 right-to-left. Thus, in order to access the Nth argument from
17654 this operation node, the picking has to skip temporaries *plus*
17655 one stack slot per argument (0 for the first one, 1 for the second
17658 The targetted argument number (N) is already set as the operand,
17659 and the number of temporaries can be computed with:
17660 frame_offsets_ - dpi->args_count */
17661 off
+= frame_offset_
- dpi
->args_count
;
17663 /* DW_OP_pick handles only offsets from 0 to 255 (inclusive)... */
17669 l
->dw_loc_opc
= DW_OP_dup
;
17670 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
17674 l
->dw_loc_opc
= DW_OP_over
;
17675 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
17679 l
->dw_loc_opc
= DW_OP_pick
;
17680 l
->dw_loc_oprnd1
.v
.val_unsigned
= off
;
17684 /* Update frame_offset according to the effect the current operation has
17686 switch (l
->dw_loc_opc
)
17694 case DW_OP_plus_uconst
:
17730 case DW_OP_deref_size
:
17732 case DW_OP_bit_piece
:
17733 case DW_OP_implicit_value
:
17734 case DW_OP_stack_value
:
17738 case DW_OP_const1u
:
17739 case DW_OP_const1s
:
17740 case DW_OP_const2u
:
17741 case DW_OP_const2s
:
17742 case DW_OP_const4u
:
17743 case DW_OP_const4s
:
17744 case DW_OP_const8u
:
17745 case DW_OP_const8s
:
17816 case DW_OP_push_object_address
:
17817 case DW_OP_call_frame_cfa
:
17818 case DW_OP_GNU_variable_value
:
17843 case DW_OP_xderef_size
:
17849 case DW_OP_call_ref
:
17851 dw_die_ref dwarf_proc
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
17852 int *stack_usage
= dwarf_proc_stack_usage_map
->get (dwarf_proc
);
17854 if (stack_usage
== NULL
)
17856 frame_offset_
+= *stack_usage
;
17860 case DW_OP_implicit_pointer
:
17861 case DW_OP_entry_value
:
17862 case DW_OP_const_type
:
17863 case DW_OP_regval_type
:
17864 case DW_OP_deref_type
:
17865 case DW_OP_convert
:
17866 case DW_OP_reinterpret
:
17867 case DW_OP_form_tls_address
:
17868 case DW_OP_GNU_push_tls_address
:
17869 case DW_OP_GNU_uninit
:
17870 case DW_OP_GNU_encoded_addr
:
17871 case DW_OP_GNU_implicit_pointer
:
17872 case DW_OP_GNU_entry_value
:
17873 case DW_OP_GNU_const_type
:
17874 case DW_OP_GNU_regval_type
:
17875 case DW_OP_GNU_deref_type
:
17876 case DW_OP_GNU_convert
:
17877 case DW_OP_GNU_reinterpret
:
17878 case DW_OP_GNU_parameter_ref
:
17879 /* loc_list_from_tree will probably not output these operations for
17880 size functions, so assume they will not appear here. */
17881 /* Fall through... */
17884 gcc_unreachable ();
17887 /* Now, follow the control flow (except subroutine calls). */
17888 switch (l
->dw_loc_opc
)
17891 if (!resolve_args_picking_1 (l
->dw_loc_next
, frame_offset_
, dpi
,
17894 /* Fall through. */
17897 l
= l
->dw_loc_oprnd1
.v
.val_loc
;
17900 case DW_OP_stack_value
:
17904 l
= l
->dw_loc_next
;
17912 /* Make a DFS over operations reachable through LOC (i.e. follow branch
17913 operations) in order to resolve the operand of DW_OP_pick operations that
17914 target DWARF procedure arguments (DPI). INITIAL_FRAME_OFFSET is the frame
17915 offset *before* LOC is executed. Return if all relocations were
17919 resolve_args_picking (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
17920 struct dwarf_procedure_info
*dpi
)
17922 /* Associate to all visited operations the frame offset *before* evaluating
17924 hash_map
<dw_loc_descr_ref
, unsigned> frame_offsets
;
17926 return resolve_args_picking_1 (loc
, initial_frame_offset
, dpi
,
17930 /* Try to generate a DWARF procedure that computes the same result as FNDECL.
17931 Return NULL if it is not possible. */
17934 function_to_dwarf_procedure (tree fndecl
)
17936 struct loc_descr_context ctx
;
17937 struct dwarf_procedure_info dpi
;
17938 dw_die_ref dwarf_proc_die
;
17939 tree tree_body
= DECL_SAVED_TREE (fndecl
);
17940 dw_loc_descr_ref loc_body
, epilogue
;
17945 /* Do not generate multiple DWARF procedures for the same function
17947 dwarf_proc_die
= lookup_decl_die (fndecl
);
17948 if (dwarf_proc_die
!= NULL
)
17949 return dwarf_proc_die
;
17951 /* DWARF procedures are available starting with the DWARFv3 standard. */
17952 if (dwarf_version
< 3 && dwarf_strict
)
17955 /* We handle only functions for which we still have a body, that return a
17956 supported type and that takes arguments with supported types. Note that
17957 there is no point translating functions that return nothing. */
17958 if (tree_body
== NULL_TREE
17959 || DECL_RESULT (fndecl
) == NULL_TREE
17960 || !is_handled_procedure_type (TREE_TYPE (DECL_RESULT (fndecl
))))
17963 for (cursor
= DECL_ARGUMENTS (fndecl
);
17964 cursor
!= NULL_TREE
;
17965 cursor
= TREE_CHAIN (cursor
))
17966 if (!is_handled_procedure_type (TREE_TYPE (cursor
)))
17969 /* Match only "expr" in: RETURN_EXPR (MODIFY_EXPR (RESULT_DECL, expr)). */
17970 if (TREE_CODE (tree_body
) != RETURN_EXPR
)
17972 tree_body
= TREE_OPERAND (tree_body
, 0);
17973 if (TREE_CODE (tree_body
) != MODIFY_EXPR
17974 || TREE_OPERAND (tree_body
, 0) != DECL_RESULT (fndecl
))
17976 tree_body
= TREE_OPERAND (tree_body
, 1);
17978 /* Try to translate the body expression itself. Note that this will probably
17979 cause an infinite recursion if its call graph has a cycle. This is very
17980 unlikely for size functions, however, so don't bother with such things at
17982 ctx
.context_type
= NULL_TREE
;
17983 ctx
.base_decl
= NULL_TREE
;
17985 ctx
.placeholder_arg
= false;
17986 ctx
.placeholder_seen
= false;
17987 dpi
.fndecl
= fndecl
;
17988 dpi
.args_count
= list_length (DECL_ARGUMENTS (fndecl
));
17989 loc_body
= loc_descriptor_from_tree (tree_body
, 0, &ctx
);
17993 /* After evaluating all operands in "loc_body", we should still have on the
17994 stack all arguments plus the desired function result (top of the stack).
17995 Generate code in order to keep only the result in our stack frame. */
17997 for (i
= 0; i
< dpi
.args_count
; ++i
)
17999 dw_loc_descr_ref op_couple
= new_loc_descr (DW_OP_swap
, 0, 0);
18000 op_couple
->dw_loc_next
= new_loc_descr (DW_OP_drop
, 0, 0);
18001 op_couple
->dw_loc_next
->dw_loc_next
= epilogue
;
18002 epilogue
= op_couple
;
18004 add_loc_descr (&loc_body
, epilogue
);
18005 if (!resolve_args_picking (loc_body
, dpi
.args_count
, &dpi
))
18008 /* Trailing nops from loc_descriptor_from_tree (if any) cannot be removed
18009 because they are considered useful. Now there is an epilogue, they are
18010 not anymore, so give it another try. */
18011 loc_descr_without_nops (loc_body
);
18013 /* fndecl may be used both as a regular DW_TAG_subprogram DIE and as
18014 a DW_TAG_dwarf_procedure, so we may have a conflict, here. It's unlikely,
18015 though, given that size functions do not come from source, so they should
18016 not have a dedicated DW_TAG_subprogram DIE. */
18018 = new_dwarf_proc_die (loc_body
, fndecl
,
18019 get_context_die (DECL_CONTEXT (fndecl
)));
18021 /* The called DWARF procedure consumes one stack slot per argument and
18022 returns one stack slot. */
18023 dwarf_proc_stack_usage_map
->put (dwarf_proc_die
, 1 - dpi
.args_count
);
18025 return dwarf_proc_die
;
18029 /* Generate Dwarf location list representing LOC.
18030 If WANT_ADDRESS is false, expression computing LOC will be computed
18031 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
18032 if WANT_ADDRESS is 2, expression computing address useable in location
18033 will be returned (i.e. DW_OP_reg can be used
18034 to refer to register values).
18036 CONTEXT provides information to customize the location descriptions
18037 generation. Its context_type field specifies what type is implicitly
18038 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
18039 will not be generated.
18041 Its DPI field determines whether we are generating a DWARF expression for a
18042 DWARF procedure, so PARM_DECL references are processed specifically.
18044 If CONTEXT is NULL, the behavior is the same as if context_type, base_decl
18045 and dpi fields were null. */
18047 static dw_loc_list_ref
18048 loc_list_from_tree_1 (tree loc
, int want_address
,
18049 struct loc_descr_context
*context
)
18051 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
18052 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
18053 int have_address
= 0;
18054 enum dwarf_location_atom op
;
18056 /* ??? Most of the time we do not take proper care for sign/zero
18057 extending the values properly. Hopefully this won't be a real
18060 if (context
!= NULL
18061 && context
->base_decl
== loc
18062 && want_address
== 0)
18064 if (dwarf_version
>= 3 || !dwarf_strict
)
18065 return new_loc_list (new_loc_descr (DW_OP_push_object_address
, 0, 0),
18066 NULL
, 0, NULL
, 0, NULL
);
18071 switch (TREE_CODE (loc
))
18074 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
18077 case PLACEHOLDER_EXPR
:
18078 /* This case involves extracting fields from an object to determine the
18079 position of other fields. It is supposed to appear only as the first
18080 operand of COMPONENT_REF nodes and to reference precisely the type
18081 that the context allows. */
18082 if (context
!= NULL
18083 && TREE_TYPE (loc
) == context
->context_type
18084 && want_address
>= 1)
18086 if (dwarf_version
>= 3 || !dwarf_strict
)
18088 ret
= new_loc_descr (DW_OP_push_object_address
, 0, 0);
18095 /* For DW_TAG_generic_subrange attributes, PLACEHOLDER_EXPR stands for
18096 the single argument passed by consumer. */
18097 else if (context
!= NULL
18098 && context
->placeholder_arg
18099 && INTEGRAL_TYPE_P (TREE_TYPE (loc
))
18100 && want_address
== 0)
18102 ret
= new_loc_descr (DW_OP_pick
, 0, 0);
18103 ret
->frame_offset_rel
= 1;
18104 context
->placeholder_seen
= true;
18108 expansion_failed (loc
, NULL_RTX
,
18109 "PLACEHOLDER_EXPR for an unexpected type");
18114 const int nargs
= call_expr_nargs (loc
);
18115 tree callee
= get_callee_fndecl (loc
);
18117 dw_die_ref dwarf_proc
;
18119 if (callee
== NULL_TREE
)
18120 goto call_expansion_failed
;
18122 /* We handle only functions that return an integer. */
18123 if (!is_handled_procedure_type (TREE_TYPE (TREE_TYPE (callee
))))
18124 goto call_expansion_failed
;
18126 dwarf_proc
= function_to_dwarf_procedure (callee
);
18127 if (dwarf_proc
== NULL
)
18128 goto call_expansion_failed
;
18130 /* Evaluate arguments right-to-left so that the first argument will
18131 be the top-most one on the stack. */
18132 for (i
= nargs
- 1; i
>= 0; --i
)
18134 dw_loc_descr_ref loc_descr
18135 = loc_descriptor_from_tree (CALL_EXPR_ARG (loc
, i
), 0,
18138 if (loc_descr
== NULL
)
18139 goto call_expansion_failed
;
18141 add_loc_descr (&ret
, loc_descr
);
18144 ret1
= new_loc_descr (DW_OP_call4
, 0, 0);
18145 ret1
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18146 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.die
= dwarf_proc
;
18147 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18148 add_loc_descr (&ret
, ret1
);
18151 call_expansion_failed
:
18152 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
18153 /* There are no opcodes for these operations. */
18157 case PREINCREMENT_EXPR
:
18158 case PREDECREMENT_EXPR
:
18159 case POSTINCREMENT_EXPR
:
18160 case POSTDECREMENT_EXPR
:
18161 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
18162 /* There are no opcodes for these operations. */
18166 /* If we already want an address, see if there is INDIRECT_REF inside
18167 e.g. for &this->field. */
18170 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
18171 (loc
, want_address
== 2, context
);
18174 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
18175 && (ret
= cst_pool_loc_descr (loc
)))
18178 /* Otherwise, process the argument and look for the address. */
18179 if (!list_ret
&& !ret
)
18180 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 1, context
);
18184 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
18190 if (DECL_THREAD_LOCAL_P (loc
))
18193 enum dwarf_location_atom tls_op
;
18194 enum dtprel_bool dtprel
= dtprel_false
;
18196 if (targetm
.have_tls
)
18198 /* If this is not defined, we have no way to emit the
18200 if (!targetm
.asm_out
.output_dwarf_dtprel
)
18203 /* The way DW_OP_GNU_push_tls_address is specified, we
18204 can only look up addresses of objects in the current
18205 module. We used DW_OP_addr as first op, but that's
18206 wrong, because DW_OP_addr is relocated by the debug
18207 info consumer, while DW_OP_GNU_push_tls_address
18208 operand shouldn't be. */
18209 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
18211 dtprel
= dtprel_true
;
18212 /* We check for DWARF 5 here because gdb did not implement
18213 DW_OP_form_tls_address until after 7.12. */
18214 tls_op
= (dwarf_version
>= 5 ? DW_OP_form_tls_address
18215 : DW_OP_GNU_push_tls_address
);
18219 if (!targetm
.emutls
.debug_form_tls_address
18220 || !(dwarf_version
>= 3 || !dwarf_strict
))
18222 /* We stuffed the control variable into the DECL_VALUE_EXPR
18223 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
18224 no longer appear in gimple code. We used the control
18225 variable in specific so that we could pick it up here. */
18226 loc
= DECL_VALUE_EXPR (loc
);
18227 tls_op
= DW_OP_form_tls_address
;
18230 rtl
= rtl_for_decl_location (loc
);
18231 if (rtl
== NULL_RTX
)
18236 rtl
= XEXP (rtl
, 0);
18237 if (! CONSTANT_P (rtl
))
18240 ret
= new_addr_loc_descr (rtl
, dtprel
);
18241 ret1
= new_loc_descr (tls_op
, 0, 0);
18242 add_loc_descr (&ret
, ret1
);
18250 if (context
!= NULL
&& context
->dpi
!= NULL
18251 && DECL_CONTEXT (loc
) == context
->dpi
->fndecl
)
18253 /* We are generating code for a DWARF procedure and we want to access
18254 one of its arguments: find the appropriate argument offset and let
18255 the resolve_args_picking pass compute the offset that complies
18256 with the stack frame size. */
18260 for (cursor
= DECL_ARGUMENTS (context
->dpi
->fndecl
);
18261 cursor
!= NULL_TREE
&& cursor
!= loc
;
18262 cursor
= TREE_CHAIN (cursor
), ++i
)
18264 /* If we are translating a DWARF procedure, all referenced parameters
18265 must belong to the current function. */
18266 gcc_assert (cursor
!= NULL_TREE
);
18268 ret
= new_loc_descr (DW_OP_pick
, i
, 0);
18269 ret
->frame_offset_rel
= 1;
18275 if (DECL_HAS_VALUE_EXPR_P (loc
))
18276 return loc_list_from_tree_1 (DECL_VALUE_EXPR (loc
),
18277 want_address
, context
);
18280 case FUNCTION_DECL
:
18283 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
18285 if (loc_list
&& loc_list
->first
)
18287 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
18288 have_address
= want_address
!= 0;
18291 rtl
= rtl_for_decl_location (loc
);
18292 if (rtl
== NULL_RTX
)
18294 if (TREE_CODE (loc
) != FUNCTION_DECL
18296 && current_function_decl
18297 && want_address
!= 1
18298 && ! DECL_IGNORED_P (loc
)
18299 && (INTEGRAL_TYPE_P (TREE_TYPE (loc
))
18300 || POINTER_TYPE_P (TREE_TYPE (loc
)))
18301 && DECL_CONTEXT (loc
) == current_function_decl
18302 && (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (loc
)))
18303 <= DWARF2_ADDR_SIZE
))
18305 dw_die_ref ref
= lookup_decl_die (loc
);
18306 ret
= new_loc_descr (DW_OP_GNU_variable_value
, 0, 0);
18309 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18310 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
18311 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18315 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
18316 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= loc
;
18320 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
18323 else if (CONST_INT_P (rtl
))
18325 HOST_WIDE_INT val
= INTVAL (rtl
);
18326 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18327 val
&= GET_MODE_MASK (DECL_MODE (loc
));
18328 ret
= int_loc_descriptor (val
);
18330 else if (GET_CODE (rtl
) == CONST_STRING
)
18332 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
18335 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
18336 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
18339 machine_mode mode
, mem_mode
;
18341 /* Certain constructs can only be represented at top-level. */
18342 if (want_address
== 2)
18344 ret
= loc_descriptor (rtl
, VOIDmode
,
18345 VAR_INIT_STATUS_INITIALIZED
);
18350 mode
= GET_MODE (rtl
);
18351 mem_mode
= VOIDmode
;
18355 mode
= get_address_mode (rtl
);
18356 rtl
= XEXP (rtl
, 0);
18359 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
18360 VAR_INIT_STATUS_INITIALIZED
);
18363 expansion_failed (loc
, rtl
,
18364 "failed to produce loc descriptor for rtl");
18370 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
18377 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18381 case TARGET_MEM_REF
:
18383 case DEBUG_EXPR_DECL
:
18386 case COMPOUND_EXPR
:
18387 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), want_address
,
18391 case VIEW_CONVERT_EXPR
:
18394 case NON_LVALUE_EXPR
:
18395 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), want_address
,
18398 case COMPONENT_REF
:
18399 case BIT_FIELD_REF
:
18401 case ARRAY_RANGE_REF
:
18402 case REALPART_EXPR
:
18403 case IMAGPART_EXPR
:
18406 poly_int64 bitsize
, bitpos
, bytepos
;
18408 int unsignedp
, reversep
, volatilep
= 0;
18410 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
18411 &unsignedp
, &reversep
, &volatilep
);
18413 gcc_assert (obj
!= loc
);
18415 list_ret
= loc_list_from_tree_1 (obj
,
18417 && known_eq (bitpos
, 0)
18418 && !offset
? 2 : 1,
18420 /* TODO: We can extract value of the small expression via shifting even
18421 for nonzero bitpos. */
18424 if (!multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
18425 || !multiple_p (bitsize
, BITS_PER_UNIT
))
18427 expansion_failed (loc
, NULL_RTX
,
18428 "bitfield access");
18432 if (offset
!= NULL_TREE
)
18434 /* Variable offset. */
18435 list_ret1
= loc_list_from_tree_1 (offset
, 0, context
);
18436 if (list_ret1
== 0)
18438 add_loc_list (&list_ret
, list_ret1
);
18441 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
18444 HOST_WIDE_INT value
;
18445 if (bytepos
.is_constant (&value
) && value
> 0)
18446 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
,
18448 else if (maybe_ne (bytepos
, 0))
18449 loc_list_plus_const (list_ret
, bytepos
);
18456 if ((want_address
|| !tree_fits_shwi_p (loc
))
18457 && (ret
= cst_pool_loc_descr (loc
)))
18459 else if (want_address
== 2
18460 && tree_fits_shwi_p (loc
)
18461 && (ret
= address_of_int_loc_descriptor
18462 (int_size_in_bytes (TREE_TYPE (loc
)),
18463 tree_to_shwi (loc
))))
18465 else if (tree_fits_shwi_p (loc
))
18466 ret
= int_loc_descriptor (tree_to_shwi (loc
));
18467 else if (tree_fits_uhwi_p (loc
))
18468 ret
= uint_loc_descriptor (tree_to_uhwi (loc
));
18471 expansion_failed (loc
, NULL_RTX
,
18472 "Integer operand is not host integer");
18481 if ((ret
= cst_pool_loc_descr (loc
)))
18483 else if (TREE_CODE (loc
) == CONSTRUCTOR
)
18485 tree type
= TREE_TYPE (loc
);
18486 unsigned HOST_WIDE_INT size
= int_size_in_bytes (type
);
18487 unsigned HOST_WIDE_INT offset
= 0;
18488 unsigned HOST_WIDE_INT cnt
;
18489 constructor_elt
*ce
;
18491 if (TREE_CODE (type
) == RECORD_TYPE
)
18493 /* This is very limited, but it's enough to output
18494 pointers to member functions, as long as the
18495 referenced function is defined in the current
18496 translation unit. */
18497 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (loc
), cnt
, ce
)
18499 tree val
= ce
->value
;
18501 tree field
= ce
->index
;
18506 if (!field
|| DECL_BIT_FIELD (field
))
18508 expansion_failed (loc
, NULL_RTX
,
18509 "bitfield in record type constructor");
18510 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
18515 HOST_WIDE_INT fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
18516 unsigned HOST_WIDE_INT pos
= int_byte_position (field
);
18517 gcc_assert (pos
+ fieldsize
<= size
);
18520 expansion_failed (loc
, NULL_RTX
,
18521 "out-of-order fields in record constructor");
18522 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
18528 ret1
= new_loc_descr (DW_OP_piece
, pos
- offset
, 0);
18529 add_loc_descr (&ret
, ret1
);
18532 if (val
&& fieldsize
!= 0)
18534 ret1
= loc_descriptor_from_tree (val
, want_address
, context
);
18537 expansion_failed (loc
, NULL_RTX
,
18538 "unsupported expression in field");
18539 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
18543 add_loc_descr (&ret
, ret1
);
18547 ret1
= new_loc_descr (DW_OP_piece
, fieldsize
, 0);
18548 add_loc_descr (&ret
, ret1
);
18549 offset
= pos
+ fieldsize
;
18553 if (offset
!= size
)
18555 ret1
= new_loc_descr (DW_OP_piece
, size
- offset
, 0);
18556 add_loc_descr (&ret
, ret1
);
18560 have_address
= !!want_address
;
18563 expansion_failed (loc
, NULL_RTX
,
18564 "constructor of non-record type");
18567 /* We can construct small constants here using int_loc_descriptor. */
18568 expansion_failed (loc
, NULL_RTX
,
18569 "constructor or constant not in constant pool");
18572 case TRUTH_AND_EXPR
:
18573 case TRUTH_ANDIF_EXPR
:
18578 case TRUTH_XOR_EXPR
:
18583 case TRUTH_OR_EXPR
:
18584 case TRUTH_ORIF_EXPR
:
18589 case FLOOR_DIV_EXPR
:
18590 case CEIL_DIV_EXPR
:
18591 case ROUND_DIV_EXPR
:
18592 case TRUNC_DIV_EXPR
:
18593 case EXACT_DIV_EXPR
:
18594 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18603 case FLOOR_MOD_EXPR
:
18604 case CEIL_MOD_EXPR
:
18605 case ROUND_MOD_EXPR
:
18606 case TRUNC_MOD_EXPR
:
18607 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18612 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18613 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
18614 if (list_ret
== 0 || list_ret1
== 0)
18617 add_loc_list (&list_ret
, list_ret1
);
18620 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
18621 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
18622 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
18623 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
18624 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
18636 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
18639 case POINTER_PLUS_EXPR
:
18642 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
18644 /* Big unsigned numbers can fit in HOST_WIDE_INT but it may be
18645 smarter to encode their opposite. The DW_OP_plus_uconst operation
18646 takes 1 + X bytes, X being the size of the ULEB128 addend. On the
18647 other hand, a "<push literal>; DW_OP_minus" pattern takes 1 + Y
18648 bytes, Y being the size of the operation that pushes the opposite
18649 of the addend. So let's choose the smallest representation. */
18650 const tree tree_addend
= TREE_OPERAND (loc
, 1);
18651 offset_int wi_addend
;
18652 HOST_WIDE_INT shwi_addend
;
18653 dw_loc_descr_ref loc_naddend
;
18655 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18659 /* Try to get the literal to push. It is the opposite of the addend,
18660 so as we rely on wrapping during DWARF evaluation, first decode
18661 the literal as a "DWARF-sized" signed number. */
18662 wi_addend
= wi::to_offset (tree_addend
);
18663 wi_addend
= wi::sext (wi_addend
, DWARF2_ADDR_SIZE
* 8);
18664 shwi_addend
= wi_addend
.to_shwi ();
18665 loc_naddend
= (shwi_addend
!= INTTYPE_MINIMUM (HOST_WIDE_INT
))
18666 ? int_loc_descriptor (-shwi_addend
)
18669 if (loc_naddend
!= NULL
18670 && ((unsigned) size_of_uleb128 (shwi_addend
)
18671 > size_of_loc_descr (loc_naddend
)))
18673 add_loc_descr_to_each (list_ret
, loc_naddend
);
18674 add_loc_descr_to_each (list_ret
,
18675 new_loc_descr (DW_OP_minus
, 0, 0));
18679 for (dw_loc_descr_ref loc_cur
= loc_naddend
; loc_cur
!= NULL
; )
18681 loc_naddend
= loc_cur
;
18682 loc_cur
= loc_cur
->dw_loc_next
;
18683 ggc_free (loc_naddend
);
18685 loc_list_plus_const (list_ret
, wi_addend
.to_shwi ());
18695 goto do_comp_binop
;
18699 goto do_comp_binop
;
18703 goto do_comp_binop
;
18707 goto do_comp_binop
;
18710 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
18712 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0, context
);
18713 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
18714 list_ret
= loc_list_from_uint_comparison (list_ret
, list_ret1
,
18730 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18731 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
18732 if (list_ret
== 0 || list_ret1
== 0)
18735 add_loc_list (&list_ret
, list_ret1
);
18738 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
18741 case TRUTH_NOT_EXPR
:
18755 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18759 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
18765 const enum tree_code code
=
18766 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
18768 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
18769 build2 (code
, integer_type_node
,
18770 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
18771 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
18778 dw_loc_descr_ref lhs
18779 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
18780 dw_loc_list_ref rhs
18781 = loc_list_from_tree_1 (TREE_OPERAND (loc
, 2), 0, context
);
18782 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
18784 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18785 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
18788 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
18789 add_loc_descr_to_each (list_ret
, bra_node
);
18791 add_loc_list (&list_ret
, rhs
);
18792 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
18793 add_loc_descr_to_each (list_ret
, jump_node
);
18795 add_loc_descr_to_each (list_ret
, lhs
);
18796 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
18797 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
18799 /* ??? Need a node to point the skip at. Use a nop. */
18800 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
18801 add_loc_descr_to_each (list_ret
, tmp
);
18802 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
18803 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
18807 case FIX_TRUNC_EXPR
:
18811 /* Leave front-end specific codes as simply unknown. This comes
18812 up, for instance, with the C STMT_EXPR. */
18813 if ((unsigned int) TREE_CODE (loc
)
18814 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
18816 expansion_failed (loc
, NULL_RTX
,
18817 "language specific tree node");
18821 /* Otherwise this is a generic code; we should just lists all of
18822 these explicitly. We forgot one. */
18824 gcc_unreachable ();
18826 /* In a release build, we want to degrade gracefully: better to
18827 generate incomplete debugging information than to crash. */
18831 if (!ret
&& !list_ret
)
18834 if (want_address
== 2 && !have_address
18835 && (dwarf_version
>= 4 || !dwarf_strict
))
18837 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
18839 expansion_failed (loc
, NULL_RTX
,
18840 "DWARF address size mismatch");
18844 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
18846 add_loc_descr_to_each (list_ret
,
18847 new_loc_descr (DW_OP_stack_value
, 0, 0));
18850 /* Show if we can't fill the request for an address. */
18851 if (want_address
&& !have_address
)
18853 expansion_failed (loc
, NULL_RTX
,
18854 "Want address and only have value");
18858 gcc_assert (!ret
|| !list_ret
);
18860 /* If we've got an address and don't want one, dereference. */
18861 if (!want_address
&& have_address
)
18863 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
18865 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
18867 expansion_failed (loc
, NULL_RTX
,
18868 "DWARF address size mismatch");
18871 else if (size
== DWARF2_ADDR_SIZE
)
18874 op
= DW_OP_deref_size
;
18877 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
18879 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
18882 list_ret
= new_loc_list (ret
, NULL
, 0, NULL
, 0, NULL
);
18887 /* Likewise, but strip useless DW_OP_nop operations in the resulting
18890 static dw_loc_list_ref
18891 loc_list_from_tree (tree loc
, int want_address
,
18892 struct loc_descr_context
*context
)
18894 dw_loc_list_ref result
= loc_list_from_tree_1 (loc
, want_address
, context
);
18896 for (dw_loc_list_ref loc_cur
= result
;
18897 loc_cur
!= NULL
; loc_cur
= loc_cur
->dw_loc_next
)
18898 loc_descr_without_nops (loc_cur
->expr
);
18902 /* Same as above but return only single location expression. */
18903 static dw_loc_descr_ref
18904 loc_descriptor_from_tree (tree loc
, int want_address
,
18905 struct loc_descr_context
*context
)
18907 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
, context
);
18910 if (ret
->dw_loc_next
)
18912 expansion_failed (loc
, NULL_RTX
,
18913 "Location list where only loc descriptor needed");
18919 /* Given a value, round it up to the lowest multiple of `boundary'
18920 which is not less than the value itself. */
18922 static inline HOST_WIDE_INT
18923 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
18925 return (((value
+ boundary
- 1) / boundary
) * boundary
);
18928 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
18929 pointer to the declared type for the relevant field variable, or return
18930 `integer_type_node' if the given node turns out to be an
18931 ERROR_MARK node. */
18934 field_type (const_tree decl
)
18938 if (TREE_CODE (decl
) == ERROR_MARK
)
18939 return integer_type_node
;
18941 type
= DECL_BIT_FIELD_TYPE (decl
);
18942 if (type
== NULL_TREE
)
18943 type
= TREE_TYPE (decl
);
18948 /* Given a pointer to a tree node, return the alignment in bits for
18949 it, or else return BITS_PER_WORD if the node actually turns out to
18950 be an ERROR_MARK node. */
18952 static inline unsigned
18953 simple_type_align_in_bits (const_tree type
)
18955 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
18958 static inline unsigned
18959 simple_decl_align_in_bits (const_tree decl
)
18961 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
18964 /* Return the result of rounding T up to ALIGN. */
18966 static inline offset_int
18967 round_up_to_align (const offset_int
&t
, unsigned int align
)
18969 return wi::udiv_trunc (t
+ align
- 1, align
) * align
;
18972 /* Compute the size of TYPE in bytes. If possible, return NULL and store the
18973 size as an integer constant in CST_SIZE. Otherwise, if possible, return a
18974 DWARF expression that computes the size. Return NULL and set CST_SIZE to -1
18975 if we fail to return the size in one of these two forms. */
18977 static dw_loc_descr_ref
18978 type_byte_size (const_tree type
, HOST_WIDE_INT
*cst_size
)
18981 struct loc_descr_context ctx
;
18983 /* Return a constant integer in priority, if possible. */
18984 *cst_size
= int_size_in_bytes (type
);
18985 if (*cst_size
!= -1)
18988 ctx
.context_type
= const_cast<tree
> (type
);
18989 ctx
.base_decl
= NULL_TREE
;
18991 ctx
.placeholder_arg
= false;
18992 ctx
.placeholder_seen
= false;
18994 type
= TYPE_MAIN_VARIANT (type
);
18995 tree_size
= TYPE_SIZE_UNIT (type
);
18996 return ((tree_size
!= NULL_TREE
)
18997 ? loc_descriptor_from_tree (tree_size
, 0, &ctx
)
19001 /* Helper structure for RECORD_TYPE processing. */
19004 /* Root RECORD_TYPE. It is needed to generate data member location
19005 descriptions in variable-length records (VLR), but also to cope with
19006 variants, which are composed of nested structures multiplexed with
19007 QUAL_UNION_TYPE nodes. Each time such a structure is passed to a
19008 function processing a FIELD_DECL, it is required to be non null. */
19010 /* When generating a variant part in a RECORD_TYPE (i.e. a nested
19011 QUAL_UNION_TYPE), this holds an expression that computes the offset for
19012 this variant part as part of the root record (in storage units). For
19013 regular records, it must be NULL_TREE. */
19014 tree variant_part_offset
;
19017 /* Given a pointer to a FIELD_DECL, compute the byte offset of the lowest
19018 addressed byte of the "containing object" for the given FIELD_DECL. If
19019 possible, return a native constant through CST_OFFSET (in which case NULL is
19020 returned); otherwise return a DWARF expression that computes the offset.
19022 Set *CST_OFFSET to 0 and return NULL if we are unable to determine what
19023 that offset is, either because the argument turns out to be a pointer to an
19024 ERROR_MARK node, or because the offset expression is too complex for us.
19026 CTX is required: see the comment for VLR_CONTEXT. */
19028 static dw_loc_descr_ref
19029 field_byte_offset (const_tree decl
, struct vlr_context
*ctx
,
19030 HOST_WIDE_INT
*cst_offset
)
19033 dw_loc_list_ref loc_result
;
19037 if (TREE_CODE (decl
) == ERROR_MARK
)
19040 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
19042 /* We cannot handle variable bit offsets at the moment, so abort if it's the
19044 if (TREE_CODE (DECL_FIELD_BIT_OFFSET (decl
)) != INTEGER_CST
)
19047 #ifdef PCC_BITFIELD_TYPE_MATTERS
19048 /* We used to handle only constant offsets in all cases. Now, we handle
19049 properly dynamic byte offsets only when PCC bitfield type doesn't
19051 if (PCC_BITFIELD_TYPE_MATTERS
19052 && TREE_CODE (DECL_FIELD_OFFSET (decl
)) == INTEGER_CST
)
19054 offset_int object_offset_in_bits
;
19055 offset_int object_offset_in_bytes
;
19056 offset_int bitpos_int
;
19058 tree field_size_tree
;
19059 offset_int deepest_bitpos
;
19060 offset_int field_size_in_bits
;
19061 unsigned int type_align_in_bits
;
19062 unsigned int decl_align_in_bits
;
19063 offset_int type_size_in_bits
;
19065 bitpos_int
= wi::to_offset (bit_position (decl
));
19066 type
= field_type (decl
);
19067 type_size_in_bits
= offset_int_type_size_in_bits (type
);
19068 type_align_in_bits
= simple_type_align_in_bits (type
);
19070 field_size_tree
= DECL_SIZE (decl
);
19072 /* The size could be unspecified if there was an error, or for
19073 a flexible array member. */
19074 if (!field_size_tree
)
19075 field_size_tree
= bitsize_zero_node
;
19077 /* If the size of the field is not constant, use the type size. */
19078 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
19079 field_size_in_bits
= wi::to_offset (field_size_tree
);
19081 field_size_in_bits
= type_size_in_bits
;
19083 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
19085 /* The GCC front-end doesn't make any attempt to keep track of the
19086 starting bit offset (relative to the start of the containing
19087 structure type) of the hypothetical "containing object" for a
19088 bit-field. Thus, when computing the byte offset value for the
19089 start of the "containing object" of a bit-field, we must deduce
19090 this information on our own. This can be rather tricky to do in
19091 some cases. For example, handling the following structure type
19092 definition when compiling for an i386/i486 target (which only
19093 aligns long long's to 32-bit boundaries) can be very tricky:
19095 struct S { int field1; long long field2:31; };
19097 Fortunately, there is a simple rule-of-thumb which can be used
19098 in such cases. When compiling for an i386/i486, GCC will
19099 allocate 8 bytes for the structure shown above. It decides to
19100 do this based upon one simple rule for bit-field allocation.
19101 GCC allocates each "containing object" for each bit-field at
19102 the first (i.e. lowest addressed) legitimate alignment boundary
19103 (based upon the required minimum alignment for the declared
19104 type of the field) which it can possibly use, subject to the
19105 condition that there is still enough available space remaining
19106 in the containing object (when allocated at the selected point)
19107 to fully accommodate all of the bits of the bit-field itself.
19109 This simple rule makes it obvious why GCC allocates 8 bytes for
19110 each object of the structure type shown above. When looking
19111 for a place to allocate the "containing object" for `field2',
19112 the compiler simply tries to allocate a 64-bit "containing
19113 object" at each successive 32-bit boundary (starting at zero)
19114 until it finds a place to allocate that 64- bit field such that
19115 at least 31 contiguous (and previously unallocated) bits remain
19116 within that selected 64 bit field. (As it turns out, for the
19117 example above, the compiler finds it is OK to allocate the
19118 "containing object" 64-bit field at bit-offset zero within the
19121 Here we attempt to work backwards from the limited set of facts
19122 we're given, and we try to deduce from those facts, where GCC
19123 must have believed that the containing object started (within
19124 the structure type). The value we deduce is then used (by the
19125 callers of this routine) to generate DW_AT_location and
19126 DW_AT_bit_offset attributes for fields (both bit-fields and, in
19127 the case of DW_AT_location, regular fields as well). */
19129 /* Figure out the bit-distance from the start of the structure to
19130 the "deepest" bit of the bit-field. */
19131 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
19133 /* This is the tricky part. Use some fancy footwork to deduce
19134 where the lowest addressed bit of the containing object must
19136 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
19138 /* Round up to type_align by default. This works best for
19140 object_offset_in_bits
19141 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
19143 if (wi::gtu_p (object_offset_in_bits
, bitpos_int
))
19145 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
19147 /* Round up to decl_align instead. */
19148 object_offset_in_bits
19149 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
19152 object_offset_in_bytes
19153 = wi::lrshift (object_offset_in_bits
, LOG2_BITS_PER_UNIT
);
19154 if (ctx
->variant_part_offset
== NULL_TREE
)
19156 *cst_offset
= object_offset_in_bytes
.to_shwi ();
19159 tree_result
= wide_int_to_tree (sizetype
, object_offset_in_bytes
);
19162 #endif /* PCC_BITFIELD_TYPE_MATTERS */
19163 tree_result
= byte_position (decl
);
19165 if (ctx
->variant_part_offset
!= NULL_TREE
)
19166 tree_result
= fold_build2 (PLUS_EXPR
, TREE_TYPE (tree_result
),
19167 ctx
->variant_part_offset
, tree_result
);
19169 /* If the byte offset is a constant, it's simplier to handle a native
19170 constant rather than a DWARF expression. */
19171 if (TREE_CODE (tree_result
) == INTEGER_CST
)
19173 *cst_offset
= wi::to_offset (tree_result
).to_shwi ();
19176 struct loc_descr_context loc_ctx
= {
19177 ctx
->struct_type
, /* context_type */
19178 NULL_TREE
, /* base_decl */
19180 false, /* placeholder_arg */
19181 false /* placeholder_seen */
19183 loc_result
= loc_list_from_tree (tree_result
, 0, &loc_ctx
);
19185 /* We want a DWARF expression: abort if we only have a location list with
19186 multiple elements. */
19187 if (!loc_result
|| !single_element_loc_list_p (loc_result
))
19190 return loc_result
->expr
;
19193 /* The following routines define various Dwarf attributes and any data
19194 associated with them. */
19196 /* Add a location description attribute value to a DIE.
19198 This emits location attributes suitable for whole variables and
19199 whole parameters. Note that the location attributes for struct fields are
19200 generated by the routine `data_member_location_attribute' below. */
19203 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
19204 dw_loc_list_ref descr
)
19206 bool check_no_locviews
= true;
19209 if (single_element_loc_list_p (descr
))
19210 add_AT_loc (die
, attr_kind
, descr
->expr
);
19213 add_AT_loc_list (die
, attr_kind
, descr
);
19214 gcc_assert (descr
->ll_symbol
);
19215 if (attr_kind
== DW_AT_location
&& descr
->vl_symbol
19216 && dwarf2out_locviews_in_attribute ())
19218 add_AT_view_list (die
, DW_AT_GNU_locviews
);
19219 check_no_locviews
= false;
19223 if (check_no_locviews
)
19224 gcc_assert (!get_AT (die
, DW_AT_GNU_locviews
));
19227 /* Add DW_AT_accessibility attribute to DIE if needed. */
19230 add_accessibility_attribute (dw_die_ref die
, tree decl
)
19232 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19233 children, otherwise the default is DW_ACCESS_public. In DWARF2
19234 the default has always been DW_ACCESS_public. */
19235 if (TREE_PROTECTED (decl
))
19236 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
19237 else if (TREE_PRIVATE (decl
))
19239 if (dwarf_version
== 2
19240 || die
->die_parent
== NULL
19241 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
19242 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
19244 else if (dwarf_version
> 2
19246 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
19247 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
19250 /* Attach the specialized form of location attribute used for data members of
19251 struct and union types. In the special case of a FIELD_DECL node which
19252 represents a bit-field, the "offset" part of this special location
19253 descriptor must indicate the distance in bytes from the lowest-addressed
19254 byte of the containing struct or union type to the lowest-addressed byte of
19255 the "containing object" for the bit-field. (See the `field_byte_offset'
19258 For any given bit-field, the "containing object" is a hypothetical object
19259 (of some integral or enum type) within which the given bit-field lives. The
19260 type of this hypothetical "containing object" is always the same as the
19261 declared type of the individual bit-field itself (for GCC anyway... the
19262 DWARF spec doesn't actually mandate this). Note that it is the size (in
19263 bytes) of the hypothetical "containing object" which will be given in the
19264 DW_AT_byte_size attribute for this bit-field. (See the
19265 `byte_size_attribute' function below.) It is also used when calculating the
19266 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
19269 CTX is required: see the comment for VLR_CONTEXT. */
19272 add_data_member_location_attribute (dw_die_ref die
,
19274 struct vlr_context
*ctx
)
19276 HOST_WIDE_INT offset
;
19277 dw_loc_descr_ref loc_descr
= 0;
19279 if (TREE_CODE (decl
) == TREE_BINFO
)
19281 /* We're working on the TAG_inheritance for a base class. */
19282 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
19284 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
19285 aren't at a fixed offset from all (sub)objects of the same
19286 type. We need to extract the appropriate offset from our
19287 vtable. The following dwarf expression means
19289 BaseAddr = ObAddr + *((*ObAddr) - Offset)
19291 This is specific to the V3 ABI, of course. */
19293 dw_loc_descr_ref tmp
;
19295 /* Make a copy of the object address. */
19296 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
19297 add_loc_descr (&loc_descr
, tmp
);
19299 /* Extract the vtable address. */
19300 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
19301 add_loc_descr (&loc_descr
, tmp
);
19303 /* Calculate the address of the offset. */
19304 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
19305 gcc_assert (offset
< 0);
19307 tmp
= int_loc_descriptor (-offset
);
19308 add_loc_descr (&loc_descr
, tmp
);
19309 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
19310 add_loc_descr (&loc_descr
, tmp
);
19312 /* Extract the offset. */
19313 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
19314 add_loc_descr (&loc_descr
, tmp
);
19316 /* Add it to the object address. */
19317 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
19318 add_loc_descr (&loc_descr
, tmp
);
19321 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
19325 loc_descr
= field_byte_offset (decl
, ctx
, &offset
);
19327 /* If loc_descr is available then we know the field offset is dynamic.
19328 However, GDB does not handle dynamic field offsets very well at the
19330 if (loc_descr
!= NULL
&& gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
)
19336 /* Data member location evalutation starts with the base address on the
19337 stack. Compute the field offset and add it to this base address. */
19338 else if (loc_descr
!= NULL
)
19339 add_loc_descr (&loc_descr
, new_loc_descr (DW_OP_plus
, 0, 0));
19344 /* While DW_AT_data_bit_offset has been added already in DWARF4,
19345 e.g. GDB only added support to it in November 2016. For DWARF5
19346 we need newer debug info consumers anyway. We might change this
19347 to dwarf_version >= 4 once most consumers catched up. */
19348 if (dwarf_version
>= 5
19349 && TREE_CODE (decl
) == FIELD_DECL
19350 && DECL_BIT_FIELD_TYPE (decl
))
19352 tree off
= bit_position (decl
);
19353 if (tree_fits_uhwi_p (off
) && get_AT (die
, DW_AT_bit_size
))
19355 remove_AT (die
, DW_AT_byte_size
);
19356 remove_AT (die
, DW_AT_bit_offset
);
19357 add_AT_unsigned (die
, DW_AT_data_bit_offset
, tree_to_uhwi (off
));
19361 if (dwarf_version
> 2)
19363 /* Don't need to output a location expression, just the constant. */
19365 add_AT_int (die
, DW_AT_data_member_location
, offset
);
19367 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
19372 enum dwarf_location_atom op
;
19374 /* The DWARF2 standard says that we should assume that the structure
19375 address is already on the stack, so we can specify a structure
19376 field address by using DW_OP_plus_uconst. */
19377 op
= DW_OP_plus_uconst
;
19378 loc_descr
= new_loc_descr (op
, offset
, 0);
19382 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
19385 /* Writes integer values to dw_vec_const array. */
19388 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
19392 *dest
++ = val
& 0xff;
19398 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
19400 static HOST_WIDE_INT
19401 extract_int (const unsigned char *src
, unsigned int size
)
19403 HOST_WIDE_INT val
= 0;
19409 val
|= *--src
& 0xff;
19415 /* Writes wide_int values to dw_vec_const array. */
19418 insert_wide_int (const wide_int
&val
, unsigned char *dest
, int elt_size
)
19422 if (elt_size
<= HOST_BITS_PER_WIDE_INT
/BITS_PER_UNIT
)
19424 insert_int ((HOST_WIDE_INT
) val
.elt (0), elt_size
, dest
);
19428 /* We'd have to extend this code to support odd sizes. */
19429 gcc_assert (elt_size
% (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
) == 0);
19431 int n
= elt_size
/ (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
19433 if (WORDS_BIG_ENDIAN
)
19434 for (i
= n
- 1; i
>= 0; i
--)
19436 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
19437 dest
+= sizeof (HOST_WIDE_INT
);
19440 for (i
= 0; i
< n
; i
++)
19442 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
19443 dest
+= sizeof (HOST_WIDE_INT
);
19447 /* Writes floating point values to dw_vec_const array. */
19450 insert_float (const_rtx rtl
, unsigned char *array
)
19454 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
19456 real_to_target (val
, CONST_DOUBLE_REAL_VALUE (rtl
), mode
);
19458 /* real_to_target puts 32-bit pieces in each long. Pack them. */
19459 for (i
= 0; i
< GET_MODE_SIZE (mode
) / 4; i
++)
19461 insert_int (val
[i
], 4, array
);
19466 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
19467 does not have a "location" either in memory or in a register. These
19468 things can arise in GNU C when a constant is passed as an actual parameter
19469 to an inlined function. They can also arise in C++ where declared
19470 constants do not necessarily get memory "homes". */
19473 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
19475 switch (GET_CODE (rtl
))
19479 HOST_WIDE_INT val
= INTVAL (rtl
);
19482 add_AT_int (die
, DW_AT_const_value
, val
);
19484 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
19488 case CONST_WIDE_INT
:
19490 wide_int w1
= rtx_mode_t (rtl
, MAX_MODE_INT
);
19491 unsigned int prec
= MIN (wi::min_precision (w1
, UNSIGNED
),
19492 (unsigned int)CONST_WIDE_INT_NUNITS (rtl
) * HOST_BITS_PER_WIDE_INT
);
19493 wide_int w
= wi::zext (w1
, prec
);
19494 add_AT_wide (die
, DW_AT_const_value
, w
);
19499 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
19500 floating-point constant. A CONST_DOUBLE is used whenever the
19501 constant requires more than one word in order to be adequately
19503 if (TARGET_SUPPORTS_WIDE_INT
== 0
19504 && !SCALAR_FLOAT_MODE_P (GET_MODE (rtl
)))
19505 add_AT_double (die
, DW_AT_const_value
,
19506 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
19509 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
19510 unsigned int length
= GET_MODE_SIZE (mode
);
19511 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
19513 insert_float (rtl
, array
);
19514 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
19520 unsigned int length
;
19521 if (!CONST_VECTOR_NUNITS (rtl
).is_constant (&length
))
19524 machine_mode mode
= GET_MODE (rtl
);
19525 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
19526 unsigned char *array
19527 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
19530 machine_mode imode
= GET_MODE_INNER (mode
);
19532 switch (GET_MODE_CLASS (mode
))
19534 case MODE_VECTOR_INT
:
19535 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
19537 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
19538 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
19542 case MODE_VECTOR_FLOAT
:
19543 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
19545 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
19546 insert_float (elt
, p
);
19551 gcc_unreachable ();
19554 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
19559 if (dwarf_version
>= 4 || !dwarf_strict
)
19561 dw_loc_descr_ref loc_result
;
19562 resolve_one_addr (&rtl
);
19564 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
19565 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
19566 add_AT_loc (die
, DW_AT_location
, loc_result
);
19567 vec_safe_push (used_rtx_array
, rtl
);
19573 if (CONSTANT_P (XEXP (rtl
, 0)))
19574 return add_const_value_attribute (die
, XEXP (rtl
, 0));
19577 if (!const_ok_for_output (rtl
))
19581 if (dwarf_version
>= 4 || !dwarf_strict
)
19586 /* In cases where an inlined instance of an inline function is passed
19587 the address of an `auto' variable (which is local to the caller) we
19588 can get a situation where the DECL_RTL of the artificial local
19589 variable (for the inlining) which acts as a stand-in for the
19590 corresponding formal parameter (of the inline function) will look
19591 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
19592 exactly a compile-time constant expression, but it isn't the address
19593 of the (artificial) local variable either. Rather, it represents the
19594 *value* which the artificial local variable always has during its
19595 lifetime. We currently have no way to represent such quasi-constant
19596 values in Dwarf, so for now we just punt and generate nothing. */
19604 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
19605 && MEM_READONLY_P (rtl
)
19606 && GET_MODE (rtl
) == BLKmode
)
19608 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
19614 /* No other kinds of rtx should be possible here. */
19615 gcc_unreachable ();
19620 /* Determine whether the evaluation of EXPR references any variables
19621 or functions which aren't otherwise used (and therefore may not be
19624 reference_to_unused (tree
* tp
, int * walk_subtrees
,
19625 void * data ATTRIBUTE_UNUSED
)
19627 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
19628 *walk_subtrees
= 0;
19630 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
19631 && ! TREE_ASM_WRITTEN (*tp
))
19633 /* ??? The C++ FE emits debug information for using decls, so
19634 putting gcc_unreachable here falls over. See PR31899. For now
19635 be conservative. */
19636 else if (!symtab
->global_info_ready
&& VAR_OR_FUNCTION_DECL_P (*tp
))
19638 else if (VAR_P (*tp
))
19640 varpool_node
*node
= varpool_node::get (*tp
);
19641 if (!node
|| !node
->definition
)
19644 else if (TREE_CODE (*tp
) == FUNCTION_DECL
19645 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
19647 /* The call graph machinery must have finished analyzing,
19648 optimizing and gimplifying the CU by now.
19649 So if *TP has no call graph node associated
19650 to it, it means *TP will not be emitted. */
19651 if (!cgraph_node::get (*tp
))
19654 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
19660 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
19661 for use in a later add_const_value_attribute call. */
19664 rtl_for_decl_init (tree init
, tree type
)
19666 rtx rtl
= NULL_RTX
;
19670 /* If a variable is initialized with a string constant without embedded
19671 zeros, build CONST_STRING. */
19672 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
19674 tree enttype
= TREE_TYPE (type
);
19675 tree domain
= TYPE_DOMAIN (type
);
19676 scalar_int_mode mode
;
19678 if (is_int_mode (TYPE_MODE (enttype
), &mode
)
19679 && GET_MODE_SIZE (mode
) == 1
19681 && TYPE_MAX_VALUE (domain
)
19682 && TREE_CODE (TYPE_MAX_VALUE (domain
)) == INTEGER_CST
19683 && integer_zerop (TYPE_MIN_VALUE (domain
))
19684 && compare_tree_int (TYPE_MAX_VALUE (domain
),
19685 TREE_STRING_LENGTH (init
) - 1) == 0
19686 && ((size_t) TREE_STRING_LENGTH (init
)
19687 == strlen (TREE_STRING_POINTER (init
)) + 1))
19689 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
19690 ggc_strdup (TREE_STRING_POINTER (init
)));
19691 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
19692 MEM_READONLY_P (rtl
) = 1;
19695 /* Other aggregates, and complex values, could be represented using
19697 else if (AGGREGATE_TYPE_P (type
)
19698 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
19699 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
19700 || TREE_CODE (type
) == COMPLEX_TYPE
)
19702 /* Vectors only work if their mode is supported by the target.
19703 FIXME: generic vectors ought to work too. */
19704 else if (TREE_CODE (type
) == VECTOR_TYPE
19705 && !VECTOR_MODE_P (TYPE_MODE (type
)))
19707 /* If the initializer is something that we know will expand into an
19708 immediate RTL constant, expand it now. We must be careful not to
19709 reference variables which won't be output. */
19710 else if (initializer_constant_valid_p (init
, type
)
19711 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
19713 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
19715 if (TREE_CODE (type
) == VECTOR_TYPE
)
19716 switch (TREE_CODE (init
))
19721 if (TREE_CONSTANT (init
))
19723 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
19724 bool constant_p
= true;
19726 unsigned HOST_WIDE_INT ix
;
19728 /* Even when ctor is constant, it might contain non-*_CST
19729 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
19730 belong into VECTOR_CST nodes. */
19731 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
19732 if (!CONSTANT_CLASS_P (value
))
19734 constant_p
= false;
19740 init
= build_vector_from_ctor (type
, elts
);
19750 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
19752 /* If expand_expr returns a MEM, it wasn't immediate. */
19753 gcc_assert (!rtl
|| !MEM_P (rtl
));
19759 /* Generate RTL for the variable DECL to represent its location. */
19762 rtl_for_decl_location (tree decl
)
19766 /* Here we have to decide where we are going to say the parameter "lives"
19767 (as far as the debugger is concerned). We only have a couple of
19768 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
19770 DECL_RTL normally indicates where the parameter lives during most of the
19771 activation of the function. If optimization is enabled however, this
19772 could be either NULL or else a pseudo-reg. Both of those cases indicate
19773 that the parameter doesn't really live anywhere (as far as the code
19774 generation parts of GCC are concerned) during most of the function's
19775 activation. That will happen (for example) if the parameter is never
19776 referenced within the function.
19778 We could just generate a location descriptor here for all non-NULL
19779 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
19780 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
19781 where DECL_RTL is NULL or is a pseudo-reg.
19783 Note however that we can only get away with using DECL_INCOMING_RTL as
19784 a backup substitute for DECL_RTL in certain limited cases. In cases
19785 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
19786 we can be sure that the parameter was passed using the same type as it is
19787 declared to have within the function, and that its DECL_INCOMING_RTL
19788 points us to a place where a value of that type is passed.
19790 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
19791 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
19792 because in these cases DECL_INCOMING_RTL points us to a value of some
19793 type which is *different* from the type of the parameter itself. Thus,
19794 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
19795 such cases, the debugger would end up (for example) trying to fetch a
19796 `float' from a place which actually contains the first part of a
19797 `double'. That would lead to really incorrect and confusing
19798 output at debug-time.
19800 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
19801 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
19802 are a couple of exceptions however. On little-endian machines we can
19803 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
19804 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
19805 an integral type that is smaller than TREE_TYPE (decl). These cases arise
19806 when (on a little-endian machine) a non-prototyped function has a
19807 parameter declared to be of type `short' or `char'. In such cases,
19808 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
19809 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
19810 passed `int' value. If the debugger then uses that address to fetch
19811 a `short' or a `char' (on a little-endian machine) the result will be
19812 the correct data, so we allow for such exceptional cases below.
19814 Note that our goal here is to describe the place where the given formal
19815 parameter lives during most of the function's activation (i.e. between the
19816 end of the prologue and the start of the epilogue). We'll do that as best
19817 as we can. Note however that if the given formal parameter is modified
19818 sometime during the execution of the function, then a stack backtrace (at
19819 debug-time) will show the function as having been called with the *new*
19820 value rather than the value which was originally passed in. This happens
19821 rarely enough that it is not a major problem, but it *is* a problem, and
19822 I'd like to fix it.
19824 A future version of dwarf2out.c may generate two additional attributes for
19825 any given DW_TAG_formal_parameter DIE which will describe the "passed
19826 type" and the "passed location" for the given formal parameter in addition
19827 to the attributes we now generate to indicate the "declared type" and the
19828 "active location" for each parameter. This additional set of attributes
19829 could be used by debuggers for stack backtraces. Separately, note that
19830 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
19831 This happens (for example) for inlined-instances of inline function formal
19832 parameters which are never referenced. This really shouldn't be
19833 happening. All PARM_DECL nodes should get valid non-NULL
19834 DECL_INCOMING_RTL values. FIXME. */
19836 /* Use DECL_RTL as the "location" unless we find something better. */
19837 rtl
= DECL_RTL_IF_SET (decl
);
19839 /* When generating abstract instances, ignore everything except
19840 constants, symbols living in memory, and symbols living in
19841 fixed registers. */
19842 if (! reload_completed
)
19845 && (CONSTANT_P (rtl
)
19847 && CONSTANT_P (XEXP (rtl
, 0)))
19850 && TREE_STATIC (decl
))))
19852 rtl
= targetm
.delegitimize_address (rtl
);
19857 else if (TREE_CODE (decl
) == PARM_DECL
)
19859 if (rtl
== NULL_RTX
19860 || is_pseudo_reg (rtl
)
19862 && is_pseudo_reg (XEXP (rtl
, 0))
19863 && DECL_INCOMING_RTL (decl
)
19864 && MEM_P (DECL_INCOMING_RTL (decl
))
19865 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
19867 tree declared_type
= TREE_TYPE (decl
);
19868 tree passed_type
= DECL_ARG_TYPE (decl
);
19869 machine_mode dmode
= TYPE_MODE (declared_type
);
19870 machine_mode pmode
= TYPE_MODE (passed_type
);
19872 /* This decl represents a formal parameter which was optimized out.
19873 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
19874 all cases where (rtl == NULL_RTX) just below. */
19875 if (dmode
== pmode
)
19876 rtl
= DECL_INCOMING_RTL (decl
);
19877 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
19878 && SCALAR_INT_MODE_P (dmode
)
19879 && known_le (GET_MODE_SIZE (dmode
), GET_MODE_SIZE (pmode
))
19880 && DECL_INCOMING_RTL (decl
))
19882 rtx inc
= DECL_INCOMING_RTL (decl
);
19885 else if (MEM_P (inc
))
19887 if (BYTES_BIG_ENDIAN
)
19888 rtl
= adjust_address_nv (inc
, dmode
,
19889 GET_MODE_SIZE (pmode
)
19890 - GET_MODE_SIZE (dmode
));
19897 /* If the parm was passed in registers, but lives on the stack, then
19898 make a big endian correction if the mode of the type of the
19899 parameter is not the same as the mode of the rtl. */
19900 /* ??? This is the same series of checks that are made in dbxout.c before
19901 we reach the big endian correction code there. It isn't clear if all
19902 of these checks are necessary here, but keeping them all is the safe
19904 else if (MEM_P (rtl
)
19905 && XEXP (rtl
, 0) != const0_rtx
19906 && ! CONSTANT_P (XEXP (rtl
, 0))
19907 /* Not passed in memory. */
19908 && !MEM_P (DECL_INCOMING_RTL (decl
))
19909 /* Not passed by invisible reference. */
19910 && (!REG_P (XEXP (rtl
, 0))
19911 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
19912 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
19913 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
19914 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
19917 /* Big endian correction check. */
19918 && BYTES_BIG_ENDIAN
19919 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
19920 && known_lt (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))),
19923 machine_mode addr_mode
= get_address_mode (rtl
);
19924 poly_int64 offset
= (UNITS_PER_WORD
19925 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
19927 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
19928 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
19931 else if (VAR_P (decl
)
19934 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
)))
19936 machine_mode addr_mode
= get_address_mode (rtl
);
19937 poly_int64 offset
= byte_lowpart_offset (TYPE_MODE (TREE_TYPE (decl
)),
19940 /* If a variable is declared "register" yet is smaller than
19941 a register, then if we store the variable to memory, it
19942 looks like we're storing a register-sized value, when in
19943 fact we are not. We need to adjust the offset of the
19944 storage location to reflect the actual value's bytes,
19945 else gdb will not be able to display it. */
19946 if (maybe_ne (offset
, 0))
19947 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
19948 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
19951 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
19952 and will have been substituted directly into all expressions that use it.
19953 C does not have such a concept, but C++ and other languages do. */
19954 if (!rtl
&& VAR_P (decl
) && DECL_INITIAL (decl
))
19955 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
19958 rtl
= targetm
.delegitimize_address (rtl
);
19960 /* If we don't look past the constant pool, we risk emitting a
19961 reference to a constant pool entry that isn't referenced from
19962 code, and thus is not emitted. */
19964 rtl
= avoid_constant_pool_reference (rtl
);
19966 /* Try harder to get a rtl. If this symbol ends up not being emitted
19967 in the current CU, resolve_addr will remove the expression referencing
19969 if (rtl
== NULL_RTX
19970 && !(early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
19972 && !DECL_EXTERNAL (decl
)
19973 && TREE_STATIC (decl
)
19974 && DECL_NAME (decl
)
19975 && !DECL_HARD_REGISTER (decl
)
19976 && DECL_MODE (decl
) != VOIDmode
)
19978 rtl
= make_decl_rtl_for_debug (decl
);
19980 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
19981 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
19988 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
19989 returned. If so, the decl for the COMMON block is returned, and the
19990 value is the offset into the common block for the symbol. */
19993 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
19995 tree val_expr
, cvar
;
19997 poly_int64 bitsize
, bitpos
;
19999 HOST_WIDE_INT cbitpos
;
20000 int unsignedp
, reversep
, volatilep
= 0;
20002 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
20003 it does not have a value (the offset into the common area), or if it
20004 is thread local (as opposed to global) then it isn't common, and shouldn't
20005 be handled as such. */
20007 || !TREE_STATIC (decl
)
20008 || !DECL_HAS_VALUE_EXPR_P (decl
)
20012 val_expr
= DECL_VALUE_EXPR (decl
);
20013 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
20016 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
, &mode
,
20017 &unsignedp
, &reversep
, &volatilep
);
20019 if (cvar
== NULL_TREE
20021 || DECL_ARTIFICIAL (cvar
)
20022 || !TREE_PUBLIC (cvar
)
20023 /* We don't expect to have to cope with variable offsets,
20024 since at present all static data must have a constant size. */
20025 || !bitpos
.is_constant (&cbitpos
))
20029 if (offset
!= NULL
)
20031 if (!tree_fits_shwi_p (offset
))
20033 *value
= tree_to_shwi (offset
);
20036 *value
+= cbitpos
/ BITS_PER_UNIT
;
20041 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
20042 data attribute for a variable or a parameter. We generate the
20043 DW_AT_const_value attribute only in those cases where the given variable
20044 or parameter does not have a true "location" either in memory or in a
20045 register. This can happen (for example) when a constant is passed as an
20046 actual argument in a call to an inline function. (It's possible that
20047 these things can crop up in other ways also.) Note that one type of
20048 constant value which can be passed into an inlined function is a constant
20049 pointer. This can happen for example if an actual argument in an inlined
20050 function call evaluates to a compile-time constant address.
20052 CACHE_P is true if it is worth caching the location list for DECL,
20053 so that future calls can reuse it rather than regenerate it from scratch.
20054 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
20055 since we will need to refer to them each time the function is inlined. */
20058 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
)
20061 dw_loc_list_ref list
;
20062 var_loc_list
*loc_list
;
20063 cached_dw_loc_list
*cache
;
20068 if (TREE_CODE (decl
) == ERROR_MARK
)
20071 if (get_AT (die
, DW_AT_location
)
20072 || get_AT (die
, DW_AT_const_value
))
20075 gcc_assert (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
20076 || TREE_CODE (decl
) == RESULT_DECL
);
20078 /* Try to get some constant RTL for this decl, and use that as the value of
20081 rtl
= rtl_for_decl_location (decl
);
20082 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
20083 && add_const_value_attribute (die
, rtl
))
20086 /* See if we have single element location list that is equivalent to
20087 a constant value. That way we are better to use add_const_value_attribute
20088 rather than expanding constant value equivalent. */
20089 loc_list
= lookup_decl_loc (decl
);
20092 && loc_list
->first
->next
== NULL
20093 && NOTE_P (loc_list
->first
->loc
)
20094 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
20095 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
20097 struct var_loc_node
*node
;
20099 node
= loc_list
->first
;
20100 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
20101 if (GET_CODE (rtl
) == EXPR_LIST
)
20102 rtl
= XEXP (rtl
, 0);
20103 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
20104 && add_const_value_attribute (die
, rtl
))
20107 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
20108 list several times. See if we've already cached the contents. */
20110 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
20114 cache
= cached_dw_loc_list_table
->find_with_hash (decl
, DECL_UID (decl
));
20116 list
= cache
->loc_list
;
20120 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2,
20122 /* It is usually worth caching this result if the decl is from
20123 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
20124 if (cache_p
&& list
&& list
->dw_loc_next
)
20126 cached_dw_loc_list
**slot
20127 = cached_dw_loc_list_table
->find_slot_with_hash (decl
,
20130 cache
= ggc_cleared_alloc
<cached_dw_loc_list
> ();
20131 cache
->decl_id
= DECL_UID (decl
);
20132 cache
->loc_list
= list
;
20138 add_AT_location_description (die
, DW_AT_location
, list
);
20141 /* None of that worked, so it must not really have a location;
20142 try adding a constant value attribute from the DECL_INITIAL. */
20143 return tree_add_const_value_attribute_for_decl (die
, decl
);
20146 /* Helper function for tree_add_const_value_attribute. Natively encode
20147 initializer INIT into an array. Return true if successful. */
20150 native_encode_initializer (tree init
, unsigned char *array
, int size
)
20154 if (init
== NULL_TREE
)
20158 switch (TREE_CODE (init
))
20161 type
= TREE_TYPE (init
);
20162 if (TREE_CODE (type
) == ARRAY_TYPE
)
20164 tree enttype
= TREE_TYPE (type
);
20165 scalar_int_mode mode
;
20167 if (!is_int_mode (TYPE_MODE (enttype
), &mode
)
20168 || GET_MODE_SIZE (mode
) != 1)
20170 if (int_size_in_bytes (type
) != size
)
20172 if (size
> TREE_STRING_LENGTH (init
))
20174 memcpy (array
, TREE_STRING_POINTER (init
),
20175 TREE_STRING_LENGTH (init
));
20176 memset (array
+ TREE_STRING_LENGTH (init
),
20177 '\0', size
- TREE_STRING_LENGTH (init
));
20180 memcpy (array
, TREE_STRING_POINTER (init
), size
);
20185 type
= TREE_TYPE (init
);
20186 if (int_size_in_bytes (type
) != size
)
20188 if (TREE_CODE (type
) == ARRAY_TYPE
)
20190 HOST_WIDE_INT min_index
;
20191 unsigned HOST_WIDE_INT cnt
;
20192 int curpos
= 0, fieldsize
;
20193 constructor_elt
*ce
;
20195 if (TYPE_DOMAIN (type
) == NULL_TREE
20196 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
20199 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
20200 if (fieldsize
<= 0)
20203 min_index
= tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)));
20204 memset (array
, '\0', size
);
20205 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
20207 tree val
= ce
->value
;
20208 tree index
= ce
->index
;
20210 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
20211 pos
= (tree_to_shwi (TREE_OPERAND (index
, 0)) - min_index
)
20214 pos
= (tree_to_shwi (index
) - min_index
) * fieldsize
;
20219 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
20222 curpos
= pos
+ fieldsize
;
20223 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
20225 int count
= tree_to_shwi (TREE_OPERAND (index
, 1))
20226 - tree_to_shwi (TREE_OPERAND (index
, 0));
20227 while (count
-- > 0)
20230 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
20231 curpos
+= fieldsize
;
20234 gcc_assert (curpos
<= size
);
20238 else if (TREE_CODE (type
) == RECORD_TYPE
20239 || TREE_CODE (type
) == UNION_TYPE
)
20241 tree field
= NULL_TREE
;
20242 unsigned HOST_WIDE_INT cnt
;
20243 constructor_elt
*ce
;
20245 if (int_size_in_bytes (type
) != size
)
20248 if (TREE_CODE (type
) == RECORD_TYPE
)
20249 field
= TYPE_FIELDS (type
);
20251 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
20253 tree val
= ce
->value
;
20254 int pos
, fieldsize
;
20256 if (ce
->index
!= 0)
20262 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
20265 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
20266 && TYPE_DOMAIN (TREE_TYPE (field
))
20267 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
20269 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
20270 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field
)))
20272 fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
20273 pos
= int_byte_position (field
);
20274 gcc_assert (pos
+ fieldsize
<= size
);
20275 if (val
&& fieldsize
!= 0
20276 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
20282 case VIEW_CONVERT_EXPR
:
20283 case NON_LVALUE_EXPR
:
20284 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
20286 return native_encode_expr (init
, array
, size
) == size
;
20290 /* Attach a DW_AT_const_value attribute to DIE. The value of the
20291 attribute is the const value T. */
20294 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
20297 tree type
= TREE_TYPE (t
);
20300 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
20304 gcc_assert (!DECL_P (init
));
20306 if (TREE_CODE (init
) == INTEGER_CST
)
20308 if (tree_fits_uhwi_p (init
))
20310 add_AT_unsigned (die
, DW_AT_const_value
, tree_to_uhwi (init
));
20313 if (tree_fits_shwi_p (init
))
20315 add_AT_int (die
, DW_AT_const_value
, tree_to_shwi (init
));
20321 rtl
= rtl_for_decl_init (init
, type
);
20323 return add_const_value_attribute (die
, rtl
);
20325 /* If the host and target are sane, try harder. */
20326 if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
20327 && initializer_constant_valid_p (init
, type
))
20329 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
20330 if (size
> 0 && (int) size
== size
)
20332 unsigned char *array
= ggc_cleared_vec_alloc
<unsigned char> (size
);
20334 if (native_encode_initializer (init
, array
, size
))
20336 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
20345 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
20346 attribute is the const value of T, where T is an integral constant
20347 variable with static storage duration
20348 (so it can't be a PARM_DECL or a RESULT_DECL). */
20351 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
20355 || (!VAR_P (decl
) && TREE_CODE (decl
) != CONST_DECL
)
20356 || (VAR_P (decl
) && !TREE_STATIC (decl
)))
20359 if (TREE_READONLY (decl
)
20360 && ! TREE_THIS_VOLATILE (decl
)
20361 && DECL_INITIAL (decl
))
20366 /* Don't add DW_AT_const_value if abstract origin already has one. */
20367 if (get_AT (var_die
, DW_AT_const_value
))
20370 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
20373 /* Convert the CFI instructions for the current function into a
20374 location list. This is used for DW_AT_frame_base when we targeting
20375 a dwarf2 consumer that does not support the dwarf3
20376 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
20379 static dw_loc_list_ref
20380 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
20384 dw_loc_list_ref list
, *list_tail
;
20386 dw_cfa_location last_cfa
, next_cfa
;
20387 const char *start_label
, *last_label
, *section
;
20388 dw_cfa_location remember
;
20391 gcc_assert (fde
!= NULL
);
20393 section
= secname_for_decl (current_function_decl
);
20397 memset (&next_cfa
, 0, sizeof (next_cfa
));
20398 next_cfa
.reg
= INVALID_REGNUM
;
20399 remember
= next_cfa
;
20401 start_label
= fde
->dw_fde_begin
;
20403 /* ??? Bald assumption that the CIE opcode list does not contain
20404 advance opcodes. */
20405 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
20406 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
20408 last_cfa
= next_cfa
;
20409 last_label
= start_label
;
20411 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
20413 /* If the first partition contained no CFI adjustments, the
20414 CIE opcodes apply to the whole first partition. */
20415 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20416 fde
->dw_fde_begin
, 0, fde
->dw_fde_end
, 0, section
);
20417 list_tail
=&(*list_tail
)->dw_loc_next
;
20418 start_label
= last_label
= fde
->dw_fde_second_begin
;
20421 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
20423 switch (cfi
->dw_cfi_opc
)
20425 case DW_CFA_set_loc
:
20426 case DW_CFA_advance_loc1
:
20427 case DW_CFA_advance_loc2
:
20428 case DW_CFA_advance_loc4
:
20429 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
20431 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20432 start_label
, 0, last_label
, 0, section
);
20434 list_tail
= &(*list_tail
)->dw_loc_next
;
20435 last_cfa
= next_cfa
;
20436 start_label
= last_label
;
20438 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
20441 case DW_CFA_advance_loc
:
20442 /* The encoding is complex enough that we should never emit this. */
20443 gcc_unreachable ();
20446 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
20449 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
20451 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
20453 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20454 start_label
, 0, last_label
, 0, section
);
20456 list_tail
= &(*list_tail
)->dw_loc_next
;
20457 last_cfa
= next_cfa
;
20458 start_label
= last_label
;
20460 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20461 start_label
, 0, fde
->dw_fde_end
, 0, section
);
20462 list_tail
= &(*list_tail
)->dw_loc_next
;
20463 start_label
= last_label
= fde
->dw_fde_second_begin
;
20467 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
20469 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20470 start_label
, 0, last_label
, 0, section
);
20471 list_tail
= &(*list_tail
)->dw_loc_next
;
20472 start_label
= last_label
;
20475 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
20477 fde
->dw_fde_second_begin
20478 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
, 0,
20481 maybe_gen_llsym (list
);
20486 /* Compute a displacement from the "steady-state frame pointer" to the
20487 frame base (often the same as the CFA), and store it in
20488 frame_pointer_fb_offset. OFFSET is added to the displacement
20489 before the latter is negated. */
20492 compute_frame_pointer_to_fb_displacement (poly_int64 offset
)
20496 #ifdef FRAME_POINTER_CFA_OFFSET
20497 reg
= frame_pointer_rtx
;
20498 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
20500 reg
= arg_pointer_rtx
;
20501 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
20504 elim
= (ira_use_lra_p
20505 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
20506 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
20507 elim
= strip_offset_and_add (elim
, &offset
);
20509 frame_pointer_fb_offset
= -offset
;
20511 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
20512 in which to eliminate. This is because it's stack pointer isn't
20513 directly accessible as a register within the ISA. To work around
20514 this, assume that while we cannot provide a proper value for
20515 frame_pointer_fb_offset, we won't need one either. We can use
20516 hard frame pointer in debug info even if frame pointer isn't used
20517 since hard frame pointer in debug info is encoded with DW_OP_fbreg
20518 which uses the DW_AT_frame_base attribute, not hard frame pointer
20520 frame_pointer_fb_offset_valid
20521 = (elim
== hard_frame_pointer_rtx
|| elim
== stack_pointer_rtx
);
20524 /* Generate a DW_AT_name attribute given some string value to be included as
20525 the value of the attribute. */
20528 add_name_attribute (dw_die_ref die
, const char *name_string
)
20530 if (name_string
!= NULL
&& *name_string
!= 0)
20532 if (demangle_name_func
)
20533 name_string
= (*demangle_name_func
) (name_string
);
20535 add_AT_string (die
, DW_AT_name
, name_string
);
20539 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
20540 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
20541 of TYPE accordingly.
20543 ??? This is a temporary measure until after we're able to generate
20544 regular DWARF for the complex Ada type system. */
20547 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
20548 dw_die_ref context_die
)
20551 dw_die_ref dtype_die
;
20553 if (!lang_hooks
.types
.descriptive_type
)
20556 dtype
= lang_hooks
.types
.descriptive_type (type
);
20560 dtype_die
= lookup_type_die (dtype
);
20563 gen_type_die (dtype
, context_die
);
20564 dtype_die
= lookup_type_die (dtype
);
20565 gcc_assert (dtype_die
);
20568 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
20571 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
20573 static const char *
20574 comp_dir_string (void)
20578 static const char *cached_wd
= NULL
;
20580 if (cached_wd
!= NULL
)
20583 wd
= get_src_pwd ();
20587 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
20591 wdlen
= strlen (wd
);
20592 wd1
= ggc_vec_alloc
<char> (wdlen
+ 2);
20594 wd1
[wdlen
] = DIR_SEPARATOR
;
20595 wd1
[wdlen
+ 1] = 0;
20599 cached_wd
= remap_debug_filename (wd
);
20603 /* Generate a DW_AT_comp_dir attribute for DIE. */
20606 add_comp_dir_attribute (dw_die_ref die
)
20608 const char * wd
= comp_dir_string ();
20610 add_AT_string (die
, DW_AT_comp_dir
, wd
);
20613 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
20614 pointer computation, ...), output a representation for that bound according
20615 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
20616 loc_list_from_tree for the meaning of CONTEXT. */
20619 add_scalar_info (dw_die_ref die
, enum dwarf_attribute attr
, tree value
,
20620 int forms
, struct loc_descr_context
*context
)
20622 dw_die_ref context_die
, decl_die
= NULL
;
20623 dw_loc_list_ref list
;
20624 bool strip_conversions
= true;
20625 bool placeholder_seen
= false;
20627 while (strip_conversions
)
20628 switch (TREE_CODE (value
))
20635 case VIEW_CONVERT_EXPR
:
20636 value
= TREE_OPERAND (value
, 0);
20640 strip_conversions
= false;
20644 /* If possible and permitted, output the attribute as a constant. */
20645 if ((forms
& dw_scalar_form_constant
) != 0
20646 && TREE_CODE (value
) == INTEGER_CST
)
20648 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (value
));
20650 /* If HOST_WIDE_INT is big enough then represent the bound as
20651 a constant value. We need to choose a form based on
20652 whether the type is signed or unsigned. We cannot just
20653 call add_AT_unsigned if the value itself is positive
20654 (add_AT_unsigned might add the unsigned value encoded as
20655 DW_FORM_data[1248]). Some DWARF consumers will lookup the
20656 bounds type and then sign extend any unsigned values found
20657 for signed types. This is needed only for
20658 DW_AT_{lower,upper}_bound, since for most other attributes,
20659 consumers will treat DW_FORM_data[1248] as unsigned values,
20660 regardless of the underlying type. */
20661 if (prec
<= HOST_BITS_PER_WIDE_INT
20662 || tree_fits_uhwi_p (value
))
20664 if (TYPE_UNSIGNED (TREE_TYPE (value
)))
20665 add_AT_unsigned (die
, attr
, TREE_INT_CST_LOW (value
));
20667 add_AT_int (die
, attr
, TREE_INT_CST_LOW (value
));
20670 /* Otherwise represent the bound as an unsigned value with
20671 the precision of its type. The precision and signedness
20672 of the type will be necessary to re-interpret it
20674 add_AT_wide (die
, attr
, wi::to_wide (value
));
20678 /* Otherwise, if it's possible and permitted too, output a reference to
20680 if ((forms
& dw_scalar_form_reference
) != 0)
20682 tree decl
= NULL_TREE
;
20684 /* Some type attributes reference an outer type. For instance, the upper
20685 bound of an array may reference an embedding record (this happens in
20687 if (TREE_CODE (value
) == COMPONENT_REF
20688 && TREE_CODE (TREE_OPERAND (value
, 0)) == PLACEHOLDER_EXPR
20689 && TREE_CODE (TREE_OPERAND (value
, 1)) == FIELD_DECL
)
20690 decl
= TREE_OPERAND (value
, 1);
20692 else if (VAR_P (value
)
20693 || TREE_CODE (value
) == PARM_DECL
20694 || TREE_CODE (value
) == RESULT_DECL
)
20697 if (decl
!= NULL_TREE
)
20699 decl_die
= lookup_decl_die (decl
);
20701 /* ??? Can this happen, or should the variable have been bound
20702 first? Probably it can, since I imagine that we try to create
20703 the types of parameters in the order in which they exist in
20704 the list, and won't have created a forward reference to a
20705 later parameter. */
20706 if (decl_die
!= NULL
)
20708 if (get_AT (decl_die
, DW_AT_location
)
20709 || get_AT (decl_die
, DW_AT_const_value
))
20711 add_AT_die_ref (die
, attr
, decl_die
);
20718 /* Last chance: try to create a stack operation procedure to evaluate the
20719 value. Do nothing if even that is not possible or permitted. */
20720 if ((forms
& dw_scalar_form_exprloc
) == 0)
20723 list
= loc_list_from_tree (value
, 2, context
);
20724 if (context
&& context
->placeholder_arg
)
20726 placeholder_seen
= context
->placeholder_seen
;
20727 context
->placeholder_seen
= false;
20729 if (list
== NULL
|| single_element_loc_list_p (list
))
20731 /* If this attribute is not a reference nor constant, it is
20732 a DWARF expression rather than location description. For that
20733 loc_list_from_tree (value, 0, &context) is needed. */
20734 dw_loc_list_ref list2
= loc_list_from_tree (value
, 0, context
);
20735 if (list2
&& single_element_loc_list_p (list2
))
20737 if (placeholder_seen
)
20739 struct dwarf_procedure_info dpi
;
20740 dpi
.fndecl
= NULL_TREE
;
20741 dpi
.args_count
= 1;
20742 if (!resolve_args_picking (list2
->expr
, 1, &dpi
))
20745 add_AT_loc (die
, attr
, list2
->expr
);
20750 /* If that failed to give a single element location list, fall back to
20751 outputting this as a reference... still if permitted. */
20753 || (forms
& dw_scalar_form_reference
) == 0
20754 || placeholder_seen
)
20759 if (current_function_decl
== 0)
20760 context_die
= comp_unit_die ();
20762 context_die
= lookup_decl_die (current_function_decl
);
20764 decl_die
= new_die (DW_TAG_variable
, context_die
, value
);
20765 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
20766 add_type_attribute (decl_die
, TREE_TYPE (value
), TYPE_QUAL_CONST
, false,
20770 add_AT_location_description (decl_die
, DW_AT_location
, list
);
20771 add_AT_die_ref (die
, attr
, decl_die
);
20774 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
20778 lower_bound_default (void)
20780 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
20786 case DW_LANG_C_plus_plus
:
20787 case DW_LANG_C_plus_plus_11
:
20788 case DW_LANG_C_plus_plus_14
:
20790 case DW_LANG_ObjC_plus_plus
:
20792 case DW_LANG_Fortran77
:
20793 case DW_LANG_Fortran90
:
20794 case DW_LANG_Fortran95
:
20795 case DW_LANG_Fortran03
:
20796 case DW_LANG_Fortran08
:
20800 case DW_LANG_Python
:
20801 return dwarf_version
>= 4 ? 0 : -1;
20802 case DW_LANG_Ada95
:
20803 case DW_LANG_Ada83
:
20804 case DW_LANG_Cobol74
:
20805 case DW_LANG_Cobol85
:
20806 case DW_LANG_Modula2
:
20808 return dwarf_version
>= 4 ? 1 : -1;
20814 /* Given a tree node describing an array bound (either lower or upper) output
20815 a representation for that bound. */
20818 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
,
20819 tree bound
, struct loc_descr_context
*context
)
20824 switch (TREE_CODE (bound
))
20826 /* Strip all conversions. */
20828 case VIEW_CONVERT_EXPR
:
20829 bound
= TREE_OPERAND (bound
, 0);
20832 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
20833 are even omitted when they are the default. */
20835 /* If the value for this bound is the default one, we can even omit the
20837 if (bound_attr
== DW_AT_lower_bound
20838 && tree_fits_shwi_p (bound
)
20839 && (dflt
= lower_bound_default ()) != -1
20840 && tree_to_shwi (bound
) == dflt
)
20846 /* Because of the complex interaction there can be with other GNAT
20847 encodings, GDB isn't ready yet to handle proper DWARF description
20848 for self-referencial subrange bounds: let GNAT encodings do the
20849 magic in such a case. */
20851 && gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
20852 && contains_placeholder_p (bound
))
20855 add_scalar_info (subrange_die
, bound_attr
, bound
,
20856 dw_scalar_form_constant
20857 | dw_scalar_form_exprloc
20858 | dw_scalar_form_reference
,
20864 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
20865 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
20866 Note that the block of subscript information for an array type also
20867 includes information about the element type of the given array type.
20869 This function reuses previously set type and bound information if
20873 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
20875 unsigned dimension_number
;
20877 dw_die_ref child
= type_die
->die_child
;
20879 for (dimension_number
= 0;
20880 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
20881 type
= TREE_TYPE (type
), dimension_number
++)
20883 tree domain
= TYPE_DOMAIN (type
);
20885 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
20888 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
20889 and (in GNU C only) variable bounds. Handle all three forms
20892 /* Find and reuse a previously generated DW_TAG_subrange_type if
20895 For multi-dimensional arrays, as we iterate through the
20896 various dimensions in the enclosing for loop above, we also
20897 iterate through the DIE children and pick at each
20898 DW_TAG_subrange_type previously generated (if available).
20899 Each child DW_TAG_subrange_type DIE describes the range of
20900 the current dimension. At this point we should have as many
20901 DW_TAG_subrange_type's as we have dimensions in the
20903 dw_die_ref subrange_die
= NULL
;
20907 child
= child
->die_sib
;
20908 if (child
->die_tag
== DW_TAG_subrange_type
)
20909 subrange_die
= child
;
20910 if (child
== type_die
->die_child
)
20912 /* If we wrapped around, stop looking next time. */
20916 if (child
->die_tag
== DW_TAG_subrange_type
)
20920 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
20924 /* We have an array type with specified bounds. */
20925 lower
= TYPE_MIN_VALUE (domain
);
20926 upper
= TYPE_MAX_VALUE (domain
);
20928 /* Define the index type. */
20929 if (TREE_TYPE (domain
)
20930 && !get_AT (subrange_die
, DW_AT_type
))
20932 /* ??? This is probably an Ada unnamed subrange type. Ignore the
20933 TREE_TYPE field. We can't emit debug info for this
20934 because it is an unnamed integral type. */
20935 if (TREE_CODE (domain
) == INTEGER_TYPE
20936 && TYPE_NAME (domain
) == NULL_TREE
20937 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
20938 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
20941 add_type_attribute (subrange_die
, TREE_TYPE (domain
),
20942 TYPE_UNQUALIFIED
, false, type_die
);
20945 /* ??? If upper is NULL, the array has unspecified length,
20946 but it does have a lower bound. This happens with Fortran
20948 Since the debugger is definitely going to need to know N
20949 to produce useful results, go ahead and output the lower
20950 bound solo, and hope the debugger can cope. */
20952 if (!get_AT (subrange_die
, DW_AT_lower_bound
))
20953 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
, NULL
);
20954 if (upper
&& !get_AT (subrange_die
, DW_AT_upper_bound
))
20955 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
, NULL
);
20958 /* Otherwise we have an array type with an unspecified length. The
20959 DWARF-2 spec does not say how to handle this; let's just leave out the
20964 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
20967 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
20969 dw_die_ref decl_die
;
20970 HOST_WIDE_INT size
;
20971 dw_loc_descr_ref size_expr
= NULL
;
20973 switch (TREE_CODE (tree_node
))
20978 case ENUMERAL_TYPE
:
20981 case QUAL_UNION_TYPE
:
20982 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
20983 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
20985 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
20988 size_expr
= type_byte_size (tree_node
, &size
);
20991 /* For a data member of a struct or union, the DW_AT_byte_size is
20992 generally given as the number of bytes normally allocated for an
20993 object of the *declared* type of the member itself. This is true
20994 even for bit-fields. */
20995 size
= int_size_in_bytes (field_type (tree_node
));
20998 gcc_unreachable ();
21001 /* Support for dynamically-sized objects was introduced by DWARFv3.
21002 At the moment, GDB does not handle variable byte sizes very well,
21004 if ((dwarf_version
>= 3 || !dwarf_strict
)
21005 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
21006 && size_expr
!= NULL
)
21007 add_AT_loc (die
, DW_AT_byte_size
, size_expr
);
21009 /* Note that `size' might be -1 when we get to this point. If it is, that
21010 indicates that the byte size of the entity in question is variable and
21011 that we could not generate a DWARF expression that computes it. */
21013 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
21016 /* Add a DW_AT_alignment attribute to DIE with TREE_NODE's non-default
21020 add_alignment_attribute (dw_die_ref die
, tree tree_node
)
21022 if (dwarf_version
< 5 && dwarf_strict
)
21027 if (DECL_P (tree_node
))
21029 if (!DECL_USER_ALIGN (tree_node
))
21032 align
= DECL_ALIGN_UNIT (tree_node
);
21034 else if (TYPE_P (tree_node
))
21036 if (!TYPE_USER_ALIGN (tree_node
))
21039 align
= TYPE_ALIGN_UNIT (tree_node
);
21042 gcc_unreachable ();
21044 add_AT_unsigned (die
, DW_AT_alignment
, align
);
21047 /* For a FIELD_DECL node which represents a bit-field, output an attribute
21048 which specifies the distance in bits from the highest order bit of the
21049 "containing object" for the bit-field to the highest order bit of the
21052 For any given bit-field, the "containing object" is a hypothetical object
21053 (of some integral or enum type) within which the given bit-field lives. The
21054 type of this hypothetical "containing object" is always the same as the
21055 declared type of the individual bit-field itself. The determination of the
21056 exact location of the "containing object" for a bit-field is rather
21057 complicated. It's handled by the `field_byte_offset' function (above).
21059 CTX is required: see the comment for VLR_CONTEXT.
21061 Note that it is the size (in bytes) of the hypothetical "containing object"
21062 which will be given in the DW_AT_byte_size attribute for this bit-field.
21063 (See `byte_size_attribute' above). */
21066 add_bit_offset_attribute (dw_die_ref die
, tree decl
, struct vlr_context
*ctx
)
21068 HOST_WIDE_INT object_offset_in_bytes
;
21069 tree original_type
= DECL_BIT_FIELD_TYPE (decl
);
21070 HOST_WIDE_INT bitpos_int
;
21071 HOST_WIDE_INT highest_order_object_bit_offset
;
21072 HOST_WIDE_INT highest_order_field_bit_offset
;
21073 HOST_WIDE_INT bit_offset
;
21075 field_byte_offset (decl
, ctx
, &object_offset_in_bytes
);
21077 /* Must be a field and a bit field. */
21078 gcc_assert (original_type
&& TREE_CODE (decl
) == FIELD_DECL
);
21080 /* We can't yet handle bit-fields whose offsets are variable, so if we
21081 encounter such things, just return without generating any attribute
21082 whatsoever. Likewise for variable or too large size. */
21083 if (! tree_fits_shwi_p (bit_position (decl
))
21084 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
21087 bitpos_int
= int_bit_position (decl
);
21089 /* Note that the bit offset is always the distance (in bits) from the
21090 highest-order bit of the "containing object" to the highest-order bit of
21091 the bit-field itself. Since the "high-order end" of any object or field
21092 is different on big-endian and little-endian machines, the computation
21093 below must take account of these differences. */
21094 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
21095 highest_order_field_bit_offset
= bitpos_int
;
21097 if (! BYTES_BIG_ENDIAN
)
21099 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
21100 highest_order_object_bit_offset
+=
21101 simple_type_size_in_bits (original_type
);
21105 = (! BYTES_BIG_ENDIAN
21106 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
21107 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
21109 if (bit_offset
< 0)
21110 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
21112 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
21115 /* For a FIELD_DECL node which represents a bit field, output an attribute
21116 which specifies the length in bits of the given field. */
21119 add_bit_size_attribute (dw_die_ref die
, tree decl
)
21121 /* Must be a field and a bit field. */
21122 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
21123 && DECL_BIT_FIELD_TYPE (decl
));
21125 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
21126 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
21129 /* If the compiled language is ANSI C, then add a 'prototyped'
21130 attribute, if arg types are given for the parameters of a function. */
21133 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
21135 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
21142 if (prototype_p (func_type
))
21143 add_AT_flag (die
, DW_AT_prototyped
, 1);
21150 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
21151 by looking in the type declaration, the object declaration equate table or
21152 the block mapping. */
21154 static inline dw_die_ref
21155 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
21157 dw_die_ref origin_die
= NULL
;
21159 if (DECL_P (origin
))
21162 origin_die
= lookup_decl_die (origin
);
21163 /* "Unwrap" the decls DIE which we put in the imported unit context.
21164 We are looking for the abstract copy here. */
21167 && (c
= get_AT_ref (origin_die
, DW_AT_abstract_origin
))
21168 /* ??? Identify this better. */
21172 else if (TYPE_P (origin
))
21173 origin_die
= lookup_type_die (origin
);
21174 else if (TREE_CODE (origin
) == BLOCK
)
21175 origin_die
= BLOCK_DIE (origin
);
21177 /* XXX: Functions that are never lowered don't always have correct block
21178 trees (in the case of java, they simply have no block tree, in some other
21179 languages). For these functions, there is nothing we can really do to
21180 output correct debug info for inlined functions in all cases. Rather
21181 than die, we'll just produce deficient debug info now, in that we will
21182 have variables without a proper abstract origin. In the future, when all
21183 functions are lowered, we should re-add a gcc_assert (origin_die)
21187 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
21191 /* We do not currently support the pure_virtual attribute. */
21194 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
21196 if (DECL_VINDEX (func_decl
))
21198 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
21200 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
21201 add_AT_loc (die
, DW_AT_vtable_elem_location
,
21202 new_loc_descr (DW_OP_constu
,
21203 tree_to_shwi (DECL_VINDEX (func_decl
)),
21206 /* GNU extension: Record what type this method came from originally. */
21207 if (debug_info_level
> DINFO_LEVEL_TERSE
21208 && DECL_CONTEXT (func_decl
))
21209 add_AT_die_ref (die
, DW_AT_containing_type
,
21210 lookup_type_die (DECL_CONTEXT (func_decl
)));
21214 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
21215 given decl. This used to be a vendor extension until after DWARF 4
21216 standardized it. */
21219 add_linkage_attr (dw_die_ref die
, tree decl
)
21221 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
21223 /* Mimic what assemble_name_raw does with a leading '*'. */
21224 if (name
[0] == '*')
21227 if (dwarf_version
>= 4)
21228 add_AT_string (die
, DW_AT_linkage_name
, name
);
21230 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
21233 /* Add source coordinate attributes for the given decl. */
21236 add_src_coords_attributes (dw_die_ref die
, tree decl
)
21238 expanded_location s
;
21240 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
21242 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
21243 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
21244 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
21245 if (debug_column_info
&& s
.column
)
21246 add_AT_unsigned (die
, DW_AT_decl_column
, s
.column
);
21249 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
21252 add_linkage_name_raw (dw_die_ref die
, tree decl
)
21254 /* Defer until we have an assembler name set. */
21255 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
21257 limbo_die_node
*asm_name
;
21259 asm_name
= ggc_cleared_alloc
<limbo_die_node
> ();
21260 asm_name
->die
= die
;
21261 asm_name
->created_for
= decl
;
21262 asm_name
->next
= deferred_asm_name
;
21263 deferred_asm_name
= asm_name
;
21265 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
21266 add_linkage_attr (die
, decl
);
21269 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl if desired. */
21272 add_linkage_name (dw_die_ref die
, tree decl
)
21274 if (debug_info_level
> DINFO_LEVEL_NONE
21275 && VAR_OR_FUNCTION_DECL_P (decl
)
21276 && TREE_PUBLIC (decl
)
21277 && !(VAR_P (decl
) && DECL_REGISTER (decl
))
21278 && die
->die_tag
!= DW_TAG_member
)
21279 add_linkage_name_raw (die
, decl
);
21282 /* Add a DW_AT_name attribute and source coordinate attribute for the
21283 given decl, but only if it actually has a name. */
21286 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
,
21287 bool no_linkage_name
)
21291 decl_name
= DECL_NAME (decl
);
21292 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
21294 const char *name
= dwarf2_name (decl
, 0);
21296 add_name_attribute (die
, name
);
21297 if (! DECL_ARTIFICIAL (decl
))
21298 add_src_coords_attributes (die
, decl
);
21300 if (!no_linkage_name
)
21301 add_linkage_name (die
, decl
);
21304 #ifdef VMS_DEBUGGING_INFO
21305 /* Get the function's name, as described by its RTL. This may be different
21306 from the DECL_NAME name used in the source file. */
21307 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
21309 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
21310 XEXP (DECL_RTL (decl
), 0), false);
21311 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
21313 #endif /* VMS_DEBUGGING_INFO */
21316 /* Add VALUE as a DW_AT_discr_value attribute to DIE. */
21319 add_discr_value (dw_die_ref die
, dw_discr_value
*value
)
21323 attr
.dw_attr
= DW_AT_discr_value
;
21324 attr
.dw_attr_val
.val_class
= dw_val_class_discr_value
;
21325 attr
.dw_attr_val
.val_entry
= NULL
;
21326 attr
.dw_attr_val
.v
.val_discr_value
.pos
= value
->pos
;
21328 attr
.dw_attr_val
.v
.val_discr_value
.v
.uval
= value
->v
.uval
;
21330 attr
.dw_attr_val
.v
.val_discr_value
.v
.sval
= value
->v
.sval
;
21331 add_dwarf_attr (die
, &attr
);
21334 /* Add DISCR_LIST as a DW_AT_discr_list to DIE. */
21337 add_discr_list (dw_die_ref die
, dw_discr_list_ref discr_list
)
21341 attr
.dw_attr
= DW_AT_discr_list
;
21342 attr
.dw_attr_val
.val_class
= dw_val_class_discr_list
;
21343 attr
.dw_attr_val
.val_entry
= NULL
;
21344 attr
.dw_attr_val
.v
.val_discr_list
= discr_list
;
21345 add_dwarf_attr (die
, &attr
);
21348 static inline dw_discr_list_ref
21349 AT_discr_list (dw_attr_node
*attr
)
21351 return attr
->dw_attr_val
.v
.val_discr_list
;
21354 #ifdef VMS_DEBUGGING_INFO
21355 /* Output the debug main pointer die for VMS */
21358 dwarf2out_vms_debug_main_pointer (void)
21360 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21363 /* Allocate the VMS debug main subprogram die. */
21364 die
= new_die_raw (DW_TAG_subprogram
);
21365 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
21366 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
21367 current_function_funcdef_no
);
21368 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
21370 /* Make it the first child of comp_unit_die (). */
21371 die
->die_parent
= comp_unit_die ();
21372 if (comp_unit_die ()->die_child
)
21374 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
21375 comp_unit_die ()->die_child
->die_sib
= die
;
21379 die
->die_sib
= die
;
21380 comp_unit_die ()->die_child
= die
;
21383 #endif /* VMS_DEBUGGING_INFO */
21385 /* walk_tree helper function for uses_local_type, below. */
21388 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
21391 *walk_subtrees
= 0;
21394 tree name
= TYPE_NAME (*tp
);
21395 if (name
&& DECL_P (name
) && decl_function_context (name
))
21401 /* If TYPE involves a function-local type (including a local typedef to a
21402 non-local type), returns that type; otherwise returns NULL_TREE. */
21405 uses_local_type (tree type
)
21407 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
21411 /* Return the DIE for the scope that immediately contains this type.
21412 Non-named types that do not involve a function-local type get global
21413 scope. Named types nested in namespaces or other types get their
21414 containing scope. All other types (i.e. function-local named types) get
21415 the current active scope. */
21418 scope_die_for (tree t
, dw_die_ref context_die
)
21420 dw_die_ref scope_die
= NULL
;
21421 tree containing_scope
;
21423 /* Non-types always go in the current scope. */
21424 gcc_assert (TYPE_P (t
));
21426 /* Use the scope of the typedef, rather than the scope of the type
21428 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
21429 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
21431 containing_scope
= TYPE_CONTEXT (t
);
21433 /* Use the containing namespace if there is one. */
21434 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
21436 if (context_die
== lookup_decl_die (containing_scope
))
21438 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
21439 context_die
= get_context_die (containing_scope
);
21441 containing_scope
= NULL_TREE
;
21444 /* Ignore function type "scopes" from the C frontend. They mean that
21445 a tagged type is local to a parmlist of a function declarator, but
21446 that isn't useful to DWARF. */
21447 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
21448 containing_scope
= NULL_TREE
;
21450 if (SCOPE_FILE_SCOPE_P (containing_scope
))
21452 /* If T uses a local type keep it local as well, to avoid references
21453 to function-local DIEs from outside the function. */
21454 if (current_function_decl
&& uses_local_type (t
))
21455 scope_die
= context_die
;
21457 scope_die
= comp_unit_die ();
21459 else if (TYPE_P (containing_scope
))
21461 /* For types, we can just look up the appropriate DIE. */
21462 if (debug_info_level
> DINFO_LEVEL_TERSE
)
21463 scope_die
= get_context_die (containing_scope
);
21466 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
21467 if (scope_die
== NULL
)
21468 scope_die
= comp_unit_die ();
21472 scope_die
= context_die
;
21477 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
21480 local_scope_p (dw_die_ref context_die
)
21482 for (; context_die
; context_die
= context_die
->die_parent
)
21483 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
21484 || context_die
->die_tag
== DW_TAG_subprogram
)
21490 /* Returns nonzero if CONTEXT_DIE is a class. */
21493 class_scope_p (dw_die_ref context_die
)
21495 return (context_die
21496 && (context_die
->die_tag
== DW_TAG_structure_type
21497 || context_die
->die_tag
== DW_TAG_class_type
21498 || context_die
->die_tag
== DW_TAG_interface_type
21499 || context_die
->die_tag
== DW_TAG_union_type
));
21502 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
21503 whether or not to treat a DIE in this context as a declaration. */
21506 class_or_namespace_scope_p (dw_die_ref context_die
)
21508 return (class_scope_p (context_die
)
21509 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
21512 /* Many forms of DIEs require a "type description" attribute. This
21513 routine locates the proper "type descriptor" die for the type given
21514 by 'type' plus any additional qualifiers given by 'cv_quals', and
21515 adds a DW_AT_type attribute below the given die. */
21518 add_type_attribute (dw_die_ref object_die
, tree type
, int cv_quals
,
21519 bool reverse
, dw_die_ref context_die
)
21521 enum tree_code code
= TREE_CODE (type
);
21522 dw_die_ref type_die
= NULL
;
21524 /* ??? If this type is an unnamed subrange type of an integral, floating-point
21525 or fixed-point type, use the inner type. This is because we have no
21526 support for unnamed types in base_type_die. This can happen if this is
21527 an Ada subrange type. Correct solution is emit a subrange type die. */
21528 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
21529 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
21530 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
21532 if (code
== ERROR_MARK
21533 /* Handle a special case. For functions whose return type is void, we
21534 generate *no* type attribute. (Note that no object may have type
21535 `void', so this only applies to function return types). */
21536 || code
== VOID_TYPE
)
21539 type_die
= modified_type_die (type
,
21540 cv_quals
| TYPE_QUALS (type
),
21544 if (type_die
!= NULL
)
21545 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
21548 /* Given an object die, add the calling convention attribute for the
21549 function call type. */
21551 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
21553 enum dwarf_calling_convention value
= DW_CC_normal
;
21555 value
= ((enum dwarf_calling_convention
)
21556 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
21559 && id_equal (DECL_ASSEMBLER_NAME (decl
), "MAIN__"))
21561 /* DWARF 2 doesn't provide a way to identify a program's source-level
21562 entry point. DW_AT_calling_convention attributes are only meant
21563 to describe functions' calling conventions. However, lacking a
21564 better way to signal the Fortran main program, we used this for
21565 a long time, following existing custom. Now, DWARF 4 has
21566 DW_AT_main_subprogram, which we add below, but some tools still
21567 rely on the old way, which we thus keep. */
21568 value
= DW_CC_program
;
21570 if (dwarf_version
>= 4 || !dwarf_strict
)
21571 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
21574 /* Only add the attribute if the backend requests it, and
21575 is not DW_CC_normal. */
21576 if (value
&& (value
!= DW_CC_normal
))
21577 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
21580 /* Given a tree pointer to a struct, class, union, or enum type node, return
21581 a pointer to the (string) tag name for the given type, or zero if the type
21582 was declared without a tag. */
21584 static const char *
21585 type_tag (const_tree type
)
21587 const char *name
= 0;
21589 if (TYPE_NAME (type
) != 0)
21593 /* Find the IDENTIFIER_NODE for the type name. */
21594 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
21595 && !TYPE_NAMELESS (type
))
21596 t
= TYPE_NAME (type
);
21598 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
21599 a TYPE_DECL node, regardless of whether or not a `typedef' was
21601 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
21602 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
21604 /* We want to be extra verbose. Don't call dwarf_name if
21605 DECL_NAME isn't set. The default hook for decl_printable_name
21606 doesn't like that, and in this context it's correct to return
21607 0, instead of "<anonymous>" or the like. */
21608 if (DECL_NAME (TYPE_NAME (type
))
21609 && !DECL_NAMELESS (TYPE_NAME (type
)))
21610 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
21613 /* Now get the name as a string, or invent one. */
21614 if (!name
&& t
!= 0)
21615 name
= IDENTIFIER_POINTER (t
);
21618 return (name
== 0 || *name
== '\0') ? 0 : name
;
21621 /* Return the type associated with a data member, make a special check
21622 for bit field types. */
21625 member_declared_type (const_tree member
)
21627 return (DECL_BIT_FIELD_TYPE (member
)
21628 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
21631 /* Get the decl's label, as described by its RTL. This may be different
21632 from the DECL_NAME name used in the source file. */
21635 static const char *
21636 decl_start_label (tree decl
)
21639 const char *fnname
;
21641 x
= DECL_RTL (decl
);
21642 gcc_assert (MEM_P (x
));
21645 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
21647 fnname
= XSTR (x
, 0);
21652 /* For variable-length arrays that have been previously generated, but
21653 may be incomplete due to missing subscript info, fill the subscript
21654 info. Return TRUE if this is one of those cases. */
21656 fill_variable_array_bounds (tree type
)
21658 if (TREE_ASM_WRITTEN (type
)
21659 && TREE_CODE (type
) == ARRAY_TYPE
21660 && variably_modified_type_p (type
, NULL
))
21662 dw_die_ref array_die
= lookup_type_die (type
);
21665 add_subscript_info (array_die
, type
, !is_ada ());
21671 /* These routines generate the internal representation of the DIE's for
21672 the compilation unit. Debugging information is collected by walking
21673 the declaration trees passed in from dwarf2out_decl(). */
21676 gen_array_type_die (tree type
, dw_die_ref context_die
)
21678 dw_die_ref array_die
;
21680 /* GNU compilers represent multidimensional array types as sequences of one
21681 dimensional array types whose element types are themselves array types.
21682 We sometimes squish that down to a single array_type DIE with multiple
21683 subscripts in the Dwarf debugging info. The draft Dwarf specification
21684 say that we are allowed to do this kind of compression in C, because
21685 there is no difference between an array of arrays and a multidimensional
21686 array. We don't do this for Ada to remain as close as possible to the
21687 actual representation, which is especially important against the language
21688 flexibilty wrt arrays of variable size. */
21690 bool collapse_nested_arrays
= !is_ada ();
21692 if (fill_variable_array_bounds (type
))
21695 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
21698 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
21699 DW_TAG_string_type doesn't have DW_AT_type attribute). */
21700 if (TYPE_STRING_FLAG (type
)
21701 && TREE_CODE (type
) == ARRAY_TYPE
21703 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
21705 HOST_WIDE_INT size
;
21707 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
21708 add_name_attribute (array_die
, type_tag (type
));
21709 equate_type_number_to_die (type
, array_die
);
21710 size
= int_size_in_bytes (type
);
21712 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
21713 /* ??? We can't annotate types late, but for LTO we may not
21714 generate a location early either (gfortran.dg/save_6.f90). */
21715 else if (! (early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
21716 && TYPE_DOMAIN (type
) != NULL_TREE
21717 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
)
21719 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
21720 tree rszdecl
= szdecl
;
21722 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
21723 if (!DECL_P (szdecl
))
21725 if (TREE_CODE (szdecl
) == INDIRECT_REF
21726 && DECL_P (TREE_OPERAND (szdecl
, 0)))
21728 rszdecl
= TREE_OPERAND (szdecl
, 0);
21729 if (int_size_in_bytes (TREE_TYPE (rszdecl
))
21730 != DWARF2_ADDR_SIZE
)
21738 dw_loc_list_ref loc
21739 = loc_list_from_tree (rszdecl
, szdecl
== rszdecl
? 2 : 0,
21743 add_AT_location_description (array_die
, DW_AT_string_length
,
21745 if (size
!= DWARF2_ADDR_SIZE
)
21746 add_AT_unsigned (array_die
, dwarf_version
>= 5
21747 ? DW_AT_string_length_byte_size
21748 : DW_AT_byte_size
, size
);
21755 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
21756 add_name_attribute (array_die
, type_tag (type
));
21757 equate_type_number_to_die (type
, array_die
);
21759 if (TREE_CODE (type
) == VECTOR_TYPE
)
21760 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
21762 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
21764 && TREE_CODE (type
) == ARRAY_TYPE
21765 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
21766 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
21767 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
21770 /* We default the array ordering. Debuggers will probably do the right
21771 things even if DW_AT_ordering is not present. It's not even an issue
21772 until we start to get into multidimensional arrays anyway. If a debugger
21773 is ever caught doing the Wrong Thing for multi-dimensional arrays,
21774 then we'll have to put the DW_AT_ordering attribute back in. (But if
21775 and when we find out that we need to put these in, we will only do so
21776 for multidimensional arrays. */
21777 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
21780 if (TREE_CODE (type
) == VECTOR_TYPE
)
21782 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
21783 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
21784 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
, NULL
);
21785 add_bound_info (subrange_die
, DW_AT_upper_bound
,
21786 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1), NULL
);
21789 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
21791 /* Add representation of the type of the elements of this array type and
21792 emit the corresponding DIE if we haven't done it already. */
21793 element_type
= TREE_TYPE (type
);
21794 if (collapse_nested_arrays
)
21795 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
21797 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
21799 element_type
= TREE_TYPE (element_type
);
21802 add_type_attribute (array_die
, element_type
, TYPE_UNQUALIFIED
,
21803 TREE_CODE (type
) == ARRAY_TYPE
21804 && TYPE_REVERSE_STORAGE_ORDER (type
),
21807 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
21808 if (TYPE_ARTIFICIAL (type
))
21809 add_AT_flag (array_die
, DW_AT_artificial
, 1);
21811 if (get_AT (array_die
, DW_AT_name
))
21812 add_pubtype (type
, array_die
);
21814 add_alignment_attribute (array_die
, type
);
21817 /* This routine generates DIE for array with hidden descriptor, details
21818 are filled into *info by a langhook. */
21821 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
21822 dw_die_ref context_die
)
21824 const dw_die_ref scope_die
= scope_die_for (type
, context_die
);
21825 const dw_die_ref array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
21826 struct loc_descr_context context
= { type
, info
->base_decl
, NULL
,
21828 enum dwarf_tag subrange_tag
= DW_TAG_subrange_type
;
21831 add_name_attribute (array_die
, type_tag (type
));
21832 equate_type_number_to_die (type
, array_die
);
21834 if (info
->ndimensions
> 1)
21835 switch (info
->ordering
)
21837 case array_descr_ordering_row_major
:
21838 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
21840 case array_descr_ordering_column_major
:
21841 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
21847 if (dwarf_version
>= 3 || !dwarf_strict
)
21849 if (info
->data_location
)
21850 add_scalar_info (array_die
, DW_AT_data_location
, info
->data_location
,
21851 dw_scalar_form_exprloc
, &context
);
21852 if (info
->associated
)
21853 add_scalar_info (array_die
, DW_AT_associated
, info
->associated
,
21854 dw_scalar_form_constant
21855 | dw_scalar_form_exprloc
21856 | dw_scalar_form_reference
, &context
);
21857 if (info
->allocated
)
21858 add_scalar_info (array_die
, DW_AT_allocated
, info
->allocated
,
21859 dw_scalar_form_constant
21860 | dw_scalar_form_exprloc
21861 | dw_scalar_form_reference
, &context
);
21864 const enum dwarf_attribute attr
21865 = (info
->stride_in_bits
) ? DW_AT_bit_stride
: DW_AT_byte_stride
;
21867 = (info
->stride_in_bits
)
21868 ? dw_scalar_form_constant
21869 : (dw_scalar_form_constant
21870 | dw_scalar_form_exprloc
21871 | dw_scalar_form_reference
);
21873 add_scalar_info (array_die
, attr
, info
->stride
, forms
, &context
);
21876 if (dwarf_version
>= 5)
21880 add_scalar_info (array_die
, DW_AT_rank
, info
->rank
,
21881 dw_scalar_form_constant
21882 | dw_scalar_form_exprloc
, &context
);
21883 subrange_tag
= DW_TAG_generic_subrange
;
21884 context
.placeholder_arg
= true;
21888 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
21890 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
21892 dw_die_ref subrange_die
= new_die (subrange_tag
, array_die
, NULL
);
21894 if (info
->dimen
[dim
].bounds_type
)
21895 add_type_attribute (subrange_die
,
21896 info
->dimen
[dim
].bounds_type
, TYPE_UNQUALIFIED
,
21897 false, context_die
);
21898 if (info
->dimen
[dim
].lower_bound
)
21899 add_bound_info (subrange_die
, DW_AT_lower_bound
,
21900 info
->dimen
[dim
].lower_bound
, &context
);
21901 if (info
->dimen
[dim
].upper_bound
)
21902 add_bound_info (subrange_die
, DW_AT_upper_bound
,
21903 info
->dimen
[dim
].upper_bound
, &context
);
21904 if ((dwarf_version
>= 3 || !dwarf_strict
) && info
->dimen
[dim
].stride
)
21905 add_scalar_info (subrange_die
, DW_AT_byte_stride
,
21906 info
->dimen
[dim
].stride
,
21907 dw_scalar_form_constant
21908 | dw_scalar_form_exprloc
21909 | dw_scalar_form_reference
,
21913 gen_type_die (info
->element_type
, context_die
);
21914 add_type_attribute (array_die
, info
->element_type
, TYPE_UNQUALIFIED
,
21915 TREE_CODE (type
) == ARRAY_TYPE
21916 && TYPE_REVERSE_STORAGE_ORDER (type
),
21919 if (get_AT (array_die
, DW_AT_name
))
21920 add_pubtype (type
, array_die
);
21922 add_alignment_attribute (array_die
, type
);
21927 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
21929 tree origin
= decl_ultimate_origin (decl
);
21930 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
21932 if (origin
!= NULL
)
21933 add_abstract_origin_attribute (decl_die
, origin
);
21936 add_name_and_src_coords_attributes (decl_die
, decl
);
21937 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
21938 TYPE_UNQUALIFIED
, false, context_die
);
21941 if (DECL_ABSTRACT_P (decl
))
21942 equate_decl_number_to_die (decl
, decl_die
);
21944 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
21948 /* Walk through the list of incomplete types again, trying once more to
21949 emit full debugging info for them. */
21952 retry_incomplete_types (void)
21957 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
21958 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
21959 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
21960 vec_safe_truncate (incomplete_types
, 0);
21963 /* Determine what tag to use for a record type. */
21965 static enum dwarf_tag
21966 record_type_tag (tree type
)
21968 if (! lang_hooks
.types
.classify_record
)
21969 return DW_TAG_structure_type
;
21971 switch (lang_hooks
.types
.classify_record (type
))
21973 case RECORD_IS_STRUCT
:
21974 return DW_TAG_structure_type
;
21976 case RECORD_IS_CLASS
:
21977 return DW_TAG_class_type
;
21979 case RECORD_IS_INTERFACE
:
21980 if (dwarf_version
>= 3 || !dwarf_strict
)
21981 return DW_TAG_interface_type
;
21982 return DW_TAG_structure_type
;
21985 gcc_unreachable ();
21989 /* Generate a DIE to represent an enumeration type. Note that these DIEs
21990 include all of the information about the enumeration values also. Each
21991 enumerated type name/value is listed as a child of the enumerated type
21995 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
21997 dw_die_ref type_die
= lookup_type_die (type
);
21998 dw_die_ref orig_type_die
= type_die
;
22000 if (type_die
== NULL
)
22002 type_die
= new_die (DW_TAG_enumeration_type
,
22003 scope_die_for (type
, context_die
), type
);
22004 equate_type_number_to_die (type
, type_die
);
22005 add_name_attribute (type_die
, type_tag (type
));
22006 if ((dwarf_version
>= 4 || !dwarf_strict
)
22007 && ENUM_IS_SCOPED (type
))
22008 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
22009 if (ENUM_IS_OPAQUE (type
) && TYPE_SIZE (type
))
22010 add_AT_flag (type_die
, DW_AT_declaration
, 1);
22012 add_AT_unsigned (type_die
, DW_AT_encoding
,
22013 TYPE_UNSIGNED (type
)
22017 else if (! TYPE_SIZE (type
) || ENUM_IS_OPAQUE (type
))
22020 remove_AT (type_die
, DW_AT_declaration
);
22022 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
22023 given enum type is incomplete, do not generate the DW_AT_byte_size
22024 attribute or the DW_AT_element_list attribute. */
22025 if (TYPE_SIZE (type
))
22029 if (!ENUM_IS_OPAQUE (type
))
22030 TREE_ASM_WRITTEN (type
) = 1;
22031 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_byte_size
))
22032 add_byte_size_attribute (type_die
, type
);
22033 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_alignment
))
22034 add_alignment_attribute (type_die
, type
);
22035 if ((dwarf_version
>= 3 || !dwarf_strict
)
22036 && (!orig_type_die
|| !get_AT (type_die
, DW_AT_type
)))
22038 tree underlying
= lang_hooks
.types
.enum_underlying_base_type (type
);
22039 add_type_attribute (type_die
, underlying
, TYPE_UNQUALIFIED
, false,
22042 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
22044 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_decl_file
))
22045 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
22046 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_accessibility
))
22047 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
22050 /* If the first reference to this type was as the return type of an
22051 inline function, then it may not have a parent. Fix this now. */
22052 if (type_die
->die_parent
== NULL
)
22053 add_child_die (scope_die_for (type
, context_die
), type_die
);
22055 for (link
= TYPE_VALUES (type
);
22056 link
!= NULL
; link
= TREE_CHAIN (link
))
22058 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
22059 tree value
= TREE_VALUE (link
);
22061 gcc_assert (!ENUM_IS_OPAQUE (type
));
22062 add_name_attribute (enum_die
,
22063 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
22065 if (TREE_CODE (value
) == CONST_DECL
)
22066 value
= DECL_INITIAL (value
);
22068 if (simple_type_size_in_bits (TREE_TYPE (value
))
22069 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
22071 /* For constant forms created by add_AT_unsigned DWARF
22072 consumers (GDB, elfutils, etc.) always zero extend
22073 the value. Only when the actual value is negative
22074 do we need to use add_AT_int to generate a constant
22075 form that can represent negative values. */
22076 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
22077 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
22078 add_AT_unsigned (enum_die
, DW_AT_const_value
,
22079 (unsigned HOST_WIDE_INT
) val
);
22081 add_AT_int (enum_die
, DW_AT_const_value
, val
);
22084 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
22085 that here. TODO: This should be re-worked to use correct
22086 signed/unsigned double tags for all cases. */
22087 add_AT_wide (enum_die
, DW_AT_const_value
, wi::to_wide (value
));
22090 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
22091 if (TYPE_ARTIFICIAL (type
)
22092 && (!orig_type_die
|| !get_AT (type_die
, DW_AT_artificial
)))
22093 add_AT_flag (type_die
, DW_AT_artificial
, 1);
22096 add_AT_flag (type_die
, DW_AT_declaration
, 1);
22098 add_pubtype (type
, type_die
);
22103 /* Generate a DIE to represent either a real live formal parameter decl or to
22104 represent just the type of some formal parameter position in some function
22107 Note that this routine is a bit unusual because its argument may be a
22108 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
22109 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
22110 node. If it's the former then this function is being called to output a
22111 DIE to represent a formal parameter object (or some inlining thereof). If
22112 it's the latter, then this function is only being called to output a
22113 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
22114 argument type of some subprogram type.
22115 If EMIT_NAME_P is true, name and source coordinate attributes
22119 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
22120 dw_die_ref context_die
)
22122 tree node_or_origin
= node
? node
: origin
;
22123 tree ultimate_origin
;
22124 dw_die_ref parm_die
= NULL
;
22126 if (DECL_P (node_or_origin
))
22128 parm_die
= lookup_decl_die (node
);
22130 /* If the contexts differ, we may not be talking about the same
22132 ??? When in LTO the DIE parent is the "abstract" copy and the
22133 context_die is the specification "copy". But this whole block
22134 should eventually be no longer needed. */
22135 if (parm_die
&& parm_die
->die_parent
!= context_die
&& !in_lto_p
)
22137 if (!DECL_ABSTRACT_P (node
))
22139 /* This can happen when creating an inlined instance, in
22140 which case we need to create a new DIE that will get
22141 annotated with DW_AT_abstract_origin. */
22145 gcc_unreachable ();
22148 if (parm_die
&& parm_die
->die_parent
== NULL
)
22150 /* Check that parm_die already has the right attributes that
22151 we would have added below. If any attributes are
22152 missing, fall through to add them. */
22153 if (! DECL_ABSTRACT_P (node_or_origin
)
22154 && !get_AT (parm_die
, DW_AT_location
)
22155 && !get_AT (parm_die
, DW_AT_const_value
))
22156 /* We are missing location info, and are about to add it. */
22160 add_child_die (context_die
, parm_die
);
22166 /* If we have a previously generated DIE, use it, unless this is an
22167 concrete instance (origin != NULL), in which case we need a new
22168 DIE with a corresponding DW_AT_abstract_origin. */
22170 if (parm_die
&& origin
== NULL
)
22171 reusing_die
= true;
22174 parm_die
= new_die (DW_TAG_formal_parameter
, context_die
, node
);
22175 reusing_die
= false;
22178 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
22180 case tcc_declaration
:
22181 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
22182 if (node
|| ultimate_origin
)
22183 origin
= ultimate_origin
;
22188 if (origin
!= NULL
)
22189 add_abstract_origin_attribute (parm_die
, origin
);
22190 else if (emit_name_p
)
22191 add_name_and_src_coords_attributes (parm_die
, node
);
22193 || (! DECL_ABSTRACT_P (node_or_origin
)
22194 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
22195 decl_function_context
22196 (node_or_origin
))))
22198 tree type
= TREE_TYPE (node_or_origin
);
22199 if (decl_by_reference_p (node_or_origin
))
22200 add_type_attribute (parm_die
, TREE_TYPE (type
),
22202 false, context_die
);
22204 add_type_attribute (parm_die
, type
,
22205 decl_quals (node_or_origin
),
22206 false, context_die
);
22208 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
22209 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22211 if (node
&& node
!= origin
)
22212 equate_decl_number_to_die (node
, parm_die
);
22213 if (! DECL_ABSTRACT_P (node_or_origin
))
22214 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
22220 /* We were called with some kind of a ..._TYPE node. */
22221 add_type_attribute (parm_die
, node_or_origin
, TYPE_UNQUALIFIED
, false,
22226 gcc_unreachable ();
22232 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
22233 children DW_TAG_formal_parameter DIEs representing the arguments of the
22236 PARM_PACK must be a function parameter pack.
22237 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
22238 must point to the subsequent arguments of the function PACK_ARG belongs to.
22239 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
22240 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
22241 following the last one for which a DIE was generated. */
22244 gen_formal_parameter_pack_die (tree parm_pack
,
22246 dw_die_ref subr_die
,
22250 dw_die_ref parm_pack_die
;
22252 gcc_assert (parm_pack
22253 && lang_hooks
.function_parameter_pack_p (parm_pack
)
22256 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
22257 add_src_coords_attributes (parm_pack_die
, parm_pack
);
22259 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
22261 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
22264 gen_formal_parameter_die (arg
, NULL
,
22265 false /* Don't emit name attribute. */,
22270 return parm_pack_die
;
22273 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
22274 at the end of an (ANSI prototyped) formal parameters list. */
22277 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
22279 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
22282 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
22283 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
22284 parameters as specified in some function type specification (except for
22285 those which appear as part of a function *definition*). */
22288 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
22291 tree formal_type
= NULL
;
22292 tree first_parm_type
;
22295 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
22297 arg
= DECL_ARGUMENTS (function_or_method_type
);
22298 function_or_method_type
= TREE_TYPE (function_or_method_type
);
22303 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
22305 /* Make our first pass over the list of formal parameter types and output a
22306 DW_TAG_formal_parameter DIE for each one. */
22307 for (link
= first_parm_type
; link
; )
22309 dw_die_ref parm_die
;
22311 formal_type
= TREE_VALUE (link
);
22312 if (formal_type
== void_type_node
)
22315 /* Output a (nameless) DIE to represent the formal parameter itself. */
22316 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
22317 true /* Emit name attribute. */,
22319 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
22320 && link
== first_parm_type
)
22322 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22323 if (dwarf_version
>= 3 || !dwarf_strict
)
22324 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
22326 else if (arg
&& DECL_ARTIFICIAL (arg
))
22327 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22329 link
= TREE_CHAIN (link
);
22331 arg
= DECL_CHAIN (arg
);
22334 /* If this function type has an ellipsis, add a
22335 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
22336 if (formal_type
!= void_type_node
)
22337 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
22339 /* Make our second (and final) pass over the list of formal parameter types
22340 and output DIEs to represent those types (as necessary). */
22341 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
22342 link
&& TREE_VALUE (link
);
22343 link
= TREE_CHAIN (link
))
22344 gen_type_die (TREE_VALUE (link
), context_die
);
22347 /* We want to generate the DIE for TYPE so that we can generate the
22348 die for MEMBER, which has been defined; we will need to refer back
22349 to the member declaration nested within TYPE. If we're trying to
22350 generate minimal debug info for TYPE, processing TYPE won't do the
22351 trick; we need to attach the member declaration by hand. */
22354 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
22356 gen_type_die (type
, context_die
);
22358 /* If we're trying to avoid duplicate debug info, we may not have
22359 emitted the member decl for this function. Emit it now. */
22360 if (TYPE_STUB_DECL (type
)
22361 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
22362 && ! lookup_decl_die (member
))
22364 dw_die_ref type_die
;
22365 gcc_assert (!decl_ultimate_origin (member
));
22367 type_die
= lookup_type_die_strip_naming_typedef (type
);
22368 if (TREE_CODE (member
) == FUNCTION_DECL
)
22369 gen_subprogram_die (member
, type_die
);
22370 else if (TREE_CODE (member
) == FIELD_DECL
)
22372 /* Ignore the nameless fields that are used to skip bits but handle
22373 C++ anonymous unions and structs. */
22374 if (DECL_NAME (member
) != NULL_TREE
22375 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
22376 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
22378 struct vlr_context vlr_ctx
= {
22379 DECL_CONTEXT (member
), /* struct_type */
22380 NULL_TREE
/* variant_part_offset */
22382 gen_type_die (member_declared_type (member
), type_die
);
22383 gen_field_die (member
, &vlr_ctx
, type_die
);
22387 gen_variable_die (member
, NULL_TREE
, type_die
);
22391 /* Forward declare these functions, because they are mutually recursive
22392 with their set_block_* pairing functions. */
22393 static void set_decl_origin_self (tree
);
22395 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
22396 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
22397 that it points to the node itself, thus indicating that the node is its
22398 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
22399 the given node is NULL, recursively descend the decl/block tree which
22400 it is the root of, and for each other ..._DECL or BLOCK node contained
22401 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
22402 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
22403 values to point to themselves. */
22406 set_block_origin_self (tree stmt
)
22408 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
22410 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
22415 for (local_decl
= BLOCK_VARS (stmt
);
22416 local_decl
!= NULL_TREE
;
22417 local_decl
= DECL_CHAIN (local_decl
))
22418 /* Do not recurse on nested functions since the inlining status
22419 of parent and child can be different as per the DWARF spec. */
22420 if (TREE_CODE (local_decl
) != FUNCTION_DECL
22421 && !DECL_EXTERNAL (local_decl
))
22422 set_decl_origin_self (local_decl
);
22428 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
22429 subblock
!= NULL_TREE
;
22430 subblock
= BLOCK_CHAIN (subblock
))
22431 set_block_origin_self (subblock
); /* Recurse. */
22436 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
22437 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
22438 node to so that it points to the node itself, thus indicating that the
22439 node represents its own (abstract) origin. Additionally, if the
22440 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
22441 the decl/block tree of which the given node is the root of, and for
22442 each other ..._DECL or BLOCK node contained therein whose
22443 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
22444 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
22445 point to themselves. */
22448 set_decl_origin_self (tree decl
)
22450 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
22452 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
22453 if (TREE_CODE (decl
) == FUNCTION_DECL
)
22457 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
22458 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
22459 if (DECL_INITIAL (decl
) != NULL_TREE
22460 && DECL_INITIAL (decl
) != error_mark_node
)
22461 set_block_origin_self (DECL_INITIAL (decl
));
22466 /* Mark the early DIE for DECL as the abstract instance. */
22469 dwarf2out_abstract_function (tree decl
)
22471 dw_die_ref old_die
;
22473 /* Make sure we have the actual abstract inline, not a clone. */
22474 decl
= DECL_ORIGIN (decl
);
22476 if (DECL_IGNORED_P (decl
))
22479 old_die
= lookup_decl_die (decl
);
22480 /* With early debug we always have an old DIE unless we are in LTO
22481 and the user did not compile but only link with debug. */
22482 if (in_lto_p
&& ! old_die
)
22484 gcc_assert (old_die
!= NULL
);
22485 if (get_AT (old_die
, DW_AT_inline
)
22486 || get_AT (old_die
, DW_AT_abstract_origin
))
22487 /* We've already generated the abstract instance. */
22490 /* Go ahead and put DW_AT_inline on the DIE. */
22491 if (DECL_DECLARED_INLINE_P (decl
))
22493 if (cgraph_function_possibly_inlined_p (decl
))
22494 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_inlined
);
22496 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
22500 if (cgraph_function_possibly_inlined_p (decl
))
22501 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_inlined
);
22503 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_not_inlined
);
22506 if (DECL_DECLARED_INLINE_P (decl
)
22507 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
22508 add_AT_flag (old_die
, DW_AT_artificial
, 1);
22510 set_decl_origin_self (decl
);
22513 /* Helper function of premark_used_types() which gets called through
22516 Marks the DIE of a given type in *SLOT as perennial, so it never gets
22517 marked as unused by prune_unused_types. */
22520 premark_used_types_helper (tree
const &type
, void *)
22524 die
= lookup_type_die (type
);
22526 die
->die_perennial_p
= 1;
22530 /* Helper function of premark_types_used_by_global_vars which gets called
22531 through htab_traverse.
22533 Marks the DIE of a given type in *SLOT as perennial, so it never gets
22534 marked as unused by prune_unused_types. The DIE of the type is marked
22535 only if the global variable using the type will actually be emitted. */
22538 premark_types_used_by_global_vars_helper (types_used_by_vars_entry
**slot
,
22541 struct types_used_by_vars_entry
*entry
;
22544 entry
= (struct types_used_by_vars_entry
*) *slot
;
22545 gcc_assert (entry
->type
!= NULL
22546 && entry
->var_decl
!= NULL
);
22547 die
= lookup_type_die (entry
->type
);
22550 /* Ask cgraph if the global variable really is to be emitted.
22551 If yes, then we'll keep the DIE of ENTRY->TYPE. */
22552 varpool_node
*node
= varpool_node::get (entry
->var_decl
);
22553 if (node
&& node
->definition
)
22555 die
->die_perennial_p
= 1;
22556 /* Keep the parent DIEs as well. */
22557 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
22558 die
->die_perennial_p
= 1;
22564 /* Mark all members of used_types_hash as perennial. */
22567 premark_used_types (struct function
*fun
)
22569 if (fun
&& fun
->used_types_hash
)
22570 fun
->used_types_hash
->traverse
<void *, premark_used_types_helper
> (NULL
);
22573 /* Mark all members of types_used_by_vars_entry as perennial. */
22576 premark_types_used_by_global_vars (void)
22578 if (types_used_by_vars_hash
)
22579 types_used_by_vars_hash
22580 ->traverse
<void *, premark_types_used_by_global_vars_helper
> (NULL
);
22583 /* Generate a DW_TAG_call_site DIE in function DECL under SUBR_DIE
22584 for CA_LOC call arg loc node. */
22587 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
22588 struct call_arg_loc_node
*ca_loc
)
22590 dw_die_ref stmt_die
= NULL
, die
;
22591 tree block
= ca_loc
->block
;
22594 && block
!= DECL_INITIAL (decl
)
22595 && TREE_CODE (block
) == BLOCK
)
22597 stmt_die
= BLOCK_DIE (block
);
22600 block
= BLOCK_SUPERCONTEXT (block
);
22602 if (stmt_die
== NULL
)
22603 stmt_die
= subr_die
;
22604 die
= new_die (dwarf_TAG (DW_TAG_call_site
), stmt_die
, NULL_TREE
);
22605 add_AT_lbl_id (die
, dwarf_AT (DW_AT_call_return_pc
), ca_loc
->label
);
22606 if (ca_loc
->tail_call_p
)
22607 add_AT_flag (die
, dwarf_AT (DW_AT_call_tail_call
), 1);
22608 if (ca_loc
->symbol_ref
)
22610 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
22612 add_AT_die_ref (die
, dwarf_AT (DW_AT_call_origin
), tdie
);
22614 add_AT_addr (die
, dwarf_AT (DW_AT_call_origin
), ca_loc
->symbol_ref
,
22620 /* Generate a DIE to represent a declared function (either file-scope or
22624 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
22626 tree origin
= decl_ultimate_origin (decl
);
22627 dw_die_ref subr_die
;
22628 dw_die_ref old_die
= lookup_decl_die (decl
);
22630 /* This function gets called multiple times for different stages of
22631 the debug process. For example, for func() in this code:
22635 void func() { ... }
22638 ...we get called 4 times. Twice in early debug and twice in
22644 1. Once while generating func() within the namespace. This is
22645 the declaration. The declaration bit below is set, as the
22646 context is the namespace.
22648 A new DIE will be generated with DW_AT_declaration set.
22650 2. Once for func() itself. This is the specification. The
22651 declaration bit below is clear as the context is the CU.
22653 We will use the cached DIE from (1) to create a new DIE with
22654 DW_AT_specification pointing to the declaration in (1).
22656 Late debug via rest_of_handle_final()
22657 -------------------------------------
22659 3. Once generating func() within the namespace. This is also the
22660 declaration, as in (1), but this time we will early exit below
22661 as we have a cached DIE and a declaration needs no additional
22662 annotations (no locations), as the source declaration line
22665 4. Once for func() itself. As in (2), this is the specification,
22666 but this time we will re-use the cached DIE, and just annotate
22667 it with the location information that should now be available.
22669 For something without namespaces, but with abstract instances, we
22670 are also called a multiple times:
22675 Base (); // constructor declaration (1)
22678 Base::Base () { } // constructor specification (2)
22683 1. Once for the Base() constructor by virtue of it being a
22684 member of the Base class. This is done via
22685 rest_of_type_compilation.
22687 This is a declaration, so a new DIE will be created with
22690 2. Once for the Base() constructor definition, but this time
22691 while generating the abstract instance of the base
22692 constructor (__base_ctor) which is being generated via early
22693 debug of reachable functions.
22695 Even though we have a cached version of the declaration (1),
22696 we will create a DW_AT_specification of the declaration DIE
22699 3. Once for the __base_ctor itself, but this time, we generate
22700 an DW_AT_abstract_origin version of the DW_AT_specification in
22703 Late debug via rest_of_handle_final
22704 -----------------------------------
22706 4. One final time for the __base_ctor (which will have a cached
22707 DIE with DW_AT_abstract_origin created in (3). This time,
22708 we will just annotate the location information now
22711 int declaration
= (current_function_decl
!= decl
22712 || class_or_namespace_scope_p (context_die
));
22714 /* A declaration that has been previously dumped needs no
22715 additional information. */
22716 if (old_die
&& declaration
)
22719 /* Now that the C++ front end lazily declares artificial member fns, we
22720 might need to retrofit the declaration into its class. */
22721 if (!declaration
&& !origin
&& !old_die
22722 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
22723 && !class_or_namespace_scope_p (context_die
)
22724 && debug_info_level
> DINFO_LEVEL_TERSE
)
22725 old_die
= force_decl_die (decl
);
22727 /* A concrete instance, tag a new DIE with DW_AT_abstract_origin. */
22728 if (origin
!= NULL
)
22730 gcc_assert (!declaration
|| local_scope_p (context_die
));
22732 /* Fixup die_parent for the abstract instance of a nested
22733 inline function. */
22734 if (old_die
&& old_die
->die_parent
== NULL
)
22735 add_child_die (context_die
, old_die
);
22737 if (old_die
&& get_AT_ref (old_die
, DW_AT_abstract_origin
))
22739 /* If we have a DW_AT_abstract_origin we have a working
22741 subr_die
= old_die
;
22745 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22746 add_abstract_origin_attribute (subr_die
, origin
);
22747 /* This is where the actual code for a cloned function is.
22748 Let's emit linkage name attribute for it. This helps
22749 debuggers to e.g, set breakpoints into
22750 constructors/destructors when the user asks "break
22752 add_linkage_name (subr_die
, decl
);
22755 /* A cached copy, possibly from early dwarf generation. Reuse as
22756 much as possible. */
22759 if (!get_AT_flag (old_die
, DW_AT_declaration
)
22760 /* We can have a normal definition following an inline one in the
22761 case of redefinition of GNU C extern inlines.
22762 It seems reasonable to use AT_specification in this case. */
22763 && !get_AT (old_die
, DW_AT_inline
))
22765 /* Detect and ignore this case, where we are trying to output
22766 something we have already output. */
22767 if (get_AT (old_die
, DW_AT_low_pc
)
22768 || get_AT (old_die
, DW_AT_ranges
))
22771 /* If we have no location information, this must be a
22772 partially generated DIE from early dwarf generation.
22773 Fall through and generate it. */
22776 /* If the definition comes from the same place as the declaration,
22777 maybe use the old DIE. We always want the DIE for this function
22778 that has the *_pc attributes to be under comp_unit_die so the
22779 debugger can find it. We also need to do this for abstract
22780 instances of inlines, since the spec requires the out-of-line copy
22781 to have the same parent. For local class methods, this doesn't
22782 apply; we just use the old DIE. */
22783 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
22784 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
22785 if (((is_unit_die (old_die
->die_parent
)
22786 /* This condition fixes the inconsistency/ICE with the
22787 following Fortran test (or some derivative thereof) while
22788 building libgfortran:
22792 logical function funky (FLAG)
22797 || (old_die
->die_parent
22798 && old_die
->die_parent
->die_tag
== DW_TAG_module
)
22799 || local_scope_p (old_die
->die_parent
)
22800 || context_die
== NULL
)
22801 && (DECL_ARTIFICIAL (decl
)
22802 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
22803 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
22804 == (unsigned) s
.line
)
22805 && (!debug_column_info
22807 || (get_AT_unsigned (old_die
, DW_AT_decl_column
)
22808 == (unsigned) s
.column
)))))
22809 /* With LTO if there's an abstract instance for
22810 the old DIE, this is a concrete instance and
22811 thus re-use the DIE. */
22812 || get_AT (old_die
, DW_AT_abstract_origin
))
22814 subr_die
= old_die
;
22816 /* Clear out the declaration attribute, but leave the
22817 parameters so they can be augmented with location
22818 information later. Unless this was a declaration, in
22819 which case, wipe out the nameless parameters and recreate
22820 them further down. */
22821 if (remove_AT (subr_die
, DW_AT_declaration
))
22824 remove_AT (subr_die
, DW_AT_object_pointer
);
22825 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
22828 /* Make a specification pointing to the previously built
22832 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22833 add_AT_specification (subr_die
, old_die
);
22834 add_pubname (decl
, subr_die
);
22835 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
22836 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
22837 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
22838 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
22839 if (debug_column_info
22841 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
22842 != (unsigned) s
.column
))
22843 add_AT_unsigned (subr_die
, DW_AT_decl_column
, s
.column
);
22845 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
22846 emit the real type on the definition die. */
22847 if (is_cxx () && debug_info_level
> DINFO_LEVEL_TERSE
)
22849 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
22850 if (die
== auto_die
|| die
== decltype_auto_die
)
22851 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
22852 TYPE_UNQUALIFIED
, false, context_die
);
22855 /* When we process the method declaration, we haven't seen
22856 the out-of-class defaulted definition yet, so we have to
22858 if ((dwarf_version
>= 5 || ! dwarf_strict
)
22859 && !get_AT (subr_die
, DW_AT_defaulted
))
22862 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22864 if (defaulted
!= -1)
22866 /* Other values must have been handled before. */
22867 gcc_assert (defaulted
== DW_DEFAULTED_out_of_class
);
22868 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
22873 /* Create a fresh DIE for anything else. */
22876 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22878 if (TREE_PUBLIC (decl
))
22879 add_AT_flag (subr_die
, DW_AT_external
, 1);
22881 add_name_and_src_coords_attributes (subr_die
, decl
);
22882 add_pubname (decl
, subr_die
);
22883 if (debug_info_level
> DINFO_LEVEL_TERSE
)
22885 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
22886 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
22887 TYPE_UNQUALIFIED
, false, context_die
);
22890 add_pure_or_virtual_attribute (subr_die
, decl
);
22891 if (DECL_ARTIFICIAL (decl
))
22892 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
22894 if (TREE_THIS_VOLATILE (decl
) && (dwarf_version
>= 5 || !dwarf_strict
))
22895 add_AT_flag (subr_die
, DW_AT_noreturn
, 1);
22897 add_alignment_attribute (subr_die
, decl
);
22899 add_accessibility_attribute (subr_die
, decl
);
22902 /* Unless we have an existing non-declaration DIE, equate the new
22904 if (!old_die
|| is_declaration_die (old_die
))
22905 equate_decl_number_to_die (decl
, subr_die
);
22909 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
22911 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
22913 /* If this is an explicit function declaration then generate
22914 a DW_AT_explicit attribute. */
22915 if ((dwarf_version
>= 3 || !dwarf_strict
)
22916 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22917 DW_AT_explicit
) == 1)
22918 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
22920 /* If this is a C++11 deleted special function member then generate
22921 a DW_AT_deleted attribute. */
22922 if ((dwarf_version
>= 5 || !dwarf_strict
)
22923 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22924 DW_AT_deleted
) == 1)
22925 add_AT_flag (subr_die
, DW_AT_deleted
, 1);
22927 /* If this is a C++11 defaulted special function member then
22928 generate a DW_AT_defaulted attribute. */
22929 if (dwarf_version
>= 5 || !dwarf_strict
)
22932 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22934 if (defaulted
!= -1)
22935 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
22938 /* If this is a C++11 non-static member function with & ref-qualifier
22939 then generate a DW_AT_reference attribute. */
22940 if ((dwarf_version
>= 5 || !dwarf_strict
)
22941 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22942 DW_AT_reference
) == 1)
22943 add_AT_flag (subr_die
, DW_AT_reference
, 1);
22945 /* If this is a C++11 non-static member function with &&
22946 ref-qualifier then generate a DW_AT_reference attribute. */
22947 if ((dwarf_version
>= 5 || !dwarf_strict
)
22948 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22949 DW_AT_rvalue_reference
)
22951 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
22954 /* For non DECL_EXTERNALs, if range information is available, fill
22955 the DIE with it. */
22956 else if (!DECL_EXTERNAL (decl
) && !early_dwarf
)
22958 HOST_WIDE_INT cfa_fb_offset
;
22960 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
22962 if (!crtl
->has_bb_partition
)
22964 dw_fde_ref fde
= fun
->fde
;
22965 if (fde
->dw_fde_begin
)
22967 /* We have already generated the labels. */
22968 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
22969 fde
->dw_fde_end
, false);
22973 /* Create start/end labels and add the range. */
22974 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
22975 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
22976 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
22977 current_function_funcdef_no
);
22978 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
22979 current_function_funcdef_no
);
22980 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
22984 #if VMS_DEBUGGING_INFO
22985 /* HP OpenVMS Industry Standard 64: DWARF Extensions
22986 Section 2.3 Prologue and Epilogue Attributes:
22987 When a breakpoint is set on entry to a function, it is generally
22988 desirable for execution to be suspended, not on the very first
22989 instruction of the function, but rather at a point after the
22990 function's frame has been set up, after any language defined local
22991 declaration processing has been completed, and before execution of
22992 the first statement of the function begins. Debuggers generally
22993 cannot properly determine where this point is. Similarly for a
22994 breakpoint set on exit from a function. The prologue and epilogue
22995 attributes allow a compiler to communicate the location(s) to use. */
22998 if (fde
->dw_fde_vms_end_prologue
)
22999 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
23000 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
23002 if (fde
->dw_fde_vms_begin_epilogue
)
23003 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
23004 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
23011 /* Generate pubnames entries for the split function code ranges. */
23012 dw_fde_ref fde
= fun
->fde
;
23014 if (fde
->dw_fde_second_begin
)
23016 if (dwarf_version
>= 3 || !dwarf_strict
)
23018 /* We should use ranges for non-contiguous code section
23019 addresses. Use the actual code range for the initial
23020 section, since the HOT/COLD labels might precede an
23021 alignment offset. */
23022 bool range_list_added
= false;
23023 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
23024 fde
->dw_fde_end
, &range_list_added
,
23026 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
23027 fde
->dw_fde_second_end
,
23028 &range_list_added
, false);
23029 if (range_list_added
)
23034 /* There is no real support in DW2 for this .. so we make
23035 a work-around. First, emit the pub name for the segment
23036 containing the function label. Then make and emit a
23037 simplified subprogram DIE for the second segment with the
23038 name pre-fixed by __hot/cold_sect_of_. We use the same
23039 linkage name for the second die so that gdb will find both
23040 sections when given "b foo". */
23041 const char *name
= NULL
;
23042 tree decl_name
= DECL_NAME (decl
);
23043 dw_die_ref seg_die
;
23045 /* Do the 'primary' section. */
23046 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
23047 fde
->dw_fde_end
, false);
23049 /* Build a minimal DIE for the secondary section. */
23050 seg_die
= new_die (DW_TAG_subprogram
,
23051 subr_die
->die_parent
, decl
);
23053 if (TREE_PUBLIC (decl
))
23054 add_AT_flag (seg_die
, DW_AT_external
, 1);
23056 if (decl_name
!= NULL
23057 && IDENTIFIER_POINTER (decl_name
) != NULL
)
23059 name
= dwarf2_name (decl
, 1);
23060 if (! DECL_ARTIFICIAL (decl
))
23061 add_src_coords_attributes (seg_die
, decl
);
23063 add_linkage_name (seg_die
, decl
);
23065 gcc_assert (name
!= NULL
);
23066 add_pure_or_virtual_attribute (seg_die
, decl
);
23067 if (DECL_ARTIFICIAL (decl
))
23068 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
23070 name
= concat ("__second_sect_of_", name
, NULL
);
23071 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
23072 fde
->dw_fde_second_end
, false);
23073 add_name_attribute (seg_die
, name
);
23074 if (want_pubnames ())
23075 add_pubname_string (name
, seg_die
);
23079 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
23083 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
23085 /* We define the "frame base" as the function's CFA. This is more
23086 convenient for several reasons: (1) It's stable across the prologue
23087 and epilogue, which makes it better than just a frame pointer,
23088 (2) With dwarf3, there exists a one-byte encoding that allows us
23089 to reference the .debug_frame data by proxy, but failing that,
23090 (3) We can at least reuse the code inspection and interpretation
23091 code that determines the CFA position at various points in the
23093 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
23095 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
23096 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
23100 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
23101 if (list
->dw_loc_next
)
23102 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
23104 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
23107 /* Compute a displacement from the "steady-state frame pointer" to
23108 the CFA. The former is what all stack slots and argument slots
23109 will reference in the rtl; the latter is what we've told the
23110 debugger about. We'll need to adjust all frame_base references
23111 by this displacement. */
23112 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
23114 if (fun
->static_chain_decl
)
23116 /* DWARF requires here a location expression that computes the
23117 address of the enclosing subprogram's frame base. The machinery
23118 in tree-nested.c is supposed to store this specific address in the
23119 last field of the FRAME record. */
23120 const tree frame_type
23121 = TREE_TYPE (TREE_TYPE (fun
->static_chain_decl
));
23122 const tree fb_decl
= tree_last (TYPE_FIELDS (frame_type
));
23125 = build1 (INDIRECT_REF
, frame_type
, fun
->static_chain_decl
);
23126 fb_expr
= build3 (COMPONENT_REF
, TREE_TYPE (fb_decl
),
23127 fb_expr
, fb_decl
, NULL_TREE
);
23129 add_AT_location_description (subr_die
, DW_AT_static_link
,
23130 loc_list_from_tree (fb_expr
, 0, NULL
));
23133 resolve_variable_values ();
23136 /* Generate child dies for template paramaters. */
23137 if (early_dwarf
&& debug_info_level
> DINFO_LEVEL_TERSE
)
23138 gen_generic_params_dies (decl
);
23140 /* Now output descriptions of the arguments for this function. This gets
23141 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
23142 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
23143 `...' at the end of the formal parameter list. In order to find out if
23144 there was a trailing ellipsis or not, we must instead look at the type
23145 associated with the FUNCTION_DECL. This will be a node of type
23146 FUNCTION_TYPE. If the chain of type nodes hanging off of this
23147 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
23148 an ellipsis at the end. */
23150 /* In the case where we are describing a mere function declaration, all we
23151 need to do here (and all we *can* do here) is to describe the *types* of
23152 its formal parameters. */
23153 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
23155 else if (declaration
)
23156 gen_formal_types_die (decl
, subr_die
);
23159 /* Generate DIEs to represent all known formal parameters. */
23160 tree parm
= DECL_ARGUMENTS (decl
);
23161 tree generic_decl
= early_dwarf
23162 ? lang_hooks
.decls
.get_generic_function_decl (decl
) : NULL
;
23163 tree generic_decl_parm
= generic_decl
23164 ? DECL_ARGUMENTS (generic_decl
)
23167 /* Now we want to walk the list of parameters of the function and
23168 emit their relevant DIEs.
23170 We consider the case of DECL being an instance of a generic function
23171 as well as it being a normal function.
23173 If DECL is an instance of a generic function we walk the
23174 parameters of the generic function declaration _and_ the parameters of
23175 DECL itself. This is useful because we want to emit specific DIEs for
23176 function parameter packs and those are declared as part of the
23177 generic function declaration. In that particular case,
23178 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
23179 That DIE has children DIEs representing the set of arguments
23180 of the pack. Note that the set of pack arguments can be empty.
23181 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
23184 Otherwise, we just consider the parameters of DECL. */
23185 while (generic_decl_parm
|| parm
)
23187 if (generic_decl_parm
23188 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
23189 gen_formal_parameter_pack_die (generic_decl_parm
,
23194 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, NULL
, subr_die
);
23197 && parm
== DECL_ARGUMENTS (decl
)
23198 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
23200 && (dwarf_version
>= 3 || !dwarf_strict
))
23201 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
23203 parm
= DECL_CHAIN (parm
);
23206 parm
= DECL_CHAIN (parm
);
23208 if (generic_decl_parm
)
23209 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
23212 /* Decide whether we need an unspecified_parameters DIE at the end.
23213 There are 2 more cases to do this for: 1) the ansi ... declaration -
23214 this is detectable when the end of the arg list is not a
23215 void_type_node 2) an unprototyped function declaration (not a
23216 definition). This just means that we have no info about the
23217 parameters at all. */
23220 if (prototype_p (TREE_TYPE (decl
)))
23222 /* This is the prototyped case, check for.... */
23223 if (stdarg_p (TREE_TYPE (decl
)))
23224 gen_unspecified_parameters_die (decl
, subr_die
);
23226 else if (DECL_INITIAL (decl
) == NULL_TREE
)
23227 gen_unspecified_parameters_die (decl
, subr_die
);
23231 if (subr_die
!= old_die
)
23232 /* Add the calling convention attribute if requested. */
23233 add_calling_convention_attribute (subr_die
, decl
);
23235 /* Output Dwarf info for all of the stuff within the body of the function
23236 (if it has one - it may be just a declaration).
23238 OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
23239 a function. This BLOCK actually represents the outermost binding contour
23240 for the function, i.e. the contour in which the function's formal
23241 parameters and labels get declared. Curiously, it appears that the front
23242 end doesn't actually put the PARM_DECL nodes for the current function onto
23243 the BLOCK_VARS list for this outer scope, but are strung off of the
23244 DECL_ARGUMENTS list for the function instead.
23246 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
23247 the LABEL_DECL nodes for the function however, and we output DWARF info
23248 for those in decls_for_scope. Just within the `outer_scope' there will be
23249 a BLOCK node representing the function's outermost pair of curly braces,
23250 and any blocks used for the base and member initializers of a C++
23251 constructor function. */
23252 tree outer_scope
= DECL_INITIAL (decl
);
23253 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
23255 int call_site_note_count
= 0;
23256 int tail_call_site_note_count
= 0;
23258 /* Emit a DW_TAG_variable DIE for a named return value. */
23259 if (DECL_NAME (DECL_RESULT (decl
)))
23260 gen_decl_die (DECL_RESULT (decl
), NULL
, NULL
, subr_die
);
23262 /* The first time through decls_for_scope we will generate the
23263 DIEs for the locals. The second time, we fill in the
23265 decls_for_scope (outer_scope
, subr_die
);
23267 if (call_arg_locations
&& (!dwarf_strict
|| dwarf_version
>= 5))
23269 struct call_arg_loc_node
*ca_loc
;
23270 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
23272 dw_die_ref die
= NULL
;
23273 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
23276 for (arg
= (ca_loc
->call_arg_loc_note
!= NULL_RTX
23277 ? XEXP (ca_loc
->call_arg_loc_note
, 0)
23279 arg
; arg
= next_arg
)
23281 dw_loc_descr_ref reg
, val
;
23282 machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
23283 dw_die_ref cdie
, tdie
= NULL
;
23285 next_arg
= XEXP (arg
, 1);
23286 if (REG_P (XEXP (XEXP (arg
, 0), 0))
23288 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
23289 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
23290 && REGNO (XEXP (XEXP (arg
, 0), 0))
23291 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
23292 next_arg
= XEXP (next_arg
, 1);
23293 if (mode
== VOIDmode
)
23295 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
23296 if (mode
== VOIDmode
)
23297 mode
= GET_MODE (XEXP (arg
, 0));
23299 if (mode
== VOIDmode
|| mode
== BLKmode
)
23301 /* Get dynamic information about call target only if we
23302 have no static information: we cannot generate both
23303 DW_AT_call_origin and DW_AT_call_target
23305 if (ca_loc
->symbol_ref
== NULL_RTX
)
23307 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
23309 tloc
= XEXP (XEXP (arg
, 0), 1);
23312 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
23313 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
23315 tlocc
= XEXP (XEXP (arg
, 0), 1);
23320 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
23321 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
23322 VAR_INIT_STATUS_INITIALIZED
);
23323 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
23325 rtx mem
= XEXP (XEXP (arg
, 0), 0);
23326 reg
= mem_loc_descriptor (XEXP (mem
, 0),
23327 get_address_mode (mem
),
23329 VAR_INIT_STATUS_INITIALIZED
);
23331 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
23332 == DEBUG_PARAMETER_REF
)
23335 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
23336 tdie
= lookup_decl_die (tdecl
);
23343 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
23344 != DEBUG_PARAMETER_REF
)
23346 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
23348 VAR_INIT_STATUS_INITIALIZED
);
23352 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
23353 cdie
= new_die (dwarf_TAG (DW_TAG_call_site_parameter
), die
,
23356 add_AT_loc (cdie
, DW_AT_location
, reg
);
23357 else if (tdie
!= NULL
)
23358 add_AT_die_ref (cdie
, dwarf_AT (DW_AT_call_parameter
),
23360 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_value
), val
);
23361 if (next_arg
!= XEXP (arg
, 1))
23363 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
23364 if (mode
== VOIDmode
)
23365 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
23366 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
23369 VAR_INIT_STATUS_INITIALIZED
);
23371 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_data_value
),
23376 && (ca_loc
->symbol_ref
|| tloc
))
23377 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
23378 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
23380 dw_loc_descr_ref tval
= NULL
;
23382 if (tloc
!= NULL_RTX
)
23383 tval
= mem_loc_descriptor (tloc
,
23384 GET_MODE (tloc
) == VOIDmode
23385 ? Pmode
: GET_MODE (tloc
),
23387 VAR_INIT_STATUS_INITIALIZED
);
23389 add_AT_loc (die
, dwarf_AT (DW_AT_call_target
), tval
);
23390 else if (tlocc
!= NULL_RTX
)
23392 tval
= mem_loc_descriptor (tlocc
,
23393 GET_MODE (tlocc
) == VOIDmode
23394 ? Pmode
: GET_MODE (tlocc
),
23396 VAR_INIT_STATUS_INITIALIZED
);
23399 dwarf_AT (DW_AT_call_target_clobbered
),
23405 call_site_note_count
++;
23406 if (ca_loc
->tail_call_p
)
23407 tail_call_site_note_count
++;
23411 call_arg_locations
= NULL
;
23412 call_arg_loc_last
= NULL
;
23413 if (tail_call_site_count
>= 0
23414 && tail_call_site_count
== tail_call_site_note_count
23415 && (!dwarf_strict
|| dwarf_version
>= 5))
23417 if (call_site_count
>= 0
23418 && call_site_count
== call_site_note_count
)
23419 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_calls
), 1);
23421 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_tail_calls
), 1);
23423 call_site_count
= -1;
23424 tail_call_site_count
= -1;
23427 /* Mark used types after we have created DIEs for the functions scopes. */
23428 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
23431 /* Returns a hash value for X (which really is a die_struct). */
23434 block_die_hasher::hash (die_struct
*d
)
23436 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
23439 /* Return nonzero if decl_id and die_parent of die_struct X is the same
23440 as decl_id and die_parent of die_struct Y. */
23443 block_die_hasher::equal (die_struct
*x
, die_struct
*y
)
23445 return x
->decl_id
== y
->decl_id
&& x
->die_parent
== y
->die_parent
;
23448 /* Hold information about markers for inlined entry points. */
23449 struct GTY ((for_user
)) inline_entry_data
23451 /* The block that's the inlined_function_outer_scope for an inlined
23455 /* The label at the inlined entry point. */
23456 const char *label_pfx
;
23457 unsigned int label_num
;
23459 /* The view number to be used as the inlined entry point. */
23463 struct inline_entry_data_hasher
: ggc_ptr_hash
<inline_entry_data
>
23465 typedef tree compare_type
;
23466 static inline hashval_t
hash (const inline_entry_data
*);
23467 static inline bool equal (const inline_entry_data
*, const_tree
);
23470 /* Hash table routines for inline_entry_data. */
23473 inline_entry_data_hasher::hash (const inline_entry_data
*data
)
23475 return htab_hash_pointer (data
->block
);
23479 inline_entry_data_hasher::equal (const inline_entry_data
*data
,
23482 return data
->block
== block
;
23485 /* Inlined entry points pending DIE creation in this compilation unit. */
23487 static GTY(()) hash_table
<inline_entry_data_hasher
> *inline_entry_data_table
;
23490 /* Return TRUE if DECL, which may have been previously generated as
23491 OLD_DIE, is a candidate for a DW_AT_specification. DECLARATION is
23492 true if decl (or its origin) is either an extern declaration or a
23493 class/namespace scoped declaration.
23495 The declare_in_namespace support causes us to get two DIEs for one
23496 variable, both of which are declarations. We want to avoid
23497 considering one to be a specification, so we must test for
23498 DECLARATION and DW_AT_declaration. */
23500 decl_will_get_specification_p (dw_die_ref old_die
, tree decl
, bool declaration
)
23502 return (old_die
&& TREE_STATIC (decl
) && !declaration
23503 && get_AT_flag (old_die
, DW_AT_declaration
) == 1);
23506 /* Return true if DECL is a local static. */
23509 local_function_static (tree decl
)
23511 gcc_assert (VAR_P (decl
));
23512 return TREE_STATIC (decl
)
23513 && DECL_CONTEXT (decl
)
23514 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
;
23517 /* Generate a DIE to represent a declared data object.
23518 Either DECL or ORIGIN must be non-null. */
23521 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
23523 HOST_WIDE_INT off
= 0;
23525 tree decl_or_origin
= decl
? decl
: origin
;
23526 tree ultimate_origin
;
23527 dw_die_ref var_die
;
23528 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
23529 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
23530 || class_or_namespace_scope_p (context_die
));
23531 bool specialization_p
= false;
23532 bool no_linkage_name
= false;
23534 /* While C++ inline static data members have definitions inside of the
23535 class, force the first DIE to be a declaration, then let gen_member_die
23536 reparent it to the class context and call gen_variable_die again
23537 to create the outside of the class DIE for the definition. */
23541 && DECL_CONTEXT (decl
)
23542 && TYPE_P (DECL_CONTEXT (decl
))
23543 && lang_hooks
.decls
.decl_dwarf_attribute (decl
, DW_AT_inline
) != -1)
23545 declaration
= true;
23546 if (dwarf_version
< 5)
23547 no_linkage_name
= true;
23550 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
23551 if (decl
|| ultimate_origin
)
23552 origin
= ultimate_origin
;
23553 com_decl
= fortran_common (decl_or_origin
, &off
);
23555 /* Symbol in common gets emitted as a child of the common block, in the form
23556 of a data member. */
23559 dw_die_ref com_die
;
23560 dw_loc_list_ref loc
= NULL
;
23561 die_node com_die_arg
;
23563 var_die
= lookup_decl_die (decl_or_origin
);
23566 if (! early_dwarf
&& get_AT (var_die
, DW_AT_location
) == NULL
)
23568 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2, NULL
);
23573 /* Optimize the common case. */
23574 if (single_element_loc_list_p (loc
)
23575 && loc
->expr
->dw_loc_opc
== DW_OP_addr
23576 && loc
->expr
->dw_loc_next
== NULL
23577 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
23580 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
23581 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
23582 = plus_constant (GET_MODE (x
), x
, off
);
23585 loc_list_plus_const (loc
, off
);
23587 add_AT_location_description (var_die
, DW_AT_location
, loc
);
23588 remove_AT (var_die
, DW_AT_declaration
);
23594 if (common_block_die_table
== NULL
)
23595 common_block_die_table
= hash_table
<block_die_hasher
>::create_ggc (10);
23597 com_die_arg
.decl_id
= DECL_UID (com_decl
);
23598 com_die_arg
.die_parent
= context_die
;
23599 com_die
= common_block_die_table
->find (&com_die_arg
);
23601 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
23602 if (com_die
== NULL
)
23605 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
23608 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
23609 add_name_and_src_coords_attributes (com_die
, com_decl
);
23612 add_AT_location_description (com_die
, DW_AT_location
, loc
);
23613 /* Avoid sharing the same loc descriptor between
23614 DW_TAG_common_block and DW_TAG_variable. */
23615 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
23617 else if (DECL_EXTERNAL (decl_or_origin
))
23618 add_AT_flag (com_die
, DW_AT_declaration
, 1);
23619 if (want_pubnames ())
23620 add_pubname_string (cnam
, com_die
); /* ??? needed? */
23621 com_die
->decl_id
= DECL_UID (com_decl
);
23622 slot
= common_block_die_table
->find_slot (com_die
, INSERT
);
23625 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
23627 add_AT_location_description (com_die
, DW_AT_location
, loc
);
23628 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
23629 remove_AT (com_die
, DW_AT_declaration
);
23631 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
23632 add_name_and_src_coords_attributes (var_die
, decl_or_origin
);
23633 add_type_attribute (var_die
, TREE_TYPE (decl_or_origin
),
23634 decl_quals (decl_or_origin
), false,
23636 add_alignment_attribute (var_die
, decl
);
23637 add_AT_flag (var_die
, DW_AT_external
, 1);
23642 /* Optimize the common case. */
23643 if (single_element_loc_list_p (loc
)
23644 && loc
->expr
->dw_loc_opc
== DW_OP_addr
23645 && loc
->expr
->dw_loc_next
== NULL
23646 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
23648 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
23649 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
23650 = plus_constant (GET_MODE (x
), x
, off
);
23653 loc_list_plus_const (loc
, off
);
23655 add_AT_location_description (var_die
, DW_AT_location
, loc
);
23657 else if (DECL_EXTERNAL (decl_or_origin
))
23658 add_AT_flag (var_die
, DW_AT_declaration
, 1);
23660 equate_decl_number_to_die (decl
, var_die
);
23668 /* A declaration that has been previously dumped, needs no
23669 further annotations, since it doesn't need location on
23670 the second pass. */
23673 else if (decl_will_get_specification_p (old_die
, decl
, declaration
)
23674 && !get_AT (old_die
, DW_AT_specification
))
23676 /* Fall-thru so we can make a new variable die along with a
23677 DW_AT_specification. */
23679 else if (origin
&& old_die
->die_parent
!= context_die
)
23681 /* If we will be creating an inlined instance, we need a
23682 new DIE that will get annotated with
23683 DW_AT_abstract_origin. */
23684 gcc_assert (!DECL_ABSTRACT_P (decl
));
23688 /* If a DIE was dumped early, it still needs location info.
23689 Skip to where we fill the location bits. */
23692 /* ??? In LTRANS we cannot annotate early created variably
23693 modified type DIEs without copying them and adjusting all
23694 references to them. Thus we dumped them again. Also add a
23695 reference to them but beware of -g0 compile and -g link
23696 in which case the reference will be already present. */
23697 tree type
= TREE_TYPE (decl_or_origin
);
23699 && ! get_AT (var_die
, DW_AT_type
)
23700 && variably_modified_type_p
23701 (type
, decl_function_context (decl_or_origin
)))
23703 if (decl_by_reference_p (decl_or_origin
))
23704 add_type_attribute (var_die
, TREE_TYPE (type
),
23705 TYPE_UNQUALIFIED
, false, context_die
);
23707 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
),
23708 false, context_die
);
23711 goto gen_variable_die_location
;
23715 /* For static data members, the declaration in the class is supposed
23716 to have DW_TAG_member tag in DWARF{3,4} and we emit it for compatibility
23717 also in DWARF2; the specification should still be DW_TAG_variable
23718 referencing the DW_TAG_member DIE. */
23719 if (declaration
&& class_scope_p (context_die
) && dwarf_version
< 5)
23720 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
23722 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
23724 if (origin
!= NULL
)
23725 add_abstract_origin_attribute (var_die
, origin
);
23727 /* Loop unrolling can create multiple blocks that refer to the same
23728 static variable, so we must test for the DW_AT_declaration flag.
23730 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
23731 copy decls and set the DECL_ABSTRACT_P flag on them instead of
23734 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
23735 else if (decl_will_get_specification_p (old_die
, decl
, declaration
))
23737 /* This is a definition of a C++ class level static. */
23738 add_AT_specification (var_die
, old_die
);
23739 specialization_p
= true;
23740 if (DECL_NAME (decl
))
23742 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
23743 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
23745 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
23746 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
23748 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
23749 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
23751 if (debug_column_info
23753 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
23754 != (unsigned) s
.column
))
23755 add_AT_unsigned (var_die
, DW_AT_decl_column
, s
.column
);
23757 if (old_die
->die_tag
== DW_TAG_member
)
23758 add_linkage_name (var_die
, decl
);
23762 add_name_and_src_coords_attributes (var_die
, decl
, no_linkage_name
);
23764 if ((origin
== NULL
&& !specialization_p
)
23766 && !DECL_ABSTRACT_P (decl_or_origin
)
23767 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
23768 decl_function_context
23769 (decl_or_origin
))))
23771 tree type
= TREE_TYPE (decl_or_origin
);
23773 if (decl_by_reference_p (decl_or_origin
))
23774 add_type_attribute (var_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
23777 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
), false,
23781 if (origin
== NULL
&& !specialization_p
)
23783 if (TREE_PUBLIC (decl
))
23784 add_AT_flag (var_die
, DW_AT_external
, 1);
23786 if (DECL_ARTIFICIAL (decl
))
23787 add_AT_flag (var_die
, DW_AT_artificial
, 1);
23789 add_alignment_attribute (var_die
, decl
);
23791 add_accessibility_attribute (var_die
, decl
);
23795 add_AT_flag (var_die
, DW_AT_declaration
, 1);
23797 if (decl
&& (DECL_ABSTRACT_P (decl
)
23798 || !old_die
|| is_declaration_die (old_die
)))
23799 equate_decl_number_to_die (decl
, var_die
);
23801 gen_variable_die_location
:
23803 && (! DECL_ABSTRACT_P (decl_or_origin
)
23804 /* Local static vars are shared between all clones/inlines,
23805 so emit DW_AT_location on the abstract DIE if DECL_RTL is
23807 || (VAR_P (decl_or_origin
)
23808 && TREE_STATIC (decl_or_origin
)
23809 && DECL_RTL_SET_P (decl_or_origin
))))
23812 add_pubname (decl_or_origin
, var_die
);
23814 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
23818 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
23820 if ((dwarf_version
>= 4 || !dwarf_strict
)
23821 && lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
23822 DW_AT_const_expr
) == 1
23823 && !get_AT (var_die
, DW_AT_const_expr
)
23824 && !specialization_p
)
23825 add_AT_flag (var_die
, DW_AT_const_expr
, 1);
23829 int inl
= lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
23832 && !get_AT (var_die
, DW_AT_inline
)
23833 && !specialization_p
)
23834 add_AT_unsigned (var_die
, DW_AT_inline
, inl
);
23838 /* Generate a DIE to represent a named constant. */
23841 gen_const_die (tree decl
, dw_die_ref context_die
)
23843 dw_die_ref const_die
;
23844 tree type
= TREE_TYPE (decl
);
23846 const_die
= lookup_decl_die (decl
);
23850 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
23851 equate_decl_number_to_die (decl
, const_die
);
23852 add_name_and_src_coords_attributes (const_die
, decl
);
23853 add_type_attribute (const_die
, type
, TYPE_QUAL_CONST
, false, context_die
);
23854 if (TREE_PUBLIC (decl
))
23855 add_AT_flag (const_die
, DW_AT_external
, 1);
23856 if (DECL_ARTIFICIAL (decl
))
23857 add_AT_flag (const_die
, DW_AT_artificial
, 1);
23858 tree_add_const_value_attribute_for_decl (const_die
, decl
);
23861 /* Generate a DIE to represent a label identifier. */
23864 gen_label_die (tree decl
, dw_die_ref context_die
)
23866 tree origin
= decl_ultimate_origin (decl
);
23867 dw_die_ref lbl_die
= lookup_decl_die (decl
);
23869 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
23873 lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
23874 equate_decl_number_to_die (decl
, lbl_die
);
23876 if (origin
!= NULL
)
23877 add_abstract_origin_attribute (lbl_die
, origin
);
23879 add_name_and_src_coords_attributes (lbl_die
, decl
);
23882 if (DECL_ABSTRACT_P (decl
))
23883 equate_decl_number_to_die (decl
, lbl_die
);
23884 else if (! early_dwarf
)
23886 insn
= DECL_RTL_IF_SET (decl
);
23888 /* Deleted labels are programmer specified labels which have been
23889 eliminated because of various optimizations. We still emit them
23890 here so that it is possible to put breakpoints on them. */
23894 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
23896 /* When optimization is enabled (via -O) some parts of the compiler
23897 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
23898 represent source-level labels which were explicitly declared by
23899 the user. This really shouldn't be happening though, so catch
23900 it if it ever does happen. */
23901 gcc_assert (!as_a
<rtx_insn
*> (insn
)->deleted ());
23903 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
23904 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
23908 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
23909 && CODE_LABEL_NUMBER (insn
) != -1)
23911 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
23912 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
23917 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
23918 attributes to the DIE for a block STMT, to describe where the inlined
23919 function was called from. This is similar to add_src_coords_attributes. */
23922 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
23924 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
23926 if (dwarf_version
>= 3 || !dwarf_strict
)
23928 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
23929 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
23930 if (debug_column_info
&& s
.column
)
23931 add_AT_unsigned (die
, DW_AT_call_column
, s
.column
);
23936 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
23937 Add low_pc and high_pc attributes to the DIE for a block STMT. */
23940 add_high_low_attributes (tree stmt
, dw_die_ref die
)
23942 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
23944 if (inline_entry_data
**iedp
23945 = !inline_entry_data_table
? NULL
23946 : inline_entry_data_table
->find_slot_with_hash (stmt
,
23947 htab_hash_pointer (stmt
),
23950 inline_entry_data
*ied
= *iedp
;
23951 gcc_assert (MAY_HAVE_DEBUG_MARKER_INSNS
);
23952 gcc_assert (debug_inline_points
);
23953 gcc_assert (inlined_function_outer_scope_p (stmt
));
23955 ASM_GENERATE_INTERNAL_LABEL (label
, ied
->label_pfx
, ied
->label_num
);
23956 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
23958 if (debug_variable_location_views
&& !ZERO_VIEW_P (ied
->view
)
23961 if (!output_asm_line_debug_info ())
23962 add_AT_unsigned (die
, DW_AT_GNU_entry_view
, ied
->view
);
23965 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", ied
->view
);
23966 /* FIXME: this will resolve to a small number. Could we
23967 possibly emit smaller data? Ideally we'd emit a
23968 uleb128, but that would make the size of DIEs
23969 impossible for the compiler to compute, since it's
23970 the assembler that computes the value of the view
23971 label in this case. Ideally, we'd have a single form
23972 encompassing both the address and the view, and
23973 indirecting them through a table might make things
23974 easier, but even that would be more wasteful,
23975 space-wise, than what we have now. */
23976 add_AT_symview (die
, DW_AT_GNU_entry_view
, label
);
23980 inline_entry_data_table
->clear_slot (iedp
);
23983 if (BLOCK_FRAGMENT_CHAIN (stmt
)
23984 && (dwarf_version
>= 3 || !dwarf_strict
))
23986 tree chain
, superblock
= NULL_TREE
;
23988 dw_attr_node
*attr
= NULL
;
23990 if (!debug_inline_points
&& inlined_function_outer_scope_p (stmt
))
23992 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
23993 BLOCK_NUMBER (stmt
));
23994 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
23997 /* Optimize duplicate .debug_ranges lists or even tails of
23998 lists. If this BLOCK has same ranges as its supercontext,
23999 lookup DW_AT_ranges attribute in the supercontext (and
24000 recursively so), verify that the ranges_table contains the
24001 right values and use it instead of adding a new .debug_range. */
24002 for (chain
= stmt
, pdie
= die
;
24003 BLOCK_SAME_RANGE (chain
);
24004 chain
= BLOCK_SUPERCONTEXT (chain
))
24006 dw_attr_node
*new_attr
;
24008 pdie
= pdie
->die_parent
;
24011 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
24013 new_attr
= get_AT (pdie
, DW_AT_ranges
);
24014 if (new_attr
== NULL
24015 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
24018 superblock
= BLOCK_SUPERCONTEXT (chain
);
24021 && ((*ranges_table
)[attr
->dw_attr_val
.v
.val_offset
].num
24022 == BLOCK_NUMBER (superblock
))
24023 && BLOCK_FRAGMENT_CHAIN (superblock
))
24025 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
;
24026 unsigned long supercnt
= 0, thiscnt
= 0;
24027 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
24028 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
24031 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
].num
24032 == BLOCK_NUMBER (chain
));
24034 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
+ 1].num
== 0);
24035 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
24036 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
24038 gcc_assert (supercnt
>= thiscnt
);
24039 add_AT_range_list (die
, DW_AT_ranges
, off
+ supercnt
- thiscnt
,
24041 note_rnglist_head (off
+ supercnt
- thiscnt
);
24045 unsigned int offset
= add_ranges (stmt
, true);
24046 add_AT_range_list (die
, DW_AT_ranges
, offset
, false);
24047 note_rnglist_head (offset
);
24049 bool prev_in_cold
= BLOCK_IN_COLD_SECTION_P (stmt
);
24050 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
24053 add_ranges (chain
, prev_in_cold
!= BLOCK_IN_COLD_SECTION_P (chain
));
24054 prev_in_cold
= BLOCK_IN_COLD_SECTION_P (chain
);
24055 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
24062 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
24063 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
24064 BLOCK_NUMBER (stmt
));
24065 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
24066 BLOCK_NUMBER (stmt
));
24067 add_AT_low_high_pc (die
, label
, label_high
, false);
24071 /* Generate a DIE for a lexical block. */
24074 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
)
24076 dw_die_ref old_die
= BLOCK_DIE (stmt
);
24077 dw_die_ref stmt_die
= NULL
;
24080 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
24081 BLOCK_DIE (stmt
) = stmt_die
;
24084 if (BLOCK_ABSTRACT (stmt
))
24088 /* This must have been generated early and it won't even
24089 need location information since it's a DW_AT_inline
24092 for (dw_die_ref c
= context_die
; c
; c
= c
->die_parent
)
24093 if (c
->die_tag
== DW_TAG_inlined_subroutine
24094 || c
->die_tag
== DW_TAG_subprogram
)
24096 gcc_assert (get_AT (c
, DW_AT_inline
));
24102 else if (BLOCK_ABSTRACT_ORIGIN (stmt
))
24104 /* If this is an inlined instance, create a new lexical die for
24105 anything below to attach DW_AT_abstract_origin to. */
24108 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
24109 BLOCK_DIE (stmt
) = stmt_die
;
24113 tree origin
= block_ultimate_origin (stmt
);
24114 if (origin
!= NULL_TREE
&& origin
!= stmt
)
24115 add_abstract_origin_attribute (stmt_die
, origin
);
24119 stmt_die
= old_die
;
24121 /* A non abstract block whose blocks have already been reordered
24122 should have the instruction range for this block. If so, set the
24123 high/low attributes. */
24124 if (!early_dwarf
&& !BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
24126 gcc_assert (stmt_die
);
24127 add_high_low_attributes (stmt
, stmt_die
);
24130 decls_for_scope (stmt
, stmt_die
);
24133 /* Generate a DIE for an inlined subprogram. */
24136 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
)
24140 /* The instance of function that is effectively being inlined shall not
24142 gcc_assert (! BLOCK_ABSTRACT (stmt
));
24144 decl
= block_ultimate_origin (stmt
);
24146 /* Make sure any inlined functions are known to be inlineable. */
24147 gcc_checking_assert (DECL_ABSTRACT_P (decl
)
24148 || cgraph_function_possibly_inlined_p (decl
));
24150 if (! BLOCK_ABSTRACT (stmt
))
24152 dw_die_ref subr_die
24153 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
24155 if (call_arg_locations
|| debug_inline_points
)
24156 BLOCK_DIE (stmt
) = subr_die
;
24157 add_abstract_origin_attribute (subr_die
, decl
);
24158 if (TREE_ASM_WRITTEN (stmt
))
24159 add_high_low_attributes (stmt
, subr_die
);
24160 add_call_src_coords_attributes (stmt
, subr_die
);
24162 decls_for_scope (stmt
, subr_die
);
24166 /* Generate a DIE for a field in a record, or structure. CTX is required: see
24167 the comment for VLR_CONTEXT. */
24170 gen_field_die (tree decl
, struct vlr_context
*ctx
, dw_die_ref context_die
)
24172 dw_die_ref decl_die
;
24174 if (TREE_TYPE (decl
) == error_mark_node
)
24177 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
24178 add_name_and_src_coords_attributes (decl_die
, decl
);
24179 add_type_attribute (decl_die
, member_declared_type (decl
), decl_quals (decl
),
24180 TYPE_REVERSE_STORAGE_ORDER (DECL_FIELD_CONTEXT (decl
)),
24183 if (DECL_BIT_FIELD_TYPE (decl
))
24185 add_byte_size_attribute (decl_die
, decl
);
24186 add_bit_size_attribute (decl_die
, decl
);
24187 add_bit_offset_attribute (decl_die
, decl
, ctx
);
24190 add_alignment_attribute (decl_die
, decl
);
24192 /* If we have a variant part offset, then we are supposed to process a member
24193 of a QUAL_UNION_TYPE, which is how we represent variant parts in
24195 gcc_assert (ctx
->variant_part_offset
== NULL_TREE
24196 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != QUAL_UNION_TYPE
);
24197 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
24198 add_data_member_location_attribute (decl_die
, decl
, ctx
);
24200 if (DECL_ARTIFICIAL (decl
))
24201 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
24203 add_accessibility_attribute (decl_die
, decl
);
24205 /* Equate decl number to die, so that we can look up this decl later on. */
24206 equate_decl_number_to_die (decl
, decl_die
);
24209 /* Generate a DIE for a pointer to a member type. TYPE can be an
24210 OFFSET_TYPE, for a pointer to data member, or a RECORD_TYPE, for a
24211 pointer to member function. */
24214 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
24216 if (lookup_type_die (type
))
24219 dw_die_ref ptr_die
= new_die (DW_TAG_ptr_to_member_type
,
24220 scope_die_for (type
, context_die
), type
);
24222 equate_type_number_to_die (type
, ptr_die
);
24223 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
24224 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
24225 add_type_attribute (ptr_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
24227 add_alignment_attribute (ptr_die
, type
);
24229 if (TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
24230 && TREE_CODE (TREE_TYPE (type
)) != METHOD_TYPE
)
24232 dw_loc_descr_ref op
= new_loc_descr (DW_OP_plus
, 0, 0);
24233 add_AT_loc (ptr_die
, DW_AT_use_location
, op
);
24237 static char *producer_string
;
24239 /* Return a heap allocated producer string including command line options
24240 if -grecord-gcc-switches. */
24243 gen_producer_string (void)
24246 auto_vec
<const char *> switches
;
24247 const char *language_string
= lang_hooks
.name
;
24248 char *producer
, *tail
;
24250 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
24251 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
24253 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
24254 switch (save_decoded_options
[j
].opt_index
)
24261 case OPT_auxbase_strip
:
24270 case OPT_SPECIAL_unknown
:
24271 case OPT_SPECIAL_ignore
:
24272 case OPT_SPECIAL_deprecated
:
24273 case OPT_SPECIAL_program_name
:
24274 case OPT_SPECIAL_input_file
:
24275 case OPT_grecord_gcc_switches
:
24276 case OPT__output_pch_
:
24277 case OPT_fdiagnostics_show_location_
:
24278 case OPT_fdiagnostics_show_option
:
24279 case OPT_fdiagnostics_show_caret
:
24280 case OPT_fdiagnostics_show_labels
:
24281 case OPT_fdiagnostics_show_line_numbers
:
24282 case OPT_fdiagnostics_color_
:
24283 case OPT_fverbose_asm
:
24285 case OPT__sysroot_
:
24287 case OPT_nostdinc__
:
24288 case OPT_fpreprocessed
:
24289 case OPT_fltrans_output_list_
:
24290 case OPT_fresolution_
:
24291 case OPT_fdebug_prefix_map_
:
24292 case OPT_fmacro_prefix_map_
:
24293 case OPT_ffile_prefix_map_
:
24294 case OPT_fcompare_debug
:
24295 case OPT_fchecking
:
24296 case OPT_fchecking_
:
24297 /* Ignore these. */
24300 if (cl_options
[save_decoded_options
[j
].opt_index
].flags
24301 & CL_NO_DWARF_RECORD
)
24303 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
24305 switch (save_decoded_options
[j
].canonical_option
[0][1])
24312 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
24319 switches
.safe_push (save_decoded_options
[j
].orig_option_with_args_text
);
24320 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
24324 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
24326 sprintf (tail
, "%s %s", language_string
, version_string
);
24329 FOR_EACH_VEC_ELT (switches
, j
, p
)
24333 memcpy (tail
+ 1, p
, len
);
24341 /* Given a C and/or C++ language/version string return the "highest".
24342 C++ is assumed to be "higher" than C in this case. Used for merging
24343 LTO translation unit languages. */
24344 static const char *
24345 highest_c_language (const char *lang1
, const char *lang2
)
24347 if (strcmp ("GNU C++17", lang1
) == 0 || strcmp ("GNU C++17", lang2
) == 0)
24348 return "GNU C++17";
24349 if (strcmp ("GNU C++14", lang1
) == 0 || strcmp ("GNU C++14", lang2
) == 0)
24350 return "GNU C++14";
24351 if (strcmp ("GNU C++11", lang1
) == 0 || strcmp ("GNU C++11", lang2
) == 0)
24352 return "GNU C++11";
24353 if (strcmp ("GNU C++98", lang1
) == 0 || strcmp ("GNU C++98", lang2
) == 0)
24354 return "GNU C++98";
24356 if (strcmp ("GNU C17", lang1
) == 0 || strcmp ("GNU C17", lang2
) == 0)
24358 if (strcmp ("GNU C11", lang1
) == 0 || strcmp ("GNU C11", lang2
) == 0)
24360 if (strcmp ("GNU C99", lang1
) == 0 || strcmp ("GNU C99", lang2
) == 0)
24362 if (strcmp ("GNU C89", lang1
) == 0 || strcmp ("GNU C89", lang2
) == 0)
24365 gcc_unreachable ();
24369 /* Generate the DIE for the compilation unit. */
24372 gen_compile_unit_die (const char *filename
)
24375 const char *language_string
= lang_hooks
.name
;
24378 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
24382 add_name_attribute (die
, filename
);
24383 /* Don't add cwd for <built-in>. */
24384 if (filename
[0] != '<')
24385 add_comp_dir_attribute (die
);
24388 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
24390 /* If our producer is LTO try to figure out a common language to use
24391 from the global list of translation units. */
24392 if (strcmp (language_string
, "GNU GIMPLE") == 0)
24396 const char *common_lang
= NULL
;
24398 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
24400 if (!TRANSLATION_UNIT_LANGUAGE (t
))
24403 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
24404 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
24406 else if (strncmp (common_lang
, "GNU C", 5) == 0
24407 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
24408 /* Mixing C and C++ is ok, use C++ in that case. */
24409 common_lang
= highest_c_language (common_lang
,
24410 TRANSLATION_UNIT_LANGUAGE (t
));
24413 /* Fall back to C. */
24414 common_lang
= NULL
;
24420 language_string
= common_lang
;
24423 language
= DW_LANG_C
;
24424 if (strncmp (language_string
, "GNU C", 5) == 0
24425 && ISDIGIT (language_string
[5]))
24427 language
= DW_LANG_C89
;
24428 if (dwarf_version
>= 3 || !dwarf_strict
)
24430 if (strcmp (language_string
, "GNU C89") != 0)
24431 language
= DW_LANG_C99
;
24433 if (dwarf_version
>= 5 /* || !dwarf_strict */)
24434 if (strcmp (language_string
, "GNU C11") == 0
24435 || strcmp (language_string
, "GNU C17") == 0)
24436 language
= DW_LANG_C11
;
24439 else if (strncmp (language_string
, "GNU C++", 7) == 0)
24441 language
= DW_LANG_C_plus_plus
;
24442 if (dwarf_version
>= 5 /* || !dwarf_strict */)
24444 if (strcmp (language_string
, "GNU C++11") == 0)
24445 language
= DW_LANG_C_plus_plus_11
;
24446 else if (strcmp (language_string
, "GNU C++14") == 0)
24447 language
= DW_LANG_C_plus_plus_14
;
24448 else if (strcmp (language_string
, "GNU C++17") == 0)
24450 language
= DW_LANG_C_plus_plus_14
;
24453 else if (strcmp (language_string
, "GNU F77") == 0)
24454 language
= DW_LANG_Fortran77
;
24455 else if (dwarf_version
>= 3 || !dwarf_strict
)
24457 if (strcmp (language_string
, "GNU Ada") == 0)
24458 language
= DW_LANG_Ada95
;
24459 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
24461 language
= DW_LANG_Fortran95
;
24462 if (dwarf_version
>= 5 /* || !dwarf_strict */)
24464 if (strcmp (language_string
, "GNU Fortran2003") == 0)
24465 language
= DW_LANG_Fortran03
;
24466 else if (strcmp (language_string
, "GNU Fortran2008") == 0)
24467 language
= DW_LANG_Fortran08
;
24470 else if (strcmp (language_string
, "GNU Objective-C") == 0)
24471 language
= DW_LANG_ObjC
;
24472 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
24473 language
= DW_LANG_ObjC_plus_plus
;
24474 else if (dwarf_version
>= 5 || !dwarf_strict
)
24476 if (strcmp (language_string
, "GNU Go") == 0)
24477 language
= DW_LANG_Go
;
24480 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
24481 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
24482 language
= DW_LANG_Fortran90
;
24483 /* Likewise for Ada. */
24484 else if (strcmp (language_string
, "GNU Ada") == 0)
24485 language
= DW_LANG_Ada83
;
24487 add_AT_unsigned (die
, DW_AT_language
, language
);
24491 case DW_LANG_Fortran77
:
24492 case DW_LANG_Fortran90
:
24493 case DW_LANG_Fortran95
:
24494 case DW_LANG_Fortran03
:
24495 case DW_LANG_Fortran08
:
24496 /* Fortran has case insensitive identifiers and the front-end
24497 lowercases everything. */
24498 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
24501 /* The default DW_ID_case_sensitive doesn't need to be specified. */
24507 /* Generate the DIE for a base class. */
24510 gen_inheritance_die (tree binfo
, tree access
, tree type
,
24511 dw_die_ref context_die
)
24513 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
24514 struct vlr_context ctx
= { type
, NULL
};
24516 add_type_attribute (die
, BINFO_TYPE (binfo
), TYPE_UNQUALIFIED
, false,
24518 add_data_member_location_attribute (die
, binfo
, &ctx
);
24520 if (BINFO_VIRTUAL_P (binfo
))
24521 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
24523 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
24524 children, otherwise the default is DW_ACCESS_public. In DWARF2
24525 the default has always been DW_ACCESS_private. */
24526 if (access
== access_public_node
)
24528 if (dwarf_version
== 2
24529 || context_die
->die_tag
== DW_TAG_class_type
)
24530 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
24532 else if (access
== access_protected_node
)
24533 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
24534 else if (dwarf_version
> 2
24535 && context_die
->die_tag
!= DW_TAG_class_type
)
24536 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
24539 /* Return whether DECL is a FIELD_DECL that represents the variant part of a
24542 is_variant_part (tree decl
)
24544 return (TREE_CODE (decl
) == FIELD_DECL
24545 && TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
);
24548 /* Check that OPERAND is a reference to a field in STRUCT_TYPE. If it is,
24549 return the FIELD_DECL. Return NULL_TREE otherwise. */
24552 analyze_discr_in_predicate (tree operand
, tree struct_type
)
24554 bool continue_stripping
= true;
24555 while (continue_stripping
)
24556 switch (TREE_CODE (operand
))
24559 operand
= TREE_OPERAND (operand
, 0);
24562 continue_stripping
= false;
24566 /* Match field access to members of struct_type only. */
24567 if (TREE_CODE (operand
) == COMPONENT_REF
24568 && TREE_CODE (TREE_OPERAND (operand
, 0)) == PLACEHOLDER_EXPR
24569 && TREE_TYPE (TREE_OPERAND (operand
, 0)) == struct_type
24570 && TREE_CODE (TREE_OPERAND (operand
, 1)) == FIELD_DECL
)
24571 return TREE_OPERAND (operand
, 1);
24576 /* Check that SRC is a constant integer that can be represented as a native
24577 integer constant (either signed or unsigned). If so, store it into DEST and
24578 return true. Return false otherwise. */
24581 get_discr_value (tree src
, dw_discr_value
*dest
)
24583 tree discr_type
= TREE_TYPE (src
);
24585 if (lang_hooks
.types
.get_debug_type
)
24587 tree debug_type
= lang_hooks
.types
.get_debug_type (discr_type
);
24588 if (debug_type
!= NULL
)
24589 discr_type
= debug_type
;
24592 if (TREE_CODE (src
) != INTEGER_CST
|| !INTEGRAL_TYPE_P (discr_type
))
24595 /* Signedness can vary between the original type and the debug type. This
24596 can happen for character types in Ada for instance: the character type
24597 used for code generation can be signed, to be compatible with the C one,
24598 but from a debugger point of view, it must be unsigned. */
24599 bool is_orig_unsigned
= TYPE_UNSIGNED (TREE_TYPE (src
));
24600 bool is_debug_unsigned
= TYPE_UNSIGNED (discr_type
);
24602 if (is_orig_unsigned
!= is_debug_unsigned
)
24603 src
= fold_convert (discr_type
, src
);
24605 if (!(is_debug_unsigned
? tree_fits_uhwi_p (src
) : tree_fits_shwi_p (src
)))
24608 dest
->pos
= is_debug_unsigned
;
24609 if (is_debug_unsigned
)
24610 dest
->v
.uval
= tree_to_uhwi (src
);
24612 dest
->v
.sval
= tree_to_shwi (src
);
24617 /* Try to extract synthetic properties out of VARIANT_PART_DECL, which is a
24618 FIELD_DECL in STRUCT_TYPE that represents a variant part. If unsuccessful,
24619 store NULL_TREE in DISCR_DECL. Otherwise:
24621 - store the discriminant field in STRUCT_TYPE that controls the variant
24622 part to *DISCR_DECL
24624 - put in *DISCR_LISTS_P an array where for each variant, the item
24625 represents the corresponding matching list of discriminant values.
24627 - put in *DISCR_LISTS_LENGTH the number of variants, which is the size of
24630 Note that when the array is allocated (i.e. when the analysis is
24631 successful), it is up to the caller to free the array. */
24634 analyze_variants_discr (tree variant_part_decl
,
24637 dw_discr_list_ref
**discr_lists_p
,
24638 unsigned *discr_lists_length
)
24640 tree variant_part_type
= TREE_TYPE (variant_part_decl
);
24642 dw_discr_list_ref
*discr_lists
;
24645 /* Compute how many variants there are in this variant part. */
24646 *discr_lists_length
= 0;
24647 for (variant
= TYPE_FIELDS (variant_part_type
);
24648 variant
!= NULL_TREE
;
24649 variant
= DECL_CHAIN (variant
))
24650 ++*discr_lists_length
;
24652 *discr_decl
= NULL_TREE
;
24654 = (dw_discr_list_ref
*) xcalloc (*discr_lists_length
,
24655 sizeof (**discr_lists_p
));
24656 discr_lists
= *discr_lists_p
;
24658 /* And then analyze all variants to extract discriminant information for all
24659 of them. This analysis is conservative: as soon as we detect something we
24660 do not support, abort everything and pretend we found nothing. */
24661 for (variant
= TYPE_FIELDS (variant_part_type
), i
= 0;
24662 variant
!= NULL_TREE
;
24663 variant
= DECL_CHAIN (variant
), ++i
)
24665 tree match_expr
= DECL_QUALIFIER (variant
);
24667 /* Now, try to analyze the predicate and deduce a discriminant for
24669 if (match_expr
== boolean_true_node
)
24670 /* Typically happens for the default variant: it matches all cases that
24671 previous variants rejected. Don't output any matching value for
24675 /* The following loop tries to iterate over each discriminant
24676 possibility: single values or ranges. */
24677 while (match_expr
!= NULL_TREE
)
24679 tree next_round_match_expr
;
24680 tree candidate_discr
= NULL_TREE
;
24681 dw_discr_list_ref new_node
= NULL
;
24683 /* Possibilities are matched one after the other by nested
24684 TRUTH_ORIF_EXPR expressions. Process the current possibility and
24685 continue with the rest at next iteration. */
24686 if (TREE_CODE (match_expr
) == TRUTH_ORIF_EXPR
)
24688 next_round_match_expr
= TREE_OPERAND (match_expr
, 0);
24689 match_expr
= TREE_OPERAND (match_expr
, 1);
24692 next_round_match_expr
= NULL_TREE
;
24694 if (match_expr
== boolean_false_node
)
24695 /* This sub-expression matches nothing: just wait for the next
24699 else if (TREE_CODE (match_expr
) == EQ_EXPR
)
24701 /* We are matching: <discr_field> == <integer_cst>
24702 This sub-expression matches a single value. */
24703 tree integer_cst
= TREE_OPERAND (match_expr
, 1);
24706 = analyze_discr_in_predicate (TREE_OPERAND (match_expr
, 0),
24709 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
24710 if (!get_discr_value (integer_cst
,
24711 &new_node
->dw_discr_lower_bound
))
24713 new_node
->dw_discr_range
= false;
24716 else if (TREE_CODE (match_expr
) == TRUTH_ANDIF_EXPR
)
24718 /* We are matching:
24719 <discr_field> > <integer_cst>
24720 && <discr_field> < <integer_cst>.
24721 This sub-expression matches the range of values between the
24722 two matched integer constants. Note that comparisons can be
24723 inclusive or exclusive. */
24724 tree candidate_discr_1
, candidate_discr_2
;
24725 tree lower_cst
, upper_cst
;
24726 bool lower_cst_included
, upper_cst_included
;
24727 tree lower_op
= TREE_OPERAND (match_expr
, 0);
24728 tree upper_op
= TREE_OPERAND (match_expr
, 1);
24730 /* When the comparison is exclusive, the integer constant is not
24731 the discriminant range bound we are looking for: we will have
24732 to increment or decrement it. */
24733 if (TREE_CODE (lower_op
) == GE_EXPR
)
24734 lower_cst_included
= true;
24735 else if (TREE_CODE (lower_op
) == GT_EXPR
)
24736 lower_cst_included
= false;
24740 if (TREE_CODE (upper_op
) == LE_EXPR
)
24741 upper_cst_included
= true;
24742 else if (TREE_CODE (upper_op
) == LT_EXPR
)
24743 upper_cst_included
= false;
24747 /* Extract the discriminant from the first operand and check it
24748 is consistant with the same analysis in the second
24751 = analyze_discr_in_predicate (TREE_OPERAND (lower_op
, 0),
24754 = analyze_discr_in_predicate (TREE_OPERAND (upper_op
, 0),
24756 if (candidate_discr_1
== candidate_discr_2
)
24757 candidate_discr
= candidate_discr_1
;
24761 /* Extract bounds from both. */
24762 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
24763 lower_cst
= TREE_OPERAND (lower_op
, 1);
24764 upper_cst
= TREE_OPERAND (upper_op
, 1);
24766 if (!lower_cst_included
)
24768 = fold_build2 (PLUS_EXPR
, TREE_TYPE (lower_cst
), lower_cst
,
24769 build_int_cst (TREE_TYPE (lower_cst
), 1));
24770 if (!upper_cst_included
)
24772 = fold_build2 (MINUS_EXPR
, TREE_TYPE (upper_cst
), upper_cst
,
24773 build_int_cst (TREE_TYPE (upper_cst
), 1));
24775 if (!get_discr_value (lower_cst
,
24776 &new_node
->dw_discr_lower_bound
)
24777 || !get_discr_value (upper_cst
,
24778 &new_node
->dw_discr_upper_bound
))
24781 new_node
->dw_discr_range
= true;
24785 /* Unsupported sub-expression: we cannot determine the set of
24786 matching discriminant values. Abort everything. */
24789 /* If the discriminant info is not consistant with what we saw so
24790 far, consider the analysis failed and abort everything. */
24791 if (candidate_discr
== NULL_TREE
24792 || (*discr_decl
!= NULL_TREE
&& candidate_discr
!= *discr_decl
))
24795 *discr_decl
= candidate_discr
;
24797 if (new_node
!= NULL
)
24799 new_node
->dw_discr_next
= discr_lists
[i
];
24800 discr_lists
[i
] = new_node
;
24802 match_expr
= next_round_match_expr
;
24806 /* If we reach this point, we could match everything we were interested
24811 /* Clean all data structure and return no result. */
24812 free (*discr_lists_p
);
24813 *discr_lists_p
= NULL
;
24814 *discr_decl
= NULL_TREE
;
24817 /* Generate a DIE to represent VARIANT_PART_DECL, a variant part that is part
24818 of STRUCT_TYPE, a record type. This new DIE is emitted as the next child
24821 Variant parts are supposed to be implemented as a FIELD_DECL whose type is a
24822 QUAL_UNION_TYPE: this is the VARIANT_PART_DECL parameter. The members for
24823 this type, which are record types, represent the available variants and each
24824 has a DECL_QUALIFIER attribute. The discriminant and the discriminant
24825 values are inferred from these attributes.
24827 In trees, the offsets for the fields inside these sub-records are relative
24828 to the variant part itself, whereas the corresponding DIEs should have
24829 offset attributes that are relative to the embedding record base address.
24830 This is why the caller must provide a VARIANT_PART_OFFSET expression: it
24831 must be an expression that computes the offset of the variant part to
24832 describe in DWARF. */
24835 gen_variant_part (tree variant_part_decl
, struct vlr_context
*vlr_ctx
,
24836 dw_die_ref context_die
)
24838 const tree variant_part_type
= TREE_TYPE (variant_part_decl
);
24839 tree variant_part_offset
= vlr_ctx
->variant_part_offset
;
24840 struct loc_descr_context ctx
= {
24841 vlr_ctx
->struct_type
, /* context_type */
24842 NULL_TREE
, /* base_decl */
24844 false, /* placeholder_arg */
24845 false /* placeholder_seen */
24848 /* The FIELD_DECL node in STRUCT_TYPE that acts as the discriminant, or
24849 NULL_TREE if there is no such field. */
24850 tree discr_decl
= NULL_TREE
;
24851 dw_discr_list_ref
*discr_lists
;
24852 unsigned discr_lists_length
= 0;
24855 dw_die_ref dwarf_proc_die
= NULL
;
24856 dw_die_ref variant_part_die
24857 = new_die (DW_TAG_variant_part
, context_die
, variant_part_type
);
24859 equate_decl_number_to_die (variant_part_decl
, variant_part_die
);
24861 analyze_variants_discr (variant_part_decl
, vlr_ctx
->struct_type
,
24862 &discr_decl
, &discr_lists
, &discr_lists_length
);
24864 if (discr_decl
!= NULL_TREE
)
24866 dw_die_ref discr_die
= lookup_decl_die (discr_decl
);
24869 add_AT_die_ref (variant_part_die
, DW_AT_discr
, discr_die
);
24871 /* We have no DIE for the discriminant, so just discard all
24872 discrimimant information in the output. */
24873 discr_decl
= NULL_TREE
;
24876 /* If the offset for this variant part is more complex than a constant,
24877 create a DWARF procedure for it so that we will not have to generate DWARF
24878 expressions for it for each member. */
24879 if (TREE_CODE (variant_part_offset
) != INTEGER_CST
24880 && (dwarf_version
>= 3 || !dwarf_strict
))
24882 const tree dwarf_proc_fndecl
24883 = build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
24884 build_function_type (TREE_TYPE (variant_part_offset
),
24886 const tree dwarf_proc_call
= build_call_expr (dwarf_proc_fndecl
, 0);
24887 const dw_loc_descr_ref dwarf_proc_body
24888 = loc_descriptor_from_tree (variant_part_offset
, 0, &ctx
);
24890 dwarf_proc_die
= new_dwarf_proc_die (dwarf_proc_body
,
24891 dwarf_proc_fndecl
, context_die
);
24892 if (dwarf_proc_die
!= NULL
)
24893 variant_part_offset
= dwarf_proc_call
;
24896 /* Output DIEs for all variants. */
24898 for (tree variant
= TYPE_FIELDS (variant_part_type
);
24899 variant
!= NULL_TREE
;
24900 variant
= DECL_CHAIN (variant
), ++i
)
24902 tree variant_type
= TREE_TYPE (variant
);
24903 dw_die_ref variant_die
;
24905 /* All variants (i.e. members of a variant part) are supposed to be
24906 encoded as structures. Sub-variant parts are QUAL_UNION_TYPE fields
24907 under these records. */
24908 gcc_assert (TREE_CODE (variant_type
) == RECORD_TYPE
);
24910 variant_die
= new_die (DW_TAG_variant
, variant_part_die
, variant_type
);
24911 equate_decl_number_to_die (variant
, variant_die
);
24913 /* Output discriminant values this variant matches, if any. */
24914 if (discr_decl
== NULL
|| discr_lists
[i
] == NULL
)
24915 /* In the case we have discriminant information at all, this is
24916 probably the default variant: as the standard says, don't
24917 output any discriminant value/list attribute. */
24919 else if (discr_lists
[i
]->dw_discr_next
== NULL
24920 && !discr_lists
[i
]->dw_discr_range
)
24921 /* If there is only one accepted value, don't bother outputting a
24923 add_discr_value (variant_die
, &discr_lists
[i
]->dw_discr_lower_bound
);
24925 add_discr_list (variant_die
, discr_lists
[i
]);
24927 for (tree member
= TYPE_FIELDS (variant_type
);
24928 member
!= NULL_TREE
;
24929 member
= DECL_CHAIN (member
))
24931 struct vlr_context vlr_sub_ctx
= {
24932 vlr_ctx
->struct_type
, /* struct_type */
24933 NULL
/* variant_part_offset */
24935 if (is_variant_part (member
))
24937 /* All offsets for fields inside variant parts are relative to
24938 the top-level embedding RECORD_TYPE's base address. On the
24939 other hand, offsets in GCC's types are relative to the
24940 nested-most variant part. So we have to sum offsets each time
24943 vlr_sub_ctx
.variant_part_offset
24944 = fold_build2 (PLUS_EXPR
, TREE_TYPE (variant_part_offset
),
24945 variant_part_offset
, byte_position (member
));
24946 gen_variant_part (member
, &vlr_sub_ctx
, variant_die
);
24950 vlr_sub_ctx
.variant_part_offset
= variant_part_offset
;
24951 gen_decl_die (member
, NULL
, &vlr_sub_ctx
, variant_die
);
24956 free (discr_lists
);
24959 /* Generate a DIE for a class member. */
24962 gen_member_die (tree type
, dw_die_ref context_die
)
24965 tree binfo
= TYPE_BINFO (type
);
24967 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
24969 /* If this is not an incomplete type, output descriptions of each of its
24970 members. Note that as we output the DIEs necessary to represent the
24971 members of this record or union type, we will also be trying to output
24972 DIEs to represent the *types* of those members. However the `type'
24973 function (above) will specifically avoid generating type DIEs for member
24974 types *within* the list of member DIEs for this (containing) type except
24975 for those types (of members) which are explicitly marked as also being
24976 members of this (containing) type themselves. The g++ front- end can
24977 force any given type to be treated as a member of some other (containing)
24978 type by setting the TYPE_CONTEXT of the given (member) type to point to
24979 the TREE node representing the appropriate (containing) type. */
24981 /* First output info about the base classes. */
24984 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
24988 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
24989 gen_inheritance_die (base
,
24990 (accesses
? (*accesses
)[i
] : access_public_node
),
24995 /* Now output info about the data members and type members. */
24996 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
24998 struct vlr_context vlr_ctx
= { type
, NULL_TREE
};
24999 bool static_inline_p
25000 = (TREE_STATIC (member
)
25001 && (lang_hooks
.decls
.decl_dwarf_attribute (member
, DW_AT_inline
)
25004 /* Ignore clones. */
25005 if (DECL_ABSTRACT_ORIGIN (member
))
25008 /* If we thought we were generating minimal debug info for TYPE
25009 and then changed our minds, some of the member declarations
25010 may have already been defined. Don't define them again, but
25011 do put them in the right order. */
25013 if (dw_die_ref child
= lookup_decl_die (member
))
25015 /* Handle inline static data members, which only have in-class
25017 dw_die_ref ref
= NULL
;
25018 if (child
->die_tag
== DW_TAG_variable
25019 && child
->die_parent
== comp_unit_die ())
25021 ref
= get_AT_ref (child
, DW_AT_specification
);
25022 /* For C++17 inline static data members followed by redundant
25023 out of class redeclaration, we might get here with
25024 child being the DIE created for the out of class
25025 redeclaration and with its DW_AT_specification being
25026 the DIE created for in-class definition. We want to
25027 reparent the latter, and don't want to create another
25028 DIE with DW_AT_specification in that case, because
25029 we already have one. */
25032 && ref
->die_tag
== DW_TAG_variable
25033 && ref
->die_parent
== comp_unit_die ()
25034 && get_AT (ref
, DW_AT_specification
) == NULL
)
25038 static_inline_p
= false;
25042 if (child
->die_tag
== DW_TAG_variable
25043 && child
->die_parent
== comp_unit_die ()
25046 reparent_child (child
, context_die
);
25047 if (dwarf_version
< 5)
25048 child
->die_tag
= DW_TAG_member
;
25051 splice_child_die (context_die
, child
);
25054 /* Do not generate standard DWARF for variant parts if we are generating
25055 the corresponding GNAT encodings: DIEs generated for both would
25056 conflict in our mappings. */
25057 else if (is_variant_part (member
)
25058 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
)
25060 vlr_ctx
.variant_part_offset
= byte_position (member
);
25061 gen_variant_part (member
, &vlr_ctx
, context_die
);
25065 vlr_ctx
.variant_part_offset
= NULL_TREE
;
25066 gen_decl_die (member
, NULL
, &vlr_ctx
, context_die
);
25069 /* For C++ inline static data members emit immediately a DW_TAG_variable
25070 DIE that will refer to that DW_TAG_member/DW_TAG_variable through
25071 DW_AT_specification. */
25072 if (static_inline_p
)
25074 int old_extern
= DECL_EXTERNAL (member
);
25075 DECL_EXTERNAL (member
) = 0;
25076 gen_decl_die (member
, NULL
, NULL
, comp_unit_die ());
25077 DECL_EXTERNAL (member
) = old_extern
;
25082 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
25083 is set, we pretend that the type was never defined, so we only get the
25084 member DIEs needed by later specification DIEs. */
25087 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
25088 enum debug_info_usage usage
)
25090 if (TREE_ASM_WRITTEN (type
))
25092 /* Fill in the bound of variable-length fields in late dwarf if
25093 still incomplete. */
25094 if (!early_dwarf
&& variably_modified_type_p (type
, NULL
))
25095 for (tree member
= TYPE_FIELDS (type
);
25097 member
= DECL_CHAIN (member
))
25098 fill_variable_array_bounds (TREE_TYPE (member
));
25102 dw_die_ref type_die
= lookup_type_die (type
);
25103 dw_die_ref scope_die
= 0;
25105 int complete
= (TYPE_SIZE (type
)
25106 && (! TYPE_STUB_DECL (type
)
25107 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
25108 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
25109 complete
= complete
&& should_emit_struct_debug (type
, usage
);
25111 if (type_die
&& ! complete
)
25114 if (TYPE_CONTEXT (type
) != NULL_TREE
25115 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
25116 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
25119 scope_die
= scope_die_for (type
, context_die
);
25121 /* Generate child dies for template paramaters. */
25122 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
25123 schedule_generic_params_dies_gen (type
);
25125 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
25126 /* First occurrence of type or toplevel definition of nested class. */
25128 dw_die_ref old_die
= type_die
;
25130 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
25131 ? record_type_tag (type
) : DW_TAG_union_type
,
25133 equate_type_number_to_die (type
, type_die
);
25135 add_AT_specification (type_die
, old_die
);
25137 add_name_attribute (type_die
, type_tag (type
));
25140 remove_AT (type_die
, DW_AT_declaration
);
25142 /* If this type has been completed, then give it a byte_size attribute and
25143 then give a list of members. */
25144 if (complete
&& !ns_decl
)
25146 /* Prevent infinite recursion in cases where the type of some member of
25147 this type is expressed in terms of this type itself. */
25148 TREE_ASM_WRITTEN (type
) = 1;
25149 add_byte_size_attribute (type_die
, type
);
25150 add_alignment_attribute (type_die
, type
);
25151 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
25153 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
25154 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
25157 /* If the first reference to this type was as the return type of an
25158 inline function, then it may not have a parent. Fix this now. */
25159 if (type_die
->die_parent
== NULL
)
25160 add_child_die (scope_die
, type_die
);
25162 gen_member_die (type
, type_die
);
25164 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
25165 if (TYPE_ARTIFICIAL (type
))
25166 add_AT_flag (type_die
, DW_AT_artificial
, 1);
25168 /* GNU extension: Record what type our vtable lives in. */
25169 if (TYPE_VFIELD (type
))
25171 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
25173 gen_type_die (vtype
, context_die
);
25174 add_AT_die_ref (type_die
, DW_AT_containing_type
,
25175 lookup_type_die (vtype
));
25180 add_AT_flag (type_die
, DW_AT_declaration
, 1);
25182 /* We don't need to do this for function-local types. */
25183 if (TYPE_STUB_DECL (type
)
25184 && ! decl_function_context (TYPE_STUB_DECL (type
)))
25185 vec_safe_push (incomplete_types
, type
);
25188 if (get_AT (type_die
, DW_AT_name
))
25189 add_pubtype (type
, type_die
);
25192 /* Generate a DIE for a subroutine _type_. */
25195 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
25197 tree return_type
= TREE_TYPE (type
);
25198 dw_die_ref subr_die
25199 = new_die (DW_TAG_subroutine_type
,
25200 scope_die_for (type
, context_die
), type
);
25202 equate_type_number_to_die (type
, subr_die
);
25203 add_prototyped_attribute (subr_die
, type
);
25204 add_type_attribute (subr_die
, return_type
, TYPE_UNQUALIFIED
, false,
25206 add_alignment_attribute (subr_die
, type
);
25207 gen_formal_types_die (type
, subr_die
);
25209 if (get_AT (subr_die
, DW_AT_name
))
25210 add_pubtype (type
, subr_die
);
25211 if ((dwarf_version
>= 5 || !dwarf_strict
)
25212 && lang_hooks
.types
.type_dwarf_attribute (type
, DW_AT_reference
) != -1)
25213 add_AT_flag (subr_die
, DW_AT_reference
, 1);
25214 if ((dwarf_version
>= 5 || !dwarf_strict
)
25215 && lang_hooks
.types
.type_dwarf_attribute (type
,
25216 DW_AT_rvalue_reference
) != -1)
25217 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
25220 /* Generate a DIE for a type definition. */
25223 gen_typedef_die (tree decl
, dw_die_ref context_die
)
25225 dw_die_ref type_die
;
25228 if (TREE_ASM_WRITTEN (decl
))
25230 if (DECL_ORIGINAL_TYPE (decl
))
25231 fill_variable_array_bounds (DECL_ORIGINAL_TYPE (decl
));
25235 /* As we avoid creating DIEs for local typedefs (see decl_ultimate_origin
25236 checks in process_scope_var and modified_type_die), this should be called
25237 only for original types. */
25238 gcc_assert (decl_ultimate_origin (decl
) == NULL
25239 || decl_ultimate_origin (decl
) == decl
);
25241 TREE_ASM_WRITTEN (decl
) = 1;
25242 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
25244 add_name_and_src_coords_attributes (type_die
, decl
);
25245 if (DECL_ORIGINAL_TYPE (decl
))
25247 type
= DECL_ORIGINAL_TYPE (decl
);
25248 if (type
== error_mark_node
)
25251 gcc_assert (type
!= TREE_TYPE (decl
));
25252 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
25256 type
= TREE_TYPE (decl
);
25257 if (type
== error_mark_node
)
25260 if (is_naming_typedef_decl (TYPE_NAME (type
)))
25262 /* Here, we are in the case of decl being a typedef naming
25263 an anonymous type, e.g:
25264 typedef struct {...} foo;
25265 In that case TREE_TYPE (decl) is not a typedef variant
25266 type and TYPE_NAME of the anonymous type is set to the
25267 TYPE_DECL of the typedef. This construct is emitted by
25270 TYPE is the anonymous struct named by the typedef
25271 DECL. As we need the DW_AT_type attribute of the
25272 DW_TAG_typedef to point to the DIE of TYPE, let's
25273 generate that DIE right away. add_type_attribute
25274 called below will then pick (via lookup_type_die) that
25275 anonymous struct DIE. */
25276 if (!TREE_ASM_WRITTEN (type
))
25277 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
25279 /* This is a GNU Extension. We are adding a
25280 DW_AT_linkage_name attribute to the DIE of the
25281 anonymous struct TYPE. The value of that attribute
25282 is the name of the typedef decl naming the anonymous
25283 struct. This greatly eases the work of consumers of
25284 this debug info. */
25285 add_linkage_name_raw (lookup_type_die (type
), decl
);
25289 add_type_attribute (type_die
, type
, decl_quals (decl
), false,
25292 if (is_naming_typedef_decl (decl
))
25293 /* We want that all subsequent calls to lookup_type_die with
25294 TYPE in argument yield the DW_TAG_typedef we have just
25296 equate_type_number_to_die (type
, type_die
);
25298 add_alignment_attribute (type_die
, TREE_TYPE (decl
));
25300 add_accessibility_attribute (type_die
, decl
);
25302 if (DECL_ABSTRACT_P (decl
))
25303 equate_decl_number_to_die (decl
, type_die
);
25305 if (get_AT (type_die
, DW_AT_name
))
25306 add_pubtype (decl
, type_die
);
25309 /* Generate a DIE for a struct, class, enum or union type. */
25312 gen_tagged_type_die (tree type
,
25313 dw_die_ref context_die
,
25314 enum debug_info_usage usage
)
25316 if (type
== NULL_TREE
25317 || !is_tagged_type (type
))
25320 if (TREE_ASM_WRITTEN (type
))
25322 /* If this is a nested type whose containing class hasn't been written
25323 out yet, writing it out will cover this one, too. This does not apply
25324 to instantiations of member class templates; they need to be added to
25325 the containing class as they are generated. FIXME: This hurts the
25326 idea of combining type decls from multiple TUs, since we can't predict
25327 what set of template instantiations we'll get. */
25328 else if (TYPE_CONTEXT (type
)
25329 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
25330 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
25332 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
25334 if (TREE_ASM_WRITTEN (type
))
25337 /* If that failed, attach ourselves to the stub. */
25338 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
25340 else if (TYPE_CONTEXT (type
) != NULL_TREE
25341 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
25343 /* If this type is local to a function that hasn't been written
25344 out yet, use a NULL context for now; it will be fixed up in
25345 decls_for_scope. */
25346 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
25347 /* A declaration DIE doesn't count; nested types need to go in the
25349 if (context_die
&& is_declaration_die (context_die
))
25350 context_die
= NULL
;
25353 context_die
= declare_in_namespace (type
, context_die
);
25355 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
25357 /* This might have been written out by the call to
25358 declare_in_namespace. */
25359 if (!TREE_ASM_WRITTEN (type
))
25360 gen_enumeration_type_die (type
, context_die
);
25363 gen_struct_or_union_type_die (type
, context_die
, usage
);
25365 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
25366 it up if it is ever completed. gen_*_type_die will set it for us
25367 when appropriate. */
25370 /* Generate a type description DIE. */
25373 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
25374 enum debug_info_usage usage
)
25376 struct array_descr_info info
;
25378 if (type
== NULL_TREE
|| type
== error_mark_node
)
25381 if (flag_checking
&& type
)
25382 verify_type (type
);
25384 if (TYPE_NAME (type
) != NULL_TREE
25385 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
25386 && is_redundant_typedef (TYPE_NAME (type
))
25387 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
25388 /* The DECL of this type is a typedef we don't want to emit debug
25389 info for but we want debug info for its underlying typedef.
25390 This can happen for e.g, the injected-class-name of a C++
25392 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
25394 /* If TYPE is a typedef type variant, let's generate debug info
25395 for the parent typedef which TYPE is a type of. */
25396 if (typedef_variant_p (type
))
25398 if (TREE_ASM_WRITTEN (type
))
25401 tree name
= TYPE_NAME (type
);
25402 tree origin
= decl_ultimate_origin (name
);
25403 if (origin
!= NULL
&& origin
!= name
)
25405 gen_decl_die (origin
, NULL
, NULL
, context_die
);
25409 /* Prevent broken recursion; we can't hand off to the same type. */
25410 gcc_assert (DECL_ORIGINAL_TYPE (name
) != type
);
25412 /* Give typedefs the right scope. */
25413 context_die
= scope_die_for (type
, context_die
);
25415 TREE_ASM_WRITTEN (type
) = 1;
25417 gen_decl_die (name
, NULL
, NULL
, context_die
);
25421 /* If type is an anonymous tagged type named by a typedef, let's
25422 generate debug info for the typedef. */
25423 if (is_naming_typedef_decl (TYPE_NAME (type
)))
25425 /* Give typedefs the right scope. */
25426 context_die
= scope_die_for (type
, context_die
);
25428 gen_decl_die (TYPE_NAME (type
), NULL
, NULL
, context_die
);
25432 if (lang_hooks
.types
.get_debug_type
)
25434 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
25436 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
25438 gen_type_die_with_usage (debug_type
, context_die
, usage
);
25443 /* We are going to output a DIE to represent the unqualified version
25444 of this type (i.e. without any const or volatile qualifiers) so
25445 get the main variant (i.e. the unqualified version) of this type
25446 now. (Vectors and arrays are special because the debugging info is in the
25447 cloned type itself. Similarly function/method types can contain extra
25448 ref-qualification). */
25449 if (TREE_CODE (type
) == FUNCTION_TYPE
25450 || TREE_CODE (type
) == METHOD_TYPE
)
25452 /* For function/method types, can't use type_main_variant here,
25453 because that can have different ref-qualifiers for C++,
25454 but try to canonicalize. */
25455 tree main
= TYPE_MAIN_VARIANT (type
);
25456 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
25457 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
25458 && check_base_type (t
, main
)
25459 && check_lang_type (t
, type
))
25465 else if (TREE_CODE (type
) != VECTOR_TYPE
25466 && TREE_CODE (type
) != ARRAY_TYPE
)
25467 type
= type_main_variant (type
);
25469 /* If this is an array type with hidden descriptor, handle it first. */
25470 if (!TREE_ASM_WRITTEN (type
)
25471 && lang_hooks
.types
.get_array_descr_info
)
25473 memset (&info
, 0, sizeof (info
));
25474 if (lang_hooks
.types
.get_array_descr_info (type
, &info
))
25476 /* Fortran sometimes emits array types with no dimension. */
25477 gcc_assert (info
.ndimensions
>= 0
25478 && (info
.ndimensions
25479 <= DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN
));
25480 gen_descr_array_type_die (type
, &info
, context_die
);
25481 TREE_ASM_WRITTEN (type
) = 1;
25486 if (TREE_ASM_WRITTEN (type
))
25488 /* Variable-length types may be incomplete even if
25489 TREE_ASM_WRITTEN. For such types, fall through to
25490 gen_array_type_die() and possibly fill in
25491 DW_AT_{upper,lower}_bound attributes. */
25492 if ((TREE_CODE (type
) != ARRAY_TYPE
25493 && TREE_CODE (type
) != RECORD_TYPE
25494 && TREE_CODE (type
) != UNION_TYPE
25495 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
25496 || !variably_modified_type_p (type
, NULL
))
25500 switch (TREE_CODE (type
))
25506 case REFERENCE_TYPE
:
25507 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
25508 ensures that the gen_type_die recursion will terminate even if the
25509 type is recursive. Recursive types are possible in Ada. */
25510 /* ??? We could perhaps do this for all types before the switch
25512 TREE_ASM_WRITTEN (type
) = 1;
25514 /* For these types, all that is required is that we output a DIE (or a
25515 set of DIEs) to represent the "basis" type. */
25516 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25517 DINFO_USAGE_IND_USE
);
25521 /* This code is used for C++ pointer-to-data-member types.
25522 Output a description of the relevant class type. */
25523 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
25524 DINFO_USAGE_IND_USE
);
25526 /* Output a description of the type of the object pointed to. */
25527 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25528 DINFO_USAGE_IND_USE
);
25530 /* Now output a DIE to represent this pointer-to-data-member type
25532 gen_ptr_to_mbr_type_die (type
, context_die
);
25535 case FUNCTION_TYPE
:
25536 /* Force out return type (in case it wasn't forced out already). */
25537 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25538 DINFO_USAGE_DIR_USE
);
25539 gen_subroutine_type_die (type
, context_die
);
25543 /* Force out return type (in case it wasn't forced out already). */
25544 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25545 DINFO_USAGE_DIR_USE
);
25546 gen_subroutine_type_die (type
, context_die
);
25551 gen_array_type_die (type
, context_die
);
25554 case ENUMERAL_TYPE
:
25557 case QUAL_UNION_TYPE
:
25558 gen_tagged_type_die (type
, context_die
, usage
);
25564 case FIXED_POINT_TYPE
:
25567 /* No DIEs needed for fundamental types. */
25572 /* Just use DW_TAG_unspecified_type. */
25574 dw_die_ref type_die
= lookup_type_die (type
);
25575 if (type_die
== NULL
)
25577 tree name
= TYPE_IDENTIFIER (type
);
25578 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
25580 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
25581 equate_type_number_to_die (type
, type_die
);
25587 if (is_cxx_auto (type
))
25589 tree name
= TYPE_IDENTIFIER (type
);
25590 dw_die_ref
*die
= (name
== get_identifier ("auto")
25591 ? &auto_die
: &decltype_auto_die
);
25594 *die
= new_die (DW_TAG_unspecified_type
,
25595 comp_unit_die (), NULL_TREE
);
25596 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
25598 equate_type_number_to_die (type
, *die
);
25601 gcc_unreachable ();
25604 TREE_ASM_WRITTEN (type
) = 1;
25608 gen_type_die (tree type
, dw_die_ref context_die
)
25610 if (type
!= error_mark_node
)
25612 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
25615 dw_die_ref die
= lookup_type_die (type
);
25622 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
25623 things which are local to the given block. */
25626 gen_block_die (tree stmt
, dw_die_ref context_die
)
25628 int must_output_die
= 0;
25631 /* Ignore blocks that are NULL. */
25632 if (stmt
== NULL_TREE
)
25635 inlined_func
= inlined_function_outer_scope_p (stmt
);
25637 /* If the block is one fragment of a non-contiguous block, do not
25638 process the variables, since they will have been done by the
25639 origin block. Do process subblocks. */
25640 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
25644 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
25645 gen_block_die (sub
, context_die
);
25650 /* Determine if we need to output any Dwarf DIEs at all to represent this
25653 /* The outer scopes for inlinings *must* always be represented. We
25654 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
25655 must_output_die
= 1;
25656 else if (BLOCK_DIE (stmt
))
25657 /* If we already have a DIE then it was filled early. Meanwhile
25658 we might have pruned all BLOCK_VARS as optimized out but we
25659 still want to generate high/low PC attributes so output it. */
25660 must_output_die
= 1;
25661 else if (TREE_USED (stmt
)
25662 || TREE_ASM_WRITTEN (stmt
)
25663 || BLOCK_ABSTRACT (stmt
))
25665 /* Determine if this block directly contains any "significant"
25666 local declarations which we will need to output DIEs for. */
25667 if (debug_info_level
> DINFO_LEVEL_TERSE
)
25669 /* We are not in terse mode so any local declaration that
25670 is not ignored for debug purposes counts as being a
25671 "significant" one. */
25672 if (BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
25673 must_output_die
= 1;
25675 for (tree var
= BLOCK_VARS (stmt
); var
; var
= DECL_CHAIN (var
))
25676 if (!DECL_IGNORED_P (var
))
25678 must_output_die
= 1;
25682 else if (!dwarf2out_ignore_block (stmt
))
25683 must_output_die
= 1;
25686 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
25687 DIE for any block which contains no significant local declarations at
25688 all. Rather, in such cases we just call `decls_for_scope' so that any
25689 needed Dwarf info for any sub-blocks will get properly generated. Note
25690 that in terse mode, our definition of what constitutes a "significant"
25691 local declaration gets restricted to include only inlined function
25692 instances and local (nested) function definitions. */
25693 if (must_output_die
)
25697 /* If STMT block is abstract, that means we have been called
25698 indirectly from dwarf2out_abstract_function.
25699 That function rightfully marks the descendent blocks (of
25700 the abstract function it is dealing with) as being abstract,
25701 precisely to prevent us from emitting any
25702 DW_TAG_inlined_subroutine DIE as a descendent
25703 of an abstract function instance. So in that case, we should
25704 not call gen_inlined_subroutine_die.
25706 Later though, when cgraph asks dwarf2out to emit info
25707 for the concrete instance of the function decl into which
25708 the concrete instance of STMT got inlined, the later will lead
25709 to the generation of a DW_TAG_inlined_subroutine DIE. */
25710 if (! BLOCK_ABSTRACT (stmt
))
25711 gen_inlined_subroutine_die (stmt
, context_die
);
25714 gen_lexical_block_die (stmt
, context_die
);
25717 decls_for_scope (stmt
, context_die
);
25720 /* Process variable DECL (or variable with origin ORIGIN) within
25721 block STMT and add it to CONTEXT_DIE. */
25723 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
25726 tree decl_or_origin
= decl
? decl
: origin
;
25728 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
25729 die
= lookup_decl_die (decl_or_origin
);
25730 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
)
25732 if (TYPE_DECL_IS_STUB (decl_or_origin
))
25733 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
25735 die
= lookup_decl_die (decl_or_origin
);
25736 /* Avoid re-creating the DIE late if it was optimized as unused early. */
25737 if (! die
&& ! early_dwarf
)
25743 /* Avoid creating DIEs for local typedefs and concrete static variables that
25744 will only be pruned later. */
25745 if ((origin
|| decl_ultimate_origin (decl
))
25746 && (TREE_CODE (decl_or_origin
) == TYPE_DECL
25747 || (VAR_P (decl_or_origin
) && TREE_STATIC (decl_or_origin
))))
25749 origin
= decl_ultimate_origin (decl_or_origin
);
25750 if (decl
&& VAR_P (decl
) && die
!= NULL
)
25752 die
= lookup_decl_die (origin
);
25754 equate_decl_number_to_die (decl
, die
);
25759 if (die
!= NULL
&& die
->die_parent
== NULL
)
25760 add_child_die (context_die
, die
);
25761 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
25764 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
25765 stmt
, context_die
);
25769 if (decl
&& DECL_P (decl
))
25771 die
= lookup_decl_die (decl
);
25773 /* Early created DIEs do not have a parent as the decls refer
25774 to the function as DECL_CONTEXT rather than the BLOCK. */
25775 if (die
&& die
->die_parent
== NULL
)
25777 gcc_assert (in_lto_p
);
25778 add_child_die (context_die
, die
);
25782 gen_decl_die (decl
, origin
, NULL
, context_die
);
25786 /* Generate all of the decls declared within a given scope and (recursively)
25787 all of its sub-blocks. */
25790 decls_for_scope (tree stmt
, dw_die_ref context_die
)
25796 /* Ignore NULL blocks. */
25797 if (stmt
== NULL_TREE
)
25800 /* Output the DIEs to represent all of the data objects and typedefs
25801 declared directly within this block but not within any nested
25802 sub-blocks. Also, nested function and tag DIEs have been
25803 generated with a parent of NULL; fix that up now. We don't
25804 have to do this if we're at -g1. */
25805 if (debug_info_level
> DINFO_LEVEL_TERSE
)
25807 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
25808 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
25809 /* BLOCK_NONLOCALIZED_VARs simply generate DIE stubs with abstract
25810 origin - avoid doing this twice as we have no good way to see
25811 if we've done it once already. */
25813 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
25815 decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
25816 if (decl
== current_function_decl
)
25817 /* Ignore declarations of the current function, while they
25818 are declarations, gen_subprogram_die would treat them
25819 as definitions again, because they are equal to
25820 current_function_decl and endlessly recurse. */;
25821 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
25822 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
25824 process_scope_var (stmt
, NULL_TREE
, decl
, context_die
);
25828 /* Even if we're at -g1, we need to process the subblocks in order to get
25829 inlined call information. */
25831 /* Output the DIEs to represent all sub-blocks (and the items declared
25832 therein) of this block. */
25833 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
25835 subblocks
= BLOCK_CHAIN (subblocks
))
25836 gen_block_die (subblocks
, context_die
);
25839 /* Is this a typedef we can avoid emitting? */
25842 is_redundant_typedef (const_tree decl
)
25844 if (TYPE_DECL_IS_STUB (decl
))
25847 if (DECL_ARTIFICIAL (decl
)
25848 && DECL_CONTEXT (decl
)
25849 && is_tagged_type (DECL_CONTEXT (decl
))
25850 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
25851 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
25852 /* Also ignore the artificial member typedef for the class name. */
25858 /* Return TRUE if TYPE is a typedef that names a type for linkage
25859 purposes. This kind of typedefs is produced by the C++ FE for
25862 typedef struct {...} foo;
25864 In that case, there is no typedef variant type produced for foo.
25865 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
25869 is_naming_typedef_decl (const_tree decl
)
25871 if (decl
== NULL_TREE
25872 || TREE_CODE (decl
) != TYPE_DECL
25873 || DECL_NAMELESS (decl
)
25874 || !is_tagged_type (TREE_TYPE (decl
))
25875 || DECL_IS_BUILTIN (decl
)
25876 || is_redundant_typedef (decl
)
25877 /* It looks like Ada produces TYPE_DECLs that are very similar
25878 to C++ naming typedefs but that have different
25879 semantics. Let's be specific to c++ for now. */
25883 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
25884 && TYPE_NAME (TREE_TYPE (decl
)) == decl
25885 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
25886 != TYPE_NAME (TREE_TYPE (decl
))));
25889 /* Looks up the DIE for a context. */
25891 static inline dw_die_ref
25892 lookup_context_die (tree context
)
25896 /* Find die that represents this context. */
25897 if (TYPE_P (context
))
25899 context
= TYPE_MAIN_VARIANT (context
);
25900 dw_die_ref ctx
= lookup_type_die (context
);
25903 return strip_naming_typedef (context
, ctx
);
25906 return lookup_decl_die (context
);
25908 return comp_unit_die ();
25911 /* Returns the DIE for a context. */
25913 static inline dw_die_ref
25914 get_context_die (tree context
)
25918 /* Find die that represents this context. */
25919 if (TYPE_P (context
))
25921 context
= TYPE_MAIN_VARIANT (context
);
25922 return strip_naming_typedef (context
, force_type_die (context
));
25925 return force_decl_die (context
);
25927 return comp_unit_die ();
25930 /* Returns the DIE for decl. A DIE will always be returned. */
25933 force_decl_die (tree decl
)
25935 dw_die_ref decl_die
;
25936 unsigned saved_external_flag
;
25937 tree save_fn
= NULL_TREE
;
25938 decl_die
= lookup_decl_die (decl
);
25941 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
25943 decl_die
= lookup_decl_die (decl
);
25947 switch (TREE_CODE (decl
))
25949 case FUNCTION_DECL
:
25950 /* Clear current_function_decl, so that gen_subprogram_die thinks
25951 that this is a declaration. At this point, we just want to force
25952 declaration die. */
25953 save_fn
= current_function_decl
;
25954 current_function_decl
= NULL_TREE
;
25955 gen_subprogram_die (decl
, context_die
);
25956 current_function_decl
= save_fn
;
25960 /* Set external flag to force declaration die. Restore it after
25961 gen_decl_die() call. */
25962 saved_external_flag
= DECL_EXTERNAL (decl
);
25963 DECL_EXTERNAL (decl
) = 1;
25964 gen_decl_die (decl
, NULL
, NULL
, context_die
);
25965 DECL_EXTERNAL (decl
) = saved_external_flag
;
25968 case NAMESPACE_DECL
:
25969 if (dwarf_version
>= 3 || !dwarf_strict
)
25970 dwarf2out_decl (decl
);
25972 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
25973 decl_die
= comp_unit_die ();
25976 case TRANSLATION_UNIT_DECL
:
25977 decl_die
= comp_unit_die ();
25981 gcc_unreachable ();
25984 /* We should be able to find the DIE now. */
25986 decl_die
= lookup_decl_die (decl
);
25987 gcc_assert (decl_die
);
25993 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
25994 always returned. */
25997 force_type_die (tree type
)
25999 dw_die_ref type_die
;
26001 type_die
= lookup_type_die (type
);
26004 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
26006 type_die
= modified_type_die (type
, TYPE_QUALS_NO_ADDR_SPACE (type
),
26007 false, context_die
);
26008 gcc_assert (type_die
);
26013 /* Force out any required namespaces to be able to output DECL,
26014 and return the new context_die for it, if it's changed. */
26017 setup_namespace_context (tree thing
, dw_die_ref context_die
)
26019 tree context
= (DECL_P (thing
)
26020 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
26021 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
26022 /* Force out the namespace. */
26023 context_die
= force_decl_die (context
);
26025 return context_die
;
26028 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
26029 type) within its namespace, if appropriate.
26031 For compatibility with older debuggers, namespace DIEs only contain
26032 declarations; all definitions are emitted at CU scope, with
26033 DW_AT_specification pointing to the declaration (like with class
26037 declare_in_namespace (tree thing
, dw_die_ref context_die
)
26039 dw_die_ref ns_context
;
26041 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26042 return context_die
;
26044 /* External declarations in the local scope only need to be emitted
26045 once, not once in the namespace and once in the scope.
26047 This avoids declaring the `extern' below in the
26048 namespace DIE as well as in the innermost scope:
26061 if (DECL_P (thing
) && DECL_EXTERNAL (thing
) && local_scope_p (context_die
))
26062 return context_die
;
26064 /* If this decl is from an inlined function, then don't try to emit it in its
26065 namespace, as we will get confused. It would have already been emitted
26066 when the abstract instance of the inline function was emitted anyways. */
26067 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
26068 return context_die
;
26070 ns_context
= setup_namespace_context (thing
, context_die
);
26072 if (ns_context
!= context_die
)
26076 if (DECL_P (thing
))
26077 gen_decl_die (thing
, NULL
, NULL
, ns_context
);
26079 gen_type_die (thing
, ns_context
);
26081 return context_die
;
26084 /* Generate a DIE for a namespace or namespace alias. */
26087 gen_namespace_die (tree decl
, dw_die_ref context_die
)
26089 dw_die_ref namespace_die
;
26091 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
26092 they are an alias of. */
26093 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
26095 /* Output a real namespace or module. */
26096 context_die
= setup_namespace_context (decl
, comp_unit_die ());
26097 namespace_die
= new_die (is_fortran ()
26098 ? DW_TAG_module
: DW_TAG_namespace
,
26099 context_die
, decl
);
26100 /* For Fortran modules defined in different CU don't add src coords. */
26101 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
26103 const char *name
= dwarf2_name (decl
, 0);
26105 add_name_attribute (namespace_die
, name
);
26108 add_name_and_src_coords_attributes (namespace_die
, decl
);
26109 if (DECL_EXTERNAL (decl
))
26110 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
26111 equate_decl_number_to_die (decl
, namespace_die
);
26115 /* Output a namespace alias. */
26117 /* Force out the namespace we are an alias of, if necessary. */
26118 dw_die_ref origin_die
26119 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
26121 if (DECL_FILE_SCOPE_P (decl
)
26122 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
26123 context_die
= setup_namespace_context (decl
, comp_unit_die ());
26124 /* Now create the namespace alias DIE. */
26125 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
26126 add_name_and_src_coords_attributes (namespace_die
, decl
);
26127 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
26128 equate_decl_number_to_die (decl
, namespace_die
);
26130 if ((dwarf_version
>= 5 || !dwarf_strict
)
26131 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
26132 DW_AT_export_symbols
) == 1)
26133 add_AT_flag (namespace_die
, DW_AT_export_symbols
, 1);
26135 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
26136 if (want_pubnames ())
26137 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
26140 /* Generate Dwarf debug information for a decl described by DECL.
26141 The return value is currently only meaningful for PARM_DECLs,
26142 for all other decls it returns NULL.
26144 If DECL is a FIELD_DECL, CTX is required: see the comment for VLR_CONTEXT.
26145 It can be NULL otherwise. */
26148 gen_decl_die (tree decl
, tree origin
, struct vlr_context
*ctx
,
26149 dw_die_ref context_die
)
26151 tree decl_or_origin
= decl
? decl
: origin
;
26152 tree class_origin
= NULL
, ultimate_origin
;
26154 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
26157 switch (TREE_CODE (decl_or_origin
))
26163 if (!is_fortran () && !is_ada ())
26165 /* The individual enumerators of an enum type get output when we output
26166 the Dwarf representation of the relevant enum type itself. */
26170 /* Emit its type. */
26171 gen_type_die (TREE_TYPE (decl
), context_die
);
26173 /* And its containing namespace. */
26174 context_die
= declare_in_namespace (decl
, context_die
);
26176 gen_const_die (decl
, context_die
);
26179 case FUNCTION_DECL
:
26182 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
26183 on local redeclarations of global functions. That seems broken. */
26184 if (current_function_decl
!= decl
)
26185 /* This is only a declaration. */;
26188 /* We should have abstract copies already and should not generate
26189 stray type DIEs in late LTO dumping. */
26193 /* If we're emitting a clone, emit info for the abstract instance. */
26194 else if (origin
|| DECL_ORIGIN (decl
) != decl
)
26195 dwarf2out_abstract_function (origin
26196 ? DECL_ORIGIN (origin
)
26197 : DECL_ABSTRACT_ORIGIN (decl
));
26199 /* If we're emitting a possibly inlined function emit it as
26200 abstract instance. */
26201 else if (cgraph_function_possibly_inlined_p (decl
)
26202 && ! DECL_ABSTRACT_P (decl
)
26203 && ! class_or_namespace_scope_p (context_die
)
26204 /* dwarf2out_abstract_function won't emit a die if this is just
26205 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
26206 that case, because that works only if we have a die. */
26207 && DECL_INITIAL (decl
) != NULL_TREE
)
26208 dwarf2out_abstract_function (decl
);
26210 /* Otherwise we're emitting the primary DIE for this decl. */
26211 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
26213 /* Before we describe the FUNCTION_DECL itself, make sure that we
26214 have its containing type. */
26216 origin
= decl_class_context (decl
);
26217 if (origin
!= NULL_TREE
)
26218 gen_type_die (origin
, context_die
);
26220 /* And its return type. */
26221 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
26223 /* And its virtual context. */
26224 if (DECL_VINDEX (decl
) != NULL_TREE
)
26225 gen_type_die (DECL_CONTEXT (decl
), context_die
);
26227 /* Make sure we have a member DIE for decl. */
26228 if (origin
!= NULL_TREE
)
26229 gen_type_die_for_member (origin
, decl
, context_die
);
26231 /* And its containing namespace. */
26232 context_die
= declare_in_namespace (decl
, context_die
);
26235 /* Now output a DIE to represent the function itself. */
26237 gen_subprogram_die (decl
, context_die
);
26241 /* If we are in terse mode, don't generate any DIEs to represent any
26242 actual typedefs. */
26243 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26246 /* In the special case of a TYPE_DECL node representing the declaration
26247 of some type tag, if the given TYPE_DECL is marked as having been
26248 instantiated from some other (original) TYPE_DECL node (e.g. one which
26249 was generated within the original definition of an inline function) we
26250 used to generate a special (abbreviated) DW_TAG_structure_type,
26251 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
26252 should be actually referencing those DIEs, as variable DIEs with that
26253 type would be emitted already in the abstract origin, so it was always
26254 removed during unused type prunning. Don't add anything in this
26256 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
26259 if (is_redundant_typedef (decl
))
26260 gen_type_die (TREE_TYPE (decl
), context_die
);
26262 /* Output a DIE to represent the typedef itself. */
26263 gen_typedef_die (decl
, context_die
);
26267 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
26268 gen_label_die (decl
, context_die
);
26273 /* If we are in terse mode, don't generate any DIEs to represent any
26274 variable declarations or definitions. */
26275 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26278 /* Avoid generating stray type DIEs during late dwarf dumping.
26279 All types have been dumped early. */
26281 /* ??? But in LTRANS we cannot annotate early created variably
26282 modified type DIEs without copying them and adjusting all
26283 references to them. Dump them again as happens for inlining
26284 which copies both the decl and the types. */
26285 /* ??? And even non-LTO needs to re-visit type DIEs to fill
26286 in VLA bound information for example. */
26287 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
26288 current_function_decl
)))
26290 /* Output any DIEs that are needed to specify the type of this data
26292 if (decl_by_reference_p (decl_or_origin
))
26293 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
26295 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
26300 /* And its containing type. */
26301 class_origin
= decl_class_context (decl_or_origin
);
26302 if (class_origin
!= NULL_TREE
)
26303 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
26305 /* And its containing namespace. */
26306 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
26309 /* Now output the DIE to represent the data object itself. This gets
26310 complicated because of the possibility that the VAR_DECL really
26311 represents an inlined instance of a formal parameter for an inline
26313 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
26314 if (ultimate_origin
!= NULL_TREE
26315 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
26316 gen_formal_parameter_die (decl
, origin
,
26317 true /* Emit name attribute. */,
26320 gen_variable_die (decl
, origin
, context_die
);
26324 gcc_assert (ctx
!= NULL
&& ctx
->struct_type
!= NULL
);
26325 /* Ignore the nameless fields that are used to skip bits but handle C++
26326 anonymous unions and structs. */
26327 if (DECL_NAME (decl
) != NULL_TREE
26328 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
26329 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
26331 gen_type_die (member_declared_type (decl
), context_die
);
26332 gen_field_die (decl
, ctx
, context_die
);
26337 /* Avoid generating stray type DIEs during late dwarf dumping.
26338 All types have been dumped early. */
26340 /* ??? But in LTRANS we cannot annotate early created variably
26341 modified type DIEs without copying them and adjusting all
26342 references to them. Dump them again as happens for inlining
26343 which copies both the decl and the types. */
26344 /* ??? And even non-LTO needs to re-visit type DIEs to fill
26345 in VLA bound information for example. */
26346 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
26347 current_function_decl
)))
26349 if (DECL_BY_REFERENCE (decl_or_origin
))
26350 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
26352 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
26354 return gen_formal_parameter_die (decl
, origin
,
26355 true /* Emit name attribute. */,
26358 case NAMESPACE_DECL
:
26359 if (dwarf_version
>= 3 || !dwarf_strict
)
26360 gen_namespace_die (decl
, context_die
);
26363 case IMPORTED_DECL
:
26364 dwarf2out_imported_module_or_decl_1 (decl
, DECL_NAME (decl
),
26365 DECL_CONTEXT (decl
), context_die
);
26368 case NAMELIST_DECL
:
26369 gen_namelist_decl (DECL_NAME (decl
), context_die
,
26370 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
26374 /* Probably some frontend-internal decl. Assume we don't care. */
26375 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
26382 /* Output initial debug information for global DECL. Called at the
26383 end of the parsing process.
26385 This is the initial debug generation process. As such, the DIEs
26386 generated may be incomplete. A later debug generation pass
26387 (dwarf2out_late_global_decl) will augment the information generated
26388 in this pass (e.g., with complete location info). */
26391 dwarf2out_early_global_decl (tree decl
)
26395 /* gen_decl_die() will set DECL_ABSTRACT because
26396 cgraph_function_possibly_inlined_p() returns true. This is in
26397 turn will cause DW_AT_inline attributes to be set.
26399 This happens because at early dwarf generation, there is no
26400 cgraph information, causing cgraph_function_possibly_inlined_p()
26401 to return true. Trick cgraph_function_possibly_inlined_p()
26402 while we generate dwarf early. */
26403 bool save
= symtab
->global_info_ready
;
26404 symtab
->global_info_ready
= true;
26406 /* We don't handle TYPE_DECLs. If required, they'll be reached via
26407 other DECLs and they can point to template types or other things
26408 that dwarf2out can't handle when done via dwarf2out_decl. */
26409 if (TREE_CODE (decl
) != TYPE_DECL
26410 && TREE_CODE (decl
) != PARM_DECL
)
26412 if (TREE_CODE (decl
) == FUNCTION_DECL
)
26414 tree save_fndecl
= current_function_decl
;
26416 /* For nested functions, make sure we have DIEs for the parents first
26417 so that all nested DIEs are generated at the proper scope in the
26419 tree context
= decl_function_context (decl
);
26420 if (context
!= NULL
)
26422 dw_die_ref context_die
= lookup_decl_die (context
);
26423 current_function_decl
= context
;
26425 /* Avoid emitting DIEs multiple times, but still process CONTEXT
26426 enough so that it lands in its own context. This avoids type
26427 pruning issues later on. */
26428 if (context_die
== NULL
|| is_declaration_die (context_die
))
26429 dwarf2out_decl (context
);
26432 /* Emit an abstract origin of a function first. This happens
26433 with C++ constructor clones for example and makes
26434 dwarf2out_abstract_function happy which requires the early
26435 DIE of the abstract instance to be present. */
26436 tree origin
= DECL_ABSTRACT_ORIGIN (decl
);
26437 dw_die_ref origin_die
;
26439 /* Do not emit the DIE multiple times but make sure to
26440 process it fully here in case we just saw a declaration. */
26441 && ((origin_die
= lookup_decl_die (origin
)) == NULL
26442 || is_declaration_die (origin_die
)))
26444 current_function_decl
= origin
;
26445 dwarf2out_decl (origin
);
26448 /* Emit the DIE for decl but avoid doing that multiple times. */
26449 dw_die_ref old_die
;
26450 if ((old_die
= lookup_decl_die (decl
)) == NULL
26451 || is_declaration_die (old_die
))
26453 current_function_decl
= decl
;
26454 dwarf2out_decl (decl
);
26457 current_function_decl
= save_fndecl
;
26460 dwarf2out_decl (decl
);
26462 symtab
->global_info_ready
= save
;
26465 /* Return whether EXPR is an expression with the following pattern:
26466 INDIRECT_REF (NOP_EXPR (INTEGER_CST)). */
26469 is_trivial_indirect_ref (tree expr
)
26471 if (expr
== NULL_TREE
|| TREE_CODE (expr
) != INDIRECT_REF
)
26474 tree nop
= TREE_OPERAND (expr
, 0);
26475 if (nop
== NULL_TREE
|| TREE_CODE (nop
) != NOP_EXPR
)
26478 tree int_cst
= TREE_OPERAND (nop
, 0);
26479 return int_cst
!= NULL_TREE
&& TREE_CODE (int_cst
) == INTEGER_CST
;
26482 /* Output debug information for global decl DECL. Called from
26483 toplev.c after compilation proper has finished. */
26486 dwarf2out_late_global_decl (tree decl
)
26488 /* Fill-in any location information we were unable to determine
26489 on the first pass. */
26492 dw_die_ref die
= lookup_decl_die (decl
);
26494 /* We may have to generate early debug late for LTO in case debug
26495 was not enabled at compile-time or the target doesn't support
26496 the LTO early debug scheme. */
26497 if (! die
&& in_lto_p
)
26499 dwarf2out_decl (decl
);
26500 die
= lookup_decl_die (decl
);
26505 /* We get called via the symtab code invoking late_global_decl
26506 for symbols that are optimized out.
26508 Do not add locations for those, except if they have a
26509 DECL_VALUE_EXPR, in which case they are relevant for debuggers.
26510 Still don't add a location if the DECL_VALUE_EXPR is not a trivial
26511 INDIRECT_REF expression, as this could generate relocations to
26512 text symbols in LTO object files, which is invalid. */
26513 varpool_node
*node
= varpool_node::get (decl
);
26514 if ((! node
|| ! node
->definition
)
26515 && ! (DECL_HAS_VALUE_EXPR_P (decl
)
26516 && is_trivial_indirect_ref (DECL_VALUE_EXPR (decl
))))
26517 tree_add_const_value_attribute_for_decl (die
, decl
);
26519 add_location_or_const_value_attribute (die
, decl
, false);
26524 /* Output debug information for type decl DECL. Called from toplev.c
26525 and from language front ends (to record built-in types). */
26527 dwarf2out_type_decl (tree decl
, int local
)
26532 dwarf2out_decl (decl
);
26536 /* Output debug information for imported module or decl DECL.
26537 NAME is non-NULL name in the lexical block if the decl has been renamed.
26538 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
26539 that DECL belongs to.
26540 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
26542 dwarf2out_imported_module_or_decl_1 (tree decl
,
26544 tree lexical_block
,
26545 dw_die_ref lexical_block_die
)
26547 expanded_location xloc
;
26548 dw_die_ref imported_die
= NULL
;
26549 dw_die_ref at_import_die
;
26551 if (TREE_CODE (decl
) == IMPORTED_DECL
)
26553 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
26554 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
26558 xloc
= expand_location (input_location
);
26560 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
26562 at_import_die
= force_type_die (TREE_TYPE (decl
));
26563 /* For namespace N { typedef void T; } using N::T; base_type_die
26564 returns NULL, but DW_TAG_imported_declaration requires
26565 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
26566 if (!at_import_die
)
26568 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
26569 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
26570 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
26571 gcc_assert (at_import_die
);
26576 at_import_die
= lookup_decl_die (decl
);
26577 if (!at_import_die
)
26579 /* If we're trying to avoid duplicate debug info, we may not have
26580 emitted the member decl for this field. Emit it now. */
26581 if (TREE_CODE (decl
) == FIELD_DECL
)
26583 tree type
= DECL_CONTEXT (decl
);
26585 if (TYPE_CONTEXT (type
)
26586 && TYPE_P (TYPE_CONTEXT (type
))
26587 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
26588 DINFO_USAGE_DIR_USE
))
26590 gen_type_die_for_member (type
, decl
,
26591 get_context_die (TYPE_CONTEXT (type
)));
26593 if (TREE_CODE (decl
) == NAMELIST_DECL
)
26594 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
26595 get_context_die (DECL_CONTEXT (decl
)),
26598 at_import_die
= force_decl_die (decl
);
26602 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
26604 if (dwarf_version
>= 3 || !dwarf_strict
)
26605 imported_die
= new_die (DW_TAG_imported_module
,
26612 imported_die
= new_die (DW_TAG_imported_declaration
,
26616 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
26617 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
26618 if (debug_column_info
&& xloc
.column
)
26619 add_AT_unsigned (imported_die
, DW_AT_decl_column
, xloc
.column
);
26621 add_AT_string (imported_die
, DW_AT_name
,
26622 IDENTIFIER_POINTER (name
));
26623 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
26626 /* Output debug information for imported module or decl DECL.
26627 NAME is non-NULL name in context if the decl has been renamed.
26628 CHILD is true if decl is one of the renamed decls as part of
26629 importing whole module.
26630 IMPLICIT is set if this hook is called for an implicit import
26631 such as inline namespace. */
26634 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
26635 bool child
, bool implicit
)
26637 /* dw_die_ref at_import_die; */
26638 dw_die_ref scope_die
;
26640 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26645 /* For DWARF5, just DW_AT_export_symbols on the DW_TAG_namespace
26646 should be enough, for DWARF4 and older even if we emit as extension
26647 DW_AT_export_symbols add the implicit DW_TAG_imported_module anyway
26648 for the benefit of consumers unaware of DW_AT_export_symbols. */
26650 && dwarf_version
>= 5
26651 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
26652 DW_AT_export_symbols
) == 1)
26657 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
26658 We need decl DIE for reference and scope die. First, get DIE for the decl
26661 /* Get the scope die for decl context. Use comp_unit_die for global module
26662 or decl. If die is not found for non globals, force new die. */
26664 && TYPE_P (context
)
26665 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
26668 scope_die
= get_context_die (context
);
26672 /* DW_TAG_imported_module was introduced in the DWARFv3 specification, so
26673 there is nothing we can do, here. */
26674 if (dwarf_version
< 3 && dwarf_strict
)
26677 gcc_assert (scope_die
->die_child
);
26678 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
26679 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
26680 scope_die
= scope_die
->die_child
;
26683 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
26684 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
26687 /* Output debug information for namelists. */
26690 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
26692 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
26696 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26699 gcc_assert (scope_die
!= NULL
);
26700 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
26701 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
26703 /* If there are no item_decls, we have a nondefining namelist, e.g.
26704 with USE association; hence, set DW_AT_declaration. */
26705 if (item_decls
== NULL_TREE
)
26707 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
26711 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
26713 nml_item_ref_die
= lookup_decl_die (value
);
26714 if (!nml_item_ref_die
)
26715 nml_item_ref_die
= force_decl_die (value
);
26717 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
26718 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
26724 /* Write the debugging output for DECL and return the DIE. */
26727 dwarf2out_decl (tree decl
)
26729 dw_die_ref context_die
= comp_unit_die ();
26731 switch (TREE_CODE (decl
))
26736 case FUNCTION_DECL
:
26737 /* If we're a nested function, initially use a parent of NULL; if we're
26738 a plain function, this will be fixed up in decls_for_scope. If
26739 we're a method, it will be ignored, since we already have a DIE.
26740 Avoid doing this late though since clones of class methods may
26741 otherwise end up in limbo and create type DIEs late. */
26743 && decl_function_context (decl
)
26744 /* But if we're in terse mode, we don't care about scope. */
26745 && debug_info_level
> DINFO_LEVEL_TERSE
)
26746 context_die
= NULL
;
26750 /* For local statics lookup proper context die. */
26751 if (local_function_static (decl
))
26752 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
26754 /* If we are in terse mode, don't generate any DIEs to represent any
26755 variable declarations or definitions. */
26756 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26761 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26763 if (!is_fortran () && !is_ada ())
26765 if (TREE_STATIC (decl
) && decl_function_context (decl
))
26766 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
26769 case NAMESPACE_DECL
:
26770 case IMPORTED_DECL
:
26771 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26773 if (lookup_decl_die (decl
) != NULL
)
26778 /* Don't emit stubs for types unless they are needed by other DIEs. */
26779 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
26782 /* Don't bother trying to generate any DIEs to represent any of the
26783 normal built-in types for the language we are compiling. */
26784 if (DECL_IS_BUILTIN (decl
))
26787 /* If we are in terse mode, don't generate any DIEs for types. */
26788 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26791 /* If we're a function-scope tag, initially use a parent of NULL;
26792 this will be fixed up in decls_for_scope. */
26793 if (decl_function_context (decl
))
26794 context_die
= NULL
;
26798 case NAMELIST_DECL
:
26805 gen_decl_die (decl
, NULL
, NULL
, context_die
);
26809 dw_die_ref die
= lookup_decl_die (decl
);
26815 /* Write the debugging output for DECL. */
26818 dwarf2out_function_decl (tree decl
)
26820 dwarf2out_decl (decl
);
26821 call_arg_locations
= NULL
;
26822 call_arg_loc_last
= NULL
;
26823 call_site_count
= -1;
26824 tail_call_site_count
= -1;
26825 decl_loc_table
->empty ();
26826 cached_dw_loc_list_table
->empty ();
26829 /* Output a marker (i.e. a label) for the beginning of the generated code for
26830 a lexical block. */
26833 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
26834 unsigned int blocknum
)
26836 switch_to_section (current_function_section ());
26837 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
26840 /* Output a marker (i.e. a label) for the end of the generated code for a
26844 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
26846 switch_to_section (current_function_section ());
26847 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
26850 /* Returns nonzero if it is appropriate not to emit any debugging
26851 information for BLOCK, because it doesn't contain any instructions.
26853 Don't allow this for blocks with nested functions or local classes
26854 as we would end up with orphans, and in the presence of scheduling
26855 we may end up calling them anyway. */
26858 dwarf2out_ignore_block (const_tree block
)
26863 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
26864 if (TREE_CODE (decl
) == FUNCTION_DECL
26865 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
26867 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
26869 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
26870 if (TREE_CODE (decl
) == FUNCTION_DECL
26871 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
26878 /* Hash table routines for file_hash. */
26881 dwarf_file_hasher::equal (dwarf_file_data
*p1
, const char *p2
)
26883 return filename_cmp (p1
->filename
, p2
) == 0;
26887 dwarf_file_hasher::hash (dwarf_file_data
*p
)
26889 return htab_hash_string (p
->filename
);
26892 /* Lookup FILE_NAME (in the list of filenames that we know about here in
26893 dwarf2out.c) and return its "index". The index of each (known) filename is
26894 just a unique number which is associated with only that one filename. We
26895 need such numbers for the sake of generating labels (in the .debug_sfnames
26896 section) and references to those files numbers (in the .debug_srcinfo
26897 and .debug_macinfo sections). If the filename given as an argument is not
26898 found in our current list, add it to the list and assign it the next
26899 available unique index number. */
26901 static struct dwarf_file_data
*
26902 lookup_filename (const char *file_name
)
26904 struct dwarf_file_data
* created
;
26909 dwarf_file_data
**slot
26910 = file_table
->find_slot_with_hash (file_name
, htab_hash_string (file_name
),
26915 created
= ggc_alloc
<dwarf_file_data
> ();
26916 created
->filename
= file_name
;
26917 created
->emitted_number
= 0;
26922 /* If the assembler will construct the file table, then translate the compiler
26923 internal file table number into the assembler file table number, and emit
26924 a .file directive if we haven't already emitted one yet. The file table
26925 numbers are different because we prune debug info for unused variables and
26926 types, which may include filenames. */
26929 maybe_emit_file (struct dwarf_file_data
* fd
)
26931 if (! fd
->emitted_number
)
26933 if (last_emitted_file
)
26934 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
26936 fd
->emitted_number
= 1;
26937 last_emitted_file
= fd
;
26939 if (output_asm_line_debug_info ())
26941 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
26942 output_quoted_string (asm_out_file
,
26943 remap_debug_filename (fd
->filename
));
26944 fputc ('\n', asm_out_file
);
26948 return fd
->emitted_number
;
26951 /* Schedule generation of a DW_AT_const_value attribute to DIE.
26952 That generation should happen after function debug info has been
26953 generated. The value of the attribute is the constant value of ARG. */
26956 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
26958 die_arg_entry entry
;
26963 gcc_assert (early_dwarf
);
26965 if (!tmpl_value_parm_die_table
)
26966 vec_alloc (tmpl_value_parm_die_table
, 32);
26970 vec_safe_push (tmpl_value_parm_die_table
, entry
);
26973 /* Return TRUE if T is an instance of generic type, FALSE
26977 generic_type_p (tree t
)
26979 if (t
== NULL_TREE
|| !TYPE_P (t
))
26981 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
26984 /* Schedule the generation of the generic parameter dies for the
26985 instance of generic type T. The proper generation itself is later
26986 done by gen_scheduled_generic_parms_dies. */
26989 schedule_generic_params_dies_gen (tree t
)
26991 if (!generic_type_p (t
))
26994 gcc_assert (early_dwarf
);
26996 if (!generic_type_instances
)
26997 vec_alloc (generic_type_instances
, 256);
26999 vec_safe_push (generic_type_instances
, t
);
27002 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
27003 by append_entry_to_tmpl_value_parm_die_table. This function must
27004 be called after function DIEs have been generated. */
27007 gen_remaining_tmpl_value_param_die_attribute (void)
27009 if (tmpl_value_parm_die_table
)
27014 /* We do this in two phases - first get the cases we can
27015 handle during early-finish, preserving those we cannot
27016 (containing symbolic constants where we don't yet know
27017 whether we are going to output the referenced symbols).
27018 For those we try again at late-finish. */
27020 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
27022 if (!e
->die
->removed
27023 && !tree_add_const_value_attribute (e
->die
, e
->arg
))
27025 dw_loc_descr_ref loc
= NULL
;
27027 && (dwarf_version
>= 5 || !dwarf_strict
))
27028 loc
= loc_descriptor_from_tree (e
->arg
, 2, NULL
);
27030 add_AT_loc (e
->die
, DW_AT_location
, loc
);
27032 (*tmpl_value_parm_die_table
)[j
++] = *e
;
27035 tmpl_value_parm_die_table
->truncate (j
);
27039 /* Generate generic parameters DIEs for instances of generic types
27040 that have been previously scheduled by
27041 schedule_generic_params_dies_gen. This function must be called
27042 after all the types of the CU have been laid out. */
27045 gen_scheduled_generic_parms_dies (void)
27050 if (!generic_type_instances
)
27053 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
27054 if (COMPLETE_TYPE_P (t
))
27055 gen_generic_params_dies (t
);
27057 generic_type_instances
= NULL
;
27061 /* Replace DW_AT_name for the decl with name. */
27064 dwarf2out_set_name (tree decl
, tree name
)
27067 dw_attr_node
*attr
;
27070 die
= TYPE_SYMTAB_DIE (decl
);
27074 dname
= dwarf2_name (name
, 0);
27078 attr
= get_AT (die
, DW_AT_name
);
27081 struct indirect_string_node
*node
;
27083 node
= find_AT_string (dname
);
27084 /* replace the string. */
27085 attr
->dw_attr_val
.v
.val_str
= node
;
27089 add_name_attribute (die
, dname
);
27092 /* True if before or during processing of the first function being emitted. */
27093 static bool in_first_function_p
= true;
27094 /* True if loc_note during dwarf2out_var_location call might still be
27095 before first real instruction at address equal to .Ltext0. */
27096 static bool maybe_at_text_label_p
= true;
27097 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
27098 static unsigned int first_loclabel_num_not_at_text_label
;
27100 /* Look ahead for a real insn, or for a begin stmt marker. */
27103 dwarf2out_next_real_insn (rtx_insn
*loc_note
)
27105 rtx_insn
*next_real
= NEXT_INSN (loc_note
);
27108 if (INSN_P (next_real
))
27111 next_real
= NEXT_INSN (next_real
);
27116 /* Called by the final INSN scan whenever we see a var location. We
27117 use it to drop labels in the right places, and throw the location in
27118 our lookup table. */
27121 dwarf2out_var_location (rtx_insn
*loc_note
)
27123 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
27124 struct var_loc_node
*newloc
;
27125 rtx_insn
*next_real
, *next_note
;
27126 rtx_insn
*call_insn
= NULL
;
27127 static const char *last_label
;
27128 static const char *last_postcall_label
;
27129 static bool last_in_cold_section_p
;
27130 static rtx_insn
*expected_next_loc_note
;
27133 var_loc_view view
= 0;
27135 if (!NOTE_P (loc_note
))
27137 if (CALL_P (loc_note
))
27139 maybe_reset_location_view (loc_note
, cur_line_info_table
);
27141 if (SIBLING_CALL_P (loc_note
))
27142 tail_call_site_count
++;
27143 if (find_reg_note (loc_note
, REG_CALL_ARG_LOCATION
, NULL_RTX
))
27145 call_insn
= loc_note
;
27149 next_real
= dwarf2out_next_real_insn (call_insn
);
27151 cached_next_real_insn
= NULL
;
27154 if (optimize
== 0 && !flag_var_tracking
)
27156 /* When the var-tracking pass is not running, there is no note
27157 for indirect calls whose target is compile-time known. In this
27158 case, process such calls specifically so that we generate call
27159 sites for them anyway. */
27160 rtx x
= PATTERN (loc_note
);
27161 if (GET_CODE (x
) == PARALLEL
)
27162 x
= XVECEXP (x
, 0, 0);
27163 if (GET_CODE (x
) == SET
)
27165 if (GET_CODE (x
) == CALL
)
27168 || GET_CODE (XEXP (x
, 0)) != SYMBOL_REF
27169 || !SYMBOL_REF_DECL (XEXP (x
, 0))
27170 || (TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0)))
27173 call_insn
= loc_note
;
27177 next_real
= dwarf2out_next_real_insn (call_insn
);
27179 cached_next_real_insn
= NULL
;
27184 else if (!debug_variable_location_views
)
27185 gcc_unreachable ();
27187 maybe_reset_location_view (loc_note
, cur_line_info_table
);
27192 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
27193 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
27196 /* Optimize processing a large consecutive sequence of location
27197 notes so we don't spend too much time in next_real_insn. If the
27198 next insn is another location note, remember the next_real_insn
27199 calculation for next time. */
27200 next_real
= cached_next_real_insn
;
27203 if (expected_next_loc_note
!= loc_note
)
27207 next_note
= NEXT_INSN (loc_note
);
27209 || next_note
->deleted ()
27210 || ! NOTE_P (next_note
)
27211 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
27212 && NOTE_KIND (next_note
) != NOTE_INSN_BEGIN_STMT
27213 && NOTE_KIND (next_note
) != NOTE_INSN_INLINE_ENTRY
))
27217 next_real
= dwarf2out_next_real_insn (loc_note
);
27221 expected_next_loc_note
= next_note
;
27222 cached_next_real_insn
= next_real
;
27225 cached_next_real_insn
= NULL
;
27227 /* If there are no instructions which would be affected by this note,
27228 don't do anything. */
27230 && next_real
== NULL_RTX
27231 && !NOTE_DURING_CALL_P (loc_note
))
27236 if (next_real
== NULL_RTX
)
27237 next_real
= get_last_insn ();
27239 /* If there were any real insns between note we processed last time
27240 and this note (or if it is the first note), clear
27241 last_{,postcall_}label so that they are not reused this time. */
27242 if (last_var_location_insn
== NULL_RTX
27243 || last_var_location_insn
!= next_real
27244 || last_in_cold_section_p
!= in_cold_section_p
)
27247 last_postcall_label
= NULL
;
27253 = NOTE_DURING_CALL_P (loc_note
) ? last_postcall_label
: last_label
;
27254 view
= cur_line_info_table
->view
;
27255 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
27256 newloc
= add_var_loc_to_decl (decl
, loc_note
, label
, view
);
27257 if (newloc
== NULL
)
27266 /* If there were no real insns between note we processed last time
27267 and this note, use the label we emitted last time. Otherwise
27268 create a new label and emit it. */
27269 if (last_label
== NULL
)
27271 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
27272 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
27274 last_label
= ggc_strdup (loclabel
);
27275 /* See if loclabel might be equal to .Ltext0. If yes,
27276 bump first_loclabel_num_not_at_text_label. */
27277 if (!have_multiple_function_sections
27278 && in_first_function_p
27279 && maybe_at_text_label_p
)
27281 static rtx_insn
*last_start
;
27283 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
27284 if (insn
== last_start
)
27286 else if (!NONDEBUG_INSN_P (insn
))
27290 rtx body
= PATTERN (insn
);
27291 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
27293 /* Inline asm could occupy zero bytes. */
27294 else if (GET_CODE (body
) == ASM_INPUT
27295 || asm_noperands (body
) >= 0)
27297 #ifdef HAVE_ATTR_length /* ??? We don't include insn-attr.h. */
27298 else if (HAVE_ATTR_length
&& get_attr_min_length (insn
) == 0)
27303 /* Assume insn has non-zero length. */
27304 maybe_at_text_label_p
= false;
27308 if (maybe_at_text_label_p
)
27310 last_start
= loc_note
;
27311 first_loclabel_num_not_at_text_label
= loclabel_num
;
27316 gcc_assert ((loc_note
== NULL_RTX
&& call_insn
!= NULL_RTX
)
27317 || (loc_note
!= NULL_RTX
&& call_insn
== NULL_RTX
));
27321 struct call_arg_loc_node
*ca_loc
27322 = ggc_cleared_alloc
<call_arg_loc_node
> ();
27323 rtx_insn
*prev
= call_insn
;
27325 ca_loc
->call_arg_loc_note
27326 = find_reg_note (call_insn
, REG_CALL_ARG_LOCATION
, NULL_RTX
);
27327 ca_loc
->next
= NULL
;
27328 ca_loc
->label
= last_label
;
27331 || (NONJUMP_INSN_P (prev
)
27332 && GET_CODE (PATTERN (prev
)) == SEQUENCE
27333 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
27334 if (!CALL_P (prev
))
27335 prev
= as_a
<rtx_sequence
*> (PATTERN (prev
))->insn (0);
27336 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
27338 /* Look for a SYMBOL_REF in the "prev" instruction. */
27339 rtx x
= get_call_rtx_from (PATTERN (prev
));
27342 /* Try to get the call symbol, if any. */
27343 if (MEM_P (XEXP (x
, 0)))
27345 /* First, look for a memory access to a symbol_ref. */
27346 if (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
27347 && SYMBOL_REF_DECL (XEXP (x
, 0))
27348 && TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0))) == FUNCTION_DECL
)
27349 ca_loc
->symbol_ref
= XEXP (x
, 0);
27350 /* Otherwise, look at a compile-time known user-level function
27354 && TREE_CODE (MEM_EXPR (x
)) == FUNCTION_DECL
)
27355 ca_loc
->symbol_ref
= XEXP (DECL_RTL (MEM_EXPR (x
)), 0);
27358 ca_loc
->block
= insn_scope (prev
);
27359 if (call_arg_locations
)
27360 call_arg_loc_last
->next
= ca_loc
;
27362 call_arg_locations
= ca_loc
;
27363 call_arg_loc_last
= ca_loc
;
27365 else if (loc_note
!= NULL_RTX
&& !NOTE_DURING_CALL_P (loc_note
))
27367 newloc
->label
= last_label
;
27368 newloc
->view
= view
;
27372 if (!last_postcall_label
)
27374 sprintf (loclabel
, "%s-1", last_label
);
27375 last_postcall_label
= ggc_strdup (loclabel
);
27377 newloc
->label
= last_postcall_label
;
27378 /* ??? This view is at last_label, not last_label-1, but we
27379 could only assume view at last_label-1 is zero if we could
27380 assume calls always have length greater than one. This is
27381 probably true in general, though there might be a rare
27382 exception to this rule, e.g. if a call insn is optimized out
27383 by target magic. Then, even the -1 in the label will be
27384 wrong, which might invalidate the range. Anyway, using view,
27385 though technically possibly incorrect, will work as far as
27386 ranges go: since L-1 is in the middle of the call insn,
27387 (L-1).0 and (L-1).V shouldn't make any difference, and having
27388 the loclist entry refer to the .loc entry might be useful, so
27389 leave it like this. */
27390 newloc
->view
= view
;
27393 if (var_loc_p
&& flag_debug_asm
)
27395 const char *name
, *sep
, *patstr
;
27396 if (decl
&& DECL_NAME (decl
))
27397 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
27400 if (NOTE_VAR_LOCATION_LOC (loc_note
))
27403 patstr
= str_pattern_slim (NOTE_VAR_LOCATION_LOC (loc_note
));
27410 fprintf (asm_out_file
, "\t%s DEBUG %s%s%s\n", ASM_COMMENT_START
,
27411 name
, sep
, patstr
);
27414 last_var_location_insn
= next_real
;
27415 last_in_cold_section_p
= in_cold_section_p
;
27418 /* Check whether BLOCK, a lexical block, is nested within OUTER, or is
27419 OUTER itself. If BOTHWAYS, check not only that BLOCK can reach
27420 OUTER through BLOCK_SUPERCONTEXT links, but also that there is a
27421 path from OUTER to BLOCK through BLOCK_SUBBLOCKs and
27422 BLOCK_FRAGMENT_ORIGIN links. */
27424 block_within_block_p (tree block
, tree outer
, bool bothways
)
27426 if (block
== outer
)
27429 /* Quickly check that OUTER is up BLOCK's supercontext chain. */
27430 for (tree context
= BLOCK_SUPERCONTEXT (block
);
27432 context
= BLOCK_SUPERCONTEXT (context
))
27433 if (!context
|| TREE_CODE (context
) != BLOCK
)
27439 /* Now check that each block is actually referenced by its
27441 for (tree context
= BLOCK_SUPERCONTEXT (block
); ;
27442 context
= BLOCK_SUPERCONTEXT (context
))
27444 if (BLOCK_FRAGMENT_ORIGIN (context
))
27446 gcc_assert (!BLOCK_SUBBLOCKS (context
));
27447 context
= BLOCK_FRAGMENT_ORIGIN (context
);
27449 for (tree sub
= BLOCK_SUBBLOCKS (context
);
27451 sub
= BLOCK_CHAIN (sub
))
27454 if (context
== outer
)
27461 /* Called during final while assembling the marker of the entry point
27462 for an inlined function. */
27465 dwarf2out_inline_entry (tree block
)
27467 gcc_assert (debug_inline_points
);
27469 /* If we can't represent it, don't bother. */
27470 if (!(dwarf_version
>= 3 || !dwarf_strict
))
27473 gcc_assert (DECL_P (block_ultimate_origin (block
)));
27475 /* Sanity check the block tree. This would catch a case in which
27476 BLOCK got removed from the tree reachable from the outermost
27477 lexical block, but got retained in markers. It would still link
27478 back to its parents, but some ancestor would be missing a link
27479 down the path to the sub BLOCK. If the block got removed, its
27480 BLOCK_NUMBER will not be a usable value. */
27482 gcc_assert (block_within_block_p (block
,
27483 DECL_INITIAL (current_function_decl
),
27486 gcc_assert (inlined_function_outer_scope_p (block
));
27487 gcc_assert (!BLOCK_DIE (block
));
27489 if (BLOCK_FRAGMENT_ORIGIN (block
))
27490 block
= BLOCK_FRAGMENT_ORIGIN (block
);
27491 /* Can the entry point ever not be at the beginning of an
27492 unfragmented lexical block? */
27493 else if (!(BLOCK_FRAGMENT_CHAIN (block
)
27494 || (cur_line_info_table
27495 && !ZERO_VIEW_P (cur_line_info_table
->view
))))
27498 if (!inline_entry_data_table
)
27499 inline_entry_data_table
27500 = hash_table
<inline_entry_data_hasher
>::create_ggc (10);
27503 inline_entry_data
**iedp
27504 = inline_entry_data_table
->find_slot_with_hash (block
,
27505 htab_hash_pointer (block
),
27508 /* ??? Ideally, we'd record all entry points for the same inlined
27509 function (some may have been duplicated by e.g. unrolling), but
27510 we have no way to represent that ATM. */
27513 inline_entry_data
*ied
= *iedp
= ggc_cleared_alloc
<inline_entry_data
> ();
27514 ied
->block
= block
;
27515 ied
->label_pfx
= BLOCK_INLINE_ENTRY_LABEL
;
27516 ied
->label_num
= BLOCK_NUMBER (block
);
27517 if (cur_line_info_table
)
27518 ied
->view
= cur_line_info_table
->view
;
27520 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27522 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_INLINE_ENTRY_LABEL
,
27523 BLOCK_NUMBER (block
));
27524 ASM_OUTPUT_LABEL (asm_out_file
, label
);
27527 /* Called from finalize_size_functions for size functions so that their body
27528 can be encoded in the debug info to describe the layout of variable-length
27532 dwarf2out_size_function (tree decl
)
27534 function_to_dwarf_procedure (decl
);
27537 /* Note in one location list that text section has changed. */
27540 var_location_switch_text_section_1 (var_loc_list
**slot
, void *)
27542 var_loc_list
*list
= *slot
;
27544 list
->last_before_switch
27545 = list
->last
->next
? list
->last
->next
: list
->last
;
27549 /* Note in all location lists that text section has changed. */
27552 var_location_switch_text_section (void)
27554 if (decl_loc_table
== NULL
)
27557 decl_loc_table
->traverse
<void *, var_location_switch_text_section_1
> (NULL
);
27560 /* Create a new line number table. */
27562 static dw_line_info_table
*
27563 new_line_info_table (void)
27565 dw_line_info_table
*table
;
27567 table
= ggc_cleared_alloc
<dw_line_info_table
> ();
27568 table
->file_num
= 1;
27569 table
->line_num
= 1;
27570 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
27571 FORCE_RESET_NEXT_VIEW (table
->view
);
27572 table
->symviews_since_reset
= 0;
27577 /* Lookup the "current" table into which we emit line info, so
27578 that we don't have to do it for every source line. */
27581 set_cur_line_info_table (section
*sec
)
27583 dw_line_info_table
*table
;
27585 if (sec
== text_section
)
27586 table
= text_section_line_info
;
27587 else if (sec
== cold_text_section
)
27589 table
= cold_text_section_line_info
;
27592 cold_text_section_line_info
= table
= new_line_info_table ();
27593 table
->end_label
= cold_end_label
;
27598 const char *end_label
;
27600 if (crtl
->has_bb_partition
)
27602 if (in_cold_section_p
)
27603 end_label
= crtl
->subsections
.cold_section_end_label
;
27605 end_label
= crtl
->subsections
.hot_section_end_label
;
27609 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27610 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
27611 current_function_funcdef_no
);
27612 end_label
= ggc_strdup (label
);
27615 table
= new_line_info_table ();
27616 table
->end_label
= end_label
;
27618 vec_safe_push (separate_line_info
, table
);
27621 if (output_asm_line_debug_info ())
27622 table
->is_stmt
= (cur_line_info_table
27623 ? cur_line_info_table
->is_stmt
27624 : DWARF_LINE_DEFAULT_IS_STMT_START
);
27625 cur_line_info_table
= table
;
27629 /* We need to reset the locations at the beginning of each
27630 function. We can't do this in the end_function hook, because the
27631 declarations that use the locations won't have been output when
27632 that hook is called. Also compute have_multiple_function_sections here. */
27635 dwarf2out_begin_function (tree fun
)
27637 section
*sec
= function_section (fun
);
27639 if (sec
!= text_section
)
27640 have_multiple_function_sections
= true;
27642 if (crtl
->has_bb_partition
&& !cold_text_section
)
27644 gcc_assert (current_function_decl
== fun
);
27645 cold_text_section
= unlikely_text_section ();
27646 switch_to_section (cold_text_section
);
27647 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
27648 switch_to_section (sec
);
27651 dwarf2out_note_section_used ();
27652 call_site_count
= 0;
27653 tail_call_site_count
= 0;
27655 set_cur_line_info_table (sec
);
27656 FORCE_RESET_NEXT_VIEW (cur_line_info_table
->view
);
27659 /* Helper function of dwarf2out_end_function, called only after emitting
27660 the very first function into assembly. Check if some .debug_loc range
27661 might end with a .LVL* label that could be equal to .Ltext0.
27662 In that case we must force using absolute addresses in .debug_loc ranges,
27663 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
27664 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
27666 Set have_multiple_function_sections to true in that case and
27667 terminate htab traversal. */
27670 find_empty_loc_ranges_at_text_label (var_loc_list
**slot
, int)
27672 var_loc_list
*entry
= *slot
;
27673 struct var_loc_node
*node
;
27675 node
= entry
->first
;
27676 if (node
&& node
->next
&& node
->next
->label
)
27679 const char *label
= node
->next
->label
;
27680 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
27682 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
27684 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
27685 if (strcmp (label
, loclabel
) == 0)
27687 have_multiple_function_sections
= true;
27695 /* Hook called after emitting a function into assembly.
27696 This does something only for the very first function emitted. */
27699 dwarf2out_end_function (unsigned int)
27701 if (in_first_function_p
27702 && !have_multiple_function_sections
27703 && first_loclabel_num_not_at_text_label
27705 decl_loc_table
->traverse
<int, find_empty_loc_ranges_at_text_label
> (0);
27706 in_first_function_p
= false;
27707 maybe_at_text_label_p
= false;
27710 /* Temporary holder for dwarf2out_register_main_translation_unit. Used to let
27711 front-ends register a translation unit even before dwarf2out_init is
27713 static tree main_translation_unit
= NULL_TREE
;
27715 /* Hook called by front-ends after they built their main translation unit.
27716 Associate comp_unit_die to UNIT. */
27719 dwarf2out_register_main_translation_unit (tree unit
)
27721 gcc_assert (TREE_CODE (unit
) == TRANSLATION_UNIT_DECL
27722 && main_translation_unit
== NULL_TREE
);
27723 main_translation_unit
= unit
;
27724 /* If dwarf2out_init has not been called yet, it will perform the association
27725 itself looking at main_translation_unit. */
27726 if (decl_die_table
!= NULL
)
27727 equate_decl_number_to_die (unit
, comp_unit_die ());
27730 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
27733 push_dw_line_info_entry (dw_line_info_table
*table
,
27734 enum dw_line_info_opcode opcode
, unsigned int val
)
27736 dw_line_info_entry e
;
27739 vec_safe_push (table
->entries
, e
);
27742 /* Output a label to mark the beginning of a source code line entry
27743 and record information relating to this source line, in
27744 'line_info_table' for later output of the .debug_line section. */
27745 /* ??? The discriminator parameter ought to be unsigned. */
27748 dwarf2out_source_line (unsigned int line
, unsigned int column
,
27749 const char *filename
,
27750 int discriminator
, bool is_stmt
)
27752 unsigned int file_num
;
27753 dw_line_info_table
*table
;
27754 static var_loc_view lvugid
;
27756 if (debug_info_level
< DINFO_LEVEL_TERSE
)
27759 table
= cur_line_info_table
;
27763 if (debug_variable_location_views
27764 && output_asm_line_debug_info ()
27765 && table
&& !RESETTING_VIEW_P (table
->view
))
27767 /* If we're using the assembler to compute view numbers, we
27768 can't issue a .loc directive for line zero, so we can't
27769 get a view number at this point. We might attempt to
27770 compute it from the previous view, or equate it to a
27771 subsequent view (though it might not be there!), but
27772 since we're omitting the line number entry, we might as
27773 well omit the view number as well. That means pretending
27774 it's a view number zero, which might very well turn out
27775 to be correct. ??? Extend the assembler so that the
27776 compiler could emit e.g. ".locview .LVU#", to output a
27777 view without changing line number information. We'd then
27778 have to count it in symviews_since_reset; when it's omitted,
27779 it doesn't count. */
27781 zero_view_p
= BITMAP_GGC_ALLOC ();
27782 bitmap_set_bit (zero_view_p
, table
->view
);
27783 if (flag_debug_asm
)
27785 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27786 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", table
->view
);
27787 fprintf (asm_out_file
, "\t%s line 0, omitted view ",
27788 ASM_COMMENT_START
);
27789 assemble_name (asm_out_file
, label
);
27790 putc ('\n', asm_out_file
);
27792 table
->view
= ++lvugid
;
27797 /* The discriminator column was added in dwarf4. Simplify the below
27798 by simply removing it if we're not supposed to output it. */
27799 if (dwarf_version
< 4 && dwarf_strict
)
27802 if (!debug_column_info
)
27805 file_num
= maybe_emit_file (lookup_filename (filename
));
27807 /* ??? TODO: Elide duplicate line number entries. Traditionally,
27808 the debugger has used the second (possibly duplicate) line number
27809 at the beginning of the function to mark the end of the prologue.
27810 We could eliminate any other duplicates within the function. For
27811 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
27812 that second line number entry. */
27813 /* Recall that this end-of-prologue indication is *not* the same thing
27814 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
27815 to which the hook corresponds, follows the last insn that was
27816 emitted by gen_prologue. What we need is to precede the first insn
27817 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
27818 insn that corresponds to something the user wrote. These may be
27819 very different locations once scheduling is enabled. */
27821 if (0 && file_num
== table
->file_num
27822 && line
== table
->line_num
27823 && column
== table
->column_num
27824 && discriminator
== table
->discrim_num
27825 && is_stmt
== table
->is_stmt
)
27828 switch_to_section (current_function_section ());
27830 /* If requested, emit something human-readable. */
27831 if (flag_debug_asm
)
27833 if (debug_column_info
)
27834 fprintf (asm_out_file
, "\t%s %s:%d:%d\n", ASM_COMMENT_START
,
27835 filename
, line
, column
);
27837 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
27841 if (output_asm_line_debug_info ())
27843 /* Emit the .loc directive understood by GNU as. */
27844 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
27845 file_num, line, is_stmt, discriminator */
27846 fputs ("\t.loc ", asm_out_file
);
27847 fprint_ul (asm_out_file
, file_num
);
27848 putc (' ', asm_out_file
);
27849 fprint_ul (asm_out_file
, line
);
27850 putc (' ', asm_out_file
);
27851 fprint_ul (asm_out_file
, column
);
27853 if (is_stmt
!= table
->is_stmt
)
27855 fputs (" is_stmt ", asm_out_file
);
27856 putc (is_stmt
? '1' : '0', asm_out_file
);
27858 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
27860 gcc_assert (discriminator
> 0);
27861 fputs (" discriminator ", asm_out_file
);
27862 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
27864 if (debug_variable_location_views
)
27866 if (!RESETTING_VIEW_P (table
->view
))
27868 table
->symviews_since_reset
++;
27869 if (table
->symviews_since_reset
> symview_upper_bound
)
27870 symview_upper_bound
= table
->symviews_since_reset
;
27871 /* When we're using the assembler to compute view
27872 numbers, we output symbolic labels after "view" in
27873 .loc directives, and the assembler will set them for
27874 us, so that we can refer to the view numbers in
27875 location lists. The only exceptions are when we know
27876 a view will be zero: "-0" is a forced reset, used
27877 e.g. in the beginning of functions, whereas "0" tells
27878 the assembler to check that there was a PC change
27879 since the previous view, in a way that implicitly
27880 resets the next view. */
27881 fputs (" view ", asm_out_file
);
27882 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27883 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", table
->view
);
27884 assemble_name (asm_out_file
, label
);
27885 table
->view
= ++lvugid
;
27889 table
->symviews_since_reset
= 0;
27890 if (FORCE_RESETTING_VIEW_P (table
->view
))
27891 fputs (" view -0", asm_out_file
);
27893 fputs (" view 0", asm_out_file
);
27894 /* Mark the present view as a zero view. Earlier debug
27895 binds may have already added its id to loclists to be
27896 emitted later, so we can't reuse the id for something
27897 else. However, it's good to know whether a view is
27898 known to be zero, because then we may be able to
27899 optimize out locviews that are all zeros, so take
27900 note of it in zero_view_p. */
27902 zero_view_p
= BITMAP_GGC_ALLOC ();
27903 bitmap_set_bit (zero_view_p
, lvugid
);
27904 table
->view
= ++lvugid
;
27907 putc ('\n', asm_out_file
);
27911 unsigned int label_num
= ++line_info_label_num
;
27913 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
27915 if (debug_variable_location_views
&& !RESETTING_VIEW_P (table
->view
))
27916 push_dw_line_info_entry (table
, LI_adv_address
, label_num
);
27918 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
27919 if (debug_variable_location_views
)
27921 bool resetting
= FORCE_RESETTING_VIEW_P (table
->view
);
27925 if (flag_debug_asm
)
27926 fprintf (asm_out_file
, "\t%s view %s%d\n",
27928 resetting
? "-" : "",
27933 if (file_num
!= table
->file_num
)
27934 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
27935 if (discriminator
!= table
->discrim_num
)
27936 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
27937 if (is_stmt
!= table
->is_stmt
)
27938 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
27939 push_dw_line_info_entry (table
, LI_set_line
, line
);
27940 if (debug_column_info
)
27941 push_dw_line_info_entry (table
, LI_set_column
, column
);
27944 table
->file_num
= file_num
;
27945 table
->line_num
= line
;
27946 table
->column_num
= column
;
27947 table
->discrim_num
= discriminator
;
27948 table
->is_stmt
= is_stmt
;
27949 table
->in_use
= true;
27952 /* Record the beginning of a new source file. */
27955 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
27957 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
27960 e
.code
= DW_MACINFO_start_file
;
27962 e
.info
= ggc_strdup (filename
);
27963 vec_safe_push (macinfo_table
, e
);
27967 /* Record the end of a source file. */
27970 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
27972 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
27975 e
.code
= DW_MACINFO_end_file
;
27978 vec_safe_push (macinfo_table
, e
);
27982 /* Called from debug_define in toplev.c. The `buffer' parameter contains
27983 the tail part of the directive line, i.e. the part which is past the
27984 initial whitespace, #, whitespace, directive-name, whitespace part. */
27987 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
27988 const char *buffer ATTRIBUTE_UNUSED
)
27990 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
27993 /* Insert a dummy first entry to be able to optimize the whole
27994 predefined macro block using DW_MACRO_import. */
27995 if (macinfo_table
->is_empty () && lineno
<= 1)
28000 vec_safe_push (macinfo_table
, e
);
28002 e
.code
= DW_MACINFO_define
;
28004 e
.info
= ggc_strdup (buffer
);
28005 vec_safe_push (macinfo_table
, e
);
28009 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
28010 the tail part of the directive line, i.e. the part which is past the
28011 initial whitespace, #, whitespace, directive-name, whitespace part. */
28014 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
28015 const char *buffer ATTRIBUTE_UNUSED
)
28017 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28020 /* Insert a dummy first entry to be able to optimize the whole
28021 predefined macro block using DW_MACRO_import. */
28022 if (macinfo_table
->is_empty () && lineno
<= 1)
28027 vec_safe_push (macinfo_table
, e
);
28029 e
.code
= DW_MACINFO_undef
;
28031 e
.info
= ggc_strdup (buffer
);
28032 vec_safe_push (macinfo_table
, e
);
28036 /* Helpers to manipulate hash table of CUs. */
28038 struct macinfo_entry_hasher
: nofree_ptr_hash
<macinfo_entry
>
28040 static inline hashval_t
hash (const macinfo_entry
*);
28041 static inline bool equal (const macinfo_entry
*, const macinfo_entry
*);
28045 macinfo_entry_hasher::hash (const macinfo_entry
*entry
)
28047 return htab_hash_string (entry
->info
);
28051 macinfo_entry_hasher::equal (const macinfo_entry
*entry1
,
28052 const macinfo_entry
*entry2
)
28054 return !strcmp (entry1
->info
, entry2
->info
);
28057 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
28059 /* Output a single .debug_macinfo entry. */
28062 output_macinfo_op (macinfo_entry
*ref
)
28066 struct indirect_string_node
*node
;
28067 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28068 struct dwarf_file_data
*fd
;
28072 case DW_MACINFO_start_file
:
28073 fd
= lookup_filename (ref
->info
);
28074 file_num
= maybe_emit_file (fd
);
28075 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
28076 dw2_asm_output_data_uleb128 (ref
->lineno
,
28077 "Included from line number %lu",
28078 (unsigned long) ref
->lineno
);
28079 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
28081 case DW_MACINFO_end_file
:
28082 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
28084 case DW_MACINFO_define
:
28085 case DW_MACINFO_undef
:
28086 len
= strlen (ref
->info
) + 1;
28088 && len
> DWARF_OFFSET_SIZE
28089 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
28090 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
28092 ref
->code
= ref
->code
== DW_MACINFO_define
28093 ? DW_MACRO_define_strp
: DW_MACRO_undef_strp
;
28094 output_macinfo_op (ref
);
28097 dw2_asm_output_data (1, ref
->code
,
28098 ref
->code
== DW_MACINFO_define
28099 ? "Define macro" : "Undefine macro");
28100 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
28101 (unsigned long) ref
->lineno
);
28102 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
28104 case DW_MACRO_define_strp
:
28105 case DW_MACRO_undef_strp
:
28106 node
= find_AT_string (ref
->info
);
28108 && (node
->form
== DW_FORM_strp
28109 || node
->form
== dwarf_FORM (DW_FORM_strx
)));
28110 dw2_asm_output_data (1, ref
->code
,
28111 ref
->code
== DW_MACRO_define_strp
28112 ? "Define macro strp"
28113 : "Undefine macro strp");
28114 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
28115 (unsigned long) ref
->lineno
);
28116 if (node
->form
== DW_FORM_strp
)
28117 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
28118 debug_str_section
, "The macro: \"%s\"",
28121 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
28124 case DW_MACRO_import
:
28125 dw2_asm_output_data (1, ref
->code
, "Import");
28126 ASM_GENERATE_INTERNAL_LABEL (label
,
28127 DEBUG_MACRO_SECTION_LABEL
,
28128 ref
->lineno
+ macinfo_label_base
);
28129 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
28132 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
28133 ASM_COMMENT_START
, (unsigned long) ref
->code
);
28138 /* Attempt to make a sequence of define/undef macinfo ops shareable with
28139 other compilation unit .debug_macinfo sections. IDX is the first
28140 index of a define/undef, return the number of ops that should be
28141 emitted in a comdat .debug_macinfo section and emit
28142 a DW_MACRO_import entry referencing it.
28143 If the define/undef entry should be emitted normally, return 0. */
28146 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
28147 macinfo_hash_type
**macinfo_htab
)
28149 macinfo_entry
*first
, *second
, *cur
, *inc
;
28150 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
28151 unsigned char checksum
[16];
28152 struct md5_ctx ctx
;
28153 char *grp_name
, *tail
;
28155 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
28156 macinfo_entry
**slot
;
28158 first
= &(*macinfo_table
)[idx
];
28159 second
= &(*macinfo_table
)[idx
+ 1];
28161 /* Optimize only if there are at least two consecutive define/undef ops,
28162 and either all of them are before first DW_MACINFO_start_file
28163 with lineno {0,1} (i.e. predefined macro block), or all of them are
28164 in some included header file. */
28165 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
28167 if (vec_safe_is_empty (files
))
28169 if (first
->lineno
> 1 || second
->lineno
> 1)
28172 else if (first
->lineno
== 0)
28175 /* Find the last define/undef entry that can be grouped together
28176 with first and at the same time compute md5 checksum of their
28177 codes, linenumbers and strings. */
28178 md5_init_ctx (&ctx
);
28179 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
28180 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
28182 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
28186 unsigned char code
= cur
->code
;
28187 md5_process_bytes (&code
, 1, &ctx
);
28188 checksum_uleb128 (cur
->lineno
, &ctx
);
28189 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
28191 md5_finish_ctx (&ctx
, checksum
);
28194 /* From the containing include filename (if any) pick up just
28195 usable characters from its basename. */
28196 if (vec_safe_is_empty (files
))
28199 base
= lbasename (files
->last ().info
);
28200 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
28201 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
28202 encoded_filename_len
++;
28203 /* Count . at the end. */
28204 if (encoded_filename_len
)
28205 encoded_filename_len
++;
28207 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
28208 linebuf_len
= strlen (linebuf
);
28210 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
28211 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
28213 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
28214 tail
= grp_name
+ 4;
28215 if (encoded_filename_len
)
28217 for (i
= 0; base
[i
]; i
++)
28218 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
28222 memcpy (tail
, linebuf
, linebuf_len
);
28223 tail
+= linebuf_len
;
28225 for (i
= 0; i
< 16; i
++)
28226 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
28228 /* Construct a macinfo_entry for DW_MACRO_import
28229 in the empty vector entry before the first define/undef. */
28230 inc
= &(*macinfo_table
)[idx
- 1];
28231 inc
->code
= DW_MACRO_import
;
28233 inc
->info
= ggc_strdup (grp_name
);
28234 if (!*macinfo_htab
)
28235 *macinfo_htab
= new macinfo_hash_type (10);
28236 /* Avoid emitting duplicates. */
28237 slot
= (*macinfo_htab
)->find_slot (inc
, INSERT
);
28242 /* If such an entry has been used before, just emit
28243 a DW_MACRO_import op. */
28245 output_macinfo_op (inc
);
28246 /* And clear all macinfo_entry in the range to avoid emitting them
28247 in the second pass. */
28248 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
28257 inc
->lineno
= (*macinfo_htab
)->elements ();
28258 output_macinfo_op (inc
);
28263 /* Save any strings needed by the macinfo table in the debug str
28264 table. All strings must be collected into the table by the time
28265 index_string is called. */
28268 save_macinfo_strings (void)
28272 macinfo_entry
*ref
;
28274 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
28278 /* Match the logic in output_macinfo_op to decide on
28279 indirect strings. */
28280 case DW_MACINFO_define
:
28281 case DW_MACINFO_undef
:
28282 len
= strlen (ref
->info
) + 1;
28284 && len
> DWARF_OFFSET_SIZE
28285 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
28286 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
28287 set_indirect_string (find_AT_string (ref
->info
));
28289 case DW_MACINFO_start_file
:
28290 /* -gsplit-dwarf -g3 will also output filename as indirect
28292 if (!dwarf_split_debug_info
)
28294 /* Fall through. */
28295 case DW_MACRO_define_strp
:
28296 case DW_MACRO_undef_strp
:
28297 set_indirect_string (find_AT_string (ref
->info
));
28305 /* Output macinfo section(s). */
28308 output_macinfo (const char *debug_line_label
, bool early_lto_debug
)
28311 unsigned long length
= vec_safe_length (macinfo_table
);
28312 macinfo_entry
*ref
;
28313 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
28314 macinfo_hash_type
*macinfo_htab
= NULL
;
28315 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
28320 /* output_macinfo* uses these interchangeably. */
28321 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_define
28322 && (int) DW_MACINFO_undef
== (int) DW_MACRO_undef
28323 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_start_file
28324 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_end_file
);
28326 /* AIX Assembler inserts the length, so adjust the reference to match the
28327 offset expected by debuggers. */
28328 strcpy (dl_section_ref
, debug_line_label
);
28329 if (XCOFF_DEBUGGING_INFO
)
28330 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
28332 /* For .debug_macro emit the section header. */
28333 if (!dwarf_strict
|| dwarf_version
>= 5)
28335 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
28336 "DWARF macro version number");
28337 if (DWARF_OFFSET_SIZE
== 8)
28338 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
28340 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
28341 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_line_label
,
28342 debug_line_section
, NULL
);
28345 /* In the first loop, it emits the primary .debug_macinfo section
28346 and after each emitted op the macinfo_entry is cleared.
28347 If a longer range of define/undef ops can be optimized using
28348 DW_MACRO_import, the DW_MACRO_import op is emitted and kept in
28349 the vector before the first define/undef in the range and the
28350 whole range of define/undef ops is not emitted and kept. */
28351 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
28355 case DW_MACINFO_start_file
:
28356 vec_safe_push (files
, *ref
);
28358 case DW_MACINFO_end_file
:
28359 if (!vec_safe_is_empty (files
))
28362 case DW_MACINFO_define
:
28363 case DW_MACINFO_undef
:
28364 if ((!dwarf_strict
|| dwarf_version
>= 5)
28365 && HAVE_COMDAT_GROUP
28366 && vec_safe_length (files
) != 1
28369 && (*macinfo_table
)[i
- 1].code
== 0)
28371 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
28380 /* A dummy entry may be inserted at the beginning to be able
28381 to optimize the whole block of predefined macros. */
28387 output_macinfo_op (ref
);
28395 /* Save the number of transparent includes so we can adjust the
28396 label number for the fat LTO object DWARF. */
28397 unsigned macinfo_label_base_adj
= macinfo_htab
->elements ();
28399 delete macinfo_htab
;
28400 macinfo_htab
= NULL
;
28402 /* If any DW_MACRO_import were used, on those DW_MACRO_import entries
28403 terminate the current chain and switch to a new comdat .debug_macinfo
28404 section and emit the define/undef entries within it. */
28405 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
28410 case DW_MACRO_import
:
28412 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28413 tree comdat_key
= get_identifier (ref
->info
);
28414 /* Terminate the previous .debug_macinfo section. */
28415 dw2_asm_output_data (1, 0, "End compilation unit");
28416 targetm
.asm_out
.named_section (debug_macinfo_section_name
,
28420 ? SECTION_EXCLUDE
: 0),
28422 ASM_GENERATE_INTERNAL_LABEL (label
,
28423 DEBUG_MACRO_SECTION_LABEL
,
28424 ref
->lineno
+ macinfo_label_base
);
28425 ASM_OUTPUT_LABEL (asm_out_file
, label
);
28428 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
28429 "DWARF macro version number");
28430 if (DWARF_OFFSET_SIZE
== 8)
28431 dw2_asm_output_data (1, 1, "Flags: 64-bit");
28433 dw2_asm_output_data (1, 0, "Flags: 32-bit");
28436 case DW_MACINFO_define
:
28437 case DW_MACINFO_undef
:
28438 output_macinfo_op (ref
);
28443 gcc_unreachable ();
28446 macinfo_label_base
+= macinfo_label_base_adj
;
28449 /* Initialize the various sections and labels for dwarf output and prefix
28450 them with PREFIX if non-NULL. Returns the generation (zero based
28451 number of times function was called). */
28454 init_sections_and_labels (bool early_lto_debug
)
28456 /* As we may get called multiple times have a generation count for
28458 static unsigned generation
= 0;
28460 if (early_lto_debug
)
28462 if (!dwarf_split_debug_info
)
28464 debug_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
28465 SECTION_DEBUG
| SECTION_EXCLUDE
,
28467 debug_abbrev_section
= get_section (DEBUG_LTO_ABBREV_SECTION
,
28468 SECTION_DEBUG
| SECTION_EXCLUDE
,
28470 debug_macinfo_section_name
28471 = ((dwarf_strict
&& dwarf_version
< 5)
28472 ? DEBUG_LTO_MACINFO_SECTION
: DEBUG_LTO_MACRO_SECTION
);
28473 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28475 | SECTION_EXCLUDE
, NULL
);
28479 /* ??? Which of the following do we need early? */
28480 debug_info_section
= get_section (DEBUG_LTO_DWO_INFO_SECTION
,
28481 SECTION_DEBUG
| SECTION_EXCLUDE
,
28483 debug_abbrev_section
= get_section (DEBUG_LTO_DWO_ABBREV_SECTION
,
28484 SECTION_DEBUG
| SECTION_EXCLUDE
,
28486 debug_skeleton_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
28488 | SECTION_EXCLUDE
, NULL
);
28489 debug_skeleton_abbrev_section
28490 = get_section (DEBUG_LTO_ABBREV_SECTION
,
28491 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28492 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
28493 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
28496 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
28497 stay in the main .o, but the skeleton_line goes into the split
28499 debug_skeleton_line_section
28500 = get_section (DEBUG_LTO_LINE_SECTION
,
28501 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28502 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
28503 DEBUG_SKELETON_LINE_SECTION_LABEL
,
28505 debug_str_offsets_section
28506 = get_section (DEBUG_LTO_DWO_STR_OFFSETS_SECTION
,
28507 SECTION_DEBUG
| SECTION_EXCLUDE
,
28509 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
28510 DEBUG_SKELETON_INFO_SECTION_LABEL
,
28512 debug_str_dwo_section
= get_section (DEBUG_LTO_STR_DWO_SECTION
,
28513 DEBUG_STR_DWO_SECTION_FLAGS
,
28515 debug_macinfo_section_name
28516 = ((dwarf_strict
&& dwarf_version
< 5)
28517 ? DEBUG_LTO_DWO_MACINFO_SECTION
: DEBUG_LTO_DWO_MACRO_SECTION
);
28518 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28519 SECTION_DEBUG
| SECTION_EXCLUDE
,
28522 /* For macro info and the file table we have to refer to a
28523 debug_line section. */
28524 debug_line_section
= get_section (DEBUG_LTO_LINE_SECTION
,
28525 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28526 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
28527 DEBUG_LINE_SECTION_LABEL
, generation
);
28529 debug_str_section
= get_section (DEBUG_LTO_STR_SECTION
,
28530 DEBUG_STR_SECTION_FLAGS
28531 | SECTION_EXCLUDE
, NULL
);
28532 if (!dwarf_split_debug_info
)
28533 debug_line_str_section
28534 = get_section (DEBUG_LTO_LINE_STR_SECTION
,
28535 DEBUG_STR_SECTION_FLAGS
| SECTION_EXCLUDE
, NULL
);
28539 if (!dwarf_split_debug_info
)
28541 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
28542 SECTION_DEBUG
, NULL
);
28543 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
28544 SECTION_DEBUG
, NULL
);
28545 debug_loc_section
= get_section (dwarf_version
>= 5
28546 ? DEBUG_LOCLISTS_SECTION
28547 : DEBUG_LOC_SECTION
,
28548 SECTION_DEBUG
, NULL
);
28549 debug_macinfo_section_name
28550 = ((dwarf_strict
&& dwarf_version
< 5)
28551 ? DEBUG_MACINFO_SECTION
: DEBUG_MACRO_SECTION
);
28552 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28553 SECTION_DEBUG
, NULL
);
28557 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
28558 SECTION_DEBUG
| SECTION_EXCLUDE
,
28560 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
28561 SECTION_DEBUG
| SECTION_EXCLUDE
,
28563 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
28564 SECTION_DEBUG
, NULL
);
28565 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
28566 SECTION_DEBUG
, NULL
);
28567 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
28568 SECTION_DEBUG
, NULL
);
28569 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
28570 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
28573 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
28574 stay in the main .o, but the skeleton_line goes into the
28576 debug_skeleton_line_section
28577 = get_section (DEBUG_DWO_LINE_SECTION
,
28578 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28579 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
28580 DEBUG_SKELETON_LINE_SECTION_LABEL
,
28582 debug_str_offsets_section
28583 = get_section (DEBUG_DWO_STR_OFFSETS_SECTION
,
28584 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28585 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
28586 DEBUG_SKELETON_INFO_SECTION_LABEL
,
28588 debug_loc_section
= get_section (dwarf_version
>= 5
28589 ? DEBUG_DWO_LOCLISTS_SECTION
28590 : DEBUG_DWO_LOC_SECTION
,
28591 SECTION_DEBUG
| SECTION_EXCLUDE
,
28593 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
28594 DEBUG_STR_DWO_SECTION_FLAGS
,
28596 debug_macinfo_section_name
28597 = ((dwarf_strict
&& dwarf_version
< 5)
28598 ? DEBUG_DWO_MACINFO_SECTION
: DEBUG_DWO_MACRO_SECTION
);
28599 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28600 SECTION_DEBUG
| SECTION_EXCLUDE
,
28603 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
28604 SECTION_DEBUG
, NULL
);
28605 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
28606 SECTION_DEBUG
, NULL
);
28607 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
28608 SECTION_DEBUG
, NULL
);
28609 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
28610 SECTION_DEBUG
, NULL
);
28611 debug_str_section
= get_section (DEBUG_STR_SECTION
,
28612 DEBUG_STR_SECTION_FLAGS
, NULL
);
28613 if (!dwarf_split_debug_info
&& !output_asm_line_debug_info ())
28614 debug_line_str_section
= get_section (DEBUG_LINE_STR_SECTION
,
28615 DEBUG_STR_SECTION_FLAGS
, NULL
);
28617 debug_ranges_section
= get_section (dwarf_version
>= 5
28618 ? DEBUG_RNGLISTS_SECTION
28619 : DEBUG_RANGES_SECTION
,
28620 SECTION_DEBUG
, NULL
);
28621 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
28622 SECTION_DEBUG
, NULL
);
28625 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
28626 DEBUG_ABBREV_SECTION_LABEL
, generation
);
28627 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
28628 DEBUG_INFO_SECTION_LABEL
, generation
);
28629 info_section_emitted
= false;
28630 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
28631 DEBUG_LINE_SECTION_LABEL
, generation
);
28632 /* There are up to 4 unique ranges labels per generation.
28633 See also output_rnglists. */
28634 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
28635 DEBUG_RANGES_SECTION_LABEL
, generation
* 4);
28636 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
28637 ASM_GENERATE_INTERNAL_LABEL (ranges_base_label
,
28638 DEBUG_RANGES_SECTION_LABEL
,
28639 1 + generation
* 4);
28640 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
28641 DEBUG_ADDR_SECTION_LABEL
, generation
);
28642 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
28643 (dwarf_strict
&& dwarf_version
< 5)
28644 ? DEBUG_MACINFO_SECTION_LABEL
28645 : DEBUG_MACRO_SECTION_LABEL
, generation
);
28646 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
,
28650 return generation
- 1;
28653 /* Set up for Dwarf output at the start of compilation. */
28656 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
28658 /* Allocate the file_table. */
28659 file_table
= hash_table
<dwarf_file_hasher
>::create_ggc (50);
28661 #ifndef DWARF2_LINENO_DEBUGGING_INFO
28662 /* Allocate the decl_die_table. */
28663 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (10);
28665 /* Allocate the decl_loc_table. */
28666 decl_loc_table
= hash_table
<decl_loc_hasher
>::create_ggc (10);
28668 /* Allocate the cached_dw_loc_list_table. */
28669 cached_dw_loc_list_table
= hash_table
<dw_loc_list_hasher
>::create_ggc (10);
28671 /* Allocate the initial hunk of the abbrev_die_table. */
28672 vec_alloc (abbrev_die_table
, 256);
28673 /* Zero-th entry is allocated, but unused. */
28674 abbrev_die_table
->quick_push (NULL
);
28676 /* Allocate the dwarf_proc_stack_usage_map. */
28677 dwarf_proc_stack_usage_map
= new hash_map
<dw_die_ref
, int>;
28679 /* Allocate the pubtypes and pubnames vectors. */
28680 vec_alloc (pubname_table
, 32);
28681 vec_alloc (pubtype_table
, 32);
28683 vec_alloc (incomplete_types
, 64);
28685 vec_alloc (used_rtx_array
, 32);
28687 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28688 vec_alloc (macinfo_table
, 64);
28691 /* If front-ends already registered a main translation unit but we were not
28692 ready to perform the association, do this now. */
28693 if (main_translation_unit
!= NULL_TREE
)
28694 equate_decl_number_to_die (main_translation_unit
, comp_unit_die ());
28697 /* Called before compile () starts outputtting functions, variables
28698 and toplevel asms into assembly. */
28701 dwarf2out_assembly_start (void)
28703 if (text_section_line_info
)
28706 #ifndef DWARF2_LINENO_DEBUGGING_INFO
28707 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
28708 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
28709 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
28710 COLD_TEXT_SECTION_LABEL
, 0);
28711 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
28713 switch_to_section (text_section
);
28714 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
28717 /* Make sure the line number table for .text always exists. */
28718 text_section_line_info
= new_line_info_table ();
28719 text_section_line_info
->end_label
= text_end_label
;
28721 #ifdef DWARF2_LINENO_DEBUGGING_INFO
28722 cur_line_info_table
= text_section_line_info
;
28725 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
28726 && dwarf2out_do_cfi_asm ()
28727 && !dwarf2out_do_eh_frame ())
28728 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
28731 /* A helper function for dwarf2out_finish called through
28732 htab_traverse. Assign a string its index. All strings must be
28733 collected into the table by the time index_string is called,
28734 because the indexing code relies on htab_traverse to traverse nodes
28735 in the same order for each run. */
28738 index_string (indirect_string_node
**h
, unsigned int *index
)
28740 indirect_string_node
*node
= *h
;
28742 find_string_form (node
);
28743 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28745 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
28746 node
->index
= *index
;
28752 /* A helper function for output_indirect_strings called through
28753 htab_traverse. Output the offset to a string and update the
28757 output_index_string_offset (indirect_string_node
**h
, unsigned int *offset
)
28759 indirect_string_node
*node
= *h
;
28761 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28763 /* Assert that this node has been assigned an index. */
28764 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
28765 && node
->index
!= NOT_INDEXED
);
28766 dw2_asm_output_data (DWARF_OFFSET_SIZE
, *offset
,
28767 "indexed string 0x%x: %s", node
->index
, node
->str
);
28768 *offset
+= strlen (node
->str
) + 1;
28773 /* A helper function for dwarf2out_finish called through
28774 htab_traverse. Output the indexed string. */
28777 output_index_string (indirect_string_node
**h
, unsigned int *cur_idx
)
28779 struct indirect_string_node
*node
= *h
;
28781 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28783 /* Assert that the strings are output in the same order as their
28784 indexes were assigned. */
28785 gcc_assert (*cur_idx
== node
->index
);
28786 assemble_string (node
->str
, strlen (node
->str
) + 1);
28792 /* A helper function for output_indirect_strings. Counts the number
28793 of index strings offsets. Must match the logic of the functions
28794 output_index_string[_offsets] above. */
28796 count_index_strings (indirect_string_node
**h
, unsigned int *last_idx
)
28798 struct indirect_string_node
*node
= *h
;
28800 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28805 /* A helper function for dwarf2out_finish called through
28806 htab_traverse. Emit one queued .debug_str string. */
28809 output_indirect_string (indirect_string_node
**h
, enum dwarf_form form
)
28811 struct indirect_string_node
*node
= *h
;
28813 node
->form
= find_string_form (node
);
28814 if (node
->form
== form
&& node
->refcount
> 0)
28816 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
28817 assemble_string (node
->str
, strlen (node
->str
) + 1);
28823 /* Output the indexed string table. */
28826 output_indirect_strings (void)
28828 switch_to_section (debug_str_section
);
28829 if (!dwarf_split_debug_info
)
28830 debug_str_hash
->traverse
<enum dwarf_form
,
28831 output_indirect_string
> (DW_FORM_strp
);
28834 unsigned int offset
= 0;
28835 unsigned int cur_idx
= 0;
28837 if (skeleton_debug_str_hash
)
28838 skeleton_debug_str_hash
->traverse
<enum dwarf_form
,
28839 output_indirect_string
> (DW_FORM_strp
);
28841 switch_to_section (debug_str_offsets_section
);
28842 /* For DWARF5 the .debug_str_offsets[.dwo] section needs a unit
28843 header. Note that we don't need to generate a label to the
28844 actual index table following the header here, because this is
28845 for the split dwarf case only. In an .dwo file there is only
28846 one string offsets table (and one debug info section). But
28847 if we would start using string offset tables for the main (or
28848 skeleton) unit, then we have to add a DW_AT_str_offsets_base
28849 pointing to the actual index after the header. Split dwarf
28850 units will never have a string offsets base attribute. When
28851 a split unit is moved into a .dwp file the string offsets can
28852 be found through the .debug_cu_index section table. */
28853 if (dwarf_version
>= 5)
28855 unsigned int last_idx
= 0;
28856 unsigned long str_offsets_length
;
28858 debug_str_hash
->traverse_noresize
28859 <unsigned int *, count_index_strings
> (&last_idx
);
28860 str_offsets_length
= last_idx
* DWARF_OFFSET_SIZE
+ 4;
28861 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
28862 dw2_asm_output_data (4, 0xffffffff,
28863 "Escape value for 64-bit DWARF extension");
28864 dw2_asm_output_data (DWARF_OFFSET_SIZE
, str_offsets_length
,
28865 "Length of string offsets unit");
28866 dw2_asm_output_data (2, 5, "DWARF string offsets version");
28867 dw2_asm_output_data (2, 0, "Header zero padding");
28869 debug_str_hash
->traverse_noresize
28870 <unsigned int *, output_index_string_offset
> (&offset
);
28871 switch_to_section (debug_str_dwo_section
);
28872 debug_str_hash
->traverse_noresize
<unsigned int *, output_index_string
>
28877 /* Callback for htab_traverse to assign an index to an entry in the
28878 table, and to write that entry to the .debug_addr section. */
28881 output_addr_table_entry (addr_table_entry
**slot
, unsigned int *cur_index
)
28883 addr_table_entry
*entry
= *slot
;
28885 if (entry
->refcount
== 0)
28887 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
28888 || entry
->index
== NOT_INDEXED
);
28892 gcc_assert (entry
->index
== *cur_index
);
28895 switch (entry
->kind
)
28898 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
28899 "0x%x", entry
->index
);
28901 case ate_kind_rtx_dtprel
:
28902 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
28903 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
28906 fputc ('\n', asm_out_file
);
28908 case ate_kind_label
:
28909 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
28910 "0x%x", entry
->index
);
28913 gcc_unreachable ();
28918 /* A helper function for dwarf2out_finish. Counts the number
28919 of indexed addresses. Must match the logic of the functions
28920 output_addr_table_entry above. */
28922 count_index_addrs (addr_table_entry
**slot
, unsigned int *last_idx
)
28924 addr_table_entry
*entry
= *slot
;
28926 if (entry
->refcount
> 0)
28931 /* Produce the .debug_addr section. */
28934 output_addr_table (void)
28936 unsigned int index
= 0;
28937 if (addr_index_table
== NULL
|| addr_index_table
->size () == 0)
28940 switch_to_section (debug_addr_section
);
28942 ->traverse_noresize
<unsigned int *, output_addr_table_entry
> (&index
);
28945 #if ENABLE_ASSERT_CHECKING
28946 /* Verify that all marks are clear. */
28949 verify_marks_clear (dw_die_ref die
)
28953 gcc_assert (! die
->die_mark
);
28954 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
28956 #endif /* ENABLE_ASSERT_CHECKING */
28958 /* Clear the marks for a die and its children.
28959 Be cool if the mark isn't set. */
28962 prune_unmark_dies (dw_die_ref die
)
28968 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
28971 /* Given LOC that is referenced by a DIE we're marking as used, find all
28972 referenced DWARF procedures it references and mark them as used. */
28975 prune_unused_types_walk_loc_descr (dw_loc_descr_ref loc
)
28977 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
28978 switch (loc
->dw_loc_opc
)
28980 case DW_OP_implicit_pointer
:
28981 case DW_OP_convert
:
28982 case DW_OP_reinterpret
:
28983 case DW_OP_GNU_implicit_pointer
:
28984 case DW_OP_GNU_convert
:
28985 case DW_OP_GNU_reinterpret
:
28986 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
)
28987 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
28989 case DW_OP_GNU_variable_value
:
28990 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
28993 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
28996 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
28997 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
28998 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29003 case DW_OP_call_ref
:
29004 case DW_OP_const_type
:
29005 case DW_OP_GNU_const_type
:
29006 case DW_OP_GNU_parameter_ref
:
29007 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
);
29008 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
29010 case DW_OP_regval_type
:
29011 case DW_OP_deref_type
:
29012 case DW_OP_GNU_regval_type
:
29013 case DW_OP_GNU_deref_type
:
29014 gcc_assert (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_die_ref
);
29015 prune_unused_types_mark (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
, 1);
29017 case DW_OP_entry_value
:
29018 case DW_OP_GNU_entry_value
:
29019 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
);
29020 prune_unused_types_walk_loc_descr (loc
->dw_loc_oprnd1
.v
.val_loc
);
29027 /* Given DIE that we're marking as used, find any other dies
29028 it references as attributes and mark them as used. */
29031 prune_unused_types_walk_attribs (dw_die_ref die
)
29036 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29038 switch (AT_class (a
))
29040 /* Make sure DWARF procedures referenced by location descriptions will
29042 case dw_val_class_loc
:
29043 prune_unused_types_walk_loc_descr (AT_loc (a
));
29045 case dw_val_class_loc_list
:
29046 for (dw_loc_list_ref list
= AT_loc_list (a
);
29048 list
= list
->dw_loc_next
)
29049 prune_unused_types_walk_loc_descr (list
->expr
);
29052 case dw_val_class_view_list
:
29053 /* This points to a loc_list in another attribute, so it's
29054 already covered. */
29057 case dw_val_class_die_ref
:
29058 /* A reference to another DIE.
29059 Make sure that it will get emitted.
29060 If it was broken out into a comdat group, don't follow it. */
29061 if (! AT_ref (a
)->comdat_type_p
29062 || a
->dw_attr
== DW_AT_specification
)
29063 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
29066 case dw_val_class_str
:
29067 /* Set the string's refcount to 0 so that prune_unused_types_mark
29068 accounts properly for it. */
29069 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
29078 /* Mark the generic parameters and arguments children DIEs of DIE. */
29081 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
29085 if (die
== NULL
|| die
->die_child
== NULL
)
29087 c
= die
->die_child
;
29090 if (is_template_parameter (c
))
29091 prune_unused_types_mark (c
, 1);
29093 } while (c
&& c
!= die
->die_child
);
29096 /* Mark DIE as being used. If DOKIDS is true, then walk down
29097 to DIE's children. */
29100 prune_unused_types_mark (dw_die_ref die
, int dokids
)
29104 if (die
->die_mark
== 0)
29106 /* We haven't done this node yet. Mark it as used. */
29108 /* If this is the DIE of a generic type instantiation,
29109 mark the children DIEs that describe its generic parms and
29111 prune_unused_types_mark_generic_parms_dies (die
);
29113 /* We also have to mark its parents as used.
29114 (But we don't want to mark our parent's kids due to this,
29115 unless it is a class.) */
29116 if (die
->die_parent
)
29117 prune_unused_types_mark (die
->die_parent
,
29118 class_scope_p (die
->die_parent
));
29120 /* Mark any referenced nodes. */
29121 prune_unused_types_walk_attribs (die
);
29123 /* If this node is a specification,
29124 also mark the definition, if it exists. */
29125 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
29126 prune_unused_types_mark (die
->die_definition
, 1);
29129 if (dokids
&& die
->die_mark
!= 2)
29131 /* We need to walk the children, but haven't done so yet.
29132 Remember that we've walked the kids. */
29135 /* If this is an array type, we need to make sure our
29136 kids get marked, even if they're types. If we're
29137 breaking out types into comdat sections, do this
29138 for all type definitions. */
29139 if (die
->die_tag
== DW_TAG_array_type
29140 || (use_debug_types
29141 && is_type_die (die
) && ! is_declaration_die (die
)))
29142 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
29144 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
29148 /* For local classes, look if any static member functions were emitted
29149 and if so, mark them. */
29152 prune_unused_types_walk_local_classes (dw_die_ref die
)
29156 if (die
->die_mark
== 2)
29159 switch (die
->die_tag
)
29161 case DW_TAG_structure_type
:
29162 case DW_TAG_union_type
:
29163 case DW_TAG_class_type
:
29166 case DW_TAG_subprogram
:
29167 if (!get_AT_flag (die
, DW_AT_declaration
)
29168 || die
->die_definition
!= NULL
)
29169 prune_unused_types_mark (die
, 1);
29176 /* Mark children. */
29177 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
29180 /* Walk the tree DIE and mark types that we actually use. */
29183 prune_unused_types_walk (dw_die_ref die
)
29187 /* Don't do anything if this node is already marked and
29188 children have been marked as well. */
29189 if (die
->die_mark
== 2)
29192 switch (die
->die_tag
)
29194 case DW_TAG_structure_type
:
29195 case DW_TAG_union_type
:
29196 case DW_TAG_class_type
:
29197 if (die
->die_perennial_p
)
29200 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
29201 if (c
->die_tag
== DW_TAG_subprogram
)
29204 /* Finding used static member functions inside of classes
29205 is needed just for local classes, because for other classes
29206 static member function DIEs with DW_AT_specification
29207 are emitted outside of the DW_TAG_*_type. If we ever change
29208 it, we'd need to call this even for non-local classes. */
29210 prune_unused_types_walk_local_classes (die
);
29212 /* It's a type node --- don't mark it. */
29215 case DW_TAG_const_type
:
29216 case DW_TAG_packed_type
:
29217 case DW_TAG_pointer_type
:
29218 case DW_TAG_reference_type
:
29219 case DW_TAG_rvalue_reference_type
:
29220 case DW_TAG_volatile_type
:
29221 case DW_TAG_typedef
:
29222 case DW_TAG_array_type
:
29223 case DW_TAG_interface_type
:
29224 case DW_TAG_friend
:
29225 case DW_TAG_enumeration_type
:
29226 case DW_TAG_subroutine_type
:
29227 case DW_TAG_string_type
:
29228 case DW_TAG_set_type
:
29229 case DW_TAG_subrange_type
:
29230 case DW_TAG_ptr_to_member_type
:
29231 case DW_TAG_file_type
:
29232 /* Type nodes are useful only when other DIEs reference them --- don't
29236 case DW_TAG_dwarf_procedure
:
29237 /* Likewise for DWARF procedures. */
29239 if (die
->die_perennial_p
)
29245 /* Mark everything else. */
29249 if (die
->die_mark
== 0)
29253 /* Now, mark any dies referenced from here. */
29254 prune_unused_types_walk_attribs (die
);
29259 /* Mark children. */
29260 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
29263 /* Increment the string counts on strings referred to from DIE's
29267 prune_unused_types_update_strings (dw_die_ref die
)
29272 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29273 if (AT_class (a
) == dw_val_class_str
)
29275 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
29277 /* Avoid unnecessarily putting strings that are used less than
29278 twice in the hash table. */
29280 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
29282 indirect_string_node
**slot
29283 = debug_str_hash
->find_slot_with_hash (s
->str
,
29284 htab_hash_string (s
->str
),
29286 gcc_assert (*slot
== NULL
);
29292 /* Mark DIE and its children as removed. */
29295 mark_removed (dw_die_ref die
)
29298 die
->removed
= true;
29299 FOR_EACH_CHILD (die
, c
, mark_removed (c
));
29302 /* Remove from the tree DIE any dies that aren't marked. */
29305 prune_unused_types_prune (dw_die_ref die
)
29309 gcc_assert (die
->die_mark
);
29310 prune_unused_types_update_strings (die
);
29312 if (! die
->die_child
)
29315 c
= die
->die_child
;
29317 dw_die_ref prev
= c
, next
;
29318 for (c
= c
->die_sib
; ! c
->die_mark
; c
= next
)
29319 if (c
== die
->die_child
)
29321 /* No marked children between 'prev' and the end of the list. */
29323 /* No marked children at all. */
29324 die
->die_child
= NULL
;
29327 prev
->die_sib
= c
->die_sib
;
29328 die
->die_child
= prev
;
29341 if (c
!= prev
->die_sib
)
29343 prune_unused_types_prune (c
);
29344 } while (c
!= die
->die_child
);
29347 /* Remove dies representing declarations that we never use. */
29350 prune_unused_types (void)
29353 limbo_die_node
*node
;
29354 comdat_type_node
*ctnode
;
29355 pubname_entry
*pub
;
29356 dw_die_ref base_type
;
29358 #if ENABLE_ASSERT_CHECKING
29359 /* All the marks should already be clear. */
29360 verify_marks_clear (comp_unit_die ());
29361 for (node
= limbo_die_list
; node
; node
= node
->next
)
29362 verify_marks_clear (node
->die
);
29363 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29364 verify_marks_clear (ctnode
->root_die
);
29365 #endif /* ENABLE_ASSERT_CHECKING */
29367 /* Mark types that are used in global variables. */
29368 premark_types_used_by_global_vars ();
29370 /* Set the mark on nodes that are actually used. */
29371 prune_unused_types_walk (comp_unit_die ());
29372 for (node
= limbo_die_list
; node
; node
= node
->next
)
29373 prune_unused_types_walk (node
->die
);
29374 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29376 prune_unused_types_walk (ctnode
->root_die
);
29377 prune_unused_types_mark (ctnode
->type_die
, 1);
29380 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
29381 are unusual in that they are pubnames that are the children of pubtypes.
29382 They should only be marked via their parent DW_TAG_enumeration_type die,
29383 not as roots in themselves. */
29384 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
29385 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
29386 prune_unused_types_mark (pub
->die
, 1);
29387 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
29388 prune_unused_types_mark (base_type
, 1);
29390 /* For -fvar-tracking-assignments, also set the mark on nodes that could be
29391 referenced by DW_TAG_call_site DW_AT_call_origin (i.e. direct call
29393 cgraph_node
*cnode
;
29394 FOR_EACH_FUNCTION (cnode
)
29395 if (cnode
->referred_to_p (false))
29397 dw_die_ref die
= lookup_decl_die (cnode
->decl
);
29398 if (die
== NULL
|| die
->die_mark
)
29400 for (cgraph_edge
*e
= cnode
->callers
; e
; e
= e
->next_caller
)
29401 if (e
->caller
!= cnode
29402 && opt_for_fn (e
->caller
->decl
, flag_var_tracking_assignments
))
29404 prune_unused_types_mark (die
, 1);
29409 if (debug_str_hash
)
29410 debug_str_hash
->empty ();
29411 if (skeleton_debug_str_hash
)
29412 skeleton_debug_str_hash
->empty ();
29413 prune_unused_types_prune (comp_unit_die ());
29414 for (limbo_die_node
**pnode
= &limbo_die_list
; *pnode
; )
29417 if (!node
->die
->die_mark
)
29418 *pnode
= node
->next
;
29421 prune_unused_types_prune (node
->die
);
29422 pnode
= &node
->next
;
29425 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29426 prune_unused_types_prune (ctnode
->root_die
);
29428 /* Leave the marks clear. */
29429 prune_unmark_dies (comp_unit_die ());
29430 for (node
= limbo_die_list
; node
; node
= node
->next
)
29431 prune_unmark_dies (node
->die
);
29432 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29433 prune_unmark_dies (ctnode
->root_die
);
29436 /* Helpers to manipulate hash table of comdat type units. */
29438 struct comdat_type_hasher
: nofree_ptr_hash
<comdat_type_node
>
29440 static inline hashval_t
hash (const comdat_type_node
*);
29441 static inline bool equal (const comdat_type_node
*, const comdat_type_node
*);
29445 comdat_type_hasher::hash (const comdat_type_node
*type_node
)
29448 memcpy (&h
, type_node
->signature
, sizeof (h
));
29453 comdat_type_hasher::equal (const comdat_type_node
*type_node_1
,
29454 const comdat_type_node
*type_node_2
)
29456 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
29457 DWARF_TYPE_SIGNATURE_SIZE
));
29460 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
29461 to the location it would have been added, should we know its
29462 DECL_ASSEMBLER_NAME when we added other attributes. This will
29463 probably improve compactness of debug info, removing equivalent
29464 abbrevs, and hide any differences caused by deferring the
29465 computation of the assembler name, triggered by e.g. PCH. */
29468 move_linkage_attr (dw_die_ref die
)
29470 unsigned ix
= vec_safe_length (die
->die_attr
);
29471 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
29473 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
29474 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
29478 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
29480 if (prev
->dw_attr
== DW_AT_decl_line
29481 || prev
->dw_attr
== DW_AT_decl_column
29482 || prev
->dw_attr
== DW_AT_name
)
29486 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
29488 die
->die_attr
->pop ();
29489 die
->die_attr
->quick_insert (ix
, linkage
);
29493 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
29494 referenced from typed stack ops and count how often they are used. */
29497 mark_base_types (dw_loc_descr_ref loc
)
29499 dw_die_ref base_type
= NULL
;
29501 for (; loc
; loc
= loc
->dw_loc_next
)
29503 switch (loc
->dw_loc_opc
)
29505 case DW_OP_regval_type
:
29506 case DW_OP_deref_type
:
29507 case DW_OP_GNU_regval_type
:
29508 case DW_OP_GNU_deref_type
:
29509 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
29511 case DW_OP_convert
:
29512 case DW_OP_reinterpret
:
29513 case DW_OP_GNU_convert
:
29514 case DW_OP_GNU_reinterpret
:
29515 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
29518 case DW_OP_const_type
:
29519 case DW_OP_GNU_const_type
:
29520 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29522 case DW_OP_entry_value
:
29523 case DW_OP_GNU_entry_value
:
29524 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
29529 gcc_assert (base_type
->die_parent
== comp_unit_die ());
29530 if (base_type
->die_mark
)
29531 base_type
->die_mark
++;
29534 base_types
.safe_push (base_type
);
29535 base_type
->die_mark
= 1;
29540 /* Comparison function for sorting marked base types. */
29543 base_type_cmp (const void *x
, const void *y
)
29545 dw_die_ref dx
= *(const dw_die_ref
*) x
;
29546 dw_die_ref dy
= *(const dw_die_ref
*) y
;
29547 unsigned int byte_size1
, byte_size2
;
29548 unsigned int encoding1
, encoding2
;
29549 unsigned int align1
, align2
;
29550 if (dx
->die_mark
> dy
->die_mark
)
29552 if (dx
->die_mark
< dy
->die_mark
)
29554 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
29555 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
29556 if (byte_size1
< byte_size2
)
29558 if (byte_size1
> byte_size2
)
29560 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
29561 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
29562 if (encoding1
< encoding2
)
29564 if (encoding1
> encoding2
)
29566 align1
= get_AT_unsigned (dx
, DW_AT_alignment
);
29567 align2
= get_AT_unsigned (dy
, DW_AT_alignment
);
29568 if (align1
< align2
)
29570 if (align1
> align2
)
29575 /* Move base types marked by mark_base_types as early as possible
29576 in the CU, sorted by decreasing usage count both to make the
29577 uleb128 references as small as possible and to make sure they
29578 will have die_offset already computed by calc_die_sizes when
29579 sizes of typed stack loc ops is computed. */
29582 move_marked_base_types (void)
29585 dw_die_ref base_type
, die
, c
;
29587 if (base_types
.is_empty ())
29590 /* Sort by decreasing usage count, they will be added again in that
29592 base_types
.qsort (base_type_cmp
);
29593 die
= comp_unit_die ();
29594 c
= die
->die_child
;
29597 dw_die_ref prev
= c
;
29599 while (c
->die_mark
)
29601 remove_child_with_prev (c
, prev
);
29602 /* As base types got marked, there must be at least
29603 one node other than DW_TAG_base_type. */
29604 gcc_assert (die
->die_child
!= NULL
);
29608 while (c
!= die
->die_child
);
29609 gcc_assert (die
->die_child
);
29610 c
= die
->die_child
;
29611 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
29613 base_type
->die_mark
= 0;
29614 base_type
->die_sib
= c
->die_sib
;
29615 c
->die_sib
= base_type
;
29620 /* Helper function for resolve_addr, attempt to resolve
29621 one CONST_STRING, return true if successful. Similarly verify that
29622 SYMBOL_REFs refer to variables emitted in the current CU. */
29625 resolve_one_addr (rtx
*addr
)
29629 if (GET_CODE (rtl
) == CONST_STRING
)
29631 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
29632 tree t
= build_string (len
, XSTR (rtl
, 0));
29633 tree tlen
= size_int (len
- 1);
29635 = build_array_type (char_type_node
, build_index_type (tlen
));
29636 rtl
= lookup_constant_def (t
);
29637 if (!rtl
|| !MEM_P (rtl
))
29639 rtl
= XEXP (rtl
, 0);
29640 if (GET_CODE (rtl
) == SYMBOL_REF
29641 && SYMBOL_REF_DECL (rtl
)
29642 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
29644 vec_safe_push (used_rtx_array
, rtl
);
29649 if (GET_CODE (rtl
) == SYMBOL_REF
29650 && SYMBOL_REF_DECL (rtl
))
29652 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
29654 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
29657 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
29661 if (GET_CODE (rtl
) == CONST
)
29663 subrtx_ptr_iterator::array_type array
;
29664 FOR_EACH_SUBRTX_PTR (iter
, array
, &XEXP (rtl
, 0), ALL
)
29665 if (!resolve_one_addr (*iter
))
29672 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
29673 if possible, and create DW_TAG_dwarf_procedure that can be referenced
29674 from DW_OP_implicit_pointer if the string hasn't been seen yet. */
29677 string_cst_pool_decl (tree t
)
29679 rtx rtl
= output_constant_def (t
, 1);
29680 unsigned char *array
;
29681 dw_loc_descr_ref l
;
29686 if (!rtl
|| !MEM_P (rtl
))
29688 rtl
= XEXP (rtl
, 0);
29689 if (GET_CODE (rtl
) != SYMBOL_REF
29690 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
29693 decl
= SYMBOL_REF_DECL (rtl
);
29694 if (!lookup_decl_die (decl
))
29696 len
= TREE_STRING_LENGTH (t
);
29697 vec_safe_push (used_rtx_array
, rtl
);
29698 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
29699 array
= ggc_vec_alloc
<unsigned char> (len
);
29700 memcpy (array
, TREE_STRING_POINTER (t
), len
);
29701 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
29702 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
29703 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
29704 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
29705 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
29706 add_AT_loc (ref
, DW_AT_location
, l
);
29707 equate_decl_number_to_die (decl
, ref
);
29712 /* Helper function of resolve_addr_in_expr. LOC is
29713 a DW_OP_addr followed by DW_OP_stack_value, either at the start
29714 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
29715 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
29716 with DW_OP_implicit_pointer if possible
29717 and return true, if unsuccessful, return false. */
29720 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
29722 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
29723 HOST_WIDE_INT offset
= 0;
29724 dw_die_ref ref
= NULL
;
29727 if (GET_CODE (rtl
) == CONST
29728 && GET_CODE (XEXP (rtl
, 0)) == PLUS
29729 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
29731 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
29732 rtl
= XEXP (XEXP (rtl
, 0), 0);
29734 if (GET_CODE (rtl
) == CONST_STRING
)
29736 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
29737 tree t
= build_string (len
, XSTR (rtl
, 0));
29738 tree tlen
= size_int (len
- 1);
29741 = build_array_type (char_type_node
, build_index_type (tlen
));
29742 rtl
= string_cst_pool_decl (t
);
29746 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
29748 decl
= SYMBOL_REF_DECL (rtl
);
29749 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
29751 ref
= lookup_decl_die (decl
);
29752 if (ref
&& (get_AT (ref
, DW_AT_location
)
29753 || get_AT (ref
, DW_AT_const_value
)))
29755 loc
->dw_loc_opc
= dwarf_OP (DW_OP_implicit_pointer
);
29756 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
29757 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
29758 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
29759 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29760 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
29761 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
29769 /* Helper function for resolve_addr, handle one location
29770 expression, return false if at least one CONST_STRING or SYMBOL_REF in
29771 the location list couldn't be resolved. */
29774 resolve_addr_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
29776 dw_loc_descr_ref keep
= NULL
;
29777 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
29778 switch (loc
->dw_loc_opc
)
29781 if (!resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
29784 || prev
->dw_loc_opc
== DW_OP_piece
29785 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
29786 && loc
->dw_loc_next
29787 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
29788 && (!dwarf_strict
|| dwarf_version
>= 5)
29789 && optimize_one_addr_into_implicit_ptr (loc
))
29794 case DW_OP_GNU_addr_index
:
29796 case DW_OP_GNU_const_index
:
29798 if ((loc
->dw_loc_opc
== DW_OP_GNU_addr_index
29799 || loc
->dw_loc_opc
== DW_OP_addrx
)
29800 || ((loc
->dw_loc_opc
== DW_OP_GNU_const_index
29801 || loc
->dw_loc_opc
== DW_OP_constx
)
29804 rtx rtl
= loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
;
29805 if (!resolve_one_addr (&rtl
))
29807 remove_addr_table_entry (loc
->dw_loc_oprnd1
.val_entry
);
29808 loc
->dw_loc_oprnd1
.val_entry
29809 = add_addr_table_entry (rtl
, ate_kind_rtx
);
29812 case DW_OP_const4u
:
29813 case DW_OP_const8u
:
29815 && !resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
29818 case DW_OP_plus_uconst
:
29819 if (size_of_loc_descr (loc
)
29820 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
29822 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
29824 dw_loc_descr_ref repl
29825 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
29826 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
29827 add_loc_descr (&repl
, loc
->dw_loc_next
);
29831 case DW_OP_implicit_value
:
29832 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
29833 && !resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
))
29836 case DW_OP_implicit_pointer
:
29837 case DW_OP_GNU_implicit_pointer
:
29838 case DW_OP_GNU_parameter_ref
:
29839 case DW_OP_GNU_variable_value
:
29840 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
29843 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
29846 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
29847 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
29848 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29850 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
)
29853 && loc
->dw_loc_next
== NULL
29854 && AT_class (a
) == dw_val_class_loc
)
29855 switch (a
->dw_attr
)
29857 /* Following attributes allow both exprloc and reference,
29858 so if the whole expression is DW_OP_GNU_variable_value
29859 alone we could transform it into reference. */
29860 case DW_AT_byte_size
:
29861 case DW_AT_bit_size
:
29862 case DW_AT_lower_bound
:
29863 case DW_AT_upper_bound
:
29864 case DW_AT_bit_stride
:
29866 case DW_AT_allocated
:
29867 case DW_AT_associated
:
29868 case DW_AT_byte_stride
:
29869 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
29870 a
->dw_attr_val
.val_entry
= NULL
;
29871 a
->dw_attr_val
.v
.val_die_ref
.die
29872 = loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29873 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
29882 case DW_OP_const_type
:
29883 case DW_OP_regval_type
:
29884 case DW_OP_deref_type
:
29885 case DW_OP_convert
:
29886 case DW_OP_reinterpret
:
29887 case DW_OP_GNU_const_type
:
29888 case DW_OP_GNU_regval_type
:
29889 case DW_OP_GNU_deref_type
:
29890 case DW_OP_GNU_convert
:
29891 case DW_OP_GNU_reinterpret
:
29892 while (loc
->dw_loc_next
29893 && (loc
->dw_loc_next
->dw_loc_opc
== DW_OP_convert
29894 || loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
))
29896 dw_die_ref base1
, base2
;
29897 unsigned enc1
, enc2
, size1
, size2
;
29898 if (loc
->dw_loc_opc
== DW_OP_regval_type
29899 || loc
->dw_loc_opc
== DW_OP_deref_type
29900 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
29901 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
29902 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
29903 else if (loc
->dw_loc_oprnd1
.val_class
29904 == dw_val_class_unsigned_const
)
29907 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29908 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
29909 == dw_val_class_unsigned_const
)
29911 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29912 gcc_assert (base1
->die_tag
== DW_TAG_base_type
29913 && base2
->die_tag
== DW_TAG_base_type
);
29914 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
29915 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
29916 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
29917 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
29919 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
29920 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
29924 /* Optimize away next DW_OP_convert after
29925 adjusting LOC's base type die reference. */
29926 if (loc
->dw_loc_opc
== DW_OP_regval_type
29927 || loc
->dw_loc_opc
== DW_OP_deref_type
29928 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
29929 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
29930 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
29932 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
29933 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
29936 /* Don't change integer DW_OP_convert after e.g. floating
29937 point typed stack entry. */
29938 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
29939 keep
= loc
->dw_loc_next
;
29949 /* Helper function of resolve_addr. DIE had DW_AT_location of
29950 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
29951 and DW_OP_addr couldn't be resolved. resolve_addr has already
29952 removed the DW_AT_location attribute. This function attempts to
29953 add a new DW_AT_location attribute with DW_OP_implicit_pointer
29954 to it or DW_AT_const_value attribute, if possible. */
29957 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
29960 || lookup_decl_die (decl
) != die
29961 || DECL_EXTERNAL (decl
)
29962 || !TREE_STATIC (decl
)
29963 || DECL_INITIAL (decl
) == NULL_TREE
29964 || DECL_P (DECL_INITIAL (decl
))
29965 || get_AT (die
, DW_AT_const_value
))
29968 tree init
= DECL_INITIAL (decl
);
29969 HOST_WIDE_INT offset
= 0;
29970 /* For variables that have been optimized away and thus
29971 don't have a memory location, see if we can emit
29972 DW_AT_const_value instead. */
29973 if (tree_add_const_value_attribute (die
, init
))
29975 if (dwarf_strict
&& dwarf_version
< 5)
29977 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
29978 and ADDR_EXPR refers to a decl that has DW_AT_location or
29979 DW_AT_const_value (but isn't addressable, otherwise
29980 resolving the original DW_OP_addr wouldn't fail), see if
29981 we can add DW_OP_implicit_pointer. */
29983 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
29984 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
29986 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
29987 init
= TREE_OPERAND (init
, 0);
29990 if (TREE_CODE (init
) != ADDR_EXPR
)
29992 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
29993 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
29994 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
29995 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
29996 && TREE_OPERAND (init
, 0) != decl
))
29999 dw_loc_descr_ref l
;
30001 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
30003 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
30006 decl
= SYMBOL_REF_DECL (rtl
);
30009 decl
= TREE_OPERAND (init
, 0);
30010 ref
= lookup_decl_die (decl
);
30012 || (!get_AT (ref
, DW_AT_location
)
30013 && !get_AT (ref
, DW_AT_const_value
)))
30015 l
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
30016 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30017 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30018 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30019 add_AT_loc (die
, DW_AT_location
, l
);
30023 /* Return NULL if l is a DWARF expression, or first op that is not
30024 valid DWARF expression. */
30026 static dw_loc_descr_ref
30027 non_dwarf_expression (dw_loc_descr_ref l
)
30031 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
30033 switch (l
->dw_loc_opc
)
30036 case DW_OP_implicit_value
:
30037 case DW_OP_stack_value
:
30038 case DW_OP_implicit_pointer
:
30039 case DW_OP_GNU_implicit_pointer
:
30040 case DW_OP_GNU_parameter_ref
:
30042 case DW_OP_bit_piece
:
30047 l
= l
->dw_loc_next
;
30052 /* Return adjusted copy of EXPR:
30053 If it is empty DWARF expression, return it.
30054 If it is valid non-empty DWARF expression,
30055 return copy of EXPR with DW_OP_deref appended to it.
30056 If it is DWARF expression followed by DW_OP_reg{N,x}, return
30057 copy of the DWARF expression with DW_OP_breg{N,x} <0> appended.
30058 If it is DWARF expression followed by DW_OP_stack_value, return
30059 copy of the DWARF expression without anything appended.
30060 Otherwise, return NULL. */
30062 static dw_loc_descr_ref
30063 copy_deref_exprloc (dw_loc_descr_ref expr
)
30065 dw_loc_descr_ref tail
= NULL
;
30070 dw_loc_descr_ref l
= non_dwarf_expression (expr
);
30071 if (l
&& l
->dw_loc_next
)
30076 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
30077 tail
= new_loc_descr ((enum dwarf_location_atom
)
30078 (DW_OP_breg0
+ (l
->dw_loc_opc
- DW_OP_reg0
)),
30081 switch (l
->dw_loc_opc
)
30084 tail
= new_loc_descr (DW_OP_bregx
,
30085 l
->dw_loc_oprnd1
.v
.val_unsigned
, 0);
30087 case DW_OP_stack_value
:
30094 tail
= new_loc_descr (DW_OP_deref
, 0, 0);
30096 dw_loc_descr_ref ret
= NULL
, *p
= &ret
;
30099 *p
= new_loc_descr (expr
->dw_loc_opc
, 0, 0);
30100 (*p
)->dw_loc_oprnd1
= expr
->dw_loc_oprnd1
;
30101 (*p
)->dw_loc_oprnd2
= expr
->dw_loc_oprnd2
;
30102 p
= &(*p
)->dw_loc_next
;
30103 expr
= expr
->dw_loc_next
;
30109 /* For DW_AT_string_length attribute with DW_OP_GNU_variable_value
30110 reference to a variable or argument, adjust it if needed and return:
30111 -1 if the DW_AT_string_length attribute and DW_AT_{string_length_,}byte_size
30112 attribute if present should be removed
30113 0 keep the attribute perhaps with minor modifications, no need to rescan
30114 1 if the attribute has been successfully adjusted. */
30117 optimize_string_length (dw_attr_node
*a
)
30119 dw_loc_descr_ref l
= AT_loc (a
), lv
;
30121 if (l
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
30123 tree decl
= l
->dw_loc_oprnd1
.v
.val_decl_ref
;
30124 die
= lookup_decl_die (decl
);
30127 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30128 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= die
;
30129 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30135 die
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30137 /* DWARF5 allows reference class, so we can then reference the DIE.
30138 Only do this for DW_OP_GNU_variable_value DW_OP_stack_value. */
30139 if (l
->dw_loc_next
!= NULL
&& dwarf_version
>= 5)
30141 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
30142 a
->dw_attr_val
.val_entry
= NULL
;
30143 a
->dw_attr_val
.v
.val_die_ref
.die
= die
;
30144 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
30148 dw_attr_node
*av
= get_AT (die
, DW_AT_location
);
30150 bool non_dwarf_expr
= false;
30153 return dwarf_strict
? -1 : 0;
30154 switch (AT_class (av
))
30156 case dw_val_class_loc_list
:
30157 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
30158 if (d
->expr
&& non_dwarf_expression (d
->expr
))
30159 non_dwarf_expr
= true;
30161 case dw_val_class_view_list
:
30162 gcc_unreachable ();
30163 case dw_val_class_loc
:
30166 return dwarf_strict
? -1 : 0;
30167 if (non_dwarf_expression (lv
))
30168 non_dwarf_expr
= true;
30171 return dwarf_strict
? -1 : 0;
30174 /* If it is safe to transform DW_OP_GNU_variable_value DW_OP_stack_value
30175 into DW_OP_call4 or DW_OP_GNU_variable_value into
30176 DW_OP_call4 DW_OP_deref, do so. */
30177 if (!non_dwarf_expr
30178 && (l
->dw_loc_next
!= NULL
|| AT_class (av
) == dw_val_class_loc
))
30180 l
->dw_loc_opc
= DW_OP_call4
;
30181 if (l
->dw_loc_next
)
30182 l
->dw_loc_next
= NULL
;
30184 l
->dw_loc_next
= new_loc_descr (DW_OP_deref
, 0, 0);
30188 /* For DW_OP_GNU_variable_value DW_OP_stack_value, we can just
30189 copy over the DW_AT_location attribute from die to a. */
30190 if (l
->dw_loc_next
!= NULL
)
30192 a
->dw_attr_val
= av
->dw_attr_val
;
30196 dw_loc_list_ref list
, *p
;
30197 switch (AT_class (av
))
30199 case dw_val_class_loc_list
:
30202 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
30204 lv
= copy_deref_exprloc (d
->expr
);
30207 *p
= new_loc_list (lv
, d
->begin
, d
->vbegin
, d
->end
, d
->vend
, d
->section
);
30208 p
= &(*p
)->dw_loc_next
;
30210 else if (!dwarf_strict
&& d
->expr
)
30214 return dwarf_strict
? -1 : 0;
30215 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
30217 *AT_loc_list_ptr (a
) = list
;
30219 case dw_val_class_loc
:
30220 lv
= copy_deref_exprloc (AT_loc (av
));
30222 return dwarf_strict
? -1 : 0;
30223 a
->dw_attr_val
.v
.val_loc
= lv
;
30226 gcc_unreachable ();
30230 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
30231 an address in .rodata section if the string literal is emitted there,
30232 or remove the containing location list or replace DW_AT_const_value
30233 with DW_AT_location and empty location expression, if it isn't found
30234 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
30235 to something that has been emitted in the current CU. */
30238 resolve_addr (dw_die_ref die
)
30242 dw_loc_list_ref
*curr
, *start
, loc
;
30244 bool remove_AT_byte_size
= false;
30246 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30247 switch (AT_class (a
))
30249 case dw_val_class_loc_list
:
30250 start
= curr
= AT_loc_list_ptr (a
);
30253 /* The same list can be referenced more than once. See if we have
30254 already recorded the result from a previous pass. */
30256 *curr
= loc
->dw_loc_next
;
30257 else if (!loc
->resolved_addr
)
30259 /* As things stand, we do not expect or allow one die to
30260 reference a suffix of another die's location list chain.
30261 References must be identical or completely separate.
30262 There is therefore no need to cache the result of this
30263 pass on any list other than the first; doing so
30264 would lead to unnecessary writes. */
30267 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
30268 if (!resolve_addr_in_expr (a
, (*curr
)->expr
))
30270 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
30271 dw_loc_descr_ref l
= (*curr
)->expr
;
30273 if (next
&& (*curr
)->ll_symbol
)
30275 gcc_assert (!next
->ll_symbol
);
30276 next
->ll_symbol
= (*curr
)->ll_symbol
;
30277 next
->vl_symbol
= (*curr
)->vl_symbol
;
30279 if (dwarf_split_debug_info
)
30280 remove_loc_list_addr_table_entries (l
);
30285 mark_base_types ((*curr
)->expr
);
30286 curr
= &(*curr
)->dw_loc_next
;
30290 loc
->resolved_addr
= 1;
30294 loc
->dw_loc_next
= *start
;
30299 remove_AT (die
, a
->dw_attr
);
30303 case dw_val_class_view_list
:
30305 gcc_checking_assert (a
->dw_attr
== DW_AT_GNU_locviews
);
30306 gcc_checking_assert (dwarf2out_locviews_in_attribute ());
30307 dw_val_node
*llnode
30308 = view_list_to_loc_list_val_node (&a
->dw_attr_val
);
30309 /* If we no longer have a loclist, or it no longer needs
30310 views, drop this attribute. */
30311 if (!llnode
|| !llnode
->v
.val_loc_list
->vl_symbol
)
30313 remove_AT (die
, a
->dw_attr
);
30318 case dw_val_class_loc
:
30320 dw_loc_descr_ref l
= AT_loc (a
);
30321 /* DW_OP_GNU_variable_value DW_OP_stack_value or
30322 DW_OP_GNU_variable_value in DW_AT_string_length can be converted
30323 into DW_OP_call4 or DW_OP_call4 DW_OP_deref, which is standard
30324 DWARF4 unlike DW_OP_GNU_variable_value. Or for DWARF5
30325 DW_OP_GNU_variable_value DW_OP_stack_value can be replaced
30326 with DW_FORM_ref referencing the same DIE as
30327 DW_OP_GNU_variable_value used to reference. */
30328 if (a
->dw_attr
== DW_AT_string_length
30330 && l
->dw_loc_opc
== DW_OP_GNU_variable_value
30331 && (l
->dw_loc_next
== NULL
30332 || (l
->dw_loc_next
->dw_loc_next
== NULL
30333 && l
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
)))
30335 switch (optimize_string_length (a
))
30338 remove_AT (die
, a
->dw_attr
);
30340 /* If we drop DW_AT_string_length, we need to drop also
30341 DW_AT_{string_length_,}byte_size. */
30342 remove_AT_byte_size
= true;
30347 /* Even if we keep the optimized DW_AT_string_length,
30348 it might have changed AT_class, so process it again. */
30353 /* For -gdwarf-2 don't attempt to optimize
30354 DW_AT_data_member_location containing
30355 DW_OP_plus_uconst - older consumers might
30356 rely on it being that op instead of a more complex,
30357 but shorter, location description. */
30358 if ((dwarf_version
> 2
30359 || a
->dw_attr
!= DW_AT_data_member_location
30361 || l
->dw_loc_opc
!= DW_OP_plus_uconst
30362 || l
->dw_loc_next
!= NULL
)
30363 && !resolve_addr_in_expr (a
, l
))
30365 if (dwarf_split_debug_info
)
30366 remove_loc_list_addr_table_entries (l
);
30368 && l
->dw_loc_next
== NULL
30369 && l
->dw_loc_opc
== DW_OP_addr
30370 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
30371 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
30372 && a
->dw_attr
== DW_AT_location
)
30374 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
30375 remove_AT (die
, a
->dw_attr
);
30377 optimize_location_into_implicit_ptr (die
, decl
);
30380 if (a
->dw_attr
== DW_AT_string_length
)
30381 /* If we drop DW_AT_string_length, we need to drop also
30382 DW_AT_{string_length_,}byte_size. */
30383 remove_AT_byte_size
= true;
30384 remove_AT (die
, a
->dw_attr
);
30388 mark_base_types (l
);
30391 case dw_val_class_addr
:
30392 if (a
->dw_attr
== DW_AT_const_value
30393 && !resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
))
30395 if (AT_index (a
) != NOT_INDEXED
)
30396 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
30397 remove_AT (die
, a
->dw_attr
);
30400 if ((die
->die_tag
== DW_TAG_call_site
30401 && a
->dw_attr
== DW_AT_call_origin
)
30402 || (die
->die_tag
== DW_TAG_GNU_call_site
30403 && a
->dw_attr
== DW_AT_abstract_origin
))
30405 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
30406 dw_die_ref tdie
= lookup_decl_die (tdecl
);
30409 && DECL_EXTERNAL (tdecl
)
30410 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
30411 && (cdie
= lookup_context_die (DECL_CONTEXT (tdecl
))))
30413 dw_die_ref pdie
= cdie
;
30414 /* Make sure we don't add these DIEs into type units.
30415 We could emit skeleton DIEs for context (namespaces,
30416 outer structs/classes) and a skeleton DIE for the
30417 innermost context with DW_AT_signature pointing to the
30418 type unit. See PR78835. */
30419 while (pdie
&& pdie
->die_tag
!= DW_TAG_type_unit
)
30420 pdie
= pdie
->die_parent
;
30423 /* Creating a full DIE for tdecl is overly expensive and
30424 at this point even wrong when in the LTO phase
30425 as it can end up generating new type DIEs we didn't
30426 output and thus optimize_external_refs will crash. */
30427 tdie
= new_die (DW_TAG_subprogram
, cdie
, NULL_TREE
);
30428 add_AT_flag (tdie
, DW_AT_external
, 1);
30429 add_AT_flag (tdie
, DW_AT_declaration
, 1);
30430 add_linkage_attr (tdie
, tdecl
);
30431 add_name_and_src_coords_attributes (tdie
, tdecl
, true);
30432 equate_decl_number_to_die (tdecl
, tdie
);
30437 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
30438 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
30439 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
30443 if (AT_index (a
) != NOT_INDEXED
)
30444 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
30445 remove_AT (die
, a
->dw_attr
);
30454 if (remove_AT_byte_size
)
30455 remove_AT (die
, dwarf_version
>= 5
30456 ? DW_AT_string_length_byte_size
30457 : DW_AT_byte_size
);
30459 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
30462 /* Helper routines for optimize_location_lists.
30463 This pass tries to share identical local lists in .debug_loc
30466 /* Iteratively hash operands of LOC opcode into HSTATE. */
30469 hash_loc_operands (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
30471 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
30472 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
30474 switch (loc
->dw_loc_opc
)
30476 case DW_OP_const4u
:
30477 case DW_OP_const8u
:
30481 case DW_OP_const1u
:
30482 case DW_OP_const1s
:
30483 case DW_OP_const2u
:
30484 case DW_OP_const2s
:
30485 case DW_OP_const4s
:
30486 case DW_OP_const8s
:
30490 case DW_OP_plus_uconst
:
30526 case DW_OP_deref_size
:
30527 case DW_OP_xderef_size
:
30528 hstate
.add_object (val1
->v
.val_int
);
30535 gcc_assert (val1
->val_class
== dw_val_class_loc
);
30536 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
30537 hstate
.add_object (offset
);
30540 case DW_OP_implicit_value
:
30541 hstate
.add_object (val1
->v
.val_unsigned
);
30542 switch (val2
->val_class
)
30544 case dw_val_class_const
:
30545 hstate
.add_object (val2
->v
.val_int
);
30547 case dw_val_class_vec
:
30549 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
30550 unsigned int len
= val2
->v
.val_vec
.length
;
30552 hstate
.add_int (elt_size
);
30553 hstate
.add_int (len
);
30554 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
30557 case dw_val_class_const_double
:
30558 hstate
.add_object (val2
->v
.val_double
.low
);
30559 hstate
.add_object (val2
->v
.val_double
.high
);
30561 case dw_val_class_wide_int
:
30562 hstate
.add (val2
->v
.val_wide
->get_val (),
30563 get_full_len (*val2
->v
.val_wide
)
30564 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
30566 case dw_val_class_addr
:
30567 inchash::add_rtx (val2
->v
.val_addr
, hstate
);
30570 gcc_unreachable ();
30574 case DW_OP_bit_piece
:
30575 hstate
.add_object (val1
->v
.val_int
);
30576 hstate
.add_object (val2
->v
.val_int
);
30582 unsigned char dtprel
= 0xd1;
30583 hstate
.add_object (dtprel
);
30585 inchash::add_rtx (val1
->v
.val_addr
, hstate
);
30587 case DW_OP_GNU_addr_index
:
30589 case DW_OP_GNU_const_index
:
30594 unsigned char dtprel
= 0xd1;
30595 hstate
.add_object (dtprel
);
30597 inchash::add_rtx (val1
->val_entry
->addr
.rtl
, hstate
);
30600 case DW_OP_implicit_pointer
:
30601 case DW_OP_GNU_implicit_pointer
:
30602 hstate
.add_int (val2
->v
.val_int
);
30604 case DW_OP_entry_value
:
30605 case DW_OP_GNU_entry_value
:
30606 hstate
.add_object (val1
->v
.val_loc
);
30608 case DW_OP_regval_type
:
30609 case DW_OP_deref_type
:
30610 case DW_OP_GNU_regval_type
:
30611 case DW_OP_GNU_deref_type
:
30613 unsigned int byte_size
30614 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
30615 unsigned int encoding
30616 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
30617 hstate
.add_object (val1
->v
.val_int
);
30618 hstate
.add_object (byte_size
);
30619 hstate
.add_object (encoding
);
30622 case DW_OP_convert
:
30623 case DW_OP_reinterpret
:
30624 case DW_OP_GNU_convert
:
30625 case DW_OP_GNU_reinterpret
:
30626 if (val1
->val_class
== dw_val_class_unsigned_const
)
30628 hstate
.add_object (val1
->v
.val_unsigned
);
30632 case DW_OP_const_type
:
30633 case DW_OP_GNU_const_type
:
30635 unsigned int byte_size
30636 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
30637 unsigned int encoding
30638 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
30639 hstate
.add_object (byte_size
);
30640 hstate
.add_object (encoding
);
30641 if (loc
->dw_loc_opc
!= DW_OP_const_type
30642 && loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
30644 hstate
.add_object (val2
->val_class
);
30645 switch (val2
->val_class
)
30647 case dw_val_class_const
:
30648 hstate
.add_object (val2
->v
.val_int
);
30650 case dw_val_class_vec
:
30652 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
30653 unsigned int len
= val2
->v
.val_vec
.length
;
30655 hstate
.add_object (elt_size
);
30656 hstate
.add_object (len
);
30657 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
30660 case dw_val_class_const_double
:
30661 hstate
.add_object (val2
->v
.val_double
.low
);
30662 hstate
.add_object (val2
->v
.val_double
.high
);
30664 case dw_val_class_wide_int
:
30665 hstate
.add (val2
->v
.val_wide
->get_val (),
30666 get_full_len (*val2
->v
.val_wide
)
30667 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
30670 gcc_unreachable ();
30676 /* Other codes have no operands. */
30681 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
30684 hash_locs (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
30686 dw_loc_descr_ref l
;
30687 bool sizes_computed
= false;
30688 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
30689 size_of_locs (loc
);
30691 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
30693 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
30694 hstate
.add_object (opc
);
30695 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
30697 size_of_locs (loc
);
30698 sizes_computed
= true;
30700 hash_loc_operands (l
, hstate
);
30704 /* Compute hash of the whole location list LIST_HEAD. */
30707 hash_loc_list (dw_loc_list_ref list_head
)
30709 dw_loc_list_ref curr
= list_head
;
30710 inchash::hash hstate
;
30712 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
30714 hstate
.add (curr
->begin
, strlen (curr
->begin
) + 1);
30715 hstate
.add (curr
->end
, strlen (curr
->end
) + 1);
30716 hstate
.add_object (curr
->vbegin
);
30717 hstate
.add_object (curr
->vend
);
30719 hstate
.add (curr
->section
, strlen (curr
->section
) + 1);
30720 hash_locs (curr
->expr
, hstate
);
30722 list_head
->hash
= hstate
.end ();
30725 /* Return true if X and Y opcodes have the same operands. */
30728 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
30730 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
30731 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
30732 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
30733 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
30735 switch (x
->dw_loc_opc
)
30737 case DW_OP_const4u
:
30738 case DW_OP_const8u
:
30742 case DW_OP_const1u
:
30743 case DW_OP_const1s
:
30744 case DW_OP_const2u
:
30745 case DW_OP_const2s
:
30746 case DW_OP_const4s
:
30747 case DW_OP_const8s
:
30751 case DW_OP_plus_uconst
:
30787 case DW_OP_deref_size
:
30788 case DW_OP_xderef_size
:
30789 return valx1
->v
.val_int
== valy1
->v
.val_int
;
30792 /* If splitting debug info, the use of DW_OP_GNU_addr_index
30793 can cause irrelevant differences in dw_loc_addr. */
30794 gcc_assert (valx1
->val_class
== dw_val_class_loc
30795 && valy1
->val_class
== dw_val_class_loc
30796 && (dwarf_split_debug_info
30797 || x
->dw_loc_addr
== y
->dw_loc_addr
));
30798 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
30799 case DW_OP_implicit_value
:
30800 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
30801 || valx2
->val_class
!= valy2
->val_class
)
30803 switch (valx2
->val_class
)
30805 case dw_val_class_const
:
30806 return valx2
->v
.val_int
== valy2
->v
.val_int
;
30807 case dw_val_class_vec
:
30808 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
30809 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
30810 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
30811 valx2
->v
.val_vec
.elt_size
30812 * valx2
->v
.val_vec
.length
) == 0;
30813 case dw_val_class_const_double
:
30814 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
30815 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
30816 case dw_val_class_wide_int
:
30817 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
30818 case dw_val_class_addr
:
30819 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
30821 gcc_unreachable ();
30824 case DW_OP_bit_piece
:
30825 return valx1
->v
.val_int
== valy1
->v
.val_int
30826 && valx2
->v
.val_int
== valy2
->v
.val_int
;
30829 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
30830 case DW_OP_GNU_addr_index
:
30832 case DW_OP_GNU_const_index
:
30835 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
30836 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
30837 return rtx_equal_p (ax1
, ay1
);
30839 case DW_OP_implicit_pointer
:
30840 case DW_OP_GNU_implicit_pointer
:
30841 return valx1
->val_class
== dw_val_class_die_ref
30842 && valx1
->val_class
== valy1
->val_class
30843 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
30844 && valx2
->v
.val_int
== valy2
->v
.val_int
;
30845 case DW_OP_entry_value
:
30846 case DW_OP_GNU_entry_value
:
30847 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
30848 case DW_OP_const_type
:
30849 case DW_OP_GNU_const_type
:
30850 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
30851 || valx2
->val_class
!= valy2
->val_class
)
30853 switch (valx2
->val_class
)
30855 case dw_val_class_const
:
30856 return valx2
->v
.val_int
== valy2
->v
.val_int
;
30857 case dw_val_class_vec
:
30858 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
30859 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
30860 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
30861 valx2
->v
.val_vec
.elt_size
30862 * valx2
->v
.val_vec
.length
) == 0;
30863 case dw_val_class_const_double
:
30864 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
30865 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
30866 case dw_val_class_wide_int
:
30867 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
30869 gcc_unreachable ();
30871 case DW_OP_regval_type
:
30872 case DW_OP_deref_type
:
30873 case DW_OP_GNU_regval_type
:
30874 case DW_OP_GNU_deref_type
:
30875 return valx1
->v
.val_int
== valy1
->v
.val_int
30876 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
30877 case DW_OP_convert
:
30878 case DW_OP_reinterpret
:
30879 case DW_OP_GNU_convert
:
30880 case DW_OP_GNU_reinterpret
:
30881 if (valx1
->val_class
!= valy1
->val_class
)
30883 if (valx1
->val_class
== dw_val_class_unsigned_const
)
30884 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
30885 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
30886 case DW_OP_GNU_parameter_ref
:
30887 return valx1
->val_class
== dw_val_class_die_ref
30888 && valx1
->val_class
== valy1
->val_class
30889 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
30891 /* Other codes have no operands. */
30896 /* Return true if DWARF location expressions X and Y are the same. */
30899 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
30901 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
30902 if (x
->dw_loc_opc
!= y
->dw_loc_opc
30903 || x
->dtprel
!= y
->dtprel
30904 || !compare_loc_operands (x
, y
))
30906 return x
== NULL
&& y
== NULL
;
30909 /* Hashtable helpers. */
30911 struct loc_list_hasher
: nofree_ptr_hash
<dw_loc_list_struct
>
30913 static inline hashval_t
hash (const dw_loc_list_struct
*);
30914 static inline bool equal (const dw_loc_list_struct
*,
30915 const dw_loc_list_struct
*);
30918 /* Return precomputed hash of location list X. */
30921 loc_list_hasher::hash (const dw_loc_list_struct
*x
)
30926 /* Return true if location lists A and B are the same. */
30929 loc_list_hasher::equal (const dw_loc_list_struct
*a
,
30930 const dw_loc_list_struct
*b
)
30934 if (a
->hash
!= b
->hash
)
30936 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
30937 if (strcmp (a
->begin
, b
->begin
) != 0
30938 || strcmp (a
->end
, b
->end
) != 0
30939 || (a
->section
== NULL
) != (b
->section
== NULL
)
30940 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
30941 || a
->vbegin
!= b
->vbegin
|| a
->vend
!= b
->vend
30942 || !compare_locs (a
->expr
, b
->expr
))
30944 return a
== NULL
&& b
== NULL
;
30947 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
30950 /* Recursively optimize location lists referenced from DIE
30951 children and share them whenever possible. */
30954 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type
*htab
)
30959 dw_loc_list_struct
**slot
;
30960 bool drop_locviews
= false;
30961 bool has_locviews
= false;
30963 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30964 if (AT_class (a
) == dw_val_class_loc_list
)
30966 dw_loc_list_ref list
= AT_loc_list (a
);
30967 /* TODO: perform some optimizations here, before hashing
30968 it and storing into the hash table. */
30969 hash_loc_list (list
);
30970 slot
= htab
->find_slot_with_hash (list
, list
->hash
, INSERT
);
30974 if (loc_list_has_views (list
))
30975 gcc_assert (list
->vl_symbol
);
30976 else if (list
->vl_symbol
)
30978 drop_locviews
= true;
30979 list
->vl_symbol
= NULL
;
30984 if (list
->vl_symbol
&& !(*slot
)->vl_symbol
)
30985 drop_locviews
= true;
30986 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
30989 else if (AT_class (a
) == dw_val_class_view_list
)
30991 gcc_checking_assert (a
->dw_attr
== DW_AT_GNU_locviews
);
30992 has_locviews
= true;
30996 if (drop_locviews
&& has_locviews
)
30997 remove_AT (die
, DW_AT_GNU_locviews
);
30999 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
31003 /* Recursively assign each location list a unique index into the debug_addr
31007 index_location_lists (dw_die_ref die
)
31013 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31014 if (AT_class (a
) == dw_val_class_loc_list
)
31016 dw_loc_list_ref list
= AT_loc_list (a
);
31017 dw_loc_list_ref curr
;
31018 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
31020 /* Don't index an entry that has already been indexed
31021 or won't be output. Make sure skip_loc_list_entry doesn't
31022 call size_of_locs, because that might cause circular dependency,
31023 index_location_lists requiring address table indexes to be
31024 computed, but adding new indexes through add_addr_table_entry
31025 and address table index computation requiring no new additions
31026 to the hash table. In the rare case of DWARF[234] >= 64KB
31027 location expression, we'll just waste unused address table entry
31029 if (curr
->begin_entry
!= NULL
31030 || skip_loc_list_entry (curr
))
31034 = add_addr_table_entry (xstrdup (curr
->begin
), ate_kind_label
);
31038 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
31041 /* Optimize location lists referenced from DIE
31042 children and share them whenever possible. */
31045 optimize_location_lists (dw_die_ref die
)
31047 loc_list_hash_type
htab (500);
31048 optimize_location_lists_1 (die
, &htab
);
31051 /* Traverse the limbo die list, and add parent/child links. The only
31052 dies without parents that should be here are concrete instances of
31053 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
31054 For concrete instances, we can get the parent die from the abstract
31058 flush_limbo_die_list (void)
31060 limbo_die_node
*node
;
31062 /* get_context_die calls force_decl_die, which can put new DIEs on the
31063 limbo list in LTO mode when nested functions are put in a different
31064 partition than that of their parent function. */
31065 while ((node
= limbo_die_list
))
31067 dw_die_ref die
= node
->die
;
31068 limbo_die_list
= node
->next
;
31070 if (die
->die_parent
== NULL
)
31072 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
31074 if (origin
&& origin
->die_parent
)
31075 add_child_die (origin
->die_parent
, die
);
31076 else if (is_cu_die (die
))
31078 else if (seen_error ())
31079 /* It's OK to be confused by errors in the input. */
31080 add_child_die (comp_unit_die (), die
);
31083 /* In certain situations, the lexical block containing a
31084 nested function can be optimized away, which results
31085 in the nested function die being orphaned. Likewise
31086 with the return type of that nested function. Force
31087 this to be a child of the containing function.
31089 It may happen that even the containing function got fully
31090 inlined and optimized out. In that case we are lost and
31091 assign the empty child. This should not be big issue as
31092 the function is likely unreachable too. */
31093 gcc_assert (node
->created_for
);
31095 if (DECL_P (node
->created_for
))
31096 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
31097 else if (TYPE_P (node
->created_for
))
31098 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
31100 origin
= comp_unit_die ();
31102 add_child_die (origin
, die
);
31108 /* Reset DIEs so we can output them again. */
31111 reset_dies (dw_die_ref die
)
31115 /* Remove stuff we re-generate. */
31117 die
->die_offset
= 0;
31118 die
->die_abbrev
= 0;
31119 remove_AT (die
, DW_AT_sibling
);
31121 FOR_EACH_CHILD (die
, c
, reset_dies (c
));
31124 /* Output stuff that dwarf requires at the end of every file,
31125 and generate the DWARF-2 debugging info. */
31128 dwarf2out_finish (const char *filename
)
31130 comdat_type_node
*ctnode
;
31131 dw_die_ref main_comp_unit_die
;
31132 unsigned char checksum
[16];
31133 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
31135 /* Flush out any latecomers to the limbo party. */
31136 flush_limbo_die_list ();
31138 if (inline_entry_data_table
)
31139 gcc_assert (inline_entry_data_table
->elements () == 0);
31143 verify_die (comp_unit_die ());
31144 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
31145 verify_die (node
->die
);
31148 /* We shouldn't have any symbols with delayed asm names for
31149 DIEs generated after early finish. */
31150 gcc_assert (deferred_asm_name
== NULL
);
31152 gen_remaining_tmpl_value_param_die_attribute ();
31154 if (flag_generate_lto
|| flag_generate_offload
)
31156 gcc_assert (flag_fat_lto_objects
|| flag_generate_offload
);
31158 /* Prune stuff so that dwarf2out_finish runs successfully
31159 for the fat part of the object. */
31160 reset_dies (comp_unit_die ());
31161 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
31162 reset_dies (node
->die
);
31164 hash_table
<comdat_type_hasher
> comdat_type_table (100);
31165 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31167 comdat_type_node
**slot
31168 = comdat_type_table
.find_slot (ctnode
, INSERT
);
31170 /* Don't reset types twice. */
31171 if (*slot
!= HTAB_EMPTY_ENTRY
)
31174 /* Remove the pointer to the line table. */
31175 remove_AT (ctnode
->root_die
, DW_AT_stmt_list
);
31177 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31178 reset_dies (ctnode
->root_die
);
31183 /* Reset die CU symbol so we don't output it twice. */
31184 comp_unit_die ()->die_id
.die_symbol
= NULL
;
31186 /* Remove DW_AT_macro and DW_AT_stmt_list from the early output. */
31187 remove_AT (comp_unit_die (), DW_AT_stmt_list
);
31189 remove_AT (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
);
31191 /* Remove indirect string decisions. */
31192 debug_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
31193 if (debug_line_str_hash
)
31195 debug_line_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
31196 debug_line_str_hash
= NULL
;
31200 #if ENABLE_ASSERT_CHECKING
31202 dw_die_ref die
= comp_unit_die (), c
;
31203 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
31206 resolve_addr (comp_unit_die ());
31207 move_marked_base_types ();
31211 fprintf (dump_file
, "DWARF for %s\n", filename
);
31212 print_die (comp_unit_die (), dump_file
);
31215 /* Initialize sections and labels used for actual assembler output. */
31216 unsigned generation
= init_sections_and_labels (false);
31218 /* Traverse the DIE's and add sibling attributes to those DIE's that
31220 add_sibling_attributes (comp_unit_die ());
31221 limbo_die_node
*node
;
31222 for (node
= cu_die_list
; node
; node
= node
->next
)
31223 add_sibling_attributes (node
->die
);
31224 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31225 add_sibling_attributes (ctnode
->root_die
);
31227 /* When splitting DWARF info, we put some attributes in the
31228 skeleton compile_unit DIE that remains in the .o, while
31229 most attributes go in the DWO compile_unit_die. */
31230 if (dwarf_split_debug_info
)
31232 limbo_die_node
*cu
;
31233 main_comp_unit_die
= gen_compile_unit_die (NULL
);
31234 if (dwarf_version
>= 5)
31235 main_comp_unit_die
->die_tag
= DW_TAG_skeleton_unit
;
31236 cu
= limbo_die_list
;
31237 gcc_assert (cu
->die
== main_comp_unit_die
);
31238 limbo_die_list
= limbo_die_list
->next
;
31239 cu
->next
= cu_die_list
;
31243 main_comp_unit_die
= comp_unit_die ();
31245 /* Output a terminator label for the .text section. */
31246 switch_to_section (text_section
);
31247 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
31248 if (cold_text_section
)
31250 switch_to_section (cold_text_section
);
31251 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
31254 /* We can only use the low/high_pc attributes if all of the code was
31256 if (!have_multiple_function_sections
31257 || (dwarf_version
< 3 && dwarf_strict
))
31259 /* Don't add if the CU has no associated code. */
31260 if (text_section_used
)
31261 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
31262 text_end_label
, true);
31268 bool range_list_added
= false;
31270 if (text_section_used
)
31271 add_ranges_by_labels (main_comp_unit_die
, text_section_label
,
31272 text_end_label
, &range_list_added
, true);
31273 if (cold_text_section_used
)
31274 add_ranges_by_labels (main_comp_unit_die
, cold_text_section_label
,
31275 cold_end_label
, &range_list_added
, true);
31277 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
31279 if (DECL_IGNORED_P (fde
->decl
))
31281 if (!fde
->in_std_section
)
31282 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
31283 fde
->dw_fde_end
, &range_list_added
,
31285 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
31286 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
31287 fde
->dw_fde_second_end
, &range_list_added
,
31291 if (range_list_added
)
31293 /* We need to give .debug_loc and .debug_ranges an appropriate
31294 "base address". Use zero so that these addresses become
31295 absolute. Historically, we've emitted the unexpected
31296 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
31297 Emit both to give time for other tools to adapt. */
31298 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
31299 if (! dwarf_strict
&& dwarf_version
< 4)
31300 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
31306 /* AIX Assembler inserts the length, so adjust the reference to match the
31307 offset expected by debuggers. */
31308 strcpy (dl_section_ref
, debug_line_section_label
);
31309 if (XCOFF_DEBUGGING_INFO
)
31310 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
31312 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31313 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
31317 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
31318 macinfo_section_label
);
31320 if (dwarf_split_debug_info
)
31322 if (have_location_lists
)
31324 /* Since we generate the loclists in the split DWARF .dwo
31325 file itself, we don't need to generate a loclists_base
31326 attribute for the split compile unit DIE. That attribute
31327 (and using relocatable sec_offset FORMs) isn't allowed
31328 for a split compile unit. Only if the .debug_loclists
31329 section was in the main file, would we need to generate a
31330 loclists_base attribute here (for the full or skeleton
31333 /* optimize_location_lists calculates the size of the lists,
31334 so index them first, and assign indices to the entries.
31335 Although optimize_location_lists will remove entries from
31336 the table, it only does so for duplicates, and therefore
31337 only reduces ref_counts to 1. */
31338 index_location_lists (comp_unit_die ());
31341 if (addr_index_table
!= NULL
)
31343 unsigned int index
= 0;
31345 ->traverse_noresize
<unsigned int *, index_addr_table_entry
>
31351 if (have_location_lists
)
31353 optimize_location_lists (comp_unit_die ());
31354 /* And finally assign indexes to the entries for -gsplit-dwarf. */
31355 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
31356 assign_location_list_indexes (comp_unit_die ());
31359 save_macinfo_strings ();
31361 if (dwarf_split_debug_info
)
31363 unsigned int index
= 0;
31365 /* Add attributes common to skeleton compile_units and
31366 type_units. Because these attributes include strings, it
31367 must be done before freezing the string table. Top-level
31368 skeleton die attrs are added when the skeleton type unit is
31369 created, so ensure it is created by this point. */
31370 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
31371 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
31374 /* Output all of the compilation units. We put the main one last so that
31375 the offsets are available to output_pubnames. */
31376 for (node
= cu_die_list
; node
; node
= node
->next
)
31377 output_comp_unit (node
->die
, 0, NULL
);
31379 hash_table
<comdat_type_hasher
> comdat_type_table (100);
31380 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31382 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
31384 /* Don't output duplicate types. */
31385 if (*slot
!= HTAB_EMPTY_ENTRY
)
31388 /* Add a pointer to the line table for the main compilation unit
31389 so that the debugger can make sense of DW_AT_decl_file
31391 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31392 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
31393 (!dwarf_split_debug_info
31395 : debug_skeleton_line_section_label
));
31397 output_comdat_type_unit (ctnode
);
31401 if (dwarf_split_debug_info
)
31404 struct md5_ctx ctx
;
31406 if (dwarf_version
>= 5 && !vec_safe_is_empty (ranges_table
))
31409 /* Compute a checksum of the comp_unit to use as the dwo_id. */
31410 md5_init_ctx (&ctx
);
31412 die_checksum (comp_unit_die (), &ctx
, &mark
);
31413 unmark_all_dies (comp_unit_die ());
31414 md5_finish_ctx (&ctx
, checksum
);
31416 if (dwarf_version
< 5)
31418 /* Use the first 8 bytes of the checksum as the dwo_id,
31419 and add it to both comp-unit DIEs. */
31420 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
31421 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
31424 /* Add the base offset of the ranges table to the skeleton
31426 if (!vec_safe_is_empty (ranges_table
))
31428 if (dwarf_version
>= 5)
31429 add_AT_lineptr (main_comp_unit_die
, DW_AT_rnglists_base
,
31430 ranges_base_label
);
31432 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
31433 ranges_section_label
);
31436 switch_to_section (debug_addr_section
);
31437 /* GNU DebugFission https://gcc.gnu.org/wiki/DebugFission
31438 which GCC uses to implement -gsplit-dwarf as DWARF GNU extension
31439 before DWARF5, didn't have a header for .debug_addr units.
31440 DWARF5 specifies a small header when address tables are used. */
31441 if (dwarf_version
>= 5)
31443 unsigned int last_idx
= 0;
31444 unsigned long addrs_length
;
31446 addr_index_table
->traverse_noresize
31447 <unsigned int *, count_index_addrs
> (&last_idx
);
31448 addrs_length
= last_idx
* DWARF2_ADDR_SIZE
+ 4;
31450 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
31451 dw2_asm_output_data (4, 0xffffffff,
31452 "Escape value for 64-bit DWARF extension");
31453 dw2_asm_output_data (DWARF_OFFSET_SIZE
, addrs_length
,
31454 "Length of Address Unit");
31455 dw2_asm_output_data (2, 5, "DWARF addr version");
31456 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
31457 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
31459 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
31460 output_addr_table ();
31463 /* Output the main compilation unit if non-empty or if .debug_macinfo
31464 or .debug_macro will be emitted. */
31465 output_comp_unit (comp_unit_die (), have_macinfo
,
31466 dwarf_split_debug_info
? checksum
: NULL
);
31468 if (dwarf_split_debug_info
&& info_section_emitted
)
31469 output_skeleton_debug_sections (main_comp_unit_die
, checksum
);
31471 /* Output the abbreviation table. */
31472 if (vec_safe_length (abbrev_die_table
) != 1)
31474 switch_to_section (debug_abbrev_section
);
31475 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
31476 output_abbrev_section ();
31479 /* Output location list section if necessary. */
31480 if (have_location_lists
)
31482 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
31483 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
31484 /* Output the location lists info. */
31485 switch_to_section (debug_loc_section
);
31486 if (dwarf_version
>= 5)
31488 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_LOC_SECTION_LABEL
, 2);
31489 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_LOC_SECTION_LABEL
, 3);
31490 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
31491 dw2_asm_output_data (4, 0xffffffff,
31492 "Initial length escape value indicating "
31493 "64-bit DWARF extension");
31494 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
31495 "Length of Location Lists");
31496 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
31497 output_dwarf_version ();
31498 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
31499 dw2_asm_output_data (1, 0, "Segment Size");
31500 dw2_asm_output_data (4, dwarf_split_debug_info
? loc_list_idx
: 0,
31501 "Offset Entry Count");
31503 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
31504 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
31506 unsigned int save_loc_list_idx
= loc_list_idx
;
31508 output_loclists_offsets (comp_unit_die ());
31509 gcc_assert (save_loc_list_idx
== loc_list_idx
);
31511 output_location_lists (comp_unit_die ());
31512 if (dwarf_version
>= 5)
31513 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
31516 output_pubtables ();
31518 /* Output the address range information if a CU (.debug_info section)
31519 was emitted. We output an empty table even if we had no functions
31520 to put in it. This because the consumer has no way to tell the
31521 difference between an empty table that we omitted and failure to
31522 generate a table that would have contained data. */
31523 if (info_section_emitted
)
31525 switch_to_section (debug_aranges_section
);
31529 /* Output ranges section if necessary. */
31530 if (!vec_safe_is_empty (ranges_table
))
31532 if (dwarf_version
>= 5)
31533 output_rnglists (generation
);
31538 /* Have to end the macro section. */
31541 switch_to_section (debug_macinfo_section
);
31542 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
31543 output_macinfo (!dwarf_split_debug_info
? debug_line_section_label
31544 : debug_skeleton_line_section_label
, false);
31545 dw2_asm_output_data (1, 0, "End compilation unit");
31548 /* Output the source line correspondence table. We must do this
31549 even if there is no line information. Otherwise, on an empty
31550 translation unit, we will generate a present, but empty,
31551 .debug_info section. IRIX 6.5 `nm' will then complain when
31552 examining the file. This is done late so that any filenames
31553 used by the debug_info section are marked as 'used'. */
31554 switch_to_section (debug_line_section
);
31555 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
31556 if (! output_asm_line_debug_info ())
31557 output_line_info (false);
31559 if (dwarf_split_debug_info
&& info_section_emitted
)
31561 switch_to_section (debug_skeleton_line_section
);
31562 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
31563 output_line_info (true);
31566 /* If we emitted any indirect strings, output the string table too. */
31567 if (debug_str_hash
|| skeleton_debug_str_hash
)
31568 output_indirect_strings ();
31569 if (debug_line_str_hash
)
31571 switch_to_section (debug_line_str_section
);
31572 const enum dwarf_form form
= DW_FORM_line_strp
;
31573 debug_line_str_hash
->traverse
<enum dwarf_form
,
31574 output_indirect_string
> (form
);
31577 /* ??? Move lvugid out of dwarf2out_source_line and reset it too? */
31578 symview_upper_bound
= 0;
31580 bitmap_clear (zero_view_p
);
31583 /* Returns a hash value for X (which really is a variable_value_struct). */
31586 variable_value_hasher::hash (variable_value_struct
*x
)
31588 return (hashval_t
) x
->decl_id
;
31591 /* Return nonzero if decl_id of variable_value_struct X is the same as
31595 variable_value_hasher::equal (variable_value_struct
*x
, tree y
)
31597 return x
->decl_id
== DECL_UID (y
);
31600 /* Helper function for resolve_variable_value, handle
31601 DW_OP_GNU_variable_value in one location expression.
31602 Return true if exprloc has been changed into loclist. */
31605 resolve_variable_value_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
31607 dw_loc_descr_ref next
;
31608 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= next
)
31610 next
= loc
->dw_loc_next
;
31611 if (loc
->dw_loc_opc
!= DW_OP_GNU_variable_value
31612 || loc
->dw_loc_oprnd1
.val_class
!= dw_val_class_decl_ref
)
31615 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
31616 if (DECL_CONTEXT (decl
) != current_function_decl
)
31619 dw_die_ref ref
= lookup_decl_die (decl
);
31622 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31623 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31624 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31627 dw_loc_list_ref l
= loc_list_from_tree (decl
, 0, NULL
);
31630 if (l
->dw_loc_next
)
31632 if (AT_class (a
) != dw_val_class_loc
)
31634 switch (a
->dw_attr
)
31636 /* Following attributes allow both exprloc and loclist
31637 classes, so we can change them into a loclist. */
31638 case DW_AT_location
:
31639 case DW_AT_string_length
:
31640 case DW_AT_return_addr
:
31641 case DW_AT_data_member_location
:
31642 case DW_AT_frame_base
:
31643 case DW_AT_segment
:
31644 case DW_AT_static_link
:
31645 case DW_AT_use_location
:
31646 case DW_AT_vtable_elem_location
:
31649 prev
->dw_loc_next
= NULL
;
31650 prepend_loc_descr_to_each (l
, AT_loc (a
));
31653 add_loc_descr_to_each (l
, next
);
31654 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
31655 a
->dw_attr_val
.val_entry
= NULL
;
31656 a
->dw_attr_val
.v
.val_loc_list
= l
;
31657 have_location_lists
= true;
31659 /* Following attributes allow both exprloc and reference,
31660 so if the whole expression is DW_OP_GNU_variable_value alone
31661 we could transform it into reference. */
31662 case DW_AT_byte_size
:
31663 case DW_AT_bit_size
:
31664 case DW_AT_lower_bound
:
31665 case DW_AT_upper_bound
:
31666 case DW_AT_bit_stride
:
31668 case DW_AT_allocated
:
31669 case DW_AT_associated
:
31670 case DW_AT_byte_stride
:
31671 if (prev
== NULL
&& next
== NULL
)
31679 /* Create DW_TAG_variable that we can refer to. */
31680 gen_decl_die (decl
, NULL_TREE
, NULL
,
31681 lookup_decl_die (current_function_decl
));
31682 ref
= lookup_decl_die (decl
);
31685 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31686 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31687 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31693 prev
->dw_loc_next
= l
->expr
;
31694 add_loc_descr (&prev
->dw_loc_next
, next
);
31695 free_loc_descr (loc
, NULL
);
31696 next
= prev
->dw_loc_next
;
31700 memcpy (loc
, l
->expr
, sizeof (dw_loc_descr_node
));
31701 add_loc_descr (&loc
, next
);
31709 /* Attempt to resolve DW_OP_GNU_variable_value using loc_list_from_tree. */
31712 resolve_variable_value (dw_die_ref die
)
31715 dw_loc_list_ref loc
;
31718 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31719 switch (AT_class (a
))
31721 case dw_val_class_loc
:
31722 if (!resolve_variable_value_in_expr (a
, AT_loc (a
)))
31725 case dw_val_class_loc_list
:
31726 loc
= AT_loc_list (a
);
31728 for (; loc
; loc
= loc
->dw_loc_next
)
31729 resolve_variable_value_in_expr (a
, loc
->expr
);
31736 /* Attempt to optimize DW_OP_GNU_variable_value refering to
31737 temporaries in the current function. */
31740 resolve_variable_values (void)
31742 if (!variable_value_hash
|| !current_function_decl
)
31745 struct variable_value_struct
*node
31746 = variable_value_hash
->find_with_hash (current_function_decl
,
31747 DECL_UID (current_function_decl
));
31754 FOR_EACH_VEC_SAFE_ELT (node
->dies
, i
, die
)
31755 resolve_variable_value (die
);
31758 /* Helper function for note_variable_value, handle one location
31762 note_variable_value_in_expr (dw_die_ref die
, dw_loc_descr_ref loc
)
31764 for (; loc
; loc
= loc
->dw_loc_next
)
31765 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
31766 && loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
31768 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
31769 dw_die_ref ref
= lookup_decl_die (decl
);
31770 if (! ref
&& (flag_generate_lto
|| flag_generate_offload
))
31772 /* ??? This is somewhat a hack because we do not create DIEs
31773 for variables not in BLOCK trees early but when generating
31774 early LTO output we need the dw_val_class_decl_ref to be
31775 fully resolved. For fat LTO objects we'd also like to
31776 undo this after LTO dwarf output. */
31777 gcc_assert (DECL_CONTEXT (decl
));
31778 dw_die_ref ctx
= lookup_decl_die (DECL_CONTEXT (decl
));
31779 gcc_assert (ctx
!= NULL
);
31780 gen_decl_die (decl
, NULL_TREE
, NULL
, ctx
);
31781 ref
= lookup_decl_die (decl
);
31782 gcc_assert (ref
!= NULL
);
31786 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31787 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31788 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31792 && DECL_CONTEXT (decl
)
31793 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
31794 && lookup_decl_die (DECL_CONTEXT (decl
)))
31796 if (!variable_value_hash
)
31797 variable_value_hash
31798 = hash_table
<variable_value_hasher
>::create_ggc (10);
31800 tree fndecl
= DECL_CONTEXT (decl
);
31801 struct variable_value_struct
*node
;
31802 struct variable_value_struct
**slot
31803 = variable_value_hash
->find_slot_with_hash (fndecl
,
31808 node
= ggc_cleared_alloc
<variable_value_struct
> ();
31809 node
->decl_id
= DECL_UID (fndecl
);
31815 vec_safe_push (node
->dies
, die
);
31820 /* Walk the tree DIE and note DIEs with DW_OP_GNU_variable_value still
31821 with dw_val_class_decl_ref operand. */
31824 note_variable_value (dw_die_ref die
)
31828 dw_loc_list_ref loc
;
31831 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31832 switch (AT_class (a
))
31834 case dw_val_class_loc_list
:
31835 loc
= AT_loc_list (a
);
31837 if (!loc
->noted_variable_value
)
31839 loc
->noted_variable_value
= 1;
31840 for (; loc
; loc
= loc
->dw_loc_next
)
31841 note_variable_value_in_expr (die
, loc
->expr
);
31844 case dw_val_class_loc
:
31845 note_variable_value_in_expr (die
, AT_loc (a
));
31851 /* Mark children. */
31852 FOR_EACH_CHILD (die
, c
, note_variable_value (c
));
31855 /* Perform any cleanups needed after the early debug generation pass
31859 dwarf2out_early_finish (const char *filename
)
31862 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
31864 /* PCH might result in DW_AT_producer string being restored from the
31865 header compilation, so always fill it with empty string initially
31866 and overwrite only here. */
31867 dw_attr_node
*producer
= get_AT (comp_unit_die (), DW_AT_producer
);
31868 producer_string
= gen_producer_string ();
31869 producer
->dw_attr_val
.v
.val_str
->refcount
--;
31870 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
31872 /* Add the name for the main input file now. We delayed this from
31873 dwarf2out_init to avoid complications with PCH. */
31874 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
31875 add_comp_dir_attribute (comp_unit_die ());
31877 /* When emitting DWARF5 .debug_line_str, move DW_AT_name and
31878 DW_AT_comp_dir into .debug_line_str section. */
31879 if (!output_asm_line_debug_info ()
31880 && dwarf_version
>= 5
31881 && DWARF5_USE_DEBUG_LINE_STR
)
31883 for (int i
= 0; i
< 2; i
++)
31885 dw_attr_node
*a
= get_AT (comp_unit_die (),
31886 i
? DW_AT_comp_dir
: DW_AT_name
);
31888 || AT_class (a
) != dw_val_class_str
31889 || strlen (AT_string (a
)) + 1 <= DWARF_OFFSET_SIZE
)
31892 if (! debug_line_str_hash
)
31893 debug_line_str_hash
31894 = hash_table
<indirect_string_hasher
>::create_ggc (10);
31896 struct indirect_string_node
*node
31897 = find_AT_string_in_table (AT_string (a
), debug_line_str_hash
);
31898 set_indirect_string (node
);
31899 node
->form
= DW_FORM_line_strp
;
31900 a
->dw_attr_val
.v
.val_str
->refcount
--;
31901 a
->dw_attr_val
.v
.val_str
= node
;
31905 /* With LTO early dwarf was really finished at compile-time, so make
31906 sure to adjust the phase after annotating the LTRANS CU DIE. */
31909 early_dwarf_finished
= true;
31912 fprintf (dump_file
, "LTO EARLY DWARF for %s\n", filename
);
31913 print_die (comp_unit_die (), dump_file
);
31918 /* Walk through the list of incomplete types again, trying once more to
31919 emit full debugging info for them. */
31920 retry_incomplete_types ();
31922 /* The point here is to flush out the limbo list so that it is empty
31923 and we don't need to stream it for LTO. */
31924 flush_limbo_die_list ();
31926 gen_scheduled_generic_parms_dies ();
31927 gen_remaining_tmpl_value_param_die_attribute ();
31929 /* Add DW_AT_linkage_name for all deferred DIEs. */
31930 for (limbo_die_node
*node
= deferred_asm_name
; node
; node
= node
->next
)
31932 tree decl
= node
->created_for
;
31933 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
31934 /* A missing DECL_ASSEMBLER_NAME can be a constant DIE that
31935 ended up in deferred_asm_name before we knew it was
31936 constant and never written to disk. */
31937 && DECL_ASSEMBLER_NAME (decl
))
31939 add_linkage_attr (node
->die
, decl
);
31940 move_linkage_attr (node
->die
);
31943 deferred_asm_name
= NULL
;
31945 if (flag_eliminate_unused_debug_types
)
31946 prune_unused_types ();
31948 /* Generate separate COMDAT sections for type DIEs. */
31949 if (use_debug_types
)
31951 break_out_comdat_types (comp_unit_die ());
31953 /* Each new type_unit DIE was added to the limbo die list when created.
31954 Since these have all been added to comdat_type_list, clear the
31956 limbo_die_list
= NULL
;
31958 /* For each new comdat type unit, copy declarations for incomplete
31959 types to make the new unit self-contained (i.e., no direct
31960 references to the main compile unit). */
31961 for (comdat_type_node
*ctnode
= comdat_type_list
;
31962 ctnode
!= NULL
; ctnode
= ctnode
->next
)
31963 copy_decls_for_unworthy_types (ctnode
->root_die
);
31964 copy_decls_for_unworthy_types (comp_unit_die ());
31966 /* In the process of copying declarations from one unit to another,
31967 we may have left some declarations behind that are no longer
31968 referenced. Prune them. */
31969 prune_unused_types ();
31972 /* Traverse the DIE's and note DIEs with DW_OP_GNU_variable_value still
31973 with dw_val_class_decl_ref operand. */
31974 note_variable_value (comp_unit_die ());
31975 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
31976 note_variable_value (node
->die
);
31977 for (comdat_type_node
*ctnode
= comdat_type_list
; ctnode
!= NULL
;
31978 ctnode
= ctnode
->next
)
31979 note_variable_value (ctnode
->root_die
);
31980 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
31981 note_variable_value (node
->die
);
31983 /* The AT_pubnames attribute needs to go in all skeleton dies, including
31984 both the main_cu and all skeleton TUs. Making this call unconditional
31985 would end up either adding a second copy of the AT_pubnames attribute, or
31986 requiring a special case in add_top_level_skeleton_die_attrs. */
31987 if (!dwarf_split_debug_info
)
31988 add_AT_pubnames (comp_unit_die ());
31990 /* The early debug phase is now finished. */
31991 early_dwarf_finished
= true;
31994 fprintf (dump_file
, "EARLY DWARF for %s\n", filename
);
31995 print_die (comp_unit_die (), dump_file
);
31998 /* Do not generate DWARF assembler now when not producing LTO bytecode. */
31999 if ((!flag_generate_lto
&& !flag_generate_offload
)
32000 /* FIXME: Disable debug info generation for (PE-)COFF targets since the
32001 copy_lto_debug_sections operation of the simple object support in
32002 libiberty is not implemented for them yet. */
32003 || TARGET_PECOFF
|| TARGET_COFF
)
32006 /* Now as we are going to output for LTO initialize sections and labels
32007 to the LTO variants. We don't need a random-seed postfix as other
32008 LTO sections as linking the LTO debug sections into one in a partial
32010 init_sections_and_labels (true);
32012 /* The output below is modeled after dwarf2out_finish with all
32013 location related output removed and some LTO specific changes.
32014 Some refactoring might make both smaller and easier to match up. */
32016 /* Traverse the DIE's and add add sibling attributes to those DIE's
32017 that have children. */
32018 add_sibling_attributes (comp_unit_die ());
32019 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
32020 add_sibling_attributes (node
->die
);
32021 for (comdat_type_node
*ctnode
= comdat_type_list
;
32022 ctnode
!= NULL
; ctnode
= ctnode
->next
)
32023 add_sibling_attributes (ctnode
->root_die
);
32025 /* AIX Assembler inserts the length, so adjust the reference to match the
32026 offset expected by debuggers. */
32027 strcpy (dl_section_ref
, debug_line_section_label
);
32028 if (XCOFF_DEBUGGING_INFO
)
32029 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
32031 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32032 add_AT_lineptr (comp_unit_die (), DW_AT_stmt_list
, dl_section_ref
);
32035 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
32036 macinfo_section_label
);
32038 save_macinfo_strings ();
32040 if (dwarf_split_debug_info
)
32042 unsigned int index
= 0;
32043 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
32046 /* Output all of the compilation units. We put the main one last so that
32047 the offsets are available to output_pubnames. */
32048 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
32049 output_comp_unit (node
->die
, 0, NULL
);
32051 hash_table
<comdat_type_hasher
> comdat_type_table (100);
32052 for (comdat_type_node
*ctnode
= comdat_type_list
;
32053 ctnode
!= NULL
; ctnode
= ctnode
->next
)
32055 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
32057 /* Don't output duplicate types. */
32058 if (*slot
!= HTAB_EMPTY_ENTRY
)
32061 /* Add a pointer to the line table for the main compilation unit
32062 so that the debugger can make sense of DW_AT_decl_file
32064 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32065 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
32066 (!dwarf_split_debug_info
32067 ? debug_line_section_label
32068 : debug_skeleton_line_section_label
));
32070 output_comdat_type_unit (ctnode
);
32074 /* Stick a unique symbol to the main debuginfo section. */
32075 compute_comp_unit_symbol (comp_unit_die ());
32077 /* Output the main compilation unit. We always need it if only for
32079 output_comp_unit (comp_unit_die (), true, NULL
);
32081 /* Output the abbreviation table. */
32082 if (vec_safe_length (abbrev_die_table
) != 1)
32084 switch_to_section (debug_abbrev_section
);
32085 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
32086 output_abbrev_section ();
32089 /* Have to end the macro section. */
32092 /* We have to save macinfo state if we need to output it again
32093 for the FAT part of the object. */
32094 vec
<macinfo_entry
, va_gc
> *saved_macinfo_table
= macinfo_table
;
32095 if (flag_fat_lto_objects
)
32096 macinfo_table
= macinfo_table
->copy ();
32098 switch_to_section (debug_macinfo_section
);
32099 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
32100 output_macinfo (debug_line_section_label
, true);
32101 dw2_asm_output_data (1, 0, "End compilation unit");
32103 if (flag_fat_lto_objects
)
32105 vec_free (macinfo_table
);
32106 macinfo_table
= saved_macinfo_table
;
32110 /* Emit a skeleton debug_line section. */
32111 switch_to_section (debug_line_section
);
32112 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
32113 output_line_info (true);
32115 /* If we emitted any indirect strings, output the string table too. */
32116 if (debug_str_hash
|| skeleton_debug_str_hash
)
32117 output_indirect_strings ();
32118 if (debug_line_str_hash
)
32120 switch_to_section (debug_line_str_section
);
32121 const enum dwarf_form form
= DW_FORM_line_strp
;
32122 debug_line_str_hash
->traverse
<enum dwarf_form
,
32123 output_indirect_string
> (form
);
32126 /* Switch back to the text section. */
32127 switch_to_section (text_section
);
32130 /* Reset all state within dwarf2out.c so that we can rerun the compiler
32131 within the same process. For use by toplev::finalize. */
32134 dwarf2out_c_finalize (void)
32136 last_var_location_insn
= NULL
;
32137 cached_next_real_insn
= NULL
;
32138 used_rtx_array
= NULL
;
32139 incomplete_types
= NULL
;
32140 debug_info_section
= NULL
;
32141 debug_skeleton_info_section
= NULL
;
32142 debug_abbrev_section
= NULL
;
32143 debug_skeleton_abbrev_section
= NULL
;
32144 debug_aranges_section
= NULL
;
32145 debug_addr_section
= NULL
;
32146 debug_macinfo_section
= NULL
;
32147 debug_line_section
= NULL
;
32148 debug_skeleton_line_section
= NULL
;
32149 debug_loc_section
= NULL
;
32150 debug_pubnames_section
= NULL
;
32151 debug_pubtypes_section
= NULL
;
32152 debug_str_section
= NULL
;
32153 debug_line_str_section
= NULL
;
32154 debug_str_dwo_section
= NULL
;
32155 debug_str_offsets_section
= NULL
;
32156 debug_ranges_section
= NULL
;
32157 debug_frame_section
= NULL
;
32159 debug_str_hash
= NULL
;
32160 debug_line_str_hash
= NULL
;
32161 skeleton_debug_str_hash
= NULL
;
32162 dw2_string_counter
= 0;
32163 have_multiple_function_sections
= false;
32164 text_section_used
= false;
32165 cold_text_section_used
= false;
32166 cold_text_section
= NULL
;
32167 current_unit_personality
= NULL
;
32169 early_dwarf
= false;
32170 early_dwarf_finished
= false;
32172 next_die_offset
= 0;
32173 single_comp_unit_die
= NULL
;
32174 comdat_type_list
= NULL
;
32175 limbo_die_list
= NULL
;
32177 decl_die_table
= NULL
;
32178 common_block_die_table
= NULL
;
32179 decl_loc_table
= NULL
;
32180 call_arg_locations
= NULL
;
32181 call_arg_loc_last
= NULL
;
32182 call_site_count
= -1;
32183 tail_call_site_count
= -1;
32184 cached_dw_loc_list_table
= NULL
;
32185 abbrev_die_table
= NULL
;
32186 delete dwarf_proc_stack_usage_map
;
32187 dwarf_proc_stack_usage_map
= NULL
;
32188 line_info_label_num
= 0;
32189 cur_line_info_table
= NULL
;
32190 text_section_line_info
= NULL
;
32191 cold_text_section_line_info
= NULL
;
32192 separate_line_info
= NULL
;
32193 info_section_emitted
= false;
32194 pubname_table
= NULL
;
32195 pubtype_table
= NULL
;
32196 macinfo_table
= NULL
;
32197 ranges_table
= NULL
;
32198 ranges_by_label
= NULL
;
32200 have_location_lists
= false;
32203 last_emitted_file
= NULL
;
32205 tmpl_value_parm_die_table
= NULL
;
32206 generic_type_instances
= NULL
;
32207 frame_pointer_fb_offset
= 0;
32208 frame_pointer_fb_offset_valid
= false;
32209 base_types
.release ();
32210 XDELETEVEC (producer_string
);
32211 producer_string
= NULL
;
32214 #include "gt-dwarf2out.h"