1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992-2019 Free Software Foundation, Inc.
3 Contributed by Gary Funck (gary@intrepid.com).
4 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
5 Extensively modified by Jason Merrill (jason@cygnus.com).
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 /* TODO: Emit .debug_line header even when there are no functions, since
24 the file numbers are used by .debug_info. Alternately, leave
25 out locations for types and decls.
26 Avoid talking about ctors and op= for PODs.
27 Factor out common prologue sequences into multiple CIEs. */
29 /* The first part of this file deals with the DWARF 2 frame unwind
30 information, which is also used by the GCC efficient exception handling
31 mechanism. The second part, controlled only by an #ifdef
32 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
35 /* DWARF2 Abbreviation Glossary:
37 CFA = Canonical Frame Address
38 a fixed address on the stack which identifies a call frame.
39 We define it to be the value of SP just before the call insn.
40 The CFA register and offset, which may change during the course
41 of the function, are used to calculate its value at runtime.
43 CFI = Call Frame Instruction
44 an instruction for the DWARF2 abstract machine
46 CIE = Common Information Entry
47 information describing information common to one or more FDEs
49 DIE = Debugging Information Entry
51 FDE = Frame Description Entry
52 information describing the stack call frame, in particular,
53 how to restore registers
55 DW_CFA_... = DWARF2 CFA call frame instruction
56 DW_TAG_... = DWARF2 DIE tag */
60 #include "coretypes.h"
67 #include "stringpool.h"
68 #include "insn-config.h"
71 #include "diagnostic.h"
72 #include "fold-const.h"
73 #include "stor-layout.h"
81 #include "dwarf2out.h"
82 #include "dwarf2asm.h"
85 #include "tree-pretty-print.h"
86 #include "print-rtl.h"
88 #include "common/common-target.h"
89 #include "langhooks.h"
94 #include "gdb/gdb-index.h"
96 #include "stringpool.h"
98 #include "file-prefix-map.h" /* remap_debug_filename() */
100 static void dwarf2out_source_line (unsigned int, unsigned int, const char *,
102 static rtx_insn
*last_var_location_insn
;
103 static rtx_insn
*cached_next_real_insn
;
104 static void dwarf2out_decl (tree
);
105 static bool is_redundant_typedef (const_tree
);
107 #ifndef XCOFF_DEBUGGING_INFO
108 #define XCOFF_DEBUGGING_INFO 0
111 #ifndef HAVE_XCOFF_DWARF_EXTRAS
112 #define HAVE_XCOFF_DWARF_EXTRAS 0
115 #ifdef VMS_DEBUGGING_INFO
116 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
118 /* Define this macro to be a nonzero value if the directory specifications
119 which are output in the debug info should end with a separator. */
120 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
121 /* Define this macro to evaluate to a nonzero value if GCC should refrain
122 from generating indirect strings in DWARF2 debug information, for instance
123 if your target is stuck with an old version of GDB that is unable to
124 process them properly or uses VMS Debug. */
125 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
127 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
128 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
131 /* ??? Poison these here until it can be done generically. They've been
132 totally replaced in this file; make sure it stays that way. */
133 #undef DWARF2_UNWIND_INFO
134 #undef DWARF2_FRAME_INFO
135 #if (GCC_VERSION >= 3000)
136 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
139 /* The size of the target's pointer type. */
141 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
144 /* Array of RTXes referenced by the debugging information, which therefore
145 must be kept around forever. */
146 static GTY(()) vec
<rtx
, va_gc
> *used_rtx_array
;
148 /* A pointer to the base of a list of incomplete types which might be
149 completed at some later time. incomplete_types_list needs to be a
150 vec<tree, va_gc> *because we want to tell the garbage collector about
152 static GTY(()) vec
<tree
, va_gc
> *incomplete_types
;
154 /* Pointers to various DWARF2 sections. */
155 static GTY(()) section
*debug_info_section
;
156 static GTY(()) section
*debug_skeleton_info_section
;
157 static GTY(()) section
*debug_abbrev_section
;
158 static GTY(()) section
*debug_skeleton_abbrev_section
;
159 static GTY(()) section
*debug_aranges_section
;
160 static GTY(()) section
*debug_addr_section
;
161 static GTY(()) section
*debug_macinfo_section
;
162 static const char *debug_macinfo_section_name
;
163 static unsigned macinfo_label_base
= 1;
164 static GTY(()) section
*debug_line_section
;
165 static GTY(()) section
*debug_skeleton_line_section
;
166 static GTY(()) section
*debug_loc_section
;
167 static GTY(()) section
*debug_pubnames_section
;
168 static GTY(()) section
*debug_pubtypes_section
;
169 static GTY(()) section
*debug_str_section
;
170 static GTY(()) section
*debug_line_str_section
;
171 static GTY(()) section
*debug_str_dwo_section
;
172 static GTY(()) section
*debug_str_offsets_section
;
173 static GTY(()) section
*debug_ranges_section
;
174 static GTY(()) section
*debug_frame_section
;
176 /* Maximum size (in bytes) of an artificially generated label. */
177 #define MAX_ARTIFICIAL_LABEL_BYTES 40
179 /* According to the (draft) DWARF 3 specification, the initial length
180 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
181 bytes are 0xffffffff, followed by the length stored in the next 8
184 However, the SGI/MIPS ABI uses an initial length which is equal to
185 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
187 #ifndef DWARF_INITIAL_LENGTH_SIZE
188 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
191 #ifndef DWARF_INITIAL_LENGTH_SIZE_STR
192 #define DWARF_INITIAL_LENGTH_SIZE_STR (DWARF_OFFSET_SIZE == 4 ? "-4" : "-12")
195 /* Round SIZE up to the nearest BOUNDARY. */
196 #define DWARF_ROUND(SIZE,BOUNDARY) \
197 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
199 /* CIE identifier. */
200 #if HOST_BITS_PER_WIDE_INT >= 64
201 #define DWARF_CIE_ID \
202 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
204 #define DWARF_CIE_ID DW_CIE_ID
208 /* A vector for a table that contains frame description
209 information for each routine. */
210 #define NOT_INDEXED (-1U)
211 #define NO_INDEX_ASSIGNED (-2U)
213 static GTY(()) vec
<dw_fde_ref
, va_gc
> *fde_vec
;
215 struct GTY((for_user
)) indirect_string_node
{
217 unsigned int refcount
;
218 enum dwarf_form form
;
223 struct indirect_string_hasher
: ggc_ptr_hash
<indirect_string_node
>
225 typedef const char *compare_type
;
227 static hashval_t
hash (indirect_string_node
*);
228 static bool equal (indirect_string_node
*, const char *);
231 static GTY (()) hash_table
<indirect_string_hasher
> *debug_str_hash
;
233 static GTY (()) hash_table
<indirect_string_hasher
> *debug_line_str_hash
;
235 /* With split_debug_info, both the comp_dir and dwo_name go in the
236 main object file, rather than the dwo, similar to the force_direct
237 parameter elsewhere but with additional complications:
239 1) The string is needed in both the main object file and the dwo.
240 That is, the comp_dir and dwo_name will appear in both places.
242 2) Strings can use four forms: DW_FORM_string, DW_FORM_strp,
243 DW_FORM_line_strp or DW_FORM_strx/GNU_str_index.
245 3) GCC chooses the form to use late, depending on the size and
248 Rather than forcing the all debug string handling functions and
249 callers to deal with these complications, simply use a separate,
250 special-cased string table for any attribute that should go in the
251 main object file. This limits the complexity to just the places
254 static GTY (()) hash_table
<indirect_string_hasher
> *skeleton_debug_str_hash
;
256 static GTY(()) int dw2_string_counter
;
258 /* True if the compilation unit places functions in more than one section. */
259 static GTY(()) bool have_multiple_function_sections
= false;
261 /* Whether the default text and cold text sections have been used at all. */
262 static GTY(()) bool text_section_used
= false;
263 static GTY(()) bool cold_text_section_used
= false;
265 /* The default cold text section. */
266 static GTY(()) section
*cold_text_section
;
268 /* The DIE for C++14 'auto' in a function return type. */
269 static GTY(()) dw_die_ref auto_die
;
271 /* The DIE for C++14 'decltype(auto)' in a function return type. */
272 static GTY(()) dw_die_ref decltype_auto_die
;
274 /* Forward declarations for functions defined in this file. */
276 static void output_call_frame_info (int);
277 static void dwarf2out_note_section_used (void);
279 /* Personality decl of current unit. Used only when assembler does not support
281 static GTY(()) rtx current_unit_personality
;
283 /* Whether an eh_frame section is required. */
284 static GTY(()) bool do_eh_frame
= false;
286 /* .debug_rnglists next index. */
287 static unsigned int rnglist_idx
;
289 /* Data and reference forms for relocatable data. */
290 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
291 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
293 #ifndef DEBUG_FRAME_SECTION
294 #define DEBUG_FRAME_SECTION ".debug_frame"
297 #ifndef FUNC_BEGIN_LABEL
298 #define FUNC_BEGIN_LABEL "LFB"
301 #ifndef FUNC_SECOND_SECT_LABEL
302 #define FUNC_SECOND_SECT_LABEL "LFSB"
305 #ifndef FUNC_END_LABEL
306 #define FUNC_END_LABEL "LFE"
309 #ifndef PROLOGUE_END_LABEL
310 #define PROLOGUE_END_LABEL "LPE"
313 #ifndef EPILOGUE_BEGIN_LABEL
314 #define EPILOGUE_BEGIN_LABEL "LEB"
317 #ifndef FRAME_BEGIN_LABEL
318 #define FRAME_BEGIN_LABEL "Lframe"
320 #define CIE_AFTER_SIZE_LABEL "LSCIE"
321 #define CIE_END_LABEL "LECIE"
322 #define FDE_LABEL "LSFDE"
323 #define FDE_AFTER_SIZE_LABEL "LASFDE"
324 #define FDE_END_LABEL "LEFDE"
325 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
326 #define LINE_NUMBER_END_LABEL "LELT"
327 #define LN_PROLOG_AS_LABEL "LASLTP"
328 #define LN_PROLOG_END_LABEL "LELTP"
329 #define DIE_LABEL_PREFIX "DW"
331 /* Match the base name of a file to the base name of a compilation unit. */
334 matches_main_base (const char *path
)
336 /* Cache the last query. */
337 static const char *last_path
= NULL
;
338 static int last_match
= 0;
339 if (path
!= last_path
)
342 int length
= base_of_path (path
, &base
);
344 last_match
= (length
== main_input_baselength
345 && memcmp (base
, main_input_basename
, length
) == 0);
350 #ifdef DEBUG_DEBUG_STRUCT
353 dump_struct_debug (tree type
, enum debug_info_usage usage
,
354 enum debug_struct_file criterion
, int generic
,
355 int matches
, int result
)
357 /* Find the type name. */
358 tree type_decl
= TYPE_STUB_DECL (type
);
360 const char *name
= 0;
361 if (TREE_CODE (t
) == TYPE_DECL
)
364 name
= IDENTIFIER_POINTER (t
);
366 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
368 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
369 matches
? "bas" : "hdr",
370 generic
? "gen" : "ord",
371 usage
== DINFO_USAGE_DFN
? ";" :
372 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
374 (void*) type_decl
, name
);
377 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
378 dump_struct_debug (type, usage, criterion, generic, matches, result)
382 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
387 /* Get the number of HOST_WIDE_INTs needed to represent the precision
388 of the number. Some constants have a large uniform precision, so
389 we get the precision needed for the actual value of the number. */
392 get_full_len (const wide_int
&op
)
394 int prec
= wi::min_precision (op
, UNSIGNED
);
395 return ((prec
+ HOST_BITS_PER_WIDE_INT
- 1)
396 / HOST_BITS_PER_WIDE_INT
);
400 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
402 enum debug_struct_file criterion
;
404 bool generic
= lang_hooks
.types
.generic_p (type
);
407 criterion
= debug_struct_generic
[usage
];
409 criterion
= debug_struct_ordinary
[usage
];
411 if (criterion
== DINFO_STRUCT_FILE_NONE
)
412 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
413 if (criterion
== DINFO_STRUCT_FILE_ANY
)
414 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
416 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
418 if (type_decl
!= NULL
)
420 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
421 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
423 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
424 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
427 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
430 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
431 switch to the data section instead, and write out a synthetic start label
432 for collect2 the first time around. */
435 switch_to_eh_frame_section (bool back ATTRIBUTE_UNUSED
)
437 if (eh_frame_section
== 0)
441 if (EH_TABLES_CAN_BE_READ_ONLY
)
447 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
449 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
451 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
454 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
455 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
456 && (per_encoding
& 0x70) != DW_EH_PE_absptr
457 && (per_encoding
& 0x70) != DW_EH_PE_aligned
458 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
459 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
460 ? 0 : SECTION_WRITE
);
463 flags
= SECTION_WRITE
;
465 #ifdef EH_FRAME_SECTION_NAME
466 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
468 eh_frame_section
= ((flags
== SECTION_WRITE
)
469 ? data_section
: readonly_data_section
);
470 #endif /* EH_FRAME_SECTION_NAME */
473 switch_to_section (eh_frame_section
);
475 #ifdef EH_FRAME_THROUGH_COLLECT2
476 /* We have no special eh_frame section. Emit special labels to guide
480 tree label
= get_file_function_name ("F");
481 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
482 targetm
.asm_out
.globalize_label (asm_out_file
,
483 IDENTIFIER_POINTER (label
));
484 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
489 /* Switch [BACK] to the eh or debug frame table section, depending on
493 switch_to_frame_table_section (int for_eh
, bool back
)
496 switch_to_eh_frame_section (back
);
499 if (!debug_frame_section
)
500 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
501 SECTION_DEBUG
, NULL
);
502 switch_to_section (debug_frame_section
);
506 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
508 enum dw_cfi_oprnd_type
509 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
514 case DW_CFA_GNU_window_save
:
515 case DW_CFA_remember_state
:
516 case DW_CFA_restore_state
:
517 return dw_cfi_oprnd_unused
;
520 case DW_CFA_advance_loc1
:
521 case DW_CFA_advance_loc2
:
522 case DW_CFA_advance_loc4
:
523 case DW_CFA_MIPS_advance_loc8
:
524 return dw_cfi_oprnd_addr
;
527 case DW_CFA_offset_extended
:
529 case DW_CFA_offset_extended_sf
:
530 case DW_CFA_def_cfa_sf
:
532 case DW_CFA_restore_extended
:
533 case DW_CFA_undefined
:
534 case DW_CFA_same_value
:
535 case DW_CFA_def_cfa_register
:
536 case DW_CFA_register
:
537 case DW_CFA_expression
:
538 case DW_CFA_val_expression
:
539 return dw_cfi_oprnd_reg_num
;
541 case DW_CFA_def_cfa_offset
:
542 case DW_CFA_GNU_args_size
:
543 case DW_CFA_def_cfa_offset_sf
:
544 return dw_cfi_oprnd_offset
;
546 case DW_CFA_def_cfa_expression
:
547 return dw_cfi_oprnd_loc
;
554 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
556 enum dw_cfi_oprnd_type
557 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
562 case DW_CFA_def_cfa_sf
:
564 case DW_CFA_offset_extended_sf
:
565 case DW_CFA_offset_extended
:
566 return dw_cfi_oprnd_offset
;
568 case DW_CFA_register
:
569 return dw_cfi_oprnd_reg_num
;
571 case DW_CFA_expression
:
572 case DW_CFA_val_expression
:
573 return dw_cfi_oprnd_loc
;
575 case DW_CFA_def_cfa_expression
:
576 return dw_cfi_oprnd_cfa_loc
;
579 return dw_cfi_oprnd_unused
;
583 /* Output one FDE. */
586 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
587 char *section_start_label
, int fde_encoding
, char *augmentation
,
588 bool any_lsda_needed
, int lsda_encoding
)
590 const char *begin
, *end
;
591 static unsigned int j
;
592 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
594 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
596 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
598 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
599 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
600 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
602 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
603 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
604 " indicating 64-bit DWARF extension");
605 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
608 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
611 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
613 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
614 debug_frame_section
, "FDE CIE offset");
616 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
617 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
621 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
622 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
623 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
624 "FDE initial location");
625 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
626 end
, begin
, "FDE address range");
630 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
631 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
638 int size
= size_of_encoded_value (lsda_encoding
);
640 if (lsda_encoding
== DW_EH_PE_aligned
)
642 int offset
= ( 4 /* Length */
644 + 2 * size_of_encoded_value (fde_encoding
)
645 + 1 /* Augmentation size */ );
646 int pad
= -offset
& (PTR_SIZE
- 1);
649 gcc_assert (size_of_uleb128 (size
) == 1);
652 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
654 if (fde
->uses_eh_lsda
)
656 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
657 fde
->funcdef_number
);
658 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
659 gen_rtx_SYMBOL_REF (Pmode
, l1
),
661 "Language Specific Data Area");
665 if (lsda_encoding
== DW_EH_PE_aligned
)
666 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
667 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
668 "Language Specific Data Area (none)");
672 dw2_asm_output_data_uleb128 (0, "Augmentation size");
675 /* Loop through the Call Frame Instructions associated with this FDE. */
676 fde
->dw_fde_current_label
= begin
;
678 size_t from
, until
, i
;
681 until
= vec_safe_length (fde
->dw_fde_cfi
);
683 if (fde
->dw_fde_second_begin
== NULL
)
686 until
= fde
->dw_fde_switch_cfi_index
;
688 from
= fde
->dw_fde_switch_cfi_index
;
690 for (i
= from
; i
< until
; i
++)
691 output_cfi ((*fde
->dw_fde_cfi
)[i
], fde
, for_eh
);
694 /* If we are to emit a ref/link from function bodies to their frame tables,
695 do it now. This is typically performed to make sure that tables
696 associated with functions are dragged with them and not discarded in
697 garbage collecting links. We need to do this on a per function basis to
698 cope with -ffunction-sections. */
700 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
701 /* Switch to the function section, emit the ref to the tables, and
702 switch *back* into the table section. */
703 switch_to_section (function_section (fde
->decl
));
704 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
705 switch_to_frame_table_section (for_eh
, true);
708 /* Pad the FDE out to an address sized boundary. */
709 ASM_OUTPUT_ALIGN (asm_out_file
,
710 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
711 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
716 /* Return true if frame description entry FDE is needed for EH. */
719 fde_needed_for_eh_p (dw_fde_ref fde
)
721 if (flag_asynchronous_unwind_tables
)
724 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
727 if (fde
->uses_eh_lsda
)
730 /* If exceptions are enabled, we have collected nothrow info. */
731 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
737 /* Output the call frame information used to record information
738 that relates to calculating the frame pointer, and records the
739 location of saved registers. */
742 output_call_frame_info (int for_eh
)
747 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
748 char section_start_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
749 bool any_lsda_needed
= false;
750 char augmentation
[6];
751 int augmentation_size
;
752 int fde_encoding
= DW_EH_PE_absptr
;
753 int per_encoding
= DW_EH_PE_absptr
;
754 int lsda_encoding
= DW_EH_PE_absptr
;
756 rtx personality
= NULL
;
759 /* Don't emit a CIE if there won't be any FDEs. */
763 /* Nothing to do if the assembler's doing it all. */
764 if (dwarf2out_do_cfi_asm ())
767 /* If we don't have any functions we'll want to unwind out of, don't emit
768 any EH unwind information. If we make FDEs linkonce, we may have to
769 emit an empty label for an FDE that wouldn't otherwise be emitted. We
770 want to avoid having an FDE kept around when the function it refers to
771 is discarded. Example where this matters: a primary function template
772 in C++ requires EH information, an explicit specialization doesn't. */
775 bool any_eh_needed
= false;
777 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
779 if (fde
->uses_eh_lsda
)
780 any_eh_needed
= any_lsda_needed
= true;
781 else if (fde_needed_for_eh_p (fde
))
782 any_eh_needed
= true;
783 else if (TARGET_USES_WEAK_UNWIND_INFO
)
784 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, 1, 1);
791 /* We're going to be generating comments, so turn on app. */
795 /* Switch to the proper frame section, first time. */
796 switch_to_frame_table_section (for_eh
, false);
798 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
799 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
801 /* Output the CIE. */
802 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
803 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
804 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
806 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
807 dw2_asm_output_data (4, 0xffffffff,
808 "Initial length escape value indicating 64-bit DWARF extension");
809 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
810 "Length of Common Information Entry");
812 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
814 /* Now that the CIE pointer is PC-relative for EH,
815 use 0 to identify the CIE. */
816 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
817 (for_eh
? 0 : DWARF_CIE_ID
),
818 "CIE Identifier Tag");
820 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
821 use CIE version 1, unless that would produce incorrect results
822 due to overflowing the return register column. */
823 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
825 if (return_reg
>= 256 || dwarf_version
> 2)
827 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
830 augmentation_size
= 0;
832 personality
= current_unit_personality
;
838 z Indicates that a uleb128 is present to size the
839 augmentation section.
840 L Indicates the encoding (and thus presence) of
841 an LSDA pointer in the FDE augmentation.
842 R Indicates a non-default pointer encoding for
844 P Indicates the presence of an encoding + language
845 personality routine in the CIE augmentation. */
847 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
848 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
849 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
851 p
= augmentation
+ 1;
855 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
856 assemble_external_libcall (personality
);
861 augmentation_size
+= 1;
863 if (fde_encoding
!= DW_EH_PE_absptr
)
866 augmentation_size
+= 1;
868 if (p
> augmentation
+ 1)
870 augmentation
[0] = 'z';
874 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
875 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
877 int offset
= ( 4 /* Length */
879 + 1 /* CIE version */
880 + strlen (augmentation
) + 1 /* Augmentation */
881 + size_of_uleb128 (1) /* Code alignment */
882 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
884 + 1 /* Augmentation size */
885 + 1 /* Personality encoding */ );
886 int pad
= -offset
& (PTR_SIZE
- 1);
888 augmentation_size
+= pad
;
890 /* Augmentations should be small, so there's scarce need to
891 iterate for a solution. Die if we exceed one uleb128 byte. */
892 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
896 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
897 if (dw_cie_version
>= 4)
899 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
900 dw2_asm_output_data (1, 0, "CIE Segment Size");
902 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
903 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
904 "CIE Data Alignment Factor");
906 if (dw_cie_version
== 1)
907 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
909 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
913 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
916 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
917 eh_data_format_name (per_encoding
));
918 dw2_asm_output_encoded_addr_rtx (per_encoding
,
924 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
925 eh_data_format_name (lsda_encoding
));
927 if (fde_encoding
!= DW_EH_PE_absptr
)
928 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
929 eh_data_format_name (fde_encoding
));
932 FOR_EACH_VEC_ELT (*cie_cfi_vec
, i
, cfi
)
933 output_cfi (cfi
, NULL
, for_eh
);
935 /* Pad the CIE out to an address sized boundary. */
936 ASM_OUTPUT_ALIGN (asm_out_file
,
937 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
938 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
940 /* Loop through all of the FDE's. */
941 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
945 /* Don't emit EH unwind info for leaf functions that don't need it. */
946 if (for_eh
&& !fde_needed_for_eh_p (fde
))
949 for (k
= 0; k
< (fde
->dw_fde_second_begin
? 2 : 1); k
++)
950 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
951 augmentation
, any_lsda_needed
, lsda_encoding
);
954 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
955 dw2_asm_output_data (4, 0, "End of Table");
957 /* Turn off app to make assembly quicker. */
962 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
965 dwarf2out_do_cfi_startproc (bool second
)
970 fprintf (asm_out_file
, "\t.cfi_startproc\n");
972 targetm
.asm_out
.post_cfi_startproc (asm_out_file
, current_function_decl
);
974 /* .cfi_personality and .cfi_lsda are only relevant to DWARF2
976 if (targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
)
979 rtx personality
= get_personality_function (current_function_decl
);
983 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
986 /* ??? The GAS support isn't entirely consistent. We have to
987 handle indirect support ourselves, but PC-relative is done
988 in the assembler. Further, the assembler can't handle any
989 of the weirder relocation types. */
990 if (enc
& DW_EH_PE_indirect
)
991 ref
= dw2_force_const_mem (ref
, true);
993 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
994 output_addr_const (asm_out_file
, ref
);
995 fputc ('\n', asm_out_file
);
998 if (crtl
->uses_eh_lsda
)
1000 char lab
[MAX_ARTIFICIAL_LABEL_BYTES
];
1002 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1003 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
1004 current_function_funcdef_no
);
1005 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
1006 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
1008 if (enc
& DW_EH_PE_indirect
)
1009 ref
= dw2_force_const_mem (ref
, true);
1011 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
1012 output_addr_const (asm_out_file
, ref
);
1013 fputc ('\n', asm_out_file
);
1017 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
1018 this allocation may be done before pass_final. */
1021 dwarf2out_alloc_current_fde (void)
1025 fde
= ggc_cleared_alloc
<dw_fde_node
> ();
1026 fde
->decl
= current_function_decl
;
1027 fde
->funcdef_number
= current_function_funcdef_no
;
1028 fde
->fde_index
= vec_safe_length (fde_vec
);
1029 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
1030 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
1031 fde
->nothrow
= crtl
->nothrow
;
1032 fde
->drap_reg
= INVALID_REGNUM
;
1033 fde
->vdrap_reg
= INVALID_REGNUM
;
1035 /* Record the FDE associated with this function. */
1037 vec_safe_push (fde_vec
, fde
);
1042 /* Output a marker (i.e. a label) for the beginning of a function, before
1046 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1047 unsigned int column ATTRIBUTE_UNUSED
,
1048 const char *file ATTRIBUTE_UNUSED
)
1050 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1056 current_function_func_begin_label
= NULL
;
1058 do_frame
= dwarf2out_do_frame ();
1060 /* ??? current_function_func_begin_label is also used by except.c for
1061 call-site information. We must emit this label if it might be used. */
1063 && (!flag_exceptions
1064 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1067 fnsec
= function_section (current_function_decl
);
1068 switch_to_section (fnsec
);
1069 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1070 current_function_funcdef_no
);
1071 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1072 current_function_funcdef_no
);
1073 dup_label
= xstrdup (label
);
1074 current_function_func_begin_label
= dup_label
;
1076 /* We can elide FDE allocation if we're not emitting frame unwind info. */
1080 /* Unlike the debug version, the EH version of frame unwind info is a per-
1081 function setting so we need to record whether we need it for the unit. */
1082 do_eh_frame
|= dwarf2out_do_eh_frame ();
1084 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1085 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1086 would include pass_dwarf2_frame. If we've not created the FDE yet,
1090 fde
= dwarf2out_alloc_current_fde ();
1092 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1093 fde
->dw_fde_begin
= dup_label
;
1094 fde
->dw_fde_current_label
= dup_label
;
1095 fde
->in_std_section
= (fnsec
== text_section
1096 || (cold_text_section
&& fnsec
== cold_text_section
));
1098 /* We only want to output line number information for the genuine dwarf2
1099 prologue case, not the eh frame case. */
1100 #ifdef DWARF2_DEBUGGING_INFO
1102 dwarf2out_source_line (line
, column
, file
, 0, true);
1105 if (dwarf2out_do_cfi_asm ())
1106 dwarf2out_do_cfi_startproc (false);
1109 rtx personality
= get_personality_function (current_function_decl
);
1110 if (!current_unit_personality
)
1111 current_unit_personality
= personality
;
1113 /* We cannot keep a current personality per function as without CFI
1114 asm, at the point where we emit the CFI data, there is no current
1115 function anymore. */
1116 if (personality
&& current_unit_personality
!= personality
)
1117 sorry ("multiple EH personalities are supported only with assemblers "
1118 "supporting %<.cfi_personality%> directive");
1122 /* Output a marker (i.e. a label) for the end of the generated code
1123 for a function prologue. This gets called *after* the prologue code has
1127 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1128 const char *file ATTRIBUTE_UNUSED
)
1130 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1132 /* Output a label to mark the endpoint of the code generated for this
1134 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1135 current_function_funcdef_no
);
1136 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1137 current_function_funcdef_no
);
1138 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1141 /* Output a marker (i.e. a label) for the beginning of the generated code
1142 for a function epilogue. This gets called *before* the prologue code has
1146 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1147 const char *file ATTRIBUTE_UNUSED
)
1149 dw_fde_ref fde
= cfun
->fde
;
1150 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1152 if (fde
->dw_fde_vms_begin_epilogue
)
1155 /* Output a label to mark the endpoint of the code generated for this
1157 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1158 current_function_funcdef_no
);
1159 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1160 current_function_funcdef_no
);
1161 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1164 /* Output a marker (i.e. a label) for the absolute end of the generated code
1165 for a function definition. This gets called *after* the epilogue code has
1169 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1170 const char *file ATTRIBUTE_UNUSED
)
1173 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1175 last_var_location_insn
= NULL
;
1176 cached_next_real_insn
= NULL
;
1178 if (dwarf2out_do_cfi_asm ())
1179 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1181 /* Output a label to mark the endpoint of the code generated for this
1183 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1184 current_function_funcdef_no
);
1185 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1187 gcc_assert (fde
!= NULL
);
1188 if (fde
->dw_fde_second_begin
== NULL
)
1189 fde
->dw_fde_end
= xstrdup (label
);
1193 dwarf2out_frame_finish (void)
1195 /* Output call frame information. */
1196 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1197 output_call_frame_info (0);
1199 /* Output another copy for the unwinder. */
1201 output_call_frame_info (1);
1204 /* Note that the current function section is being used for code. */
1207 dwarf2out_note_section_used (void)
1209 section
*sec
= current_function_section ();
1210 if (sec
== text_section
)
1211 text_section_used
= true;
1212 else if (sec
== cold_text_section
)
1213 cold_text_section_used
= true;
1216 static void var_location_switch_text_section (void);
1217 static void set_cur_line_info_table (section
*);
1220 dwarf2out_switch_text_section (void)
1222 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1224 dw_fde_ref fde
= cfun
->fde
;
1226 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1228 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_SECOND_SECT_LABEL
,
1229 current_function_funcdef_no
);
1231 fde
->dw_fde_second_begin
= ggc_strdup (label
);
1232 if (!in_cold_section_p
)
1234 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1235 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1239 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1240 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1242 have_multiple_function_sections
= true;
1244 /* There is no need to mark used sections when not debugging. */
1245 if (cold_text_section
!= NULL
)
1246 dwarf2out_note_section_used ();
1248 if (dwarf2out_do_cfi_asm ())
1249 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1251 /* Now do the real section switch. */
1252 sect
= current_function_section ();
1253 switch_to_section (sect
);
1255 fde
->second_in_std_section
1256 = (sect
== text_section
1257 || (cold_text_section
&& sect
== cold_text_section
));
1259 if (dwarf2out_do_cfi_asm ())
1260 dwarf2out_do_cfi_startproc (true);
1262 var_location_switch_text_section ();
1264 if (cold_text_section
!= NULL
)
1265 set_cur_line_info_table (sect
);
1268 /* And now, the subset of the debugging information support code necessary
1269 for emitting location expressions. */
1271 /* Data about a single source file. */
1272 struct GTY((for_user
)) dwarf_file_data
{
1273 const char * filename
;
1277 /* Describe an entry into the .debug_addr section. */
1281 ate_kind_rtx_dtprel
,
1285 struct GTY((for_user
)) addr_table_entry
{
1287 unsigned int refcount
;
1289 union addr_table_entry_struct_union
1291 rtx
GTY ((tag ("0"))) rtl
;
1292 char * GTY ((tag ("1"))) label
;
1294 GTY ((desc ("%1.kind"))) addr
;
1297 typedef unsigned int var_loc_view
;
1299 /* Location lists are ranges + location descriptions for that range,
1300 so you can track variables that are in different places over
1301 their entire life. */
1302 typedef struct GTY(()) dw_loc_list_struct
{
1303 dw_loc_list_ref dw_loc_next
;
1304 const char *begin
; /* Label and addr_entry for start of range */
1305 addr_table_entry
*begin_entry
;
1306 const char *end
; /* Label for end of range */
1307 char *ll_symbol
; /* Label for beginning of location list.
1308 Only on head of list. */
1309 char *vl_symbol
; /* Label for beginning of view list. Ditto. */
1310 const char *section
; /* Section this loclist is relative to */
1311 dw_loc_descr_ref expr
;
1312 var_loc_view vbegin
, vend
;
1314 /* True if all addresses in this and subsequent lists are known to be
1317 /* True if this list has been replaced by dw_loc_next. */
1319 /* True if it has been emitted into .debug_loc* / .debug_loclists*
1321 unsigned char emitted
: 1;
1322 /* True if hash field is index rather than hash value. */
1323 unsigned char num_assigned
: 1;
1324 /* True if .debug_loclists.dwo offset has been emitted for it already. */
1325 unsigned char offset_emitted
: 1;
1326 /* True if note_variable_value_in_expr has been called on it. */
1327 unsigned char noted_variable_value
: 1;
1328 /* True if the range should be emitted even if begin and end
1333 static dw_loc_descr_ref
int_loc_descriptor (poly_int64
);
1334 static dw_loc_descr_ref
uint_loc_descriptor (unsigned HOST_WIDE_INT
);
1336 /* Convert a DWARF stack opcode into its string name. */
1339 dwarf_stack_op_name (unsigned int op
)
1341 const char *name
= get_DW_OP_name (op
);
1346 return "OP_<unknown>";
1349 /* Return TRUE iff we're to output location view lists as a separate
1350 attribute next to the location lists, as an extension compatible
1351 with DWARF 2 and above. */
1354 dwarf2out_locviews_in_attribute ()
1356 return debug_variable_location_views
== 1;
1359 /* Return TRUE iff we're to output location view lists as part of the
1360 location lists, as proposed for standardization after DWARF 5. */
1363 dwarf2out_locviews_in_loclist ()
1365 #ifndef DW_LLE_view_pair
1368 return debug_variable_location_views
== -1;
1372 /* Return a pointer to a newly allocated location description. Location
1373 descriptions are simple expression terms that can be strung
1374 together to form more complicated location (address) descriptions. */
1376 static inline dw_loc_descr_ref
1377 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1378 unsigned HOST_WIDE_INT oprnd2
)
1380 dw_loc_descr_ref descr
= ggc_cleared_alloc
<dw_loc_descr_node
> ();
1382 descr
->dw_loc_opc
= op
;
1383 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1384 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1385 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1386 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1387 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1388 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1393 /* Add a location description term to a location description expression. */
1396 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1398 dw_loc_descr_ref
*d
;
1400 /* Find the end of the chain. */
1401 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1407 /* Compare two location operands for exact equality. */
1410 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1412 if (a
->val_class
!= b
->val_class
)
1414 switch (a
->val_class
)
1416 case dw_val_class_none
:
1418 case dw_val_class_addr
:
1419 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1421 case dw_val_class_offset
:
1422 case dw_val_class_unsigned_const
:
1423 case dw_val_class_const
:
1424 case dw_val_class_unsigned_const_implicit
:
1425 case dw_val_class_const_implicit
:
1426 case dw_val_class_range_list
:
1427 /* These are all HOST_WIDE_INT, signed or unsigned. */
1428 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1430 case dw_val_class_loc
:
1431 return a
->v
.val_loc
== b
->v
.val_loc
;
1432 case dw_val_class_loc_list
:
1433 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1434 case dw_val_class_view_list
:
1435 return a
->v
.val_view_list
== b
->v
.val_view_list
;
1436 case dw_val_class_die_ref
:
1437 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1438 case dw_val_class_fde_ref
:
1439 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1440 case dw_val_class_symview
:
1441 return strcmp (a
->v
.val_symbolic_view
, b
->v
.val_symbolic_view
) == 0;
1442 case dw_val_class_lbl_id
:
1443 case dw_val_class_lineptr
:
1444 case dw_val_class_macptr
:
1445 case dw_val_class_loclistsptr
:
1446 case dw_val_class_high_pc
:
1447 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1448 case dw_val_class_str
:
1449 return a
->v
.val_str
== b
->v
.val_str
;
1450 case dw_val_class_flag
:
1451 return a
->v
.val_flag
== b
->v
.val_flag
;
1452 case dw_val_class_file
:
1453 case dw_val_class_file_implicit
:
1454 return a
->v
.val_file
== b
->v
.val_file
;
1455 case dw_val_class_decl_ref
:
1456 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1458 case dw_val_class_const_double
:
1459 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1460 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1462 case dw_val_class_wide_int
:
1463 return *a
->v
.val_wide
== *b
->v
.val_wide
;
1465 case dw_val_class_vec
:
1467 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1468 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1470 return (a_len
== b_len
1471 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1474 case dw_val_class_data8
:
1475 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1477 case dw_val_class_vms_delta
:
1478 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1479 && !strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
));
1481 case dw_val_class_discr_value
:
1482 return (a
->v
.val_discr_value
.pos
== b
->v
.val_discr_value
.pos
1483 && a
->v
.val_discr_value
.v
.uval
== b
->v
.val_discr_value
.v
.uval
);
1484 case dw_val_class_discr_list
:
1485 /* It makes no sense comparing two discriminant value lists. */
1491 /* Compare two location atoms for exact equality. */
1494 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1496 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1499 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1500 address size, but since we always allocate cleared storage it
1501 should be zero for other types of locations. */
1502 if (a
->dtprel
!= b
->dtprel
)
1505 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1506 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1509 /* Compare two complete location expressions for exact equality. */
1512 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1518 if (a
== NULL
|| b
== NULL
)
1520 if (!loc_descr_equal_p_1 (a
, b
))
1529 /* Add a constant POLY_OFFSET to a location expression. */
1532 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, poly_int64 poly_offset
)
1534 dw_loc_descr_ref loc
;
1537 gcc_assert (*list_head
!= NULL
);
1539 if (known_eq (poly_offset
, 0))
1542 /* Find the end of the chain. */
1543 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1546 HOST_WIDE_INT offset
;
1547 if (!poly_offset
.is_constant (&offset
))
1549 loc
->dw_loc_next
= int_loc_descriptor (poly_offset
);
1550 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_plus
, 0, 0));
1555 if (loc
->dw_loc_opc
== DW_OP_fbreg
1556 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1557 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1558 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1559 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1561 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1562 offset. Don't optimize if an signed integer overflow would happen. */
1564 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1565 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1568 else if (offset
> 0)
1569 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1574 = uint_loc_descriptor (-(unsigned HOST_WIDE_INT
) offset
);
1575 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1579 /* Return a pointer to a newly allocated location description for
1582 static inline dw_loc_descr_ref
1583 new_reg_loc_descr (unsigned int reg
, poly_int64 offset
)
1585 HOST_WIDE_INT const_offset
;
1586 if (offset
.is_constant (&const_offset
))
1589 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1592 return new_loc_descr (DW_OP_bregx
, reg
, const_offset
);
1596 dw_loc_descr_ref ret
= new_reg_loc_descr (reg
, 0);
1597 loc_descr_plus_const (&ret
, offset
);
1602 /* Add a constant OFFSET to a location list. */
1605 loc_list_plus_const (dw_loc_list_ref list_head
, poly_int64 offset
)
1608 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1609 loc_descr_plus_const (&d
->expr
, offset
);
1612 #define DWARF_REF_SIZE \
1613 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1615 /* The number of bits that can be encoded by largest DW_FORM_dataN.
1616 In DWARF4 and earlier it is DW_FORM_data8 with 64 bits, in DWARF5
1617 DW_FORM_data16 with 128 bits. */
1618 #define DWARF_LARGEST_DATA_FORM_BITS \
1619 (dwarf_version >= 5 ? 128 : 64)
1621 /* Utility inline function for construction of ops that were GNU extension
1623 static inline enum dwarf_location_atom
1624 dwarf_OP (enum dwarf_location_atom op
)
1628 case DW_OP_implicit_pointer
:
1629 if (dwarf_version
< 5)
1630 return DW_OP_GNU_implicit_pointer
;
1633 case DW_OP_entry_value
:
1634 if (dwarf_version
< 5)
1635 return DW_OP_GNU_entry_value
;
1638 case DW_OP_const_type
:
1639 if (dwarf_version
< 5)
1640 return DW_OP_GNU_const_type
;
1643 case DW_OP_regval_type
:
1644 if (dwarf_version
< 5)
1645 return DW_OP_GNU_regval_type
;
1648 case DW_OP_deref_type
:
1649 if (dwarf_version
< 5)
1650 return DW_OP_GNU_deref_type
;
1654 if (dwarf_version
< 5)
1655 return DW_OP_GNU_convert
;
1658 case DW_OP_reinterpret
:
1659 if (dwarf_version
< 5)
1660 return DW_OP_GNU_reinterpret
;
1664 if (dwarf_version
< 5)
1665 return DW_OP_GNU_addr_index
;
1669 if (dwarf_version
< 5)
1670 return DW_OP_GNU_const_index
;
1679 /* Similarly for attributes. */
1680 static inline enum dwarf_attribute
1681 dwarf_AT (enum dwarf_attribute at
)
1685 case DW_AT_call_return_pc
:
1686 if (dwarf_version
< 5)
1687 return DW_AT_low_pc
;
1690 case DW_AT_call_tail_call
:
1691 if (dwarf_version
< 5)
1692 return DW_AT_GNU_tail_call
;
1695 case DW_AT_call_origin
:
1696 if (dwarf_version
< 5)
1697 return DW_AT_abstract_origin
;
1700 case DW_AT_call_target
:
1701 if (dwarf_version
< 5)
1702 return DW_AT_GNU_call_site_target
;
1705 case DW_AT_call_target_clobbered
:
1706 if (dwarf_version
< 5)
1707 return DW_AT_GNU_call_site_target_clobbered
;
1710 case DW_AT_call_parameter
:
1711 if (dwarf_version
< 5)
1712 return DW_AT_abstract_origin
;
1715 case DW_AT_call_value
:
1716 if (dwarf_version
< 5)
1717 return DW_AT_GNU_call_site_value
;
1720 case DW_AT_call_data_value
:
1721 if (dwarf_version
< 5)
1722 return DW_AT_GNU_call_site_data_value
;
1725 case DW_AT_call_all_calls
:
1726 if (dwarf_version
< 5)
1727 return DW_AT_GNU_all_call_sites
;
1730 case DW_AT_call_all_tail_calls
:
1731 if (dwarf_version
< 5)
1732 return DW_AT_GNU_all_tail_call_sites
;
1735 case DW_AT_dwo_name
:
1736 if (dwarf_version
< 5)
1737 return DW_AT_GNU_dwo_name
;
1740 case DW_AT_addr_base
:
1741 if (dwarf_version
< 5)
1742 return DW_AT_GNU_addr_base
;
1751 /* And similarly for tags. */
1752 static inline enum dwarf_tag
1753 dwarf_TAG (enum dwarf_tag tag
)
1757 case DW_TAG_call_site
:
1758 if (dwarf_version
< 5)
1759 return DW_TAG_GNU_call_site
;
1762 case DW_TAG_call_site_parameter
:
1763 if (dwarf_version
< 5)
1764 return DW_TAG_GNU_call_site_parameter
;
1773 /* And similarly for forms. */
1774 static inline enum dwarf_form
1775 dwarf_FORM (enum dwarf_form form
)
1780 if (dwarf_version
< 5)
1781 return DW_FORM_GNU_addr_index
;
1785 if (dwarf_version
< 5)
1786 return DW_FORM_GNU_str_index
;
1795 static unsigned long int get_base_type_offset (dw_die_ref
);
1797 /* Return the size of a location descriptor. */
1799 static unsigned long
1800 size_of_loc_descr (dw_loc_descr_ref loc
)
1802 unsigned long size
= 1;
1804 switch (loc
->dw_loc_opc
)
1807 size
+= DWARF2_ADDR_SIZE
;
1809 case DW_OP_GNU_addr_index
:
1811 case DW_OP_GNU_const_index
:
1813 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1814 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1833 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1836 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1841 case DW_OP_plus_uconst
:
1842 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1880 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1883 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1886 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1889 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1890 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1893 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1895 case DW_OP_bit_piece
:
1896 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1897 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1899 case DW_OP_deref_size
:
1900 case DW_OP_xderef_size
:
1909 case DW_OP_call_ref
:
1910 case DW_OP_GNU_variable_value
:
1911 size
+= DWARF_REF_SIZE
;
1913 case DW_OP_implicit_value
:
1914 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1915 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1917 case DW_OP_implicit_pointer
:
1918 case DW_OP_GNU_implicit_pointer
:
1919 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1921 case DW_OP_entry_value
:
1922 case DW_OP_GNU_entry_value
:
1924 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1925 size
+= size_of_uleb128 (op_size
) + op_size
;
1928 case DW_OP_const_type
:
1929 case DW_OP_GNU_const_type
:
1932 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1933 size
+= size_of_uleb128 (o
) + 1;
1934 switch (loc
->dw_loc_oprnd2
.val_class
)
1936 case dw_val_class_vec
:
1937 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1938 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1940 case dw_val_class_const
:
1941 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1943 case dw_val_class_const_double
:
1944 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
1946 case dw_val_class_wide_int
:
1947 size
+= (get_full_len (*loc
->dw_loc_oprnd2
.v
.val_wide
)
1948 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
1955 case DW_OP_regval_type
:
1956 case DW_OP_GNU_regval_type
:
1959 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1960 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1961 + size_of_uleb128 (o
);
1964 case DW_OP_deref_type
:
1965 case DW_OP_GNU_deref_type
:
1968 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1969 size
+= 1 + size_of_uleb128 (o
);
1973 case DW_OP_reinterpret
:
1974 case DW_OP_GNU_convert
:
1975 case DW_OP_GNU_reinterpret
:
1976 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
1977 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1981 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1982 size
+= size_of_uleb128 (o
);
1985 case DW_OP_GNU_parameter_ref
:
1995 /* Return the size of a series of location descriptors. */
1998 size_of_locs (dw_loc_descr_ref loc
)
2003 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
2004 field, to avoid writing to a PCH file. */
2005 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
2007 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
2009 size
+= size_of_loc_descr (l
);
2014 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
2016 l
->dw_loc_addr
= size
;
2017 size
+= size_of_loc_descr (l
);
2023 /* Return the size of the value in a DW_AT_discr_value attribute. */
2026 size_of_discr_value (dw_discr_value
*discr_value
)
2028 if (discr_value
->pos
)
2029 return size_of_uleb128 (discr_value
->v
.uval
);
2031 return size_of_sleb128 (discr_value
->v
.sval
);
2034 /* Return the size of the value in a DW_AT_discr_list attribute. */
2037 size_of_discr_list (dw_discr_list_ref discr_list
)
2041 for (dw_discr_list_ref list
= discr_list
;
2043 list
= list
->dw_discr_next
)
2045 /* One byte for the discriminant value descriptor, and then one or two
2046 LEB128 numbers, depending on whether it's a single case label or a
2049 size
+= size_of_discr_value (&list
->dw_discr_lower_bound
);
2050 if (list
->dw_discr_range
!= 0)
2051 size
+= size_of_discr_value (&list
->dw_discr_upper_bound
);
2056 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
2057 static void get_ref_die_offset_label (char *, dw_die_ref
);
2058 static unsigned long int get_ref_die_offset (dw_die_ref
);
2060 /* Output location description stack opcode's operands (if any).
2061 The for_eh_or_skip parameter controls whether register numbers are
2062 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2063 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2064 info). This should be suppressed for the cases that have not been converted
2065 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2068 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2070 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2071 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2073 switch (loc
->dw_loc_opc
)
2075 #ifdef DWARF2_DEBUGGING_INFO
2078 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
2083 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2084 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
2086 fputc ('\n', asm_out_file
);
2091 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
2096 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2097 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
2099 fputc ('\n', asm_out_file
);
2104 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2105 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
2112 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2113 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2115 dw2_asm_output_data (2, offset
, NULL
);
2118 case DW_OP_implicit_value
:
2119 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2120 switch (val2
->val_class
)
2122 case dw_val_class_const
:
2123 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
2125 case dw_val_class_vec
:
2127 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2128 unsigned int len
= val2
->v
.val_vec
.length
;
2132 if (elt_size
> sizeof (HOST_WIDE_INT
))
2137 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2140 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2141 "fp or vector constant word %u", i
);
2144 case dw_val_class_const_double
:
2146 unsigned HOST_WIDE_INT first
, second
;
2148 if (WORDS_BIG_ENDIAN
)
2150 first
= val2
->v
.val_double
.high
;
2151 second
= val2
->v
.val_double
.low
;
2155 first
= val2
->v
.val_double
.low
;
2156 second
= val2
->v
.val_double
.high
;
2158 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2160 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2164 case dw_val_class_wide_int
:
2167 int len
= get_full_len (*val2
->v
.val_wide
);
2168 if (WORDS_BIG_ENDIAN
)
2169 for (i
= len
- 1; i
>= 0; --i
)
2170 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2171 val2
->v
.val_wide
->elt (i
), NULL
);
2173 for (i
= 0; i
< len
; ++i
)
2174 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2175 val2
->v
.val_wide
->elt (i
), NULL
);
2178 case dw_val_class_addr
:
2179 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
2180 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
2195 case DW_OP_implicit_value
:
2196 /* We currently don't make any attempt to make sure these are
2197 aligned properly like we do for the main unwind info, so
2198 don't support emitting things larger than a byte if we're
2199 only doing unwinding. */
2204 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2207 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2210 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2213 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2215 case DW_OP_plus_uconst
:
2216 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2250 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2254 unsigned r
= val1
->v
.val_unsigned
;
2255 if (for_eh_or_skip
>= 0)
2256 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2257 gcc_assert (size_of_uleb128 (r
)
2258 == size_of_uleb128 (val1
->v
.val_unsigned
));
2259 dw2_asm_output_data_uleb128 (r
, NULL
);
2263 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2267 unsigned r
= val1
->v
.val_unsigned
;
2268 if (for_eh_or_skip
>= 0)
2269 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2270 gcc_assert (size_of_uleb128 (r
)
2271 == size_of_uleb128 (val1
->v
.val_unsigned
));
2272 dw2_asm_output_data_uleb128 (r
, NULL
);
2273 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2277 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2279 case DW_OP_bit_piece
:
2280 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2281 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
2283 case DW_OP_deref_size
:
2284 case DW_OP_xderef_size
:
2285 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2291 if (targetm
.asm_out
.output_dwarf_dtprel
)
2293 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
2296 fputc ('\n', asm_out_file
);
2303 #ifdef DWARF2_DEBUGGING_INFO
2304 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
2311 case DW_OP_GNU_addr_index
:
2313 case DW_OP_GNU_const_index
:
2315 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
2316 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
2317 "(index into .debug_addr)");
2323 unsigned long die_offset
2324 = get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2325 /* Make sure the offset has been computed and that we can encode it as
2327 gcc_assert (die_offset
> 0
2328 && die_offset
<= (loc
->dw_loc_opc
== DW_OP_call2
2331 dw2_asm_output_data ((loc
->dw_loc_opc
== DW_OP_call2
) ? 2 : 4,
2336 case DW_OP_call_ref
:
2337 case DW_OP_GNU_variable_value
:
2339 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2340 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2341 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2342 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2343 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2347 case DW_OP_implicit_pointer
:
2348 case DW_OP_GNU_implicit_pointer
:
2350 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2351 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2352 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2353 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2354 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2355 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2359 case DW_OP_entry_value
:
2360 case DW_OP_GNU_entry_value
:
2361 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
2362 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
2365 case DW_OP_const_type
:
2366 case DW_OP_GNU_const_type
:
2368 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
2370 dw2_asm_output_data_uleb128 (o
, NULL
);
2371 switch (val2
->val_class
)
2373 case dw_val_class_const
:
2374 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2375 dw2_asm_output_data (1, l
, NULL
);
2376 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
2378 case dw_val_class_vec
:
2380 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2381 unsigned int len
= val2
->v
.val_vec
.length
;
2386 dw2_asm_output_data (1, l
, NULL
);
2387 if (elt_size
> sizeof (HOST_WIDE_INT
))
2392 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2395 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2396 "fp or vector constant word %u", i
);
2399 case dw_val_class_const_double
:
2401 unsigned HOST_WIDE_INT first
, second
;
2402 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2404 dw2_asm_output_data (1, 2 * l
, NULL
);
2405 if (WORDS_BIG_ENDIAN
)
2407 first
= val2
->v
.val_double
.high
;
2408 second
= val2
->v
.val_double
.low
;
2412 first
= val2
->v
.val_double
.low
;
2413 second
= val2
->v
.val_double
.high
;
2415 dw2_asm_output_data (l
, first
, NULL
);
2416 dw2_asm_output_data (l
, second
, NULL
);
2419 case dw_val_class_wide_int
:
2422 int len
= get_full_len (*val2
->v
.val_wide
);
2423 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2425 dw2_asm_output_data (1, len
* l
, NULL
);
2426 if (WORDS_BIG_ENDIAN
)
2427 for (i
= len
- 1; i
>= 0; --i
)
2428 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2430 for (i
= 0; i
< len
; ++i
)
2431 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2439 case DW_OP_regval_type
:
2440 case DW_OP_GNU_regval_type
:
2442 unsigned r
= val1
->v
.val_unsigned
;
2443 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2445 if (for_eh_or_skip
>= 0)
2447 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2448 gcc_assert (size_of_uleb128 (r
)
2449 == size_of_uleb128 (val1
->v
.val_unsigned
));
2451 dw2_asm_output_data_uleb128 (r
, NULL
);
2452 dw2_asm_output_data_uleb128 (o
, NULL
);
2455 case DW_OP_deref_type
:
2456 case DW_OP_GNU_deref_type
:
2458 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2460 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2461 dw2_asm_output_data_uleb128 (o
, NULL
);
2465 case DW_OP_reinterpret
:
2466 case DW_OP_GNU_convert
:
2467 case DW_OP_GNU_reinterpret
:
2468 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2469 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2472 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2474 dw2_asm_output_data_uleb128 (o
, NULL
);
2478 case DW_OP_GNU_parameter_ref
:
2481 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2482 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2483 dw2_asm_output_data (4, o
, NULL
);
2488 /* Other codes have no operands. */
2493 /* Output a sequence of location operations.
2494 The for_eh_or_skip parameter controls whether register numbers are
2495 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2496 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2497 info). This should be suppressed for the cases that have not been converted
2498 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2501 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2503 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2505 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2506 /* Output the opcode. */
2507 if (for_eh_or_skip
>= 0
2508 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2510 unsigned r
= (opc
- DW_OP_breg0
);
2511 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2512 gcc_assert (r
<= 31);
2513 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2515 else if (for_eh_or_skip
>= 0
2516 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2518 unsigned r
= (opc
- DW_OP_reg0
);
2519 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2520 gcc_assert (r
<= 31);
2521 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2524 dw2_asm_output_data (1, opc
,
2525 "%s", dwarf_stack_op_name (opc
));
2527 /* Output the operand(s) (if any). */
2528 output_loc_operands (loc
, for_eh_or_skip
);
2532 /* Output location description stack opcode's operands (if any).
2533 The output is single bytes on a line, suitable for .cfi_escape. */
2536 output_loc_operands_raw (dw_loc_descr_ref loc
)
2538 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2539 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2541 switch (loc
->dw_loc_opc
)
2544 case DW_OP_GNU_addr_index
:
2546 case DW_OP_GNU_const_index
:
2548 case DW_OP_implicit_value
:
2549 /* We cannot output addresses in .cfi_escape, only bytes. */
2555 case DW_OP_deref_size
:
2556 case DW_OP_xderef_size
:
2557 fputc (',', asm_out_file
);
2558 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2563 fputc (',', asm_out_file
);
2564 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2569 fputc (',', asm_out_file
);
2570 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2575 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2576 fputc (',', asm_out_file
);
2577 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2585 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2586 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2588 fputc (',', asm_out_file
);
2589 dw2_asm_output_data_raw (2, offset
);
2595 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2596 gcc_assert (size_of_uleb128 (r
)
2597 == size_of_uleb128 (val1
->v
.val_unsigned
));
2598 fputc (',', asm_out_file
);
2599 dw2_asm_output_data_uleb128_raw (r
);
2604 case DW_OP_plus_uconst
:
2606 fputc (',', asm_out_file
);
2607 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2610 case DW_OP_bit_piece
:
2611 fputc (',', asm_out_file
);
2612 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2613 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2650 fputc (',', asm_out_file
);
2651 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2656 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2657 gcc_assert (size_of_uleb128 (r
)
2658 == size_of_uleb128 (val1
->v
.val_unsigned
));
2659 fputc (',', asm_out_file
);
2660 dw2_asm_output_data_uleb128_raw (r
);
2661 fputc (',', asm_out_file
);
2662 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2666 case DW_OP_implicit_pointer
:
2667 case DW_OP_entry_value
:
2668 case DW_OP_const_type
:
2669 case DW_OP_regval_type
:
2670 case DW_OP_deref_type
:
2672 case DW_OP_reinterpret
:
2673 case DW_OP_GNU_implicit_pointer
:
2674 case DW_OP_GNU_entry_value
:
2675 case DW_OP_GNU_const_type
:
2676 case DW_OP_GNU_regval_type
:
2677 case DW_OP_GNU_deref_type
:
2678 case DW_OP_GNU_convert
:
2679 case DW_OP_GNU_reinterpret
:
2680 case DW_OP_GNU_parameter_ref
:
2685 /* Other codes have no operands. */
2691 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2695 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2696 /* Output the opcode. */
2697 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2699 unsigned r
= (opc
- DW_OP_breg0
);
2700 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2701 gcc_assert (r
<= 31);
2702 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2704 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2706 unsigned r
= (opc
- DW_OP_reg0
);
2707 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2708 gcc_assert (r
<= 31);
2709 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2711 /* Output the opcode. */
2712 fprintf (asm_out_file
, "%#x", opc
);
2713 output_loc_operands_raw (loc
);
2715 if (!loc
->dw_loc_next
)
2717 loc
= loc
->dw_loc_next
;
2719 fputc (',', asm_out_file
);
2723 /* This function builds a dwarf location descriptor sequence from a
2724 dw_cfa_location, adding the given OFFSET to the result of the
2727 struct dw_loc_descr_node
*
2728 build_cfa_loc (dw_cfa_location
*cfa
, poly_int64 offset
)
2730 struct dw_loc_descr_node
*head
, *tmp
;
2732 offset
+= cfa
->offset
;
2736 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
2737 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2738 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2739 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2740 add_loc_descr (&head
, tmp
);
2741 loc_descr_plus_const (&head
, offset
);
2744 head
= new_reg_loc_descr (cfa
->reg
, offset
);
2749 /* This function builds a dwarf location descriptor sequence for
2750 the address at OFFSET from the CFA when stack is aligned to
2753 struct dw_loc_descr_node
*
2754 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2755 poly_int64 offset
, HOST_WIDE_INT alignment
)
2757 struct dw_loc_descr_node
*head
;
2758 unsigned int dwarf_fp
2759 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2761 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2762 if (cfa
->reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2764 head
= new_reg_loc_descr (dwarf_fp
, 0);
2765 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2766 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2767 loc_descr_plus_const (&head
, offset
);
2770 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2774 /* And now, the support for symbolic debugging information. */
2776 /* .debug_str support. */
2778 static void dwarf2out_init (const char *);
2779 static void dwarf2out_finish (const char *);
2780 static void dwarf2out_early_finish (const char *);
2781 static void dwarf2out_assembly_start (void);
2782 static void dwarf2out_define (unsigned int, const char *);
2783 static void dwarf2out_undef (unsigned int, const char *);
2784 static void dwarf2out_start_source_file (unsigned, const char *);
2785 static void dwarf2out_end_source_file (unsigned);
2786 static void dwarf2out_function_decl (tree
);
2787 static void dwarf2out_begin_block (unsigned, unsigned);
2788 static void dwarf2out_end_block (unsigned, unsigned);
2789 static bool dwarf2out_ignore_block (const_tree
);
2790 static void dwarf2out_early_global_decl (tree
);
2791 static void dwarf2out_late_global_decl (tree
);
2792 static void dwarf2out_type_decl (tree
, int);
2793 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool, bool);
2794 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2796 static void dwarf2out_abstract_function (tree
);
2797 static void dwarf2out_var_location (rtx_insn
*);
2798 static void dwarf2out_inline_entry (tree
);
2799 static void dwarf2out_size_function (tree
);
2800 static void dwarf2out_begin_function (tree
);
2801 static void dwarf2out_end_function (unsigned int);
2802 static void dwarf2out_register_main_translation_unit (tree unit
);
2803 static void dwarf2out_set_name (tree
, tree
);
2804 static void dwarf2out_register_external_die (tree decl
, const char *sym
,
2805 unsigned HOST_WIDE_INT off
);
2806 static bool dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
2807 unsigned HOST_WIDE_INT
*off
);
2809 /* The debug hooks structure. */
2811 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2815 dwarf2out_early_finish
,
2816 dwarf2out_assembly_start
,
2819 dwarf2out_start_source_file
,
2820 dwarf2out_end_source_file
,
2821 dwarf2out_begin_block
,
2822 dwarf2out_end_block
,
2823 dwarf2out_ignore_block
,
2824 dwarf2out_source_line
,
2825 dwarf2out_begin_prologue
,
2826 #if VMS_DEBUGGING_INFO
2827 dwarf2out_vms_end_prologue
,
2828 dwarf2out_vms_begin_epilogue
,
2830 debug_nothing_int_charstar
,
2831 debug_nothing_int_charstar
,
2833 dwarf2out_end_epilogue
,
2834 dwarf2out_begin_function
,
2835 dwarf2out_end_function
, /* end_function */
2836 dwarf2out_register_main_translation_unit
,
2837 dwarf2out_function_decl
, /* function_decl */
2838 dwarf2out_early_global_decl
,
2839 dwarf2out_late_global_decl
,
2840 dwarf2out_type_decl
, /* type_decl */
2841 dwarf2out_imported_module_or_decl
,
2842 dwarf2out_die_ref_for_decl
,
2843 dwarf2out_register_external_die
,
2844 debug_nothing_tree
, /* deferred_inline_function */
2845 /* The DWARF 2 backend tries to reduce debugging bloat by not
2846 emitting the abstract description of inline functions until
2847 something tries to reference them. */
2848 dwarf2out_abstract_function
, /* outlining_inline_function */
2849 debug_nothing_rtx_code_label
, /* label */
2850 debug_nothing_int
, /* handle_pch */
2851 dwarf2out_var_location
,
2852 dwarf2out_inline_entry
, /* inline_entry */
2853 dwarf2out_size_function
, /* size_function */
2854 dwarf2out_switch_text_section
,
2856 1, /* start_end_main_source_file */
2857 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2860 const struct gcc_debug_hooks dwarf2_lineno_debug_hooks
=
2863 debug_nothing_charstar
,
2864 debug_nothing_charstar
,
2865 dwarf2out_assembly_start
,
2866 debug_nothing_int_charstar
,
2867 debug_nothing_int_charstar
,
2868 debug_nothing_int_charstar
,
2870 debug_nothing_int_int
, /* begin_block */
2871 debug_nothing_int_int
, /* end_block */
2872 debug_true_const_tree
, /* ignore_block */
2873 dwarf2out_source_line
, /* source_line */
2874 debug_nothing_int_int_charstar
, /* begin_prologue */
2875 debug_nothing_int_charstar
, /* end_prologue */
2876 debug_nothing_int_charstar
, /* begin_epilogue */
2877 debug_nothing_int_charstar
, /* end_epilogue */
2878 debug_nothing_tree
, /* begin_function */
2879 debug_nothing_int
, /* end_function */
2880 debug_nothing_tree
, /* register_main_translation_unit */
2881 debug_nothing_tree
, /* function_decl */
2882 debug_nothing_tree
, /* early_global_decl */
2883 debug_nothing_tree
, /* late_global_decl */
2884 debug_nothing_tree_int
, /* type_decl */
2885 debug_nothing_tree_tree_tree_bool_bool
,/* imported_module_or_decl */
2886 debug_false_tree_charstarstar_uhwistar
,/* die_ref_for_decl */
2887 debug_nothing_tree_charstar_uhwi
, /* register_external_die */
2888 debug_nothing_tree
, /* deferred_inline_function */
2889 debug_nothing_tree
, /* outlining_inline_function */
2890 debug_nothing_rtx_code_label
, /* label */
2891 debug_nothing_int
, /* handle_pch */
2892 debug_nothing_rtx_insn
, /* var_location */
2893 debug_nothing_tree
, /* inline_entry */
2894 debug_nothing_tree
, /* size_function */
2895 debug_nothing_void
, /* switch_text_section */
2896 debug_nothing_tree_tree
, /* set_name */
2897 0, /* start_end_main_source_file */
2898 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
2901 /* NOTE: In the comments in this file, many references are made to
2902 "Debugging Information Entries". This term is abbreviated as `DIE'
2903 throughout the remainder of this file. */
2905 /* An internal representation of the DWARF output is built, and then
2906 walked to generate the DWARF debugging info. The walk of the internal
2907 representation is done after the entire program has been compiled.
2908 The types below are used to describe the internal representation. */
2910 /* Whether to put type DIEs into their own section .debug_types instead
2911 of making them part of the .debug_info section. Only supported for
2912 Dwarf V4 or higher and the user didn't disable them through
2913 -fno-debug-types-section. It is more efficient to put them in a
2914 separate comdat sections since the linker will then be able to
2915 remove duplicates. But not all tools support .debug_types sections
2916 yet. For Dwarf V5 or higher .debug_types doesn't exist any more,
2917 it is DW_UT_type unit type in .debug_info section. For late LTO
2918 debug there should be almost no types emitted so avoid enabling
2919 -fdebug-types-section there. */
2921 #define use_debug_types (dwarf_version >= 4 \
2922 && flag_debug_types_section \
2925 /* Various DIE's use offsets relative to the beginning of the
2926 .debug_info section to refer to each other. */
2928 typedef long int dw_offset
;
2930 struct comdat_type_node
;
2932 /* The entries in the line_info table more-or-less mirror the opcodes
2933 that are used in the real dwarf line table. Arrays of these entries
2934 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2937 enum dw_line_info_opcode
{
2938 /* Emit DW_LNE_set_address; the operand is the label index. */
2941 /* Emit a row to the matrix with the given line. This may be done
2942 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2946 /* Emit a DW_LNS_set_file. */
2949 /* Emit a DW_LNS_set_column. */
2952 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2955 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2956 LI_set_prologue_end
,
2957 LI_set_epilogue_begin
,
2959 /* Emit a DW_LNE_set_discriminator. */
2960 LI_set_discriminator
,
2962 /* Output a Fixed Advance PC; the target PC is the label index; the
2963 base PC is the previous LI_adv_address or LI_set_address entry.
2964 We only use this when emitting debug views without assembler
2965 support, at explicit user request. Ideally, we should only use
2966 it when the offset might be zero but we can't tell: it's the only
2967 way to maybe change the PC without resetting the view number. */
2971 typedef struct GTY(()) dw_line_info_struct
{
2972 enum dw_line_info_opcode opcode
;
2974 } dw_line_info_entry
;
2977 struct GTY(()) dw_line_info_table
{
2978 /* The label that marks the end of this section. */
2979 const char *end_label
;
2981 /* The values for the last row of the matrix, as collected in the table.
2982 These are used to minimize the changes to the next row. */
2983 unsigned int file_num
;
2984 unsigned int line_num
;
2985 unsigned int column_num
;
2990 /* This denotes the NEXT view number.
2992 If it is 0, it is known that the NEXT view will be the first view
2995 If it is -1, we're forcing the view number to be reset, e.g. at a
2998 The meaning of other nonzero values depends on whether we're
2999 computing views internally or leaving it for the assembler to do
3000 so. If we're emitting them internally, view denotes the view
3001 number since the last known advance of PC. If we're leaving it
3002 for the assembler, it denotes the LVU label number that we're
3003 going to ask the assembler to assign. */
3006 /* This counts the number of symbolic views emitted in this table
3007 since the latest view reset. Its max value, over all tables,
3008 sets symview_upper_bound. */
3009 var_loc_view symviews_since_reset
;
3011 #define FORCE_RESET_NEXT_VIEW(x) ((x) = (var_loc_view)-1)
3012 #define RESET_NEXT_VIEW(x) ((x) = (var_loc_view)0)
3013 #define FORCE_RESETTING_VIEW_P(x) ((x) == (var_loc_view)-1)
3014 #define RESETTING_VIEW_P(x) ((x) == (var_loc_view)0 || FORCE_RESETTING_VIEW_P (x))
3016 vec
<dw_line_info_entry
, va_gc
> *entries
;
3019 /* This is an upper bound for view numbers that the assembler may
3020 assign to symbolic views output in this translation. It is used to
3021 decide how big a field to use to represent view numbers in
3022 symview-classed attributes. */
3024 static var_loc_view symview_upper_bound
;
3026 /* If we're keep track of location views and their reset points, and
3027 INSN is a reset point (i.e., it necessarily advances the PC), mark
3028 the next view in TABLE as reset. */
3031 maybe_reset_location_view (rtx_insn
*insn
, dw_line_info_table
*table
)
3033 if (!debug_internal_reset_location_views
)
3036 /* Maybe turn (part of?) this test into a default target hook. */
3039 if (targetm
.reset_location_view
)
3040 reset
= targetm
.reset_location_view (insn
);
3044 else if (JUMP_TABLE_DATA_P (insn
))
3046 else if (GET_CODE (insn
) == USE
3047 || GET_CODE (insn
) == CLOBBER
3048 || GET_CODE (insn
) == ASM_INPUT
3049 || asm_noperands (insn
) >= 0)
3051 else if (get_attr_min_length (insn
) > 0)
3054 if (reset
> 0 && !RESETTING_VIEW_P (table
->view
))
3055 RESET_NEXT_VIEW (table
->view
);
3058 /* Each DIE attribute has a field specifying the attribute kind,
3059 a link to the next attribute in the chain, and an attribute value.
3060 Attributes are typically linked below the DIE they modify. */
3062 typedef struct GTY(()) dw_attr_struct
{
3063 enum dwarf_attribute dw_attr
;
3064 dw_val_node dw_attr_val
;
3069 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
3070 The children of each node form a circular list linked by
3071 die_sib. die_child points to the node *before* the "first" child node. */
3073 typedef struct GTY((chain_circular ("%h.die_sib"), for_user
)) die_struct
{
3074 union die_symbol_or_type_node
3076 const char * GTY ((tag ("0"))) die_symbol
;
3077 comdat_type_node
*GTY ((tag ("1"))) die_type_node
;
3079 GTY ((desc ("%0.comdat_type_p"))) die_id
;
3080 vec
<dw_attr_node
, va_gc
> *die_attr
;
3081 dw_die_ref die_parent
;
3082 dw_die_ref die_child
;
3084 dw_die_ref die_definition
; /* ref from a specification to its definition */
3085 dw_offset die_offset
;
3086 unsigned long die_abbrev
;
3088 unsigned int decl_id
;
3089 enum dwarf_tag die_tag
;
3090 /* Die is used and must not be pruned as unused. */
3091 BOOL_BITFIELD die_perennial_p
: 1;
3092 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
3093 /* For an external ref to die_symbol if die_offset contains an extra
3094 offset to that symbol. */
3095 BOOL_BITFIELD with_offset
: 1;
3096 /* Whether this DIE was removed from the DIE tree, for example via
3097 prune_unused_types. We don't consider those present from the
3098 DIE lookup routines. */
3099 BOOL_BITFIELD removed
: 1;
3100 /* Lots of spare bits. */
3104 /* Set to TRUE while dwarf2out_early_global_decl is running. */
3105 static bool early_dwarf
;
3106 static bool early_dwarf_finished
;
3107 struct set_early_dwarf
{
3109 set_early_dwarf () : saved(early_dwarf
)
3111 gcc_assert (! early_dwarf_finished
);
3114 ~set_early_dwarf () { early_dwarf
= saved
; }
3117 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
3118 #define FOR_EACH_CHILD(die, c, expr) do { \
3119 c = die->die_child; \
3123 } while (c != die->die_child); \
3126 /* The pubname structure */
3128 typedef struct GTY(()) pubname_struct
{
3135 struct GTY(()) dw_ranges
{
3137 /* If this is positive, it's a block number, otherwise it's a
3138 bitwise-negated index into dw_ranges_by_label. */
3140 /* Index for the range list for DW_FORM_rnglistx. */
3141 unsigned int idx
: 31;
3142 /* True if this range might be possibly in a different section
3143 from previous entry. */
3144 unsigned int maybe_new_sec
: 1;
3147 /* A structure to hold a macinfo entry. */
3149 typedef struct GTY(()) macinfo_struct
{
3151 unsigned HOST_WIDE_INT lineno
;
3157 struct GTY(()) dw_ranges_by_label
{
3162 /* The comdat type node structure. */
3163 struct GTY(()) comdat_type_node
3165 dw_die_ref root_die
;
3166 dw_die_ref type_die
;
3167 dw_die_ref skeleton_die
;
3168 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
3169 comdat_type_node
*next
;
3172 /* A list of DIEs for which we can't determine ancestry (parent_die
3173 field) just yet. Later in dwarf2out_finish we will fill in the
3175 typedef struct GTY(()) limbo_die_struct
{
3177 /* The tree for which this DIE was created. We use this to
3178 determine ancestry later. */
3180 struct limbo_die_struct
*next
;
3184 typedef struct skeleton_chain_struct
3188 struct skeleton_chain_struct
*parent
;
3190 skeleton_chain_node
;
3192 /* Define a macro which returns nonzero for a TYPE_DECL which was
3193 implicitly generated for a type.
3195 Note that, unlike the C front-end (which generates a NULL named
3196 TYPE_DECL node for each complete tagged type, each array type,
3197 and each function type node created) the C++ front-end generates
3198 a _named_ TYPE_DECL node for each tagged type node created.
3199 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3200 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
3201 front-end, but for each type, tagged or not. */
3203 #define TYPE_DECL_IS_STUB(decl) \
3204 (DECL_NAME (decl) == NULL_TREE \
3205 || (DECL_ARTIFICIAL (decl) \
3206 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3207 /* This is necessary for stub decls that \
3208 appear in nested inline functions. */ \
3209 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3210 && (decl_ultimate_origin (decl) \
3211 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3213 /* Information concerning the compilation unit's programming
3214 language, and compiler version. */
3216 /* Fixed size portion of the DWARF compilation unit header. */
3217 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3218 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE \
3219 + (dwarf_version >= 5 ? 4 : 3))
3221 /* Fixed size portion of the DWARF comdat type unit header. */
3222 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
3223 (DWARF_COMPILE_UNIT_HEADER_SIZE \
3224 + DWARF_TYPE_SIGNATURE_SIZE + DWARF_OFFSET_SIZE)
3226 /* Fixed size portion of the DWARF skeleton compilation unit header. */
3227 #define DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE \
3228 (DWARF_COMPILE_UNIT_HEADER_SIZE + (dwarf_version >= 5 ? 8 : 0))
3230 /* Fixed size portion of public names info. */
3231 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3233 /* Fixed size portion of the address range info. */
3234 #define DWARF_ARANGES_HEADER_SIZE \
3235 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3236 DWARF2_ADDR_SIZE * 2) \
3237 - DWARF_INITIAL_LENGTH_SIZE)
3239 /* Size of padding portion in the address range info. It must be
3240 aligned to twice the pointer size. */
3241 #define DWARF_ARANGES_PAD_SIZE \
3242 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3243 DWARF2_ADDR_SIZE * 2) \
3244 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3246 /* Use assembler line directives if available. */
3247 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3248 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3249 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3251 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3255 /* Use assembler views in line directives if available. */
3256 #ifndef DWARF2_ASM_VIEW_DEBUG_INFO
3257 #ifdef HAVE_AS_DWARF2_DEBUG_VIEW
3258 #define DWARF2_ASM_VIEW_DEBUG_INFO 1
3260 #define DWARF2_ASM_VIEW_DEBUG_INFO 0
3264 /* Return true if GCC configure detected assembler support for .loc. */
3267 dwarf2out_default_as_loc_support (void)
3269 return DWARF2_ASM_LINE_DEBUG_INFO
;
3270 #if (GCC_VERSION >= 3000)
3271 # undef DWARF2_ASM_LINE_DEBUG_INFO
3272 # pragma GCC poison DWARF2_ASM_LINE_DEBUG_INFO
3276 /* Return true if GCC configure detected assembler support for views
3277 in .loc directives. */
3280 dwarf2out_default_as_locview_support (void)
3282 return DWARF2_ASM_VIEW_DEBUG_INFO
;
3283 #if (GCC_VERSION >= 3000)
3284 # undef DWARF2_ASM_VIEW_DEBUG_INFO
3285 # pragma GCC poison DWARF2_ASM_VIEW_DEBUG_INFO
3289 /* A bit is set in ZERO_VIEW_P if we are using the assembler-supported
3290 view computation, and it refers to a view identifier for which we
3291 will not emit a label because it is known to map to a view number
3292 zero. We won't allocate the bitmap if we're not using assembler
3293 support for location views, but we have to make the variable
3294 visible for GGC and for code that will be optimized out for lack of
3295 support but that's still parsed and compiled. We could abstract it
3296 out with macros, but it's not worth it. */
3297 static GTY(()) bitmap zero_view_p
;
3299 /* Evaluate to TRUE iff N is known to identify the first location view
3300 at its PC. When not using assembler location view computation,
3301 that must be view number zero. Otherwise, ZERO_VIEW_P is allocated
3302 and views label numbers recorded in it are the ones known to be
3304 #define ZERO_VIEW_P(N) ((N) == (var_loc_view)0 \
3305 || (N) == (var_loc_view)-1 \
3307 && bitmap_bit_p (zero_view_p, (N))))
3309 /* Return true iff we're to emit .loc directives for the assembler to
3310 generate line number sections.
3312 When we're not emitting views, all we need from the assembler is
3313 support for .loc directives.
3315 If we are emitting views, we can only use the assembler's .loc
3316 support if it also supports views.
3318 When the compiler is emitting the line number programs and
3319 computing view numbers itself, it resets view numbers at known PC
3320 changes and counts from that, and then it emits view numbers as
3321 literal constants in locviewlists. There are cases in which the
3322 compiler is not sure about PC changes, e.g. when extra alignment is
3323 requested for a label. In these cases, the compiler may not reset
3324 the view counter, and the potential PC advance in the line number
3325 program will use an opcode that does not reset the view counter
3326 even if the PC actually changes, so that compiler and debug info
3327 consumer can keep view numbers in sync.
3329 When the compiler defers view computation to the assembler, it
3330 emits symbolic view numbers in locviewlists, with the exception of
3331 views known to be zero (forced resets, or reset after
3332 compiler-visible PC changes): instead of emitting symbols for
3333 these, we emit literal zero and assert the assembler agrees with
3334 the compiler's assessment. We could use symbolic views everywhere,
3335 instead of special-casing zero views, but then we'd be unable to
3336 optimize out locviewlists that contain only zeros. */
3339 output_asm_line_debug_info (void)
3341 return (dwarf2out_as_loc_support
3342 && (dwarf2out_as_locview_support
3343 || !debug_variable_location_views
));
3346 /* Minimum line offset in a special line info. opcode.
3347 This value was chosen to give a reasonable range of values. */
3348 #define DWARF_LINE_BASE -10
3350 /* First special line opcode - leave room for the standard opcodes. */
3351 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
3353 /* Range of line offsets in a special line info. opcode. */
3354 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3356 /* Flag that indicates the initial value of the is_stmt_start flag.
3357 In the present implementation, we do not mark any lines as
3358 the beginning of a source statement, because that information
3359 is not made available by the GCC front-end. */
3360 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3362 /* Maximum number of operations per instruction bundle. */
3363 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
3364 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
3367 /* This location is used by calc_die_sizes() to keep track
3368 the offset of each DIE within the .debug_info section. */
3369 static unsigned long next_die_offset
;
3371 /* Record the root of the DIE's built for the current compilation unit. */
3372 static GTY(()) dw_die_ref single_comp_unit_die
;
3374 /* A list of type DIEs that have been separated into comdat sections. */
3375 static GTY(()) comdat_type_node
*comdat_type_list
;
3377 /* A list of CU DIEs that have been separated. */
3378 static GTY(()) limbo_die_node
*cu_die_list
;
3380 /* A list of DIEs with a NULL parent waiting to be relocated. */
3381 static GTY(()) limbo_die_node
*limbo_die_list
;
3383 /* A list of DIEs for which we may have to generate
3384 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
3385 static GTY(()) limbo_die_node
*deferred_asm_name
;
3387 struct dwarf_file_hasher
: ggc_ptr_hash
<dwarf_file_data
>
3389 typedef const char *compare_type
;
3391 static hashval_t
hash (dwarf_file_data
*);
3392 static bool equal (dwarf_file_data
*, const char *);
3395 /* Filenames referenced by this compilation unit. */
3396 static GTY(()) hash_table
<dwarf_file_hasher
> *file_table
;
3398 struct decl_die_hasher
: ggc_ptr_hash
<die_node
>
3400 typedef tree compare_type
;
3402 static hashval_t
hash (die_node
*);
3403 static bool equal (die_node
*, tree
);
3405 /* A hash table of references to DIE's that describe declarations.
3406 The key is a DECL_UID() which is a unique number identifying each decl. */
3407 static GTY (()) hash_table
<decl_die_hasher
> *decl_die_table
;
3409 struct GTY ((for_user
)) variable_value_struct
{
3410 unsigned int decl_id
;
3411 vec
<dw_die_ref
, va_gc
> *dies
;
3414 struct variable_value_hasher
: ggc_ptr_hash
<variable_value_struct
>
3416 typedef tree compare_type
;
3418 static hashval_t
hash (variable_value_struct
*);
3419 static bool equal (variable_value_struct
*, tree
);
3421 /* A hash table of DIEs that contain DW_OP_GNU_variable_value with
3422 dw_val_class_decl_ref class, indexed by FUNCTION_DECLs which is
3423 DECL_CONTEXT of the referenced VAR_DECLs. */
3424 static GTY (()) hash_table
<variable_value_hasher
> *variable_value_hash
;
3426 struct block_die_hasher
: ggc_ptr_hash
<die_struct
>
3428 static hashval_t
hash (die_struct
*);
3429 static bool equal (die_struct
*, die_struct
*);
3432 /* A hash table of references to DIE's that describe COMMON blocks.
3433 The key is DECL_UID() ^ die_parent. */
3434 static GTY (()) hash_table
<block_die_hasher
> *common_block_die_table
;
3436 typedef struct GTY(()) die_arg_entry_struct
{
3442 /* Node of the variable location list. */
3443 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
3444 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
3445 EXPR_LIST chain. For small bitsizes, bitsize is encoded
3446 in mode of the EXPR_LIST node and first EXPR_LIST operand
3447 is either NOTE_INSN_VAR_LOCATION for a piece with a known
3448 location or NULL for padding. For larger bitsizes,
3449 mode is 0 and first operand is a CONCAT with bitsize
3450 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
3451 NULL as second operand. */
3453 const char * GTY (()) label
;
3454 struct var_loc_node
* GTY (()) next
;
3458 /* Variable location list. */
3459 struct GTY ((for_user
)) var_loc_list_def
{
3460 struct var_loc_node
* GTY (()) first
;
3462 /* Pointer to the last but one or last element of the
3463 chained list. If the list is empty, both first and
3464 last are NULL, if the list contains just one node
3465 or the last node certainly is not redundant, it points
3466 to the last node, otherwise points to the last but one.
3467 Do not mark it for GC because it is marked through the chain. */
3468 struct var_loc_node
* GTY ((skip ("%h"))) last
;
3470 /* Pointer to the last element before section switch,
3471 if NULL, either sections weren't switched or first
3472 is after section switch. */
3473 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
3475 /* DECL_UID of the variable decl. */
3476 unsigned int decl_id
;
3478 typedef struct var_loc_list_def var_loc_list
;
3480 /* Call argument location list. */
3481 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
3482 rtx
GTY (()) call_arg_loc_note
;
3483 const char * GTY (()) label
;
3484 tree
GTY (()) block
;
3486 rtx
GTY (()) symbol_ref
;
3487 struct call_arg_loc_node
* GTY (()) next
;
3491 struct decl_loc_hasher
: ggc_ptr_hash
<var_loc_list
>
3493 typedef const_tree compare_type
;
3495 static hashval_t
hash (var_loc_list
*);
3496 static bool equal (var_loc_list
*, const_tree
);
3499 /* Table of decl location linked lists. */
3500 static GTY (()) hash_table
<decl_loc_hasher
> *decl_loc_table
;
3502 /* Head and tail of call_arg_loc chain. */
3503 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
3504 static struct call_arg_loc_node
*call_arg_loc_last
;
3506 /* Number of call sites in the current function. */
3507 static int call_site_count
= -1;
3508 /* Number of tail call sites in the current function. */
3509 static int tail_call_site_count
= -1;
3511 /* A cached location list. */
3512 struct GTY ((for_user
)) cached_dw_loc_list_def
{
3513 /* The DECL_UID of the decl that this entry describes. */
3514 unsigned int decl_id
;
3516 /* The cached location list. */
3517 dw_loc_list_ref loc_list
;
3519 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
3521 struct dw_loc_list_hasher
: ggc_ptr_hash
<cached_dw_loc_list
>
3524 typedef const_tree compare_type
;
3526 static hashval_t
hash (cached_dw_loc_list
*);
3527 static bool equal (cached_dw_loc_list
*, const_tree
);
3530 /* Table of cached location lists. */
3531 static GTY (()) hash_table
<dw_loc_list_hasher
> *cached_dw_loc_list_table
;
3533 /* A vector of references to DIE's that are uniquely identified by their tag,
3534 presence/absence of children DIE's, and list of attribute/value pairs. */
3535 static GTY(()) vec
<dw_die_ref
, va_gc
> *abbrev_die_table
;
3537 /* A hash map to remember the stack usage for DWARF procedures. The value
3538 stored is the stack size difference between before the DWARF procedure
3539 invokation and after it returned. In other words, for a DWARF procedure
3540 that consumes N stack slots and that pushes M ones, this stores M - N. */
3541 static hash_map
<dw_die_ref
, int> *dwarf_proc_stack_usage_map
;
3543 /* A global counter for generating labels for line number data. */
3544 static unsigned int line_info_label_num
;
3546 /* The current table to which we should emit line number information
3547 for the current function. This will be set up at the beginning of
3548 assembly for the function. */
3549 static GTY(()) dw_line_info_table
*cur_line_info_table
;
3551 /* The two default tables of line number info. */
3552 static GTY(()) dw_line_info_table
*text_section_line_info
;
3553 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
3555 /* The set of all non-default tables of line number info. */
3556 static GTY(()) vec
<dw_line_info_table
*, va_gc
> *separate_line_info
;
3558 /* A flag to tell pubnames/types export if there is an info section to
3560 static bool info_section_emitted
;
3562 /* A pointer to the base of a table that contains a list of publicly
3563 accessible names. */
3564 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
3566 /* A pointer to the base of a table that contains a list of publicly
3567 accessible types. */
3568 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
3570 /* A pointer to the base of a table that contains a list of macro
3571 defines/undefines (and file start/end markers). */
3572 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
3574 /* True if .debug_macinfo or .debug_macros section is going to be
3576 #define have_macinfo \
3577 ((!XCOFF_DEBUGGING_INFO || HAVE_XCOFF_DWARF_EXTRAS) \
3578 && debug_info_level >= DINFO_LEVEL_VERBOSE \
3579 && !macinfo_table->is_empty ())
3581 /* Vector of dies for which we should generate .debug_ranges info. */
3582 static GTY (()) vec
<dw_ranges
, va_gc
> *ranges_table
;
3584 /* Vector of pairs of labels referenced in ranges_table. */
3585 static GTY (()) vec
<dw_ranges_by_label
, va_gc
> *ranges_by_label
;
3587 /* Whether we have location lists that need outputting */
3588 static GTY(()) bool have_location_lists
;
3590 /* Unique label counter. */
3591 static GTY(()) unsigned int loclabel_num
;
3593 /* Unique label counter for point-of-call tables. */
3594 static GTY(()) unsigned int poc_label_num
;
3596 /* The last file entry emitted by maybe_emit_file(). */
3597 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
3599 /* Number of internal labels generated by gen_internal_sym(). */
3600 static GTY(()) int label_num
;
3602 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
3604 /* Instances of generic types for which we need to generate debug
3605 info that describe their generic parameters and arguments. That
3606 generation needs to happen once all types are properly laid out so
3607 we do it at the end of compilation. */
3608 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
3610 /* Offset from the "steady-state frame pointer" to the frame base,
3611 within the current function. */
3612 static poly_int64 frame_pointer_fb_offset
;
3613 static bool frame_pointer_fb_offset_valid
;
3615 static vec
<dw_die_ref
> base_types
;
3617 /* Flags to represent a set of attribute classes for attributes that represent
3618 a scalar value (bounds, pointers, ...). */
3621 dw_scalar_form_constant
= 0x01,
3622 dw_scalar_form_exprloc
= 0x02,
3623 dw_scalar_form_reference
= 0x04
3626 /* Forward declarations for functions defined in this file. */
3628 static int is_pseudo_reg (const_rtx
);
3629 static tree
type_main_variant (tree
);
3630 static int is_tagged_type (const_tree
);
3631 static const char *dwarf_tag_name (unsigned);
3632 static const char *dwarf_attr_name (unsigned);
3633 static const char *dwarf_form_name (unsigned);
3634 static tree
decl_ultimate_origin (const_tree
);
3635 static tree
decl_class_context (tree
);
3636 static void add_dwarf_attr (dw_die_ref
, dw_attr_node
*);
3637 static inline enum dw_val_class
AT_class (dw_attr_node
*);
3638 static inline unsigned int AT_index (dw_attr_node
*);
3639 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3640 static inline unsigned AT_flag (dw_attr_node
*);
3641 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3642 static inline HOST_WIDE_INT
AT_int (dw_attr_node
*);
3643 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3644 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_node
*);
3645 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
3646 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
3647 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3648 unsigned int, unsigned char *);
3649 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
3650 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3651 static inline const char *AT_string (dw_attr_node
*);
3652 static enum dwarf_form
AT_string_form (dw_attr_node
*);
3653 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3654 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3655 static inline dw_die_ref
AT_ref (dw_attr_node
*);
3656 static inline int AT_ref_external (dw_attr_node
*);
3657 static inline void set_AT_ref_external (dw_attr_node
*, int);
3658 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3659 static inline dw_loc_descr_ref
AT_loc (dw_attr_node
*);
3660 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3662 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3663 static void add_AT_view_list (dw_die_ref
, enum dwarf_attribute
);
3664 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3665 static addr_table_entry
*add_addr_table_entry (void *, enum ate_kind
);
3666 static void remove_addr_table_entry (addr_table_entry
*);
3667 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
, bool);
3668 static inline rtx
AT_addr (dw_attr_node
*);
3669 static void add_AT_symview (dw_die_ref
, enum dwarf_attribute
, const char *);
3670 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3671 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3672 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3673 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3674 unsigned long, bool);
3675 static inline const char *AT_lbl (dw_attr_node
*);
3676 static dw_attr_node
*get_AT (dw_die_ref
, enum dwarf_attribute
);
3677 static const char *get_AT_low_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_c (void);
3683 static bool is_cxx (void);
3684 static bool is_cxx (const_tree
);
3685 static bool is_fortran (void);
3686 static bool is_ada (void);
3687 static bool remove_AT (dw_die_ref
, enum dwarf_attribute
);
3688 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3689 static void add_child_die (dw_die_ref
, dw_die_ref
);
3690 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3691 static dw_die_ref
lookup_type_die (tree
);
3692 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3693 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3694 static void equate_type_number_to_die (tree
, dw_die_ref
);
3695 static dw_die_ref
lookup_decl_die (tree
);
3696 static var_loc_list
*lookup_decl_loc (const_tree
);
3697 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3698 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *, var_loc_view
);
3699 static void print_spaces (FILE *);
3700 static void print_die (dw_die_ref
, FILE *);
3701 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3702 static void attr_checksum (dw_attr_node
*, struct md5_ctx
*, int *);
3703 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3704 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3705 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3706 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3707 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_node
*,
3708 struct md5_ctx
*, int *);
3709 struct checksum_attributes
;
3710 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3711 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3712 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3713 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3714 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3715 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3716 static int same_attr_p (dw_attr_node
*, dw_attr_node
*, int *);
3717 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3718 static int is_type_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
*, bool);
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 unsigned int dbx_reg_number (const_rtx
);
3776 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3777 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3778 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3779 enum var_init_status
);
3780 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3781 enum var_init_status
);
3782 static dw_loc_descr_ref
based_loc_descr (rtx
, poly_int64
,
3783 enum var_init_status
);
3784 static int is_based_loc (const_rtx
);
3785 static bool resolve_one_addr (rtx
*);
3786 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3787 enum var_init_status
);
3788 static dw_loc_descr_ref
loc_descriptor (rtx
, machine_mode mode
,
3789 enum var_init_status
);
3790 struct loc_descr_context
;
3791 static void add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
);
3792 static void add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
);
3793 static dw_loc_list_ref
loc_list_from_tree (tree
, int,
3794 struct loc_descr_context
*);
3795 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int,
3796 struct loc_descr_context
*);
3797 static tree
field_type (const_tree
);
3798 static unsigned int simple_type_align_in_bits (const_tree
);
3799 static unsigned int simple_decl_align_in_bits (const_tree
);
3800 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3802 static dw_loc_descr_ref
field_byte_offset (const_tree
, struct vlr_context
*,
3804 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3806 static void add_data_member_location_attribute (dw_die_ref
, tree
,
3807 struct vlr_context
*);
3808 static bool add_const_value_attribute (dw_die_ref
, rtx
);
3809 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3810 static void insert_wide_int (const wide_int
&, unsigned char *, int);
3811 static void insert_float (const_rtx
, unsigned char *);
3812 static rtx
rtl_for_decl_location (tree
);
3813 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool);
3814 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3815 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3816 static void add_name_attribute (dw_die_ref
, const char *);
3817 static void add_desc_attribute (dw_die_ref
, tree
);
3818 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3819 static void add_comp_dir_attribute (dw_die_ref
);
3820 static void add_scalar_info (dw_die_ref
, enum dwarf_attribute
, tree
, int,
3821 struct loc_descr_context
*);
3822 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
,
3823 struct loc_descr_context
*);
3824 static void add_subscript_info (dw_die_ref
, tree
, bool);
3825 static void add_byte_size_attribute (dw_die_ref
, tree
);
3826 static void add_alignment_attribute (dw_die_ref
, tree
);
3827 static inline void add_bit_offset_attribute (dw_die_ref
, tree
,
3828 struct vlr_context
*);
3829 static void add_bit_size_attribute (dw_die_ref
, tree
);
3830 static void add_prototyped_attribute (dw_die_ref
, tree
);
3831 static void add_abstract_origin_attribute (dw_die_ref
, tree
);
3832 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3833 static void add_src_coords_attributes (dw_die_ref
, tree
);
3834 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
, bool = false);
3835 static void add_discr_value (dw_die_ref
, dw_discr_value
*);
3836 static void add_discr_list (dw_die_ref
, dw_discr_list_ref
);
3837 static inline dw_discr_list_ref
AT_discr_list (dw_attr_node
*);
3838 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3839 static inline int local_scope_p (dw_die_ref
);
3840 static inline int class_scope_p (dw_die_ref
);
3841 static inline int class_or_namespace_scope_p (dw_die_ref
);
3842 static void add_type_attribute (dw_die_ref
, tree
, int, bool, dw_die_ref
);
3843 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3844 static const char *type_tag (const_tree
);
3845 static tree
member_declared_type (const_tree
);
3847 static const char *decl_start_label (tree
);
3849 static void gen_array_type_die (tree
, dw_die_ref
);
3850 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3852 static void gen_entry_point_die (tree
, dw_die_ref
);
3854 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3855 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3856 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3857 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3858 static void gen_formal_types_die (tree
, dw_die_ref
);
3859 static void gen_subprogram_die (tree
, dw_die_ref
);
3860 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3861 static void gen_const_die (tree
, dw_die_ref
);
3862 static void gen_label_die (tree
, dw_die_ref
);
3863 static void gen_lexical_block_die (tree
, dw_die_ref
);
3864 static void gen_inlined_subroutine_die (tree
, dw_die_ref
);
3865 static void gen_field_die (tree
, struct vlr_context
*, dw_die_ref
);
3866 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3867 static dw_die_ref
gen_compile_unit_die (const char *);
3868 static void gen_inheritance_die (tree
, tree
, tree
, dw_die_ref
);
3869 static void gen_member_die (tree
, dw_die_ref
);
3870 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3871 enum debug_info_usage
);
3872 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3873 static void gen_typedef_die (tree
, dw_die_ref
);
3874 static void gen_type_die (tree
, dw_die_ref
);
3875 static void gen_block_die (tree
, dw_die_ref
);
3876 static void decls_for_scope (tree
, dw_die_ref
, bool = true);
3877 static bool is_naming_typedef_decl (const_tree
);
3878 static inline dw_die_ref
get_context_die (tree
);
3879 static void gen_namespace_die (tree
, dw_die_ref
);
3880 static dw_die_ref
gen_namelist_decl (tree
, dw_die_ref
, tree
);
3881 static dw_die_ref
gen_decl_die (tree
, tree
, struct vlr_context
*, dw_die_ref
);
3882 static dw_die_ref
force_decl_die (tree
);
3883 static dw_die_ref
force_type_die (tree
);
3884 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3885 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3886 static struct dwarf_file_data
* lookup_filename (const char *);
3887 static void retry_incomplete_types (void);
3888 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3889 static void gen_generic_params_dies (tree
);
3890 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3891 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3892 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3893 static int file_info_cmp (const void *, const void *);
3894 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *, var_loc_view
,
3895 const char *, var_loc_view
, const char *);
3896 static void output_loc_list (dw_loc_list_ref
);
3897 static char *gen_internal_sym (const char *);
3898 static bool want_pubnames (void);
3900 static void prune_unmark_dies (dw_die_ref
);
3901 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3902 static void prune_unused_types_mark (dw_die_ref
, int);
3903 static void prune_unused_types_walk (dw_die_ref
);
3904 static void prune_unused_types_walk_attribs (dw_die_ref
);
3905 static void prune_unused_types_prune (dw_die_ref
);
3906 static void prune_unused_types (void);
3907 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3908 static inline const char *AT_vms_delta1 (dw_attr_node
*);
3909 static inline const char *AT_vms_delta2 (dw_attr_node
*);
3910 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
3911 const char *, const char *);
3912 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
3913 static void gen_remaining_tmpl_value_param_die_attribute (void);
3914 static bool generic_type_p (tree
);
3915 static void schedule_generic_params_dies_gen (tree t
);
3916 static void gen_scheduled_generic_parms_dies (void);
3917 static void resolve_variable_values (void);
3919 static const char *comp_dir_string (void);
3921 static void hash_loc_operands (dw_loc_descr_ref
, inchash::hash
&);
3923 /* enum for tracking thread-local variables whose address is really an offset
3924 relative to the TLS pointer, which will need link-time relocation, but will
3925 not need relocation by the DWARF consumer. */
3933 /* Return the operator to use for an address of a variable. For dtprel_true, we
3934 use DW_OP_const*. For regular variables, which need both link-time
3935 relocation and consumer-level relocation (e.g., to account for shared objects
3936 loaded at a random address), we use DW_OP_addr*. */
3938 static inline enum dwarf_location_atom
3939 dw_addr_op (enum dtprel_bool dtprel
)
3941 if (dtprel
== dtprel_true
)
3942 return (dwarf_split_debug_info
? dwarf_OP (DW_OP_constx
)
3943 : (DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
));
3945 return dwarf_split_debug_info
? dwarf_OP (DW_OP_addrx
) : DW_OP_addr
;
3948 /* Return a pointer to a newly allocated address location description. If
3949 dwarf_split_debug_info is true, then record the address with the appropriate
3951 static inline dw_loc_descr_ref
3952 new_addr_loc_descr (rtx addr
, enum dtprel_bool dtprel
)
3954 dw_loc_descr_ref ref
= new_loc_descr (dw_addr_op (dtprel
), 0, 0);
3956 ref
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
3957 ref
->dw_loc_oprnd1
.v
.val_addr
= addr
;
3958 ref
->dtprel
= dtprel
;
3959 if (dwarf_split_debug_info
)
3960 ref
->dw_loc_oprnd1
.val_entry
3961 = add_addr_table_entry (addr
,
3962 dtprel
? ate_kind_rtx_dtprel
: ate_kind_rtx
);
3964 ref
->dw_loc_oprnd1
.val_entry
= NULL
;
3969 /* Section names used to hold DWARF debugging information. */
3971 #ifndef DEBUG_INFO_SECTION
3972 #define DEBUG_INFO_SECTION ".debug_info"
3974 #ifndef DEBUG_DWO_INFO_SECTION
3975 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3977 #ifndef DEBUG_LTO_INFO_SECTION
3978 #define DEBUG_LTO_INFO_SECTION ".gnu.debuglto_.debug_info"
3980 #ifndef DEBUG_LTO_DWO_INFO_SECTION
3981 #define DEBUG_LTO_DWO_INFO_SECTION ".gnu.debuglto_.debug_info.dwo"
3983 #ifndef DEBUG_ABBREV_SECTION
3984 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3986 #ifndef DEBUG_LTO_ABBREV_SECTION
3987 #define DEBUG_LTO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev"
3989 #ifndef DEBUG_DWO_ABBREV_SECTION
3990 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3992 #ifndef DEBUG_LTO_DWO_ABBREV_SECTION
3993 #define DEBUG_LTO_DWO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev.dwo"
3995 #ifndef DEBUG_ARANGES_SECTION
3996 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3998 #ifndef DEBUG_ADDR_SECTION
3999 #define DEBUG_ADDR_SECTION ".debug_addr"
4001 #ifndef DEBUG_MACINFO_SECTION
4002 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
4004 #ifndef DEBUG_LTO_MACINFO_SECTION
4005 #define DEBUG_LTO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo"
4007 #ifndef DEBUG_DWO_MACINFO_SECTION
4008 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
4010 #ifndef DEBUG_LTO_DWO_MACINFO_SECTION
4011 #define DEBUG_LTO_DWO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo.dwo"
4013 #ifndef DEBUG_MACRO_SECTION
4014 #define DEBUG_MACRO_SECTION ".debug_macro"
4016 #ifndef DEBUG_LTO_MACRO_SECTION
4017 #define DEBUG_LTO_MACRO_SECTION ".gnu.debuglto_.debug_macro"
4019 #ifndef DEBUG_DWO_MACRO_SECTION
4020 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
4022 #ifndef DEBUG_LTO_DWO_MACRO_SECTION
4023 #define DEBUG_LTO_DWO_MACRO_SECTION ".gnu.debuglto_.debug_macro.dwo"
4025 #ifndef DEBUG_LINE_SECTION
4026 #define DEBUG_LINE_SECTION ".debug_line"
4028 #ifndef DEBUG_LTO_LINE_SECTION
4029 #define DEBUG_LTO_LINE_SECTION ".gnu.debuglto_.debug_line"
4031 #ifndef DEBUG_DWO_LINE_SECTION
4032 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
4034 #ifndef DEBUG_LTO_DWO_LINE_SECTION
4035 #define DEBUG_LTO_DWO_LINE_SECTION ".gnu.debuglto_.debug_line.dwo"
4037 #ifndef DEBUG_LOC_SECTION
4038 #define DEBUG_LOC_SECTION ".debug_loc"
4040 #ifndef DEBUG_DWO_LOC_SECTION
4041 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
4043 #ifndef DEBUG_LOCLISTS_SECTION
4044 #define DEBUG_LOCLISTS_SECTION ".debug_loclists"
4046 #ifndef DEBUG_DWO_LOCLISTS_SECTION
4047 #define DEBUG_DWO_LOCLISTS_SECTION ".debug_loclists.dwo"
4049 #ifndef DEBUG_PUBNAMES_SECTION
4050 #define DEBUG_PUBNAMES_SECTION \
4051 ((debug_generate_pub_sections == 2) \
4052 ? ".debug_gnu_pubnames" : ".debug_pubnames")
4054 #ifndef DEBUG_PUBTYPES_SECTION
4055 #define DEBUG_PUBTYPES_SECTION \
4056 ((debug_generate_pub_sections == 2) \
4057 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
4059 #ifndef DEBUG_STR_OFFSETS_SECTION
4060 #define DEBUG_STR_OFFSETS_SECTION ".debug_str_offsets"
4062 #ifndef DEBUG_DWO_STR_OFFSETS_SECTION
4063 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
4065 #ifndef DEBUG_LTO_DWO_STR_OFFSETS_SECTION
4066 #define DEBUG_LTO_DWO_STR_OFFSETS_SECTION ".gnu.debuglto_.debug_str_offsets.dwo"
4068 #ifndef DEBUG_STR_SECTION
4069 #define DEBUG_STR_SECTION ".debug_str"
4071 #ifndef DEBUG_LTO_STR_SECTION
4072 #define DEBUG_LTO_STR_SECTION ".gnu.debuglto_.debug_str"
4074 #ifndef DEBUG_STR_DWO_SECTION
4075 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
4077 #ifndef DEBUG_LTO_STR_DWO_SECTION
4078 #define DEBUG_LTO_STR_DWO_SECTION ".gnu.debuglto_.debug_str.dwo"
4080 #ifndef DEBUG_RANGES_SECTION
4081 #define DEBUG_RANGES_SECTION ".debug_ranges"
4083 #ifndef DEBUG_RNGLISTS_SECTION
4084 #define DEBUG_RNGLISTS_SECTION ".debug_rnglists"
4086 #ifndef DEBUG_LINE_STR_SECTION
4087 #define DEBUG_LINE_STR_SECTION ".debug_line_str"
4089 #ifndef DEBUG_LTO_LINE_STR_SECTION
4090 #define DEBUG_LTO_LINE_STR_SECTION ".gnu.debuglto_.debug_line_str"
4093 /* Standard ELF section names for compiled code and data. */
4094 #ifndef TEXT_SECTION_NAME
4095 #define TEXT_SECTION_NAME ".text"
4098 /* Section flags for .debug_str section. */
4099 #define DEBUG_STR_SECTION_FLAGS \
4100 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
4101 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4104 /* Section flags for .debug_str.dwo section. */
4105 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
4107 /* Attribute used to refer to the macro section. */
4108 #define DEBUG_MACRO_ATTRIBUTE (dwarf_version >= 5 ? DW_AT_macros \
4109 : dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros)
4111 /* Labels we insert at beginning sections we can reference instead of
4112 the section names themselves. */
4114 #ifndef TEXT_SECTION_LABEL
4115 #define TEXT_SECTION_LABEL "Ltext"
4117 #ifndef COLD_TEXT_SECTION_LABEL
4118 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
4120 #ifndef DEBUG_LINE_SECTION_LABEL
4121 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4123 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
4124 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
4126 #ifndef DEBUG_INFO_SECTION_LABEL
4127 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4129 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
4130 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
4132 #ifndef DEBUG_ABBREV_SECTION_LABEL
4133 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4135 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
4136 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
4138 #ifndef DEBUG_ADDR_SECTION_LABEL
4139 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
4141 #ifndef DEBUG_LOC_SECTION_LABEL
4142 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4144 #ifndef DEBUG_RANGES_SECTION_LABEL
4145 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4147 #ifndef DEBUG_MACINFO_SECTION_LABEL
4148 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4150 #ifndef DEBUG_MACRO_SECTION_LABEL
4151 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
4153 #define SKELETON_COMP_DIE_ABBREV 1
4154 #define SKELETON_TYPE_DIE_ABBREV 2
4156 /* Definitions of defaults for formats and names of various special
4157 (artificial) labels which may be generated within this file (when the -g
4158 options is used and DWARF2_DEBUGGING_INFO is in effect.
4159 If necessary, these may be overridden from within the tm.h file, but
4160 typically, overriding these defaults is unnecessary. */
4162 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4163 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4164 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4165 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4166 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4167 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4168 static char debug_skeleton_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4169 static char debug_skeleton_abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4170 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4171 static char debug_addr_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4172 static char debug_skeleton_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4173 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4174 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4175 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4176 static char ranges_base_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4178 #ifndef TEXT_END_LABEL
4179 #define TEXT_END_LABEL "Letext"
4181 #ifndef COLD_END_LABEL
4182 #define COLD_END_LABEL "Letext_cold"
4184 #ifndef BLOCK_BEGIN_LABEL
4185 #define BLOCK_BEGIN_LABEL "LBB"
4187 #ifndef BLOCK_INLINE_ENTRY_LABEL
4188 #define BLOCK_INLINE_ENTRY_LABEL "LBI"
4190 #ifndef BLOCK_END_LABEL
4191 #define BLOCK_END_LABEL "LBE"
4193 #ifndef LINE_CODE_LABEL
4194 #define LINE_CODE_LABEL "LM"
4198 /* Return the root of the DIE's built for the current compilation unit. */
4200 comp_unit_die (void)
4202 if (!single_comp_unit_die
)
4203 single_comp_unit_die
= gen_compile_unit_die (NULL
);
4204 return single_comp_unit_die
;
4207 /* We allow a language front-end to designate a function that is to be
4208 called to "demangle" any name before it is put into a DIE. */
4210 static const char *(*demangle_name_func
) (const char *);
4213 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
4215 demangle_name_func
= func
;
4218 /* Test if rtl node points to a pseudo register. */
4221 is_pseudo_reg (const_rtx rtl
)
4223 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
4224 || (GET_CODE (rtl
) == SUBREG
4225 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
4228 /* Return a reference to a type, with its const and volatile qualifiers
4232 type_main_variant (tree type
)
4234 type
= TYPE_MAIN_VARIANT (type
);
4236 /* ??? There really should be only one main variant among any group of
4237 variants of a given type (and all of the MAIN_VARIANT values for all
4238 members of the group should point to that one type) but sometimes the C
4239 front-end messes this up for array types, so we work around that bug
4241 if (TREE_CODE (type
) == ARRAY_TYPE
)
4242 while (type
!= TYPE_MAIN_VARIANT (type
))
4243 type
= TYPE_MAIN_VARIANT (type
);
4248 /* Return nonzero if the given type node represents a tagged type. */
4251 is_tagged_type (const_tree type
)
4253 enum tree_code code
= TREE_CODE (type
);
4255 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
4256 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
4259 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
4262 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
4264 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
4267 /* Return die_offset of a DIE reference to a base type. */
4269 static unsigned long int
4270 get_base_type_offset (dw_die_ref ref
)
4272 if (ref
->die_offset
)
4273 return ref
->die_offset
;
4274 if (comp_unit_die ()->die_abbrev
)
4276 calc_base_type_die_sizes ();
4277 gcc_assert (ref
->die_offset
);
4279 return ref
->die_offset
;
4282 /* Return die_offset of a DIE reference other than base type. */
4284 static unsigned long int
4285 get_ref_die_offset (dw_die_ref ref
)
4287 gcc_assert (ref
->die_offset
);
4288 return ref
->die_offset
;
4291 /* Convert a DIE tag into its string name. */
4294 dwarf_tag_name (unsigned int tag
)
4296 const char *name
= get_DW_TAG_name (tag
);
4301 return "DW_TAG_<unknown>";
4304 /* Convert a DWARF attribute code into its string name. */
4307 dwarf_attr_name (unsigned int attr
)
4313 #if VMS_DEBUGGING_INFO
4314 case DW_AT_HP_prologue
:
4315 return "DW_AT_HP_prologue";
4317 case DW_AT_MIPS_loop_unroll_factor
:
4318 return "DW_AT_MIPS_loop_unroll_factor";
4321 #if VMS_DEBUGGING_INFO
4322 case DW_AT_HP_epilogue
:
4323 return "DW_AT_HP_epilogue";
4325 case DW_AT_MIPS_stride
:
4326 return "DW_AT_MIPS_stride";
4330 name
= get_DW_AT_name (attr
);
4335 return "DW_AT_<unknown>";
4338 /* Convert a DWARF value form code into its string name. */
4341 dwarf_form_name (unsigned int form
)
4343 const char *name
= get_DW_FORM_name (form
);
4348 return "DW_FORM_<unknown>";
4351 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4352 instance of an inlined instance of a decl which is local to an inline
4353 function, so we have to trace all of the way back through the origin chain
4354 to find out what sort of node actually served as the original seed for the
4358 decl_ultimate_origin (const_tree decl
)
4360 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
4363 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
4364 we're trying to output the abstract instance of this function. */
4365 if (DECL_ABSTRACT_P (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
4368 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4369 most distant ancestor, this should never happen. */
4370 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
4372 return DECL_ABSTRACT_ORIGIN (decl
);
4375 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4376 of a virtual function may refer to a base class, so we check the 'this'
4380 decl_class_context (tree decl
)
4382 tree context
= NULL_TREE
;
4384 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
4385 context
= DECL_CONTEXT (decl
);
4387 context
= TYPE_MAIN_VARIANT
4388 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
4390 if (context
&& !TYPE_P (context
))
4391 context
= NULL_TREE
;
4396 /* Add an attribute/value pair to a DIE. */
4399 add_dwarf_attr (dw_die_ref die
, dw_attr_node
*attr
)
4401 /* Maybe this should be an assert? */
4407 /* Check we do not add duplicate attrs. Can't use get_AT here
4408 because that recurses to the specification/abstract origin DIE. */
4411 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4412 gcc_assert (a
->dw_attr
!= attr
->dw_attr
);
4415 vec_safe_reserve (die
->die_attr
, 1);
4416 vec_safe_push (die
->die_attr
, *attr
);
4419 static inline enum dw_val_class
4420 AT_class (dw_attr_node
*a
)
4422 return a
->dw_attr_val
.val_class
;
4425 /* Return the index for any attribute that will be referenced with a
4426 DW_FORM_addrx/GNU_addr_index or DW_FORM_strx/GNU_str_index. String
4427 indices are stored in dw_attr_val.v.val_str for reference counting
4430 static inline unsigned int
4431 AT_index (dw_attr_node
*a
)
4433 if (AT_class (a
) == dw_val_class_str
)
4434 return a
->dw_attr_val
.v
.val_str
->index
;
4435 else if (a
->dw_attr_val
.val_entry
!= NULL
)
4436 return a
->dw_attr_val
.val_entry
->index
;
4440 /* Add a flag value attribute to a DIE. */
4443 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
4447 attr
.dw_attr
= attr_kind
;
4448 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
4449 attr
.dw_attr_val
.val_entry
= NULL
;
4450 attr
.dw_attr_val
.v
.val_flag
= flag
;
4451 add_dwarf_attr (die
, &attr
);
4454 static inline unsigned
4455 AT_flag (dw_attr_node
*a
)
4457 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
4458 return a
->dw_attr_val
.v
.val_flag
;
4461 /* Add a signed integer attribute value to a DIE. */
4464 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
4468 attr
.dw_attr
= attr_kind
;
4469 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
4470 attr
.dw_attr_val
.val_entry
= NULL
;
4471 attr
.dw_attr_val
.v
.val_int
= int_val
;
4472 add_dwarf_attr (die
, &attr
);
4475 static inline HOST_WIDE_INT
4476 AT_int (dw_attr_node
*a
)
4478 gcc_assert (a
&& (AT_class (a
) == dw_val_class_const
4479 || AT_class (a
) == dw_val_class_const_implicit
));
4480 return a
->dw_attr_val
.v
.val_int
;
4483 /* Add an unsigned integer attribute value to a DIE. */
4486 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4487 unsigned HOST_WIDE_INT unsigned_val
)
4491 attr
.dw_attr
= attr_kind
;
4492 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
4493 attr
.dw_attr_val
.val_entry
= NULL
;
4494 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
4495 add_dwarf_attr (die
, &attr
);
4498 static inline unsigned HOST_WIDE_INT
4499 AT_unsigned (dw_attr_node
*a
)
4501 gcc_assert (a
&& (AT_class (a
) == dw_val_class_unsigned_const
4502 || AT_class (a
) == dw_val_class_unsigned_const_implicit
));
4503 return a
->dw_attr_val
.v
.val_unsigned
;
4506 /* Add an unsigned wide integer attribute value to a DIE. */
4509 add_AT_wide (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4514 attr
.dw_attr
= attr_kind
;
4515 attr
.dw_attr_val
.val_class
= dw_val_class_wide_int
;
4516 attr
.dw_attr_val
.val_entry
= NULL
;
4517 attr
.dw_attr_val
.v
.val_wide
= ggc_alloc
<wide_int
> ();
4518 *attr
.dw_attr_val
.v
.val_wide
= w
;
4519 add_dwarf_attr (die
, &attr
);
4522 /* Add an unsigned double integer attribute value to a DIE. */
4525 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4526 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
4530 attr
.dw_attr
= attr_kind
;
4531 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
4532 attr
.dw_attr_val
.val_entry
= NULL
;
4533 attr
.dw_attr_val
.v
.val_double
.high
= high
;
4534 attr
.dw_attr_val
.v
.val_double
.low
= low
;
4535 add_dwarf_attr (die
, &attr
);
4538 /* Add a floating point attribute value to a DIE and return it. */
4541 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4542 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
4546 attr
.dw_attr
= attr_kind
;
4547 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
4548 attr
.dw_attr_val
.val_entry
= NULL
;
4549 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
4550 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
4551 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
4552 add_dwarf_attr (die
, &attr
);
4555 /* Add an 8-byte data attribute value to a DIE. */
4558 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4559 unsigned char data8
[8])
4563 attr
.dw_attr
= attr_kind
;
4564 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
4565 attr
.dw_attr_val
.val_entry
= NULL
;
4566 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
4567 add_dwarf_attr (die
, &attr
);
4570 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
4571 dwarf_split_debug_info, address attributes in dies destined for the
4572 final executable have force_direct set to avoid using indexed
4576 add_AT_low_high_pc (dw_die_ref die
, const char *lbl_low
, const char *lbl_high
,
4582 lbl_id
= xstrdup (lbl_low
);
4583 attr
.dw_attr
= DW_AT_low_pc
;
4584 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4585 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4586 if (dwarf_split_debug_info
&& !force_direct
)
4587 attr
.dw_attr_val
.val_entry
4588 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4590 attr
.dw_attr_val
.val_entry
= NULL
;
4591 add_dwarf_attr (die
, &attr
);
4593 attr
.dw_attr
= DW_AT_high_pc
;
4594 if (dwarf_version
< 4)
4595 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4597 attr
.dw_attr_val
.val_class
= dw_val_class_high_pc
;
4598 lbl_id
= xstrdup (lbl_high
);
4599 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4600 if (attr
.dw_attr_val
.val_class
== dw_val_class_lbl_id
4601 && dwarf_split_debug_info
&& !force_direct
)
4602 attr
.dw_attr_val
.val_entry
4603 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4605 attr
.dw_attr_val
.val_entry
= NULL
;
4606 add_dwarf_attr (die
, &attr
);
4609 /* Hash and equality functions for debug_str_hash. */
4612 indirect_string_hasher::hash (indirect_string_node
*x
)
4614 return htab_hash_string (x
->str
);
4618 indirect_string_hasher::equal (indirect_string_node
*x1
, const char *x2
)
4620 return strcmp (x1
->str
, x2
) == 0;
4623 /* Add STR to the given string hash table. */
4625 static struct indirect_string_node
*
4626 find_AT_string_in_table (const char *str
,
4627 hash_table
<indirect_string_hasher
> *table
,
4628 enum insert_option insert
= INSERT
)
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
, enum insert_option insert
= INSERT
)
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
, insert
);
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 a location description attribute value to a DIE. */
4840 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4844 attr
.dw_attr
= attr_kind
;
4845 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4846 attr
.dw_attr_val
.val_entry
= NULL
;
4847 attr
.dw_attr_val
.v
.val_loc
= loc
;
4848 add_dwarf_attr (die
, &attr
);
4851 static inline dw_loc_descr_ref
4852 AT_loc (dw_attr_node
*a
)
4854 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4855 return a
->dw_attr_val
.v
.val_loc
;
4859 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4863 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4866 attr
.dw_attr
= attr_kind
;
4867 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
4868 attr
.dw_attr_val
.val_entry
= NULL
;
4869 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
4870 add_dwarf_attr (die
, &attr
);
4871 have_location_lists
= true;
4874 static inline dw_loc_list_ref
4875 AT_loc_list (dw_attr_node
*a
)
4877 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4878 return a
->dw_attr_val
.v
.val_loc_list
;
4881 /* Add a view list attribute to DIE. It must have a DW_AT_location
4882 attribute, because the view list complements the location list. */
4885 add_AT_view_list (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4889 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4892 attr
.dw_attr
= attr_kind
;
4893 attr
.dw_attr_val
.val_class
= dw_val_class_view_list
;
4894 attr
.dw_attr_val
.val_entry
= NULL
;
4895 attr
.dw_attr_val
.v
.val_view_list
= die
;
4896 add_dwarf_attr (die
, &attr
);
4897 gcc_checking_assert (get_AT (die
, DW_AT_location
));
4898 gcc_assert (have_location_lists
);
4901 /* Return a pointer to the location list referenced by the attribute.
4902 If the named attribute is a view list, look up the corresponding
4903 DW_AT_location attribute and return its location list. */
4905 static inline dw_loc_list_ref
*
4906 AT_loc_list_ptr (dw_attr_node
*a
)
4909 switch (AT_class (a
))
4911 case dw_val_class_loc_list
:
4912 return &a
->dw_attr_val
.v
.val_loc_list
;
4913 case dw_val_class_view_list
:
4916 l
= get_AT (a
->dw_attr_val
.v
.val_view_list
, DW_AT_location
);
4919 gcc_checking_assert (l
+ 1 == a
);
4920 return AT_loc_list_ptr (l
);
4927 /* Return the location attribute value associated with a view list
4930 static inline dw_val_node
*
4931 view_list_to_loc_list_val_node (dw_val_node
*val
)
4933 gcc_assert (val
->val_class
== dw_val_class_view_list
);
4934 dw_attr_node
*loc
= get_AT (val
->v
.val_view_list
, DW_AT_location
);
4937 gcc_checking_assert (&(loc
+ 1)->dw_attr_val
== val
);
4938 gcc_assert (AT_class (loc
) == dw_val_class_loc_list
);
4939 return &loc
->dw_attr_val
;
4942 struct addr_hasher
: ggc_ptr_hash
<addr_table_entry
>
4944 static hashval_t
hash (addr_table_entry
*);
4945 static bool equal (addr_table_entry
*, addr_table_entry
*);
4948 /* Table of entries into the .debug_addr section. */
4950 static GTY (()) hash_table
<addr_hasher
> *addr_index_table
;
4952 /* Hash an address_table_entry. */
4955 addr_hasher::hash (addr_table_entry
*a
)
4957 inchash::hash hstate
;
4963 case ate_kind_rtx_dtprel
:
4966 case ate_kind_label
:
4967 return htab_hash_string (a
->addr
.label
);
4971 inchash::add_rtx (a
->addr
.rtl
, hstate
);
4972 return hstate
.end ();
4975 /* Determine equality for two address_table_entries. */
4978 addr_hasher::equal (addr_table_entry
*a1
, addr_table_entry
*a2
)
4980 if (a1
->kind
!= a2
->kind
)
4985 case ate_kind_rtx_dtprel
:
4986 return rtx_equal_p (a1
->addr
.rtl
, a2
->addr
.rtl
);
4987 case ate_kind_label
:
4988 return strcmp (a1
->addr
.label
, a2
->addr
.label
) == 0;
4994 /* Initialize an addr_table_entry. */
4997 init_addr_table_entry (addr_table_entry
*e
, enum ate_kind kind
, void *addr
)
5003 case ate_kind_rtx_dtprel
:
5004 e
->addr
.rtl
= (rtx
) addr
;
5006 case ate_kind_label
:
5007 e
->addr
.label
= (char *) addr
;
5011 e
->index
= NO_INDEX_ASSIGNED
;
5014 /* Add attr to the address table entry to the table. Defer setting an
5015 index until output time. */
5017 static addr_table_entry
*
5018 add_addr_table_entry (void *addr
, enum ate_kind kind
)
5020 addr_table_entry
*node
;
5021 addr_table_entry finder
;
5023 gcc_assert (dwarf_split_debug_info
);
5024 if (! addr_index_table
)
5025 addr_index_table
= hash_table
<addr_hasher
>::create_ggc (10);
5026 init_addr_table_entry (&finder
, kind
, addr
);
5027 addr_table_entry
**slot
= addr_index_table
->find_slot (&finder
, INSERT
);
5029 if (*slot
== HTAB_EMPTY_ENTRY
)
5031 node
= ggc_cleared_alloc
<addr_table_entry
> ();
5032 init_addr_table_entry (node
, kind
, addr
);
5042 /* Remove an entry from the addr table by decrementing its refcount.
5043 Strictly, decrementing the refcount would be enough, but the
5044 assertion that the entry is actually in the table has found
5048 remove_addr_table_entry (addr_table_entry
*entry
)
5050 gcc_assert (dwarf_split_debug_info
&& addr_index_table
);
5051 /* After an index is assigned, the table is frozen. */
5052 gcc_assert (entry
->refcount
> 0 && entry
->index
== NO_INDEX_ASSIGNED
);
5056 /* Given a location list, remove all addresses it refers to from the
5060 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr
)
5062 for (; descr
; descr
= descr
->dw_loc_next
)
5063 if (descr
->dw_loc_oprnd1
.val_entry
!= NULL
)
5065 gcc_assert (descr
->dw_loc_oprnd1
.val_entry
->index
== NO_INDEX_ASSIGNED
);
5066 remove_addr_table_entry (descr
->dw_loc_oprnd1
.val_entry
);
5070 /* A helper function for dwarf2out_finish called through
5071 htab_traverse. Assign an addr_table_entry its index. All entries
5072 must be collected into the table when this function is called,
5073 because the indexing code relies on htab_traverse to traverse nodes
5074 in the same order for each run. */
5077 index_addr_table_entry (addr_table_entry
**h
, unsigned int *index
)
5079 addr_table_entry
*node
= *h
;
5081 /* Don't index unreferenced nodes. */
5082 if (node
->refcount
== 0)
5085 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
5086 node
->index
= *index
;
5092 /* Add an address constant attribute value to a DIE. When using
5093 dwarf_split_debug_info, address attributes in dies destined for the
5094 final executable should be direct references--setting the parameter
5095 force_direct ensures this behavior. */
5098 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
,
5103 attr
.dw_attr
= attr_kind
;
5104 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
5105 attr
.dw_attr_val
.v
.val_addr
= addr
;
5106 if (dwarf_split_debug_info
&& !force_direct
)
5107 attr
.dw_attr_val
.val_entry
= add_addr_table_entry (addr
, ate_kind_rtx
);
5109 attr
.dw_attr_val
.val_entry
= NULL
;
5110 add_dwarf_attr (die
, &attr
);
5113 /* Get the RTX from to an address DIE attribute. */
5116 AT_addr (dw_attr_node
*a
)
5118 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
5119 return a
->dw_attr_val
.v
.val_addr
;
5122 /* Add a file attribute value to a DIE. */
5125 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5126 struct dwarf_file_data
*fd
)
5130 attr
.dw_attr
= attr_kind
;
5131 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
5132 attr
.dw_attr_val
.val_entry
= NULL
;
5133 attr
.dw_attr_val
.v
.val_file
= fd
;
5134 add_dwarf_attr (die
, &attr
);
5137 /* Get the dwarf_file_data from a file DIE attribute. */
5139 static inline struct dwarf_file_data
*
5140 AT_file (dw_attr_node
*a
)
5142 gcc_assert (a
&& (AT_class (a
) == dw_val_class_file
5143 || AT_class (a
) == dw_val_class_file_implicit
));
5144 return a
->dw_attr_val
.v
.val_file
;
5147 /* Add a vms delta attribute value to a DIE. */
5150 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5151 const char *lbl1
, const char *lbl2
)
5155 attr
.dw_attr
= attr_kind
;
5156 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
5157 attr
.dw_attr_val
.val_entry
= NULL
;
5158 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
5159 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
5160 add_dwarf_attr (die
, &attr
);
5163 /* Add a symbolic view identifier attribute value to a DIE. */
5166 add_AT_symview (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5167 const char *view_label
)
5171 attr
.dw_attr
= attr_kind
;
5172 attr
.dw_attr_val
.val_class
= dw_val_class_symview
;
5173 attr
.dw_attr_val
.val_entry
= NULL
;
5174 attr
.dw_attr_val
.v
.val_symbolic_view
= xstrdup (view_label
);
5175 add_dwarf_attr (die
, &attr
);
5178 /* Add a label identifier attribute value to a DIE. */
5181 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5186 attr
.dw_attr
= attr_kind
;
5187 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
5188 attr
.dw_attr_val
.val_entry
= NULL
;
5189 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
5190 if (dwarf_split_debug_info
)
5191 attr
.dw_attr_val
.val_entry
5192 = add_addr_table_entry (attr
.dw_attr_val
.v
.val_lbl_id
,
5194 add_dwarf_attr (die
, &attr
);
5197 /* Add a section offset attribute value to a DIE, an offset into the
5198 debug_line section. */
5201 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5206 attr
.dw_attr
= attr_kind
;
5207 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
5208 attr
.dw_attr_val
.val_entry
= NULL
;
5209 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5210 add_dwarf_attr (die
, &attr
);
5213 /* Add a section offset attribute value to a DIE, an offset into the
5214 debug_macinfo section. */
5217 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5222 attr
.dw_attr
= attr_kind
;
5223 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
5224 attr
.dw_attr_val
.val_entry
= NULL
;
5225 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
5226 add_dwarf_attr (die
, &attr
);
5229 /* Add a range_list attribute value to a DIE. When using
5230 dwarf_split_debug_info, address attributes in dies destined for the
5231 final executable should be direct references--setting the parameter
5232 force_direct ensures this behavior. */
5234 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
5235 #define RELOCATED_OFFSET (NULL)
5238 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5239 long unsigned int offset
, bool force_direct
)
5243 attr
.dw_attr
= attr_kind
;
5244 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
5245 /* For the range_list attribute, use val_entry to store whether the
5246 offset should follow split-debug-info or normal semantics. This
5247 value is read in output_range_list_offset. */
5248 if (dwarf_split_debug_info
&& !force_direct
)
5249 attr
.dw_attr_val
.val_entry
= UNRELOCATED_OFFSET
;
5251 attr
.dw_attr_val
.val_entry
= RELOCATED_OFFSET
;
5252 attr
.dw_attr_val
.v
.val_offset
= offset
;
5253 add_dwarf_attr (die
, &attr
);
5256 /* Return the start label of a delta attribute. */
5258 static inline const char *
5259 AT_vms_delta1 (dw_attr_node
*a
)
5261 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5262 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
5265 /* Return the end label of a delta attribute. */
5267 static inline const char *
5268 AT_vms_delta2 (dw_attr_node
*a
)
5270 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5271 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
5274 static inline const char *
5275 AT_lbl (dw_attr_node
*a
)
5277 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
5278 || AT_class (a
) == dw_val_class_lineptr
5279 || AT_class (a
) == dw_val_class_macptr
5280 || AT_class (a
) == dw_val_class_loclistsptr
5281 || AT_class (a
) == dw_val_class_high_pc
));
5282 return a
->dw_attr_val
.v
.val_lbl_id
;
5285 /* Get the attribute of type attr_kind. */
5287 static dw_attr_node
*
5288 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5292 dw_die_ref spec
= NULL
;
5297 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5298 if (a
->dw_attr
== attr_kind
)
5300 else if (a
->dw_attr
== DW_AT_specification
5301 || a
->dw_attr
== DW_AT_abstract_origin
)
5305 return get_AT (spec
, attr_kind
);
5310 /* Returns the parent of the declaration of DIE. */
5313 get_die_parent (dw_die_ref die
)
5320 if ((t
= get_AT_ref (die
, DW_AT_abstract_origin
))
5321 || (t
= get_AT_ref (die
, DW_AT_specification
)))
5324 return die
->die_parent
;
5327 /* Return the "low pc" attribute value, typically associated with a subprogram
5328 DIE. Return null if the "low pc" attribute is either not present, or if it
5329 cannot be represented as an assembler label identifier. */
5331 static inline const char *
5332 get_AT_low_pc (dw_die_ref die
)
5334 dw_attr_node
*a
= get_AT (die
, DW_AT_low_pc
);
5336 return a
? AT_lbl (a
) : NULL
;
5339 /* Return the value of the string attribute designated by ATTR_KIND, or
5340 NULL if it is not present. */
5342 static inline const char *
5343 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5345 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5347 return a
? AT_string (a
) : NULL
;
5350 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5351 if it is not present. */
5354 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5356 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5358 return a
? AT_flag (a
) : 0;
5361 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5362 if it is not present. */
5364 static inline unsigned
5365 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5367 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5369 return a
? AT_unsigned (a
) : 0;
5372 static inline dw_die_ref
5373 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5375 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5377 return a
? AT_ref (a
) : NULL
;
5380 static inline struct dwarf_file_data
*
5381 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5383 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5385 return a
? AT_file (a
) : NULL
;
5388 /* Return TRUE if the language is C. */
5393 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5395 return (lang
== DW_LANG_C
|| lang
== DW_LANG_C89
|| lang
== DW_LANG_C99
5396 || lang
== DW_LANG_C11
|| lang
== DW_LANG_ObjC
);
5401 /* Return TRUE if the language is C++. */
5406 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5408 return (lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
5409 || lang
== DW_LANG_C_plus_plus_11
|| lang
== DW_LANG_C_plus_plus_14
);
5412 /* Return TRUE if DECL was created by the C++ frontend. */
5415 is_cxx (const_tree decl
)
5419 const_tree context
= get_ultimate_context (decl
);
5420 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5421 return strncmp (TRANSLATION_UNIT_LANGUAGE (context
), "GNU C++", 7) == 0;
5426 /* Return TRUE if the language is Fortran. */
5431 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5433 return (lang
== DW_LANG_Fortran77
5434 || lang
== DW_LANG_Fortran90
5435 || lang
== DW_LANG_Fortran95
5436 || lang
== DW_LANG_Fortran03
5437 || lang
== DW_LANG_Fortran08
);
5441 is_fortran (const_tree decl
)
5445 const_tree context
= get_ultimate_context (decl
);
5446 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5447 return (strncmp (TRANSLATION_UNIT_LANGUAGE (context
),
5448 "GNU Fortran", 11) == 0
5449 || strcmp (TRANSLATION_UNIT_LANGUAGE (context
),
5452 return is_fortran ();
5455 /* Return TRUE if the language is Ada. */
5460 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5462 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
5465 /* Return TRUE if the language is D. */
5470 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5472 return lang
== DW_LANG_D
;
5475 /* Remove the specified attribute if present. Return TRUE if removal
5479 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5487 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5488 if (a
->dw_attr
== attr_kind
)
5490 if (AT_class (a
) == dw_val_class_str
)
5491 if (a
->dw_attr_val
.v
.val_str
->refcount
)
5492 a
->dw_attr_val
.v
.val_str
->refcount
--;
5494 /* vec::ordered_remove should help reduce the number of abbrevs
5496 die
->die_attr
->ordered_remove (ix
);
5502 /* Remove CHILD from its parent. PREV must have the property that
5503 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
5506 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
5508 gcc_assert (child
->die_parent
== prev
->die_parent
);
5509 gcc_assert (prev
->die_sib
== child
);
5512 gcc_assert (child
->die_parent
->die_child
== child
);
5516 prev
->die_sib
= child
->die_sib
;
5517 if (child
->die_parent
->die_child
== child
)
5518 child
->die_parent
->die_child
= prev
;
5519 child
->die_sib
= NULL
;
5522 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
5523 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
5526 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
5528 dw_die_ref parent
= old_child
->die_parent
;
5530 gcc_assert (parent
== prev
->die_parent
);
5531 gcc_assert (prev
->die_sib
== old_child
);
5533 new_child
->die_parent
= parent
;
5534 if (prev
== old_child
)
5536 gcc_assert (parent
->die_child
== old_child
);
5537 new_child
->die_sib
= new_child
;
5541 prev
->die_sib
= new_child
;
5542 new_child
->die_sib
= old_child
->die_sib
;
5544 if (old_child
->die_parent
->die_child
== old_child
)
5545 old_child
->die_parent
->die_child
= new_child
;
5546 old_child
->die_sib
= NULL
;
5549 /* Move all children from OLD_PARENT to NEW_PARENT. */
5552 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
5555 new_parent
->die_child
= old_parent
->die_child
;
5556 old_parent
->die_child
= NULL
;
5557 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
5560 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
5564 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
5570 dw_die_ref prev
= c
;
5572 while (c
->die_tag
== tag
)
5574 remove_child_with_prev (c
, prev
);
5575 c
->die_parent
= NULL
;
5576 /* Might have removed every child. */
5577 if (die
->die_child
== NULL
)
5581 } while (c
!= die
->die_child
);
5584 /* Add a CHILD_DIE as the last child of DIE. */
5587 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
5589 /* FIXME this should probably be an assert. */
5590 if (! die
|| ! child_die
)
5592 gcc_assert (die
!= child_die
);
5594 child_die
->die_parent
= die
;
5597 child_die
->die_sib
= die
->die_child
->die_sib
;
5598 die
->die_child
->die_sib
= child_die
;
5601 child_die
->die_sib
= child_die
;
5602 die
->die_child
= child_die
;
5605 /* Like add_child_die, but put CHILD_DIE after AFTER_DIE. */
5608 add_child_die_after (dw_die_ref die
, dw_die_ref child_die
,
5609 dw_die_ref after_die
)
5615 && die
!= child_die
);
5617 child_die
->die_parent
= die
;
5618 child_die
->die_sib
= after_die
->die_sib
;
5619 after_die
->die_sib
= child_die
;
5620 if (die
->die_child
== after_die
)
5621 die
->die_child
= child_die
;
5624 /* Unassociate CHILD from its parent, and make its parent be
5628 reparent_child (dw_die_ref child
, dw_die_ref new_parent
)
5630 for (dw_die_ref p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
5631 if (p
->die_sib
== child
)
5633 remove_child_with_prev (child
, p
);
5636 add_child_die (new_parent
, child
);
5639 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5640 is the specification, to the end of PARENT's list of children.
5641 This is done by removing and re-adding it. */
5644 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
5646 /* We want the declaration DIE from inside the class, not the
5647 specification DIE at toplevel. */
5648 if (child
->die_parent
!= parent
)
5650 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5656 gcc_assert (child
->die_parent
== parent
5657 || (child
->die_parent
5658 == get_AT_ref (parent
, DW_AT_specification
)));
5660 reparent_child (child
, parent
);
5663 /* Create and return a new die with TAG_VALUE as tag. */
5665 static inline dw_die_ref
5666 new_die_raw (enum dwarf_tag tag_value
)
5668 dw_die_ref die
= ggc_cleared_alloc
<die_node
> ();
5669 die
->die_tag
= tag_value
;
5673 /* Create and return a new die with a parent of PARENT_DIE. If
5674 PARENT_DIE is NULL, the new DIE is placed in limbo and an
5675 associated tree T must be supplied to determine parenthood
5678 static inline dw_die_ref
5679 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5681 dw_die_ref die
= new_die_raw (tag_value
);
5683 if (parent_die
!= NULL
)
5684 add_child_die (parent_die
, die
);
5687 limbo_die_node
*limbo_node
;
5689 /* No DIEs created after early dwarf should end up in limbo,
5690 because the limbo list should not persist past LTO
5692 if (tag_value
!= DW_TAG_compile_unit
5693 /* These are allowed because they're generated while
5694 breaking out COMDAT units late. */
5695 && tag_value
!= DW_TAG_type_unit
5696 && tag_value
!= DW_TAG_skeleton_unit
5698 /* Allow nested functions to live in limbo because they will
5699 only temporarily live there, as decls_for_scope will fix
5701 && (TREE_CODE (t
) != FUNCTION_DECL
5702 || !decl_function_context (t
))
5703 /* Same as nested functions above but for types. Types that
5704 are local to a function will be fixed in
5706 && (!RECORD_OR_UNION_TYPE_P (t
)
5707 || !TYPE_CONTEXT (t
)
5708 || TREE_CODE (TYPE_CONTEXT (t
)) != FUNCTION_DECL
)
5709 /* FIXME debug-early: Allow late limbo DIE creation for LTO,
5710 especially in the ltrans stage, but once we implement LTO
5711 dwarf streaming, we should remove this exception. */
5714 fprintf (stderr
, "symbol ended up in limbo too late:");
5715 debug_generic_stmt (t
);
5719 limbo_node
= ggc_cleared_alloc
<limbo_die_node
> ();
5720 limbo_node
->die
= die
;
5721 limbo_node
->created_for
= t
;
5722 limbo_node
->next
= limbo_die_list
;
5723 limbo_die_list
= limbo_node
;
5729 /* Return the DIE associated with the given type specifier. */
5731 static inline dw_die_ref
5732 lookup_type_die (tree type
)
5734 dw_die_ref die
= TYPE_SYMTAB_DIE (type
);
5735 if (die
&& die
->removed
)
5737 TYPE_SYMTAB_DIE (type
) = NULL
;
5743 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
5744 anonymous type named by the typedef TYPE_DIE, return the DIE of the
5745 anonymous type instead the one of the naming typedef. */
5747 static inline dw_die_ref
5748 strip_naming_typedef (tree type
, dw_die_ref type_die
)
5751 && TREE_CODE (type
) == RECORD_TYPE
5753 && type_die
->die_tag
== DW_TAG_typedef
5754 && is_naming_typedef_decl (TYPE_NAME (type
)))
5755 type_die
= get_AT_ref (type_die
, DW_AT_type
);
5759 /* Like lookup_type_die, but if type is an anonymous type named by a
5760 typedef[1], return the DIE of the anonymous type instead the one of
5761 the naming typedef. This is because in gen_typedef_die, we did
5762 equate the anonymous struct named by the typedef with the DIE of
5763 the naming typedef. So by default, lookup_type_die on an anonymous
5764 struct yields the DIE of the naming typedef.
5766 [1]: Read the comment of is_naming_typedef_decl to learn about what
5767 a naming typedef is. */
5769 static inline dw_die_ref
5770 lookup_type_die_strip_naming_typedef (tree type
)
5772 dw_die_ref die
= lookup_type_die (type
);
5773 return strip_naming_typedef (type
, die
);
5776 /* Equate a DIE to a given type specifier. */
5779 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5781 TYPE_SYMTAB_DIE (type
) = type_die
;
5784 static dw_die_ref
maybe_create_die_with_external_ref (tree
);
5785 struct GTY(()) sym_off_pair
5787 const char * GTY((skip
)) sym
;
5788 unsigned HOST_WIDE_INT off
;
5790 static GTY(()) hash_map
<tree
, sym_off_pair
> *external_die_map
;
5792 /* Returns a hash value for X (which really is a die_struct). */
5795 decl_die_hasher::hash (die_node
*x
)
5797 return (hashval_t
) x
->decl_id
;
5800 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5803 decl_die_hasher::equal (die_node
*x
, tree y
)
5805 return (x
->decl_id
== DECL_UID (y
));
5808 /* Return the DIE associated with a given declaration. */
5810 static inline dw_die_ref
5811 lookup_decl_die (tree decl
)
5813 dw_die_ref
*die
= decl_die_table
->find_slot_with_hash (decl
, DECL_UID (decl
),
5818 return maybe_create_die_with_external_ref (decl
);
5821 if ((*die
)->removed
)
5823 decl_die_table
->clear_slot (die
);
5830 /* Return the DIE associated with BLOCK. */
5832 static inline dw_die_ref
5833 lookup_block_die (tree block
)
5835 dw_die_ref die
= BLOCK_DIE (block
);
5836 if (!die
&& in_lto_p
)
5837 return maybe_create_die_with_external_ref (block
);
5841 /* Associate DIE with BLOCK. */
5844 equate_block_to_die (tree block
, dw_die_ref die
)
5846 BLOCK_DIE (block
) = die
;
5851 /* For DECL which might have early dwarf output query a SYMBOL + OFFSET
5852 style reference. Return true if we found one refering to a DIE for
5853 DECL, otherwise return false. */
5856 dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
5857 unsigned HOST_WIDE_INT
*off
)
5863 /* During WPA stage and incremental linking we use a hash-map
5864 to store the decl <-> label + offset map. */
5865 if (!external_die_map
)
5867 sym_off_pair
*desc
= external_die_map
->get (decl
);
5875 if (TREE_CODE (decl
) == BLOCK
)
5876 die
= lookup_block_die (decl
);
5878 die
= lookup_decl_die (decl
);
5882 /* Similar to get_ref_die_offset_label, but using the "correct"
5884 *off
= die
->die_offset
;
5885 while (die
->die_parent
)
5886 die
= die
->die_parent
;
5887 /* For the containing CU DIE we compute a die_symbol in
5888 compute_comp_unit_symbol. */
5889 gcc_assert (die
->die_tag
== DW_TAG_compile_unit
5890 && die
->die_id
.die_symbol
!= NULL
);
5891 *sym
= die
->die_id
.die_symbol
;
5895 /* Add a reference of kind ATTR_KIND to a DIE at SYMBOL + OFFSET to DIE. */
5898 add_AT_external_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5899 const char *symbol
, HOST_WIDE_INT offset
)
5901 /* Create a fake DIE that contains the reference. Don't use
5902 new_die because we don't want to end up in the limbo list. */
5903 /* ??? We probably want to share these, thus put a ref to the DIE
5904 we create here to the external_die_map entry. */
5905 dw_die_ref ref
= new_die_raw (die
->die_tag
);
5906 ref
->die_id
.die_symbol
= symbol
;
5907 ref
->die_offset
= offset
;
5908 ref
->with_offset
= 1;
5909 add_AT_die_ref (die
, attr_kind
, ref
);
5912 /* Create a DIE for DECL if required and add a reference to a DIE
5913 at SYMBOL + OFFSET which contains attributes dumped early. */
5916 dwarf2out_register_external_die (tree decl
, const char *sym
,
5917 unsigned HOST_WIDE_INT off
)
5919 if (debug_info_level
== DINFO_LEVEL_NONE
)
5922 if (!external_die_map
)
5923 external_die_map
= hash_map
<tree
, sym_off_pair
>::create_ggc (1000);
5924 gcc_checking_assert (!external_die_map
->get (decl
));
5925 sym_off_pair p
= { IDENTIFIER_POINTER (get_identifier (sym
)), off
};
5926 external_die_map
->put (decl
, p
);
5929 /* If we have a registered external DIE for DECL return a new DIE for
5930 the concrete instance with an appropriate abstract origin. */
5933 maybe_create_die_with_external_ref (tree decl
)
5935 if (!external_die_map
)
5937 sym_off_pair
*desc
= external_die_map
->get (decl
);
5941 const char *sym
= desc
->sym
;
5942 unsigned HOST_WIDE_INT off
= desc
->off
;
5945 dw_die_ref die
= (TREE_CODE (decl
) == BLOCK
5946 ? lookup_block_die (decl
) : lookup_decl_die (decl
));
5951 dw_die_ref parent
= NULL
;
5952 /* Need to lookup a DIE for the decls context - the containing
5953 function or translation unit. */
5954 if (TREE_CODE (decl
) == BLOCK
)
5956 ctx
= BLOCK_SUPERCONTEXT (decl
);
5957 /* ??? We do not output DIEs for all scopes thus skip as
5958 many DIEs as needed. */
5959 while (TREE_CODE (ctx
) == BLOCK
5960 && !lookup_block_die (ctx
))
5961 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5964 ctx
= DECL_CONTEXT (decl
);
5965 /* Peel types in the context stack. */
5966 while (ctx
&& TYPE_P (ctx
))
5967 ctx
= TYPE_CONTEXT (ctx
);
5968 /* Likewise namespaces in case we do not want to emit DIEs for them. */
5969 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
5970 while (ctx
&& TREE_CODE (ctx
) == NAMESPACE_DECL
)
5971 ctx
= DECL_CONTEXT (ctx
);
5974 if (TREE_CODE (ctx
) == BLOCK
)
5975 parent
= lookup_block_die (ctx
);
5976 else if (TREE_CODE (ctx
) == TRANSLATION_UNIT_DECL
5977 /* Keep the 1:1 association during WPA. */
5979 && flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
5980 /* Otherwise all late annotations go to the main CU which
5981 imports the original CUs. */
5982 parent
= comp_unit_die ();
5983 else if (TREE_CODE (ctx
) == FUNCTION_DECL
5984 && TREE_CODE (decl
) != FUNCTION_DECL
5985 && TREE_CODE (decl
) != PARM_DECL
5986 && TREE_CODE (decl
) != RESULT_DECL
5987 && TREE_CODE (decl
) != BLOCK
)
5988 /* Leave function local entities parent determination to when
5989 we process scope vars. */
5992 parent
= lookup_decl_die (ctx
);
5995 /* In some cases the FEs fail to set DECL_CONTEXT properly.
5996 Handle this case gracefully by globalizing stuff. */
5997 parent
= comp_unit_die ();
5998 /* Create a DIE "stub". */
5999 switch (TREE_CODE (decl
))
6001 case TRANSLATION_UNIT_DECL
:
6003 die
= comp_unit_die ();
6004 /* We re-target all CU decls to the LTRANS CU DIE, so no need
6005 to create a DIE for the original CUs. */
6008 case NAMESPACE_DECL
:
6009 if (is_fortran (decl
))
6010 die
= new_die (DW_TAG_module
, parent
, decl
);
6012 die
= new_die (DW_TAG_namespace
, parent
, decl
);
6015 die
= new_die (DW_TAG_subprogram
, parent
, decl
);
6018 die
= new_die (DW_TAG_variable
, parent
, decl
);
6021 die
= new_die (DW_TAG_variable
, parent
, decl
);
6024 die
= new_die (DW_TAG_formal_parameter
, parent
, decl
);
6027 die
= new_die (DW_TAG_constant
, parent
, decl
);
6030 die
= new_die (DW_TAG_label
, parent
, decl
);
6033 die
= new_die (DW_TAG_lexical_block
, parent
, decl
);
6038 if (TREE_CODE (decl
) == BLOCK
)
6039 equate_block_to_die (decl
, die
);
6041 equate_decl_number_to_die (decl
, die
);
6043 add_desc_attribute (die
, decl
);
6045 /* Add a reference to the DIE providing early debug at $sym + off. */
6046 add_AT_external_die_ref (die
, DW_AT_abstract_origin
, sym
, off
);
6051 /* Returns a hash value for X (which really is a var_loc_list). */
6054 decl_loc_hasher::hash (var_loc_list
*x
)
6056 return (hashval_t
) x
->decl_id
;
6059 /* Return nonzero if decl_id of var_loc_list X is the same as
6063 decl_loc_hasher::equal (var_loc_list
*x
, const_tree y
)
6065 return (x
->decl_id
== DECL_UID (y
));
6068 /* Return the var_loc list associated with a given declaration. */
6070 static inline var_loc_list
*
6071 lookup_decl_loc (const_tree decl
)
6073 if (!decl_loc_table
)
6075 return decl_loc_table
->find_with_hash (decl
, DECL_UID (decl
));
6078 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
6081 dw_loc_list_hasher::hash (cached_dw_loc_list
*x
)
6083 return (hashval_t
) x
->decl_id
;
6086 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
6090 dw_loc_list_hasher::equal (cached_dw_loc_list
*x
, const_tree y
)
6092 return (x
->decl_id
== DECL_UID (y
));
6095 /* Equate a DIE to a particular declaration. */
6098 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
6100 unsigned int decl_id
= DECL_UID (decl
);
6102 *decl_die_table
->find_slot_with_hash (decl
, decl_id
, INSERT
) = decl_die
;
6103 decl_die
->decl_id
= decl_id
;
6106 /* Return how many bits covers PIECE EXPR_LIST. */
6108 static HOST_WIDE_INT
6109 decl_piece_bitsize (rtx piece
)
6111 int ret
= (int) GET_MODE (piece
);
6114 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
6115 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
6116 return INTVAL (XEXP (XEXP (piece
, 0), 0));
6119 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
6122 decl_piece_varloc_ptr (rtx piece
)
6124 if ((int) GET_MODE (piece
))
6125 return &XEXP (piece
, 0);
6127 return &XEXP (XEXP (piece
, 0), 1);
6130 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
6131 Next is the chain of following piece nodes. */
6133 static rtx_expr_list
*
6134 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
6136 if (bitsize
> 0 && bitsize
<= (int) MAX_MACHINE_MODE
)
6137 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
6139 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
6144 /* Return rtx that should be stored into loc field for
6145 LOC_NOTE and BITPOS/BITSIZE. */
6148 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
6149 HOST_WIDE_INT bitsize
)
6153 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
6155 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
6160 /* This function either modifies location piece list *DEST in
6161 place (if SRC and INNER is NULL), or copies location piece list
6162 *SRC to *DEST while modifying it. Location BITPOS is modified
6163 to contain LOC_NOTE, any pieces overlapping it are removed resp.
6164 not copied and if needed some padding around it is added.
6165 When modifying in place, DEST should point to EXPR_LIST where
6166 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
6167 to the start of the whole list and INNER points to the EXPR_LIST
6168 where earlier pieces cover PIECE_BITPOS bits. */
6171 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
6172 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
6173 HOST_WIDE_INT bitsize
, rtx loc_note
)
6176 bool copy
= inner
!= NULL
;
6180 /* First copy all nodes preceding the current bitpos. */
6181 while (src
!= inner
)
6183 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
6184 decl_piece_bitsize (*src
), NULL_RTX
);
6185 dest
= &XEXP (*dest
, 1);
6186 src
= &XEXP (*src
, 1);
6189 /* Add padding if needed. */
6190 if (bitpos
!= piece_bitpos
)
6192 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
6193 copy
? NULL_RTX
: *dest
);
6194 dest
= &XEXP (*dest
, 1);
6196 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
6199 /* A piece with correct bitpos and bitsize already exist,
6200 just update the location for it and return. */
6201 *decl_piece_varloc_ptr (*dest
) = loc_note
;
6204 /* Add the piece that changed. */
6205 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
6206 dest
= &XEXP (*dest
, 1);
6207 /* Skip over pieces that overlap it. */
6208 diff
= bitpos
- piece_bitpos
+ bitsize
;
6211 while (diff
> 0 && *src
)
6214 diff
-= decl_piece_bitsize (piece
);
6216 src
= &XEXP (piece
, 1);
6219 *src
= XEXP (piece
, 1);
6220 free_EXPR_LIST_node (piece
);
6223 /* Add padding if needed. */
6224 if (diff
< 0 && *src
)
6228 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
6229 dest
= &XEXP (*dest
, 1);
6233 /* Finally copy all nodes following it. */
6236 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
6237 decl_piece_bitsize (*src
), NULL_RTX
);
6238 dest
= &XEXP (*dest
, 1);
6239 src
= &XEXP (*src
, 1);
6243 /* Add a variable location node to the linked list for DECL. */
6245 static struct var_loc_node
*
6246 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
, var_loc_view view
)
6248 unsigned int decl_id
;
6250 struct var_loc_node
*loc
= NULL
;
6251 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
6253 if (VAR_P (decl
) && DECL_HAS_DEBUG_EXPR_P (decl
))
6255 tree realdecl
= DECL_DEBUG_EXPR (decl
);
6256 if (handled_component_p (realdecl
)
6257 || (TREE_CODE (realdecl
) == MEM_REF
6258 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
6261 tree innerdecl
= get_ref_base_and_extent_hwi (realdecl
, &bitpos
,
6262 &bitsize
, &reverse
);
6264 || !DECL_P (innerdecl
)
6265 || DECL_IGNORED_P (innerdecl
)
6266 || TREE_STATIC (innerdecl
)
6268 || bitpos
+ bitsize
> 256)
6274 decl_id
= DECL_UID (decl
);
6276 = decl_loc_table
->find_slot_with_hash (decl
, decl_id
, INSERT
);
6279 temp
= ggc_cleared_alloc
<var_loc_list
> ();
6280 temp
->decl_id
= decl_id
;
6286 /* For PARM_DECLs try to keep around the original incoming value,
6287 even if that means we'll emit a zero-range .debug_loc entry. */
6289 && temp
->first
== temp
->last
6290 && TREE_CODE (decl
) == PARM_DECL
6291 && NOTE_P (temp
->first
->loc
)
6292 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
6293 && DECL_INCOMING_RTL (decl
)
6294 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
6295 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
6296 == GET_CODE (DECL_INCOMING_RTL (decl
))
6297 && prev_real_insn (as_a
<rtx_insn
*> (temp
->first
->loc
)) == NULL_RTX
6299 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
6300 NOTE_VAR_LOCATION_LOC (loc_note
))
6301 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
6302 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
6304 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6305 temp
->first
->next
= loc
;
6307 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6309 else if (temp
->last
)
6311 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
6312 rtx
*piece_loc
= NULL
, last_loc_note
;
6313 HOST_WIDE_INT piece_bitpos
= 0;
6317 gcc_assert (last
->next
== NULL
);
6319 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
6321 piece_loc
= &last
->loc
;
6324 HOST_WIDE_INT cur_bitsize
= decl_piece_bitsize (*piece_loc
);
6325 if (piece_bitpos
+ cur_bitsize
> bitpos
)
6327 piece_bitpos
+= cur_bitsize
;
6328 piece_loc
= &XEXP (*piece_loc
, 1);
6332 /* TEMP->LAST here is either pointer to the last but one or
6333 last element in the chained list, LAST is pointer to the
6335 if (label
&& strcmp (last
->label
, label
) == 0 && last
->view
== view
)
6337 /* For SRA optimized variables if there weren't any real
6338 insns since last note, just modify the last node. */
6339 if (piece_loc
!= NULL
)
6341 adjust_piece_list (piece_loc
, NULL
, NULL
,
6342 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6345 /* If the last note doesn't cover any instructions, remove it. */
6346 if (temp
->last
!= last
)
6348 temp
->last
->next
= NULL
;
6351 gcc_assert (strcmp (last
->label
, label
) != 0 || last
->view
!= view
);
6355 gcc_assert (temp
->first
== temp
->last
6356 || (temp
->first
->next
== temp
->last
6357 && TREE_CODE (decl
) == PARM_DECL
));
6358 memset (temp
->last
, '\0', sizeof (*temp
->last
));
6359 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6363 if (bitsize
== -1 && NOTE_P (last
->loc
))
6364 last_loc_note
= last
->loc
;
6365 else if (piece_loc
!= NULL
6366 && *piece_loc
!= NULL_RTX
6367 && piece_bitpos
== bitpos
6368 && decl_piece_bitsize (*piece_loc
) == bitsize
)
6369 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
6371 last_loc_note
= NULL_RTX
;
6372 /* If the current location is the same as the end of the list,
6373 and either both or neither of the locations is uninitialized,
6374 we have nothing to do. */
6375 if (last_loc_note
== NULL_RTX
6376 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
6377 NOTE_VAR_LOCATION_LOC (loc_note
)))
6378 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6379 != NOTE_VAR_LOCATION_STATUS (loc_note
))
6380 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6381 == VAR_INIT_STATUS_UNINITIALIZED
)
6382 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
6383 == VAR_INIT_STATUS_UNINITIALIZED
))))
6385 /* Add LOC to the end of list and update LAST. If the last
6386 element of the list has been removed above, reuse its
6387 memory for the new node, otherwise allocate a new one. */
6391 memset (loc
, '\0', sizeof (*loc
));
6394 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6395 if (bitsize
== -1 || piece_loc
== NULL
)
6396 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6398 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
6399 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6401 /* Ensure TEMP->LAST will point either to the new last but one
6402 element of the chain, or to the last element in it. */
6403 if (last
!= temp
->last
)
6411 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6414 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6419 /* Keep track of the number of spaces used to indent the
6420 output of the debugging routines that print the structure of
6421 the DIE internal representation. */
6422 static int print_indent
;
6424 /* Indent the line the number of spaces given by print_indent. */
6427 print_spaces (FILE *outfile
)
6429 fprintf (outfile
, "%*s", print_indent
, "");
6432 /* Print a type signature in hex. */
6435 print_signature (FILE *outfile
, char *sig
)
6439 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
6440 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
6444 print_discr_value (FILE *outfile
, dw_discr_value
*discr_value
)
6446 if (discr_value
->pos
)
6447 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, discr_value
->v
.sval
);
6449 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, discr_value
->v
.uval
);
6452 static void print_loc_descr (dw_loc_descr_ref
, FILE *);
6454 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
6455 RECURSE, output location descriptor operations. */
6458 print_dw_val (dw_val_node
*val
, bool recurse
, FILE *outfile
)
6460 switch (val
->val_class
)
6462 case dw_val_class_addr
:
6463 fprintf (outfile
, "address");
6465 case dw_val_class_offset
:
6466 fprintf (outfile
, "offset");
6468 case dw_val_class_loc
:
6469 fprintf (outfile
, "location descriptor");
6470 if (val
->v
.val_loc
== NULL
)
6471 fprintf (outfile
, " -> <null>\n");
6474 fprintf (outfile
, ":\n");
6476 print_loc_descr (val
->v
.val_loc
, outfile
);
6481 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6482 fprintf (outfile
, " #\n");
6484 fprintf (outfile
, " (%p)\n", (void *) val
->v
.val_loc
);
6487 case dw_val_class_loc_list
:
6488 fprintf (outfile
, "location list -> label:%s",
6489 val
->v
.val_loc_list
->ll_symbol
);
6491 case dw_val_class_view_list
:
6492 val
= view_list_to_loc_list_val_node (val
);
6493 fprintf (outfile
, "location list with views -> labels:%s and %s",
6494 val
->v
.val_loc_list
->ll_symbol
,
6495 val
->v
.val_loc_list
->vl_symbol
);
6497 case dw_val_class_range_list
:
6498 fprintf (outfile
, "range list");
6500 case dw_val_class_const
:
6501 case dw_val_class_const_implicit
:
6502 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, val
->v
.val_int
);
6504 case dw_val_class_unsigned_const
:
6505 case dw_val_class_unsigned_const_implicit
:
6506 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, val
->v
.val_unsigned
);
6508 case dw_val_class_const_double
:
6509 fprintf (outfile
, "constant (" HOST_WIDE_INT_PRINT_DEC
","\
6510 HOST_WIDE_INT_PRINT_UNSIGNED
")",
6511 val
->v
.val_double
.high
,
6512 val
->v
.val_double
.low
);
6514 case dw_val_class_wide_int
:
6516 int i
= val
->v
.val_wide
->get_len ();
6517 fprintf (outfile
, "constant (");
6519 if (val
->v
.val_wide
->elt (i
- 1) == 0)
6520 fprintf (outfile
, "0x");
6521 fprintf (outfile
, HOST_WIDE_INT_PRINT_HEX
,
6522 val
->v
.val_wide
->elt (--i
));
6524 fprintf (outfile
, HOST_WIDE_INT_PRINT_PADDED_HEX
,
6525 val
->v
.val_wide
->elt (i
));
6526 fprintf (outfile
, ")");
6529 case dw_val_class_vec
:
6530 fprintf (outfile
, "floating-point or vector constant");
6532 case dw_val_class_flag
:
6533 fprintf (outfile
, "%u", val
->v
.val_flag
);
6535 case dw_val_class_die_ref
:
6536 if (val
->v
.val_die_ref
.die
!= NULL
)
6538 dw_die_ref die
= val
->v
.val_die_ref
.die
;
6540 if (die
->comdat_type_p
)
6542 fprintf (outfile
, "die -> signature: ");
6543 print_signature (outfile
,
6544 die
->die_id
.die_type_node
->signature
);
6546 else if (die
->die_id
.die_symbol
)
6548 fprintf (outfile
, "die -> label: %s", die
->die_id
.die_symbol
);
6549 if (die
->with_offset
)
6550 fprintf (outfile
, " + %ld", die
->die_offset
);
6553 fprintf (outfile
, "die -> %ld", die
->die_offset
);
6554 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6555 fprintf (outfile
, " #");
6557 fprintf (outfile
, " (%p)", (void *) die
);
6560 fprintf (outfile
, "die -> <null>");
6562 case dw_val_class_vms_delta
:
6563 fprintf (outfile
, "delta: @slotcount(%s-%s)",
6564 val
->v
.val_vms_delta
.lbl2
, val
->v
.val_vms_delta
.lbl1
);
6566 case dw_val_class_symview
:
6567 fprintf (outfile
, "view: %s", val
->v
.val_symbolic_view
);
6569 case dw_val_class_lbl_id
:
6570 case dw_val_class_lineptr
:
6571 case dw_val_class_macptr
:
6572 case dw_val_class_loclistsptr
:
6573 case dw_val_class_high_pc
:
6574 fprintf (outfile
, "label: %s", val
->v
.val_lbl_id
);
6576 case dw_val_class_str
:
6577 if (val
->v
.val_str
->str
!= NULL
)
6578 fprintf (outfile
, "\"%s\"", val
->v
.val_str
->str
);
6580 fprintf (outfile
, "<null>");
6582 case dw_val_class_file
:
6583 case dw_val_class_file_implicit
:
6584 fprintf (outfile
, "\"%s\" (%d)", val
->v
.val_file
->filename
,
6585 val
->v
.val_file
->emitted_number
);
6587 case dw_val_class_data8
:
6591 for (i
= 0; i
< 8; i
++)
6592 fprintf (outfile
, "%02x", val
->v
.val_data8
[i
]);
6595 case dw_val_class_discr_value
:
6596 print_discr_value (outfile
, &val
->v
.val_discr_value
);
6598 case dw_val_class_discr_list
:
6599 for (dw_discr_list_ref node
= val
->v
.val_discr_list
;
6601 node
= node
->dw_discr_next
)
6603 if (node
->dw_discr_range
)
6605 fprintf (outfile
, " .. ");
6606 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6607 print_discr_value (outfile
, &node
->dw_discr_upper_bound
);
6610 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6612 if (node
->dw_discr_next
!= NULL
)
6613 fprintf (outfile
, " | ");
6620 /* Likewise, for a DIE attribute. */
6623 print_attribute (dw_attr_node
*a
, bool recurse
, FILE *outfile
)
6625 print_dw_val (&a
->dw_attr_val
, recurse
, outfile
);
6629 /* Print the list of operands in the LOC location description to OUTFILE. This
6630 routine is a debugging aid only. */
6633 print_loc_descr (dw_loc_descr_ref loc
, FILE *outfile
)
6635 dw_loc_descr_ref l
= loc
;
6639 print_spaces (outfile
);
6640 fprintf (outfile
, "<null>\n");
6644 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
6646 print_spaces (outfile
);
6647 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6648 fprintf (outfile
, "#");
6650 fprintf (outfile
, "(%p)", (void *) l
);
6651 fprintf (outfile
, " %s",
6652 dwarf_stack_op_name (l
->dw_loc_opc
));
6653 if (l
->dw_loc_oprnd1
.val_class
!= dw_val_class_none
)
6655 fprintf (outfile
, " ");
6656 print_dw_val (&l
->dw_loc_oprnd1
, false, outfile
);
6658 if (l
->dw_loc_oprnd2
.val_class
!= dw_val_class_none
)
6660 fprintf (outfile
, ", ");
6661 print_dw_val (&l
->dw_loc_oprnd2
, false, outfile
);
6663 fprintf (outfile
, "\n");
6667 /* Print the information associated with a given DIE, and its children.
6668 This routine is a debugging aid only. */
6671 print_die (dw_die_ref die
, FILE *outfile
)
6677 print_spaces (outfile
);
6678 fprintf (outfile
, "DIE %4ld: %s ",
6679 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
6680 if (flag_dump_noaddr
|| flag_dump_unnumbered
)
6681 fprintf (outfile
, "#\n");
6683 fprintf (outfile
, "(%p)\n", (void*) die
);
6684 print_spaces (outfile
);
6685 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
6686 fprintf (outfile
, " offset: %ld", die
->die_offset
);
6687 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
6689 if (die
->comdat_type_p
)
6691 print_spaces (outfile
);
6692 fprintf (outfile
, " signature: ");
6693 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
6694 fprintf (outfile
, "\n");
6697 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6699 print_spaces (outfile
);
6700 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
6702 print_attribute (a
, true, outfile
);
6703 fprintf (outfile
, "\n");
6706 if (die
->die_child
!= NULL
)
6709 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
6712 if (print_indent
== 0)
6713 fprintf (outfile
, "\n");
6716 /* Print the list of operations in the LOC location description. */
6719 debug_dwarf_loc_descr (dw_loc_descr_ref loc
)
6721 print_loc_descr (loc
, stderr
);
6724 /* Print the information collected for a given DIE. */
6727 debug_dwarf_die (dw_die_ref die
)
6729 print_die (die
, stderr
);
6733 debug (die_struct
&ref
)
6735 print_die (&ref
, stderr
);
6739 debug (die_struct
*ptr
)
6744 fprintf (stderr
, "<nil>\n");
6748 /* Print all DWARF information collected for the compilation unit.
6749 This routine is a debugging aid only. */
6755 print_die (comp_unit_die (), stderr
);
6758 /* Verify the DIE tree structure. */
6761 verify_die (dw_die_ref die
)
6763 gcc_assert (!die
->die_mark
);
6764 if (die
->die_parent
== NULL
6765 && die
->die_sib
== NULL
)
6767 /* Verify the die_sib list is cyclic. */
6774 while (x
&& !x
->die_mark
);
6775 gcc_assert (x
== die
);
6779 /* Verify all dies have the same parent. */
6780 gcc_assert (x
->die_parent
== die
->die_parent
);
6783 /* Verify the child has the proper parent and recurse. */
6784 gcc_assert (x
->die_child
->die_parent
== x
);
6785 verify_die (x
->die_child
);
6790 while (x
&& x
->die_mark
);
6793 /* Sanity checks on DIEs. */
6796 check_die (dw_die_ref die
)
6800 bool inline_found
= false;
6801 int n_location
= 0, n_low_pc
= 0, n_high_pc
= 0, n_artificial
= 0;
6802 int n_decl_line
= 0, n_decl_column
= 0, n_decl_file
= 0;
6803 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6808 if (a
->dw_attr_val
.v
.val_unsigned
)
6809 inline_found
= true;
6811 case DW_AT_location
:
6820 case DW_AT_artificial
:
6823 case DW_AT_decl_column
:
6826 case DW_AT_decl_line
:
6829 case DW_AT_decl_file
:
6836 if (n_location
> 1 || n_low_pc
> 1 || n_high_pc
> 1 || n_artificial
> 1
6837 || n_decl_column
> 1 || n_decl_line
> 1 || n_decl_file
> 1)
6839 fprintf (stderr
, "Duplicate attributes in DIE:\n");
6840 debug_dwarf_die (die
);
6845 /* A debugging information entry that is a member of an abstract
6846 instance tree [that has DW_AT_inline] should not contain any
6847 attributes which describe aspects of the subroutine which vary
6848 between distinct inlined expansions or distinct out-of-line
6850 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6851 gcc_assert (a
->dw_attr
!= DW_AT_low_pc
6852 && a
->dw_attr
!= DW_AT_high_pc
6853 && a
->dw_attr
!= DW_AT_location
6854 && a
->dw_attr
!= DW_AT_frame_base
6855 && a
->dw_attr
!= DW_AT_call_all_calls
6856 && a
->dw_attr
!= DW_AT_GNU_all_call_sites
);
6860 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6861 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6862 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
6864 /* Calculate the checksum of a location expression. */
6867 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
6870 inchash::hash hstate
;
6873 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
6875 hash_loc_operands (loc
, hstate
);
6876 hash
= hstate
.end();
6880 /* Calculate the checksum of an attribute. */
6883 attr_checksum (dw_attr_node
*at
, struct md5_ctx
*ctx
, int *mark
)
6885 dw_loc_descr_ref loc
;
6888 CHECKSUM (at
->dw_attr
);
6890 /* We don't care that this was compiled with a different compiler
6891 snapshot; if the output is the same, that's what matters. */
6892 if (at
->dw_attr
== DW_AT_producer
)
6895 switch (AT_class (at
))
6897 case dw_val_class_const
:
6898 case dw_val_class_const_implicit
:
6899 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
6901 case dw_val_class_unsigned_const
:
6902 case dw_val_class_unsigned_const_implicit
:
6903 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
6905 case dw_val_class_const_double
:
6906 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
6908 case dw_val_class_wide_int
:
6909 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
6910 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
6911 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
6913 case dw_val_class_vec
:
6914 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
6915 (at
->dw_attr_val
.v
.val_vec
.length
6916 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
6918 case dw_val_class_flag
:
6919 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
6921 case dw_val_class_str
:
6922 CHECKSUM_STRING (AT_string (at
));
6925 case dw_val_class_addr
:
6927 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
6928 CHECKSUM_STRING (XSTR (r
, 0));
6931 case dw_val_class_offset
:
6932 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
6935 case dw_val_class_loc
:
6936 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
6937 loc_checksum (loc
, ctx
);
6940 case dw_val_class_die_ref
:
6941 die_checksum (AT_ref (at
), ctx
, mark
);
6944 case dw_val_class_fde_ref
:
6945 case dw_val_class_vms_delta
:
6946 case dw_val_class_symview
:
6947 case dw_val_class_lbl_id
:
6948 case dw_val_class_lineptr
:
6949 case dw_val_class_macptr
:
6950 case dw_val_class_loclistsptr
:
6951 case dw_val_class_high_pc
:
6954 case dw_val_class_file
:
6955 case dw_val_class_file_implicit
:
6956 CHECKSUM_STRING (AT_file (at
)->filename
);
6959 case dw_val_class_data8
:
6960 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
6968 /* Calculate the checksum of a DIE. */
6971 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6977 /* To avoid infinite recursion. */
6980 CHECKSUM (die
->die_mark
);
6983 die
->die_mark
= ++(*mark
);
6985 CHECKSUM (die
->die_tag
);
6987 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6988 attr_checksum (a
, ctx
, mark
);
6990 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
6994 #undef CHECKSUM_BLOCK
6995 #undef CHECKSUM_STRING
6997 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
6998 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6999 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
7000 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
7001 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
7002 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
7003 #define CHECKSUM_ATTR(FOO) \
7004 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
7006 /* Calculate the checksum of a number in signed LEB128 format. */
7009 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
7016 byte
= (value
& 0x7f);
7018 more
= !((value
== 0 && (byte
& 0x40) == 0)
7019 || (value
== -1 && (byte
& 0x40) != 0));
7028 /* Calculate the checksum of a number in unsigned LEB128 format. */
7031 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
7035 unsigned char byte
= (value
& 0x7f);
7038 /* More bytes to follow. */
7046 /* Checksum the context of the DIE. This adds the names of any
7047 surrounding namespaces or structures to the checksum. */
7050 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
7054 int tag
= die
->die_tag
;
7056 if (tag
!= DW_TAG_namespace
7057 && tag
!= DW_TAG_structure_type
7058 && tag
!= DW_TAG_class_type
)
7061 name
= get_AT_string (die
, DW_AT_name
);
7063 spec
= get_AT_ref (die
, DW_AT_specification
);
7067 if (die
->die_parent
!= NULL
)
7068 checksum_die_context (die
->die_parent
, ctx
);
7070 CHECKSUM_ULEB128 ('C');
7071 CHECKSUM_ULEB128 (tag
);
7073 CHECKSUM_STRING (name
);
7076 /* Calculate the checksum of a location expression. */
7079 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
7081 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
7082 were emitted as a DW_FORM_sdata instead of a location expression. */
7083 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
7085 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7086 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
7090 /* Otherwise, just checksum the raw location expression. */
7093 inchash::hash hstate
;
7096 CHECKSUM_ULEB128 (loc
->dtprel
);
7097 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
7098 hash_loc_operands (loc
, hstate
);
7099 hash
= hstate
.end ();
7101 loc
= loc
->dw_loc_next
;
7105 /* Calculate the checksum of an attribute. */
7108 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_node
*at
,
7109 struct md5_ctx
*ctx
, int *mark
)
7111 dw_loc_descr_ref loc
;
7114 if (AT_class (at
) == dw_val_class_die_ref
)
7116 dw_die_ref target_die
= AT_ref (at
);
7118 /* For pointer and reference types, we checksum only the (qualified)
7119 name of the target type (if there is a name). For friend entries,
7120 we checksum only the (qualified) name of the target type or function.
7121 This allows the checksum to remain the same whether the target type
7122 is complete or not. */
7123 if ((at
->dw_attr
== DW_AT_type
7124 && (tag
== DW_TAG_pointer_type
7125 || tag
== DW_TAG_reference_type
7126 || tag
== DW_TAG_rvalue_reference_type
7127 || tag
== DW_TAG_ptr_to_member_type
))
7128 || (at
->dw_attr
== DW_AT_friend
7129 && tag
== DW_TAG_friend
))
7131 dw_attr_node
*name_attr
= get_AT (target_die
, DW_AT_name
);
7133 if (name_attr
!= NULL
)
7135 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
7139 CHECKSUM_ULEB128 ('N');
7140 CHECKSUM_ULEB128 (at
->dw_attr
);
7141 if (decl
->die_parent
!= NULL
)
7142 checksum_die_context (decl
->die_parent
, ctx
);
7143 CHECKSUM_ULEB128 ('E');
7144 CHECKSUM_STRING (AT_string (name_attr
));
7149 /* For all other references to another DIE, we check to see if the
7150 target DIE has already been visited. If it has, we emit a
7151 backward reference; if not, we descend recursively. */
7152 if (target_die
->die_mark
> 0)
7154 CHECKSUM_ULEB128 ('R');
7155 CHECKSUM_ULEB128 (at
->dw_attr
);
7156 CHECKSUM_ULEB128 (target_die
->die_mark
);
7160 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
7164 target_die
->die_mark
= ++(*mark
);
7165 CHECKSUM_ULEB128 ('T');
7166 CHECKSUM_ULEB128 (at
->dw_attr
);
7167 if (decl
->die_parent
!= NULL
)
7168 checksum_die_context (decl
->die_parent
, ctx
);
7169 die_checksum_ordered (target_die
, ctx
, mark
);
7174 CHECKSUM_ULEB128 ('A');
7175 CHECKSUM_ULEB128 (at
->dw_attr
);
7177 switch (AT_class (at
))
7179 case dw_val_class_const
:
7180 case dw_val_class_const_implicit
:
7181 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7182 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
7185 case dw_val_class_unsigned_const
:
7186 case dw_val_class_unsigned_const_implicit
:
7187 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7188 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
7191 case dw_val_class_const_double
:
7192 CHECKSUM_ULEB128 (DW_FORM_block
);
7193 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
7194 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
7197 case dw_val_class_wide_int
:
7198 CHECKSUM_ULEB128 (DW_FORM_block
);
7199 CHECKSUM_ULEB128 (get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7200 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
7201 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
7202 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
7203 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
7206 case dw_val_class_vec
:
7207 CHECKSUM_ULEB128 (DW_FORM_block
);
7208 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_vec
.length
7209 * at
->dw_attr_val
.v
.val_vec
.elt_size
);
7210 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
7211 (at
->dw_attr_val
.v
.val_vec
.length
7212 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
7215 case dw_val_class_flag
:
7216 CHECKSUM_ULEB128 (DW_FORM_flag
);
7217 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
7220 case dw_val_class_str
:
7221 CHECKSUM_ULEB128 (DW_FORM_string
);
7222 CHECKSUM_STRING (AT_string (at
));
7225 case dw_val_class_addr
:
7227 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
7228 CHECKSUM_ULEB128 (DW_FORM_string
);
7229 CHECKSUM_STRING (XSTR (r
, 0));
7232 case dw_val_class_offset
:
7233 CHECKSUM_ULEB128 (DW_FORM_sdata
);
7234 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
7237 case dw_val_class_loc
:
7238 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
7239 loc_checksum_ordered (loc
, ctx
);
7242 case dw_val_class_fde_ref
:
7243 case dw_val_class_symview
:
7244 case dw_val_class_lbl_id
:
7245 case dw_val_class_lineptr
:
7246 case dw_val_class_macptr
:
7247 case dw_val_class_loclistsptr
:
7248 case dw_val_class_high_pc
:
7251 case dw_val_class_file
:
7252 case dw_val_class_file_implicit
:
7253 CHECKSUM_ULEB128 (DW_FORM_string
);
7254 CHECKSUM_STRING (AT_file (at
)->filename
);
7257 case dw_val_class_data8
:
7258 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
7266 struct checksum_attributes
7268 dw_attr_node
*at_name
;
7269 dw_attr_node
*at_type
;
7270 dw_attr_node
*at_friend
;
7271 dw_attr_node
*at_accessibility
;
7272 dw_attr_node
*at_address_class
;
7273 dw_attr_node
*at_alignment
;
7274 dw_attr_node
*at_allocated
;
7275 dw_attr_node
*at_artificial
;
7276 dw_attr_node
*at_associated
;
7277 dw_attr_node
*at_binary_scale
;
7278 dw_attr_node
*at_bit_offset
;
7279 dw_attr_node
*at_bit_size
;
7280 dw_attr_node
*at_bit_stride
;
7281 dw_attr_node
*at_byte_size
;
7282 dw_attr_node
*at_byte_stride
;
7283 dw_attr_node
*at_const_value
;
7284 dw_attr_node
*at_containing_type
;
7285 dw_attr_node
*at_count
;
7286 dw_attr_node
*at_data_location
;
7287 dw_attr_node
*at_data_member_location
;
7288 dw_attr_node
*at_decimal_scale
;
7289 dw_attr_node
*at_decimal_sign
;
7290 dw_attr_node
*at_default_value
;
7291 dw_attr_node
*at_digit_count
;
7292 dw_attr_node
*at_discr
;
7293 dw_attr_node
*at_discr_list
;
7294 dw_attr_node
*at_discr_value
;
7295 dw_attr_node
*at_encoding
;
7296 dw_attr_node
*at_endianity
;
7297 dw_attr_node
*at_explicit
;
7298 dw_attr_node
*at_is_optional
;
7299 dw_attr_node
*at_location
;
7300 dw_attr_node
*at_lower_bound
;
7301 dw_attr_node
*at_mutable
;
7302 dw_attr_node
*at_ordering
;
7303 dw_attr_node
*at_picture_string
;
7304 dw_attr_node
*at_prototyped
;
7305 dw_attr_node
*at_small
;
7306 dw_attr_node
*at_segment
;
7307 dw_attr_node
*at_string_length
;
7308 dw_attr_node
*at_string_length_bit_size
;
7309 dw_attr_node
*at_string_length_byte_size
;
7310 dw_attr_node
*at_threads_scaled
;
7311 dw_attr_node
*at_upper_bound
;
7312 dw_attr_node
*at_use_location
;
7313 dw_attr_node
*at_use_UTF8
;
7314 dw_attr_node
*at_variable_parameter
;
7315 dw_attr_node
*at_virtuality
;
7316 dw_attr_node
*at_visibility
;
7317 dw_attr_node
*at_vtable_elem_location
;
7320 /* Collect the attributes that we will want to use for the checksum. */
7323 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
7328 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7339 attrs
->at_friend
= a
;
7341 case DW_AT_accessibility
:
7342 attrs
->at_accessibility
= a
;
7344 case DW_AT_address_class
:
7345 attrs
->at_address_class
= a
;
7347 case DW_AT_alignment
:
7348 attrs
->at_alignment
= a
;
7350 case DW_AT_allocated
:
7351 attrs
->at_allocated
= a
;
7353 case DW_AT_artificial
:
7354 attrs
->at_artificial
= a
;
7356 case DW_AT_associated
:
7357 attrs
->at_associated
= a
;
7359 case DW_AT_binary_scale
:
7360 attrs
->at_binary_scale
= a
;
7362 case DW_AT_bit_offset
:
7363 attrs
->at_bit_offset
= a
;
7365 case DW_AT_bit_size
:
7366 attrs
->at_bit_size
= a
;
7368 case DW_AT_bit_stride
:
7369 attrs
->at_bit_stride
= a
;
7371 case DW_AT_byte_size
:
7372 attrs
->at_byte_size
= a
;
7374 case DW_AT_byte_stride
:
7375 attrs
->at_byte_stride
= a
;
7377 case DW_AT_const_value
:
7378 attrs
->at_const_value
= a
;
7380 case DW_AT_containing_type
:
7381 attrs
->at_containing_type
= a
;
7384 attrs
->at_count
= a
;
7386 case DW_AT_data_location
:
7387 attrs
->at_data_location
= a
;
7389 case DW_AT_data_member_location
:
7390 attrs
->at_data_member_location
= a
;
7392 case DW_AT_decimal_scale
:
7393 attrs
->at_decimal_scale
= a
;
7395 case DW_AT_decimal_sign
:
7396 attrs
->at_decimal_sign
= a
;
7398 case DW_AT_default_value
:
7399 attrs
->at_default_value
= a
;
7401 case DW_AT_digit_count
:
7402 attrs
->at_digit_count
= a
;
7405 attrs
->at_discr
= a
;
7407 case DW_AT_discr_list
:
7408 attrs
->at_discr_list
= a
;
7410 case DW_AT_discr_value
:
7411 attrs
->at_discr_value
= a
;
7413 case DW_AT_encoding
:
7414 attrs
->at_encoding
= a
;
7416 case DW_AT_endianity
:
7417 attrs
->at_endianity
= a
;
7419 case DW_AT_explicit
:
7420 attrs
->at_explicit
= a
;
7422 case DW_AT_is_optional
:
7423 attrs
->at_is_optional
= a
;
7425 case DW_AT_location
:
7426 attrs
->at_location
= a
;
7428 case DW_AT_lower_bound
:
7429 attrs
->at_lower_bound
= a
;
7432 attrs
->at_mutable
= a
;
7434 case DW_AT_ordering
:
7435 attrs
->at_ordering
= a
;
7437 case DW_AT_picture_string
:
7438 attrs
->at_picture_string
= a
;
7440 case DW_AT_prototyped
:
7441 attrs
->at_prototyped
= a
;
7444 attrs
->at_small
= a
;
7447 attrs
->at_segment
= a
;
7449 case DW_AT_string_length
:
7450 attrs
->at_string_length
= a
;
7452 case DW_AT_string_length_bit_size
:
7453 attrs
->at_string_length_bit_size
= a
;
7455 case DW_AT_string_length_byte_size
:
7456 attrs
->at_string_length_byte_size
= a
;
7458 case DW_AT_threads_scaled
:
7459 attrs
->at_threads_scaled
= a
;
7461 case DW_AT_upper_bound
:
7462 attrs
->at_upper_bound
= a
;
7464 case DW_AT_use_location
:
7465 attrs
->at_use_location
= a
;
7467 case DW_AT_use_UTF8
:
7468 attrs
->at_use_UTF8
= a
;
7470 case DW_AT_variable_parameter
:
7471 attrs
->at_variable_parameter
= a
;
7473 case DW_AT_virtuality
:
7474 attrs
->at_virtuality
= a
;
7476 case DW_AT_visibility
:
7477 attrs
->at_visibility
= a
;
7479 case DW_AT_vtable_elem_location
:
7480 attrs
->at_vtable_elem_location
= a
;
7488 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
7491 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
7495 struct checksum_attributes attrs
;
7497 CHECKSUM_ULEB128 ('D');
7498 CHECKSUM_ULEB128 (die
->die_tag
);
7500 memset (&attrs
, 0, sizeof (attrs
));
7502 decl
= get_AT_ref (die
, DW_AT_specification
);
7504 collect_checksum_attributes (&attrs
, decl
);
7505 collect_checksum_attributes (&attrs
, die
);
7507 CHECKSUM_ATTR (attrs
.at_name
);
7508 CHECKSUM_ATTR (attrs
.at_accessibility
);
7509 CHECKSUM_ATTR (attrs
.at_address_class
);
7510 CHECKSUM_ATTR (attrs
.at_allocated
);
7511 CHECKSUM_ATTR (attrs
.at_artificial
);
7512 CHECKSUM_ATTR (attrs
.at_associated
);
7513 CHECKSUM_ATTR (attrs
.at_binary_scale
);
7514 CHECKSUM_ATTR (attrs
.at_bit_offset
);
7515 CHECKSUM_ATTR (attrs
.at_bit_size
);
7516 CHECKSUM_ATTR (attrs
.at_bit_stride
);
7517 CHECKSUM_ATTR (attrs
.at_byte_size
);
7518 CHECKSUM_ATTR (attrs
.at_byte_stride
);
7519 CHECKSUM_ATTR (attrs
.at_const_value
);
7520 CHECKSUM_ATTR (attrs
.at_containing_type
);
7521 CHECKSUM_ATTR (attrs
.at_count
);
7522 CHECKSUM_ATTR (attrs
.at_data_location
);
7523 CHECKSUM_ATTR (attrs
.at_data_member_location
);
7524 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
7525 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
7526 CHECKSUM_ATTR (attrs
.at_default_value
);
7527 CHECKSUM_ATTR (attrs
.at_digit_count
);
7528 CHECKSUM_ATTR (attrs
.at_discr
);
7529 CHECKSUM_ATTR (attrs
.at_discr_list
);
7530 CHECKSUM_ATTR (attrs
.at_discr_value
);
7531 CHECKSUM_ATTR (attrs
.at_encoding
);
7532 CHECKSUM_ATTR (attrs
.at_endianity
);
7533 CHECKSUM_ATTR (attrs
.at_explicit
);
7534 CHECKSUM_ATTR (attrs
.at_is_optional
);
7535 CHECKSUM_ATTR (attrs
.at_location
);
7536 CHECKSUM_ATTR (attrs
.at_lower_bound
);
7537 CHECKSUM_ATTR (attrs
.at_mutable
);
7538 CHECKSUM_ATTR (attrs
.at_ordering
);
7539 CHECKSUM_ATTR (attrs
.at_picture_string
);
7540 CHECKSUM_ATTR (attrs
.at_prototyped
);
7541 CHECKSUM_ATTR (attrs
.at_small
);
7542 CHECKSUM_ATTR (attrs
.at_segment
);
7543 CHECKSUM_ATTR (attrs
.at_string_length
);
7544 CHECKSUM_ATTR (attrs
.at_string_length_bit_size
);
7545 CHECKSUM_ATTR (attrs
.at_string_length_byte_size
);
7546 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
7547 CHECKSUM_ATTR (attrs
.at_upper_bound
);
7548 CHECKSUM_ATTR (attrs
.at_use_location
);
7549 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
7550 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
7551 CHECKSUM_ATTR (attrs
.at_virtuality
);
7552 CHECKSUM_ATTR (attrs
.at_visibility
);
7553 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
7554 CHECKSUM_ATTR (attrs
.at_type
);
7555 CHECKSUM_ATTR (attrs
.at_friend
);
7556 CHECKSUM_ATTR (attrs
.at_alignment
);
7558 /* Checksum the child DIEs. */
7561 dw_attr_node
*name_attr
;
7564 name_attr
= get_AT (c
, DW_AT_name
);
7565 if (is_template_instantiation (c
))
7567 /* Ignore instantiations of member type and function templates. */
7569 else if (name_attr
!= NULL
7570 && (is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
))
7572 /* Use a shallow checksum for named nested types and member
7574 CHECKSUM_ULEB128 ('S');
7575 CHECKSUM_ULEB128 (c
->die_tag
);
7576 CHECKSUM_STRING (AT_string (name_attr
));
7580 /* Use a deep checksum for other children. */
7581 /* Mark this DIE so it gets processed when unmarking. */
7582 if (c
->die_mark
== 0)
7584 die_checksum_ordered (c
, ctx
, mark
);
7586 } while (c
!= die
->die_child
);
7588 CHECKSUM_ULEB128 (0);
7591 /* Add a type name and tag to a hash. */
7593 die_odr_checksum (int tag
, const char *name
, md5_ctx
*ctx
)
7595 CHECKSUM_ULEB128 (tag
);
7596 CHECKSUM_STRING (name
);
7600 #undef CHECKSUM_STRING
7601 #undef CHECKSUM_ATTR
7602 #undef CHECKSUM_LEB128
7603 #undef CHECKSUM_ULEB128
7605 /* Generate the type signature for DIE. This is computed by generating an
7606 MD5 checksum over the DIE's tag, its relevant attributes, and its
7607 children. Attributes that are references to other DIEs are processed
7608 by recursion, using the MARK field to prevent infinite recursion.
7609 If the DIE is nested inside a namespace or another type, we also
7610 need to include that context in the signature. The lower 64 bits
7611 of the resulting MD5 checksum comprise the signature. */
7614 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
7618 unsigned char checksum
[16];
7623 name
= get_AT_string (die
, DW_AT_name
);
7624 decl
= get_AT_ref (die
, DW_AT_specification
);
7625 parent
= get_die_parent (die
);
7627 /* First, compute a signature for just the type name (and its surrounding
7628 context, if any. This is stored in the type unit DIE for link-time
7629 ODR (one-definition rule) checking. */
7631 if (is_cxx () && name
!= NULL
)
7633 md5_init_ctx (&ctx
);
7635 /* Checksum the names of surrounding namespaces and structures. */
7637 checksum_die_context (parent
, &ctx
);
7639 /* Checksum the current DIE. */
7640 die_odr_checksum (die
->die_tag
, name
, &ctx
);
7641 md5_finish_ctx (&ctx
, checksum
);
7643 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
7646 /* Next, compute the complete type signature. */
7648 md5_init_ctx (&ctx
);
7650 die
->die_mark
= mark
;
7652 /* Checksum the names of surrounding namespaces and structures. */
7654 checksum_die_context (parent
, &ctx
);
7656 /* Checksum the DIE and its children. */
7657 die_checksum_ordered (die
, &ctx
, &mark
);
7658 unmark_all_dies (die
);
7659 md5_finish_ctx (&ctx
, checksum
);
7661 /* Store the signature in the type node and link the type DIE and the
7662 type node together. */
7663 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
7664 DWARF_TYPE_SIGNATURE_SIZE
);
7665 die
->comdat_type_p
= true;
7666 die
->die_id
.die_type_node
= type_node
;
7667 type_node
->type_die
= die
;
7669 /* If the DIE is a specification, link its declaration to the type node
7673 decl
->comdat_type_p
= true;
7674 decl
->die_id
.die_type_node
= type_node
;
7678 /* Do the location expressions look same? */
7680 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
7682 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
7683 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
7684 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
7687 /* Do the values look the same? */
7689 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
7691 dw_loc_descr_ref loc1
, loc2
;
7694 if (v1
->val_class
!= v2
->val_class
)
7697 switch (v1
->val_class
)
7699 case dw_val_class_const
:
7700 case dw_val_class_const_implicit
:
7701 return v1
->v
.val_int
== v2
->v
.val_int
;
7702 case dw_val_class_unsigned_const
:
7703 case dw_val_class_unsigned_const_implicit
:
7704 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
7705 case dw_val_class_const_double
:
7706 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
7707 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
7708 case dw_val_class_wide_int
:
7709 return *v1
->v
.val_wide
== *v2
->v
.val_wide
;
7710 case dw_val_class_vec
:
7711 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
7712 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
7714 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
7715 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
7718 case dw_val_class_flag
:
7719 return v1
->v
.val_flag
== v2
->v
.val_flag
;
7720 case dw_val_class_str
:
7721 return !strcmp (v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
7723 case dw_val_class_addr
:
7724 r1
= v1
->v
.val_addr
;
7725 r2
= v2
->v
.val_addr
;
7726 if (GET_CODE (r1
) != GET_CODE (r2
))
7728 return !rtx_equal_p (r1
, r2
);
7730 case dw_val_class_offset
:
7731 return v1
->v
.val_offset
== v2
->v
.val_offset
;
7733 case dw_val_class_loc
:
7734 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
7736 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
7737 if (!same_loc_p (loc1
, loc2
, mark
))
7739 return !loc1
&& !loc2
;
7741 case dw_val_class_die_ref
:
7742 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
7744 case dw_val_class_symview
:
7745 return strcmp (v1
->v
.val_symbolic_view
, v2
->v
.val_symbolic_view
) == 0;
7747 case dw_val_class_fde_ref
:
7748 case dw_val_class_vms_delta
:
7749 case dw_val_class_lbl_id
:
7750 case dw_val_class_lineptr
:
7751 case dw_val_class_macptr
:
7752 case dw_val_class_loclistsptr
:
7753 case dw_val_class_high_pc
:
7756 case dw_val_class_file
:
7757 case dw_val_class_file_implicit
:
7758 return v1
->v
.val_file
== v2
->v
.val_file
;
7760 case dw_val_class_data8
:
7761 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
7768 /* Do the attributes look the same? */
7771 same_attr_p (dw_attr_node
*at1
, dw_attr_node
*at2
, int *mark
)
7773 if (at1
->dw_attr
!= at2
->dw_attr
)
7776 /* We don't care that this was compiled with a different compiler
7777 snapshot; if the output is the same, that's what matters. */
7778 if (at1
->dw_attr
== DW_AT_producer
)
7781 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
7784 /* Do the dies look the same? */
7787 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
7793 /* To avoid infinite recursion. */
7795 return die1
->die_mark
== die2
->die_mark
;
7796 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
7798 if (die1
->die_tag
!= die2
->die_tag
)
7801 if (vec_safe_length (die1
->die_attr
) != vec_safe_length (die2
->die_attr
))
7804 FOR_EACH_VEC_SAFE_ELT (die1
->die_attr
, ix
, a1
)
7805 if (!same_attr_p (a1
, &(*die2
->die_attr
)[ix
], mark
))
7808 c1
= die1
->die_child
;
7809 c2
= die2
->die_child
;
7818 if (!same_die_p (c1
, c2
, mark
))
7822 if (c1
== die1
->die_child
)
7824 if (c2
== die2
->die_child
)
7834 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7835 children, and set die_symbol. */
7838 compute_comp_unit_symbol (dw_die_ref unit_die
)
7840 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
7841 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
7842 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
7845 unsigned char checksum
[16];
7848 /* Compute the checksum of the DIE, then append part of it as hex digits to
7849 the name filename of the unit. */
7851 md5_init_ctx (&ctx
);
7853 die_checksum (unit_die
, &ctx
, &mark
);
7854 unmark_all_dies (unit_die
);
7855 md5_finish_ctx (&ctx
, checksum
);
7857 /* When we this for comp_unit_die () we have a DW_AT_name that might
7858 not start with a letter but with anything valid for filenames and
7859 clean_symbol_name doesn't fix that up. Prepend 'g' if the first
7860 character is not a letter. */
7861 sprintf (name
, "%s%s.", ISALPHA (*base
) ? "" : "g", base
);
7862 clean_symbol_name (name
);
7864 p
= name
+ strlen (name
);
7865 for (i
= 0; i
< 4; i
++)
7867 sprintf (p
, "%.2x", checksum
[i
]);
7871 unit_die
->die_id
.die_symbol
= xstrdup (name
);
7874 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7877 is_type_die (dw_die_ref die
)
7879 switch (die
->die_tag
)
7881 case DW_TAG_array_type
:
7882 case DW_TAG_class_type
:
7883 case DW_TAG_interface_type
:
7884 case DW_TAG_enumeration_type
:
7885 case DW_TAG_pointer_type
:
7886 case DW_TAG_reference_type
:
7887 case DW_TAG_rvalue_reference_type
:
7888 case DW_TAG_string_type
:
7889 case DW_TAG_structure_type
:
7890 case DW_TAG_subroutine_type
:
7891 case DW_TAG_union_type
:
7892 case DW_TAG_ptr_to_member_type
:
7893 case DW_TAG_set_type
:
7894 case DW_TAG_subrange_type
:
7895 case DW_TAG_base_type
:
7896 case DW_TAG_const_type
:
7897 case DW_TAG_file_type
:
7898 case DW_TAG_packed_type
:
7899 case DW_TAG_volatile_type
:
7900 case DW_TAG_typedef
:
7907 /* Returns true iff C is a compile-unit DIE. */
7910 is_cu_die (dw_die_ref c
)
7912 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7913 || c
->die_tag
== DW_TAG_skeleton_unit
);
7916 /* Returns true iff C is a unit DIE of some sort. */
7919 is_unit_die (dw_die_ref c
)
7921 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7922 || c
->die_tag
== DW_TAG_partial_unit
7923 || c
->die_tag
== DW_TAG_type_unit
7924 || c
->die_tag
== DW_TAG_skeleton_unit
);
7927 /* Returns true iff C is a namespace DIE. */
7930 is_namespace_die (dw_die_ref c
)
7932 return c
&& c
->die_tag
== DW_TAG_namespace
;
7935 /* Return non-zero if this DIE is a template parameter. */
7938 is_template_parameter (dw_die_ref die
)
7940 switch (die
->die_tag
)
7942 case DW_TAG_template_type_param
:
7943 case DW_TAG_template_value_param
:
7944 case DW_TAG_GNU_template_template_param
:
7945 case DW_TAG_GNU_template_parameter_pack
:
7952 /* Return non-zero if this DIE represents a template instantiation. */
7955 is_template_instantiation (dw_die_ref die
)
7959 if (!is_type_die (die
) && die
->die_tag
!= DW_TAG_subprogram
)
7961 FOR_EACH_CHILD (die
, c
, if (is_template_parameter (c
)) return true);
7966 gen_internal_sym (const char *prefix
)
7968 char buf
[MAX_ARTIFICIAL_LABEL_BYTES
];
7970 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
7971 return xstrdup (buf
);
7974 /* Return non-zero if this DIE is a declaration. */
7977 is_declaration_die (dw_die_ref die
)
7982 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7983 if (a
->dw_attr
== DW_AT_declaration
)
7989 /* Return non-zero if this DIE is nested inside a subprogram. */
7992 is_nested_in_subprogram (dw_die_ref die
)
7994 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
7998 return local_scope_p (decl
);
8001 /* Return non-zero if this DIE contains a defining declaration of a
8005 contains_subprogram_definition (dw_die_ref die
)
8009 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
8011 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
8015 /* Return non-zero if this is a type DIE that should be moved to a
8016 COMDAT .debug_types section or .debug_info section with DW_UT_*type
8020 should_move_die_to_comdat (dw_die_ref die
)
8022 switch (die
->die_tag
)
8024 case DW_TAG_class_type
:
8025 case DW_TAG_structure_type
:
8026 case DW_TAG_enumeration_type
:
8027 case DW_TAG_union_type
:
8028 /* Don't move declarations, inlined instances, types nested in a
8029 subprogram, or types that contain subprogram definitions. */
8030 if (is_declaration_die (die
)
8031 || get_AT (die
, DW_AT_abstract_origin
)
8032 || is_nested_in_subprogram (die
)
8033 || contains_subprogram_definition (die
))
8036 case DW_TAG_array_type
:
8037 case DW_TAG_interface_type
:
8038 case DW_TAG_pointer_type
:
8039 case DW_TAG_reference_type
:
8040 case DW_TAG_rvalue_reference_type
:
8041 case DW_TAG_string_type
:
8042 case DW_TAG_subroutine_type
:
8043 case DW_TAG_ptr_to_member_type
:
8044 case DW_TAG_set_type
:
8045 case DW_TAG_subrange_type
:
8046 case DW_TAG_base_type
:
8047 case DW_TAG_const_type
:
8048 case DW_TAG_file_type
:
8049 case DW_TAG_packed_type
:
8050 case DW_TAG_volatile_type
:
8051 case DW_TAG_typedef
:
8057 /* Make a clone of DIE. */
8060 clone_die (dw_die_ref die
)
8062 dw_die_ref clone
= new_die_raw (die
->die_tag
);
8066 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8067 add_dwarf_attr (clone
, a
);
8072 /* Make a clone of the tree rooted at DIE. */
8075 clone_tree (dw_die_ref die
)
8078 dw_die_ref clone
= clone_die (die
);
8080 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
8085 /* Make a clone of DIE as a declaration. */
8088 clone_as_declaration (dw_die_ref die
)
8095 /* If the DIE is already a declaration, just clone it. */
8096 if (is_declaration_die (die
))
8097 return clone_die (die
);
8099 /* If the DIE is a specification, just clone its declaration DIE. */
8100 decl
= get_AT_ref (die
, DW_AT_specification
);
8103 clone
= clone_die (decl
);
8104 if (die
->comdat_type_p
)
8105 add_AT_die_ref (clone
, DW_AT_signature
, die
);
8109 clone
= new_die_raw (die
->die_tag
);
8111 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8113 /* We don't want to copy over all attributes.
8114 For example we don't want DW_AT_byte_size because otherwise we will no
8115 longer have a declaration and GDB will treat it as a definition. */
8119 case DW_AT_abstract_origin
:
8120 case DW_AT_artificial
:
8121 case DW_AT_containing_type
:
8122 case DW_AT_external
:
8125 case DW_AT_virtuality
:
8126 case DW_AT_linkage_name
:
8127 case DW_AT_MIPS_linkage_name
:
8128 add_dwarf_attr (clone
, a
);
8130 case DW_AT_byte_size
:
8131 case DW_AT_alignment
:
8137 if (die
->comdat_type_p
)
8138 add_AT_die_ref (clone
, DW_AT_signature
, die
);
8140 add_AT_flag (clone
, DW_AT_declaration
, 1);
8145 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
8147 struct decl_table_entry
8153 /* Helpers to manipulate hash table of copied declarations. */
8155 /* Hashtable helpers. */
8157 struct decl_table_entry_hasher
: free_ptr_hash
<decl_table_entry
>
8159 typedef die_struct
*compare_type
;
8160 static inline hashval_t
hash (const decl_table_entry
*);
8161 static inline bool equal (const decl_table_entry
*, const die_struct
*);
8165 decl_table_entry_hasher::hash (const decl_table_entry
*entry
)
8167 return htab_hash_pointer (entry
->orig
);
8171 decl_table_entry_hasher::equal (const decl_table_entry
*entry1
,
8172 const die_struct
*entry2
)
8174 return entry1
->orig
== entry2
;
8177 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
8179 /* Copy DIE and its ancestors, up to, but not including, the compile unit
8180 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
8181 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
8182 to check if the ancestor has already been copied into UNIT. */
8185 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
,
8186 decl_hash_type
*decl_table
)
8188 dw_die_ref parent
= die
->die_parent
;
8189 dw_die_ref new_parent
= unit
;
8191 decl_table_entry
**slot
= NULL
;
8192 struct decl_table_entry
*entry
= NULL
;
8194 /* If DIE refers to a stub unfold that so we get the appropriate
8195 DIE registered as orig in decl_table. */
8196 if (dw_die_ref c
= get_AT_ref (die
, DW_AT_signature
))
8201 /* Check if the entry has already been copied to UNIT. */
8202 slot
= decl_table
->find_slot_with_hash (die
, htab_hash_pointer (die
),
8204 if (*slot
!= HTAB_EMPTY_ENTRY
)
8210 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
8211 entry
= XCNEW (struct decl_table_entry
);
8219 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
8222 if (!is_unit_die (parent
))
8223 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
8226 copy
= clone_as_declaration (die
);
8227 add_child_die (new_parent
, copy
);
8231 /* Record the pointer to the copy. */
8237 /* Copy the declaration context to the new type unit DIE. This includes
8238 any surrounding namespace or type declarations. If the DIE has an
8239 AT_specification attribute, it also includes attributes and children
8240 attached to the specification, and returns a pointer to the original
8241 parent of the declaration DIE. Returns NULL otherwise. */
8244 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
8247 dw_die_ref new_decl
;
8248 dw_die_ref orig_parent
= NULL
;
8250 decl
= get_AT_ref (die
, DW_AT_specification
);
8259 /* The original DIE will be changed to a declaration, and must
8260 be moved to be a child of the original declaration DIE. */
8261 orig_parent
= decl
->die_parent
;
8263 /* Copy the type node pointer from the new DIE to the original
8264 declaration DIE so we can forward references later. */
8265 decl
->comdat_type_p
= true;
8266 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
8268 remove_AT (die
, DW_AT_specification
);
8270 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
8272 if (a
->dw_attr
!= DW_AT_name
8273 && a
->dw_attr
!= DW_AT_declaration
8274 && a
->dw_attr
!= DW_AT_external
)
8275 add_dwarf_attr (die
, a
);
8278 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
8281 if (decl
->die_parent
!= NULL
8282 && !is_unit_die (decl
->die_parent
))
8284 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
8285 if (new_decl
!= NULL
)
8287 remove_AT (new_decl
, DW_AT_signature
);
8288 add_AT_specification (die
, new_decl
);
8295 /* Generate the skeleton ancestor tree for the given NODE, then clone
8296 the DIE and add the clone into the tree. */
8299 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
8301 if (node
->new_die
!= NULL
)
8304 node
->new_die
= clone_as_declaration (node
->old_die
);
8306 if (node
->parent
!= NULL
)
8308 generate_skeleton_ancestor_tree (node
->parent
);
8309 add_child_die (node
->parent
->new_die
, node
->new_die
);
8313 /* Generate a skeleton tree of DIEs containing any declarations that are
8314 found in the original tree. We traverse the tree looking for declaration
8315 DIEs, and construct the skeleton from the bottom up whenever we find one. */
8318 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
8320 skeleton_chain_node node
;
8323 dw_die_ref prev
= NULL
;
8324 dw_die_ref next
= NULL
;
8326 node
.parent
= parent
;
8328 first
= c
= parent
->old_die
->die_child
;
8332 if (prev
== NULL
|| prev
->die_sib
== c
)
8335 next
= (c
== first
? NULL
: c
->die_sib
);
8337 node
.new_die
= NULL
;
8338 if (is_declaration_die (c
))
8340 if (is_template_instantiation (c
))
8342 /* Instantiated templates do not need to be cloned into the
8343 type unit. Just move the DIE and its children back to
8344 the skeleton tree (in the main CU). */
8345 remove_child_with_prev (c
, prev
);
8346 add_child_die (parent
->new_die
, c
);
8349 else if (c
->comdat_type_p
)
8351 /* This is the skeleton of earlier break_out_comdat_types
8352 type. Clone the existing DIE, but keep the children
8353 under the original (which is in the main CU). */
8354 dw_die_ref clone
= clone_die (c
);
8356 replace_child (c
, clone
, prev
);
8357 generate_skeleton_ancestor_tree (parent
);
8358 add_child_die (parent
->new_die
, c
);
8364 /* Clone the existing DIE, move the original to the skeleton
8365 tree (which is in the main CU), and put the clone, with
8366 all the original's children, where the original came from
8367 (which is about to be moved to the type unit). */
8368 dw_die_ref clone
= clone_die (c
);
8369 move_all_children (c
, clone
);
8371 /* If the original has a DW_AT_object_pointer attribute,
8372 it would now point to a child DIE just moved to the
8373 cloned tree, so we need to remove that attribute from
8375 remove_AT (c
, DW_AT_object_pointer
);
8377 replace_child (c
, clone
, prev
);
8378 generate_skeleton_ancestor_tree (parent
);
8379 add_child_die (parent
->new_die
, c
);
8380 node
.old_die
= clone
;
8385 generate_skeleton_bottom_up (&node
);
8386 } while (next
!= NULL
);
8389 /* Wrapper function for generate_skeleton_bottom_up. */
8392 generate_skeleton (dw_die_ref die
)
8394 skeleton_chain_node node
;
8397 node
.new_die
= NULL
;
8400 /* If this type definition is nested inside another type,
8401 and is not an instantiation of a template, always leave
8402 at least a declaration in its place. */
8403 if (die
->die_parent
!= NULL
8404 && is_type_die (die
->die_parent
)
8405 && !is_template_instantiation (die
))
8406 node
.new_die
= clone_as_declaration (die
);
8408 generate_skeleton_bottom_up (&node
);
8409 return node
.new_die
;
8412 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
8413 declaration. The original DIE is moved to a new compile unit so that
8414 existing references to it follow it to the new location. If any of the
8415 original DIE's descendants is a declaration, we need to replace the
8416 original DIE with a skeleton tree and move the declarations back into the
8420 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
8423 dw_die_ref skeleton
, orig_parent
;
8425 /* Copy the declaration context to the type unit DIE. If the returned
8426 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
8428 orig_parent
= copy_declaration_context (unit
, child
);
8430 skeleton
= generate_skeleton (child
);
8431 if (skeleton
== NULL
)
8432 remove_child_with_prev (child
, prev
);
8435 skeleton
->comdat_type_p
= true;
8436 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
8438 /* If the original DIE was a specification, we need to put
8439 the skeleton under the parent DIE of the declaration.
8440 This leaves the original declaration in the tree, but
8441 it will be pruned later since there are no longer any
8442 references to it. */
8443 if (orig_parent
!= NULL
)
8445 remove_child_with_prev (child
, prev
);
8446 add_child_die (orig_parent
, skeleton
);
8449 replace_child (child
, skeleton
, prev
);
8456 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8457 comdat_type_node
*type_node
,
8458 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
);
8460 /* Helper for copy_dwarf_procs_ref_in_dies. Make a copy of the DIE DWARF
8461 procedure, put it under TYPE_NODE and return the copy. Continue looking for
8462 DWARF procedure references in the DW_AT_location attribute. */
8465 copy_dwarf_procedure (dw_die_ref die
,
8466 comdat_type_node
*type_node
,
8467 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8469 gcc_assert (die
->die_tag
== DW_TAG_dwarf_procedure
);
8471 /* DWARF procedures are not supposed to have children... */
8472 gcc_assert (die
->die_child
== NULL
);
8474 /* ... and they are supposed to have only one attribute: DW_AT_location. */
8475 gcc_assert (vec_safe_length (die
->die_attr
) == 1
8476 && ((*die
->die_attr
)[0].dw_attr
== DW_AT_location
));
8478 /* Do not copy more than once DWARF procedures. */
8480 dw_die_ref
&die_copy
= copied_dwarf_procs
.get_or_insert (die
, &existed
);
8484 die_copy
= clone_die (die
);
8485 add_child_die (type_node
->root_die
, die_copy
);
8486 copy_dwarf_procs_ref_in_attrs (die_copy
, type_node
, copied_dwarf_procs
);
8490 /* Helper for copy_dwarf_procs_ref_in_dies. Look for references to DWARF
8491 procedures in DIE's attributes. */
8494 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8495 comdat_type_node
*type_node
,
8496 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8501 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, i
, a
)
8503 dw_loc_descr_ref loc
;
8505 if (a
->dw_attr_val
.val_class
!= dw_val_class_loc
)
8508 for (loc
= a
->dw_attr_val
.v
.val_loc
; loc
!= NULL
; loc
= loc
->dw_loc_next
)
8510 switch (loc
->dw_loc_opc
)
8514 case DW_OP_call_ref
:
8515 gcc_assert (loc
->dw_loc_oprnd1
.val_class
8516 == dw_val_class_die_ref
);
8517 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
8518 = copy_dwarf_procedure (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
,
8520 copied_dwarf_procs
);
8529 /* Copy DWARF procedures that are referenced by the DIE tree to TREE_NODE and
8530 rewrite references to point to the copies.
8532 References are looked for in DIE's attributes and recursively in all its
8533 children attributes that are location descriptions. COPIED_DWARF_PROCS is a
8534 mapping from old DWARF procedures to their copy. It is used not to copy
8535 twice the same DWARF procedure under TYPE_NODE. */
8538 copy_dwarf_procs_ref_in_dies (dw_die_ref die
,
8539 comdat_type_node
*type_node
,
8540 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8544 copy_dwarf_procs_ref_in_attrs (die
, type_node
, copied_dwarf_procs
);
8545 FOR_EACH_CHILD (die
, c
, copy_dwarf_procs_ref_in_dies (c
,
8547 copied_dwarf_procs
));
8550 /* Traverse the DIE and set up additional .debug_types or .debug_info
8551 DW_UT_*type sections for each type worthy of being placed in a COMDAT
8555 break_out_comdat_types (dw_die_ref die
)
8559 dw_die_ref prev
= NULL
;
8560 dw_die_ref next
= NULL
;
8561 dw_die_ref unit
= NULL
;
8563 first
= c
= die
->die_child
;
8567 if (prev
== NULL
|| prev
->die_sib
== c
)
8570 next
= (c
== first
? NULL
: c
->die_sib
);
8571 if (should_move_die_to_comdat (c
))
8573 dw_die_ref replacement
;
8574 comdat_type_node
*type_node
;
8576 /* Break out nested types into their own type units. */
8577 break_out_comdat_types (c
);
8579 /* Create a new type unit DIE as the root for the new tree. */
8580 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
8581 add_AT_unsigned (unit
, DW_AT_language
,
8582 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
8584 /* Add the new unit's type DIE into the comdat type list. */
8585 type_node
= ggc_cleared_alloc
<comdat_type_node
> ();
8586 type_node
->root_die
= unit
;
8587 type_node
->next
= comdat_type_list
;
8588 comdat_type_list
= type_node
;
8590 /* Generate the type signature. */
8591 generate_type_signature (c
, type_node
);
8593 /* Copy the declaration context, attributes, and children of the
8594 declaration into the new type unit DIE, then remove this DIE
8595 from the main CU (or replace it with a skeleton if necessary). */
8596 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
8597 type_node
->skeleton_die
= replacement
;
8599 /* Add the DIE to the new compunit. */
8600 add_child_die (unit
, c
);
8602 /* Types can reference DWARF procedures for type size or data location
8603 expressions. Calls in DWARF expressions cannot target procedures
8604 that are not in the same section. So we must copy DWARF procedures
8605 along with this type and then rewrite references to them. */
8606 hash_map
<dw_die_ref
, dw_die_ref
> copied_dwarf_procs
;
8607 copy_dwarf_procs_ref_in_dies (c
, type_node
, copied_dwarf_procs
);
8609 if (replacement
!= NULL
)
8612 else if (c
->die_tag
== DW_TAG_namespace
8613 || c
->die_tag
== DW_TAG_class_type
8614 || c
->die_tag
== DW_TAG_structure_type
8615 || c
->die_tag
== DW_TAG_union_type
)
8617 /* Look for nested types that can be broken out. */
8618 break_out_comdat_types (c
);
8620 } while (next
!= NULL
);
8623 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
8624 Enter all the cloned children into the hash table decl_table. */
8627 clone_tree_partial (dw_die_ref die
, decl_hash_type
*decl_table
)
8631 struct decl_table_entry
*entry
;
8632 decl_table_entry
**slot
;
8634 if (die
->die_tag
== DW_TAG_subprogram
)
8635 clone
= clone_as_declaration (die
);
8637 clone
= clone_die (die
);
8639 slot
= decl_table
->find_slot_with_hash (die
,
8640 htab_hash_pointer (die
), INSERT
);
8642 /* Assert that DIE isn't in the hash table yet. If it would be there
8643 before, the ancestors would be necessarily there as well, therefore
8644 clone_tree_partial wouldn't be called. */
8645 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
8647 entry
= XCNEW (struct decl_table_entry
);
8649 entry
->copy
= clone
;
8652 if (die
->die_tag
!= DW_TAG_subprogram
)
8653 FOR_EACH_CHILD (die
, c
,
8654 add_child_die (clone
, clone_tree_partial (c
, decl_table
)));
8659 /* Walk the DIE and its children, looking for references to incomplete
8660 or trivial types that are unmarked (i.e., that are not in the current
8664 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type
*decl_table
)
8670 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8672 if (AT_class (a
) == dw_val_class_die_ref
)
8674 dw_die_ref targ
= AT_ref (a
);
8675 decl_table_entry
**slot
;
8676 struct decl_table_entry
*entry
;
8678 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
8681 slot
= decl_table
->find_slot_with_hash (targ
,
8682 htab_hash_pointer (targ
),
8685 if (*slot
!= HTAB_EMPTY_ENTRY
)
8687 /* TARG has already been copied, so we just need to
8688 modify the reference to point to the copy. */
8690 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
8694 dw_die_ref parent
= unit
;
8695 dw_die_ref copy
= clone_die (targ
);
8697 /* Record in DECL_TABLE that TARG has been copied.
8698 Need to do this now, before the recursive call,
8699 because DECL_TABLE may be expanded and SLOT
8700 would no longer be a valid pointer. */
8701 entry
= XCNEW (struct decl_table_entry
);
8706 /* If TARG is not a declaration DIE, we need to copy its
8708 if (!is_declaration_die (targ
))
8712 add_child_die (copy
,
8713 clone_tree_partial (c
, decl_table
)));
8716 /* Make sure the cloned tree is marked as part of the
8720 /* If TARG has surrounding context, copy its ancestor tree
8721 into the new type unit. */
8722 if (targ
->die_parent
!= NULL
8723 && !is_unit_die (targ
->die_parent
))
8724 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
8727 add_child_die (parent
, copy
);
8728 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
8730 /* Make sure the newly-copied DIE is walked. If it was
8731 installed in a previously-added context, it won't
8732 get visited otherwise. */
8735 /* Find the highest point of the newly-added tree,
8736 mark each node along the way, and walk from there. */
8737 parent
->die_mark
= 1;
8738 while (parent
->die_parent
8739 && parent
->die_parent
->die_mark
== 0)
8741 parent
= parent
->die_parent
;
8742 parent
->die_mark
= 1;
8744 copy_decls_walk (unit
, parent
, decl_table
);
8750 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
8753 /* Collect skeleton dies in DIE created by break_out_comdat_types already
8754 and record them in DECL_TABLE. */
8757 collect_skeleton_dies (dw_die_ref die
, decl_hash_type
*decl_table
)
8761 if (dw_attr_node
*a
= get_AT (die
, DW_AT_signature
))
8763 dw_die_ref targ
= AT_ref (a
);
8764 gcc_assert (targ
->die_mark
== 0 && targ
->comdat_type_p
);
8765 decl_table_entry
**slot
8766 = decl_table
->find_slot_with_hash (targ
,
8767 htab_hash_pointer (targ
),
8769 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
8770 /* Record in DECL_TABLE that TARG has been already copied
8771 by remove_child_or_replace_with_skeleton. */
8772 decl_table_entry
*entry
= XCNEW (struct decl_table_entry
);
8777 FOR_EACH_CHILD (die
, c
, collect_skeleton_dies (c
, decl_table
));
8780 /* Copy declarations for "unworthy" types into the new comdat section.
8781 Incomplete types, modified types, and certain other types aren't broken
8782 out into comdat sections of their own, so they don't have a signature,
8783 and we need to copy the declaration into the same section so that we
8784 don't have an external reference. */
8787 copy_decls_for_unworthy_types (dw_die_ref unit
)
8790 decl_hash_type
decl_table (10);
8791 collect_skeleton_dies (unit
, &decl_table
);
8792 copy_decls_walk (unit
, unit
, &decl_table
);
8796 /* Traverse the DIE and add a sibling attribute if it may have the
8797 effect of speeding up access to siblings. To save some space,
8798 avoid generating sibling attributes for DIE's without children. */
8801 add_sibling_attributes (dw_die_ref die
)
8805 if (! die
->die_child
)
8808 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
8809 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
8811 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
8814 /* Output all location lists for the DIE and its children. */
8817 output_location_lists (dw_die_ref die
)
8823 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8824 if (AT_class (a
) == dw_val_class_loc_list
)
8825 output_loc_list (AT_loc_list (a
));
8827 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
8830 /* During assign_location_list_indexes and output_loclists_offset the
8831 current index, after it the number of assigned indexes (i.e. how
8832 large the .debug_loclists* offset table should be). */
8833 static unsigned int loc_list_idx
;
8835 /* Output all location list offsets for the DIE and its children. */
8838 output_loclists_offsets (dw_die_ref die
)
8844 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8845 if (AT_class (a
) == dw_val_class_loc_list
)
8847 dw_loc_list_ref l
= AT_loc_list (a
);
8848 if (l
->offset_emitted
)
8850 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l
->ll_symbol
,
8851 loc_section_label
, NULL
);
8852 gcc_assert (l
->hash
== loc_list_idx
);
8854 l
->offset_emitted
= true;
8857 FOR_EACH_CHILD (die
, c
, output_loclists_offsets (c
));
8860 /* Recursively set indexes of location lists. */
8863 assign_location_list_indexes (dw_die_ref die
)
8869 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8870 if (AT_class (a
) == dw_val_class_loc_list
)
8872 dw_loc_list_ref list
= AT_loc_list (a
);
8873 if (!list
->num_assigned
)
8875 list
->num_assigned
= true;
8876 list
->hash
= loc_list_idx
++;
8880 FOR_EACH_CHILD (die
, c
, assign_location_list_indexes (c
));
8883 /* We want to limit the number of external references, because they are
8884 larger than local references: a relocation takes multiple words, and
8885 even a sig8 reference is always eight bytes, whereas a local reference
8886 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
8887 So if we encounter multiple external references to the same type DIE, we
8888 make a local typedef stub for it and redirect all references there.
8890 This is the element of the hash table for keeping track of these
8900 /* Hashtable helpers. */
8902 struct external_ref_hasher
: free_ptr_hash
<external_ref
>
8904 static inline hashval_t
hash (const external_ref
*);
8905 static inline bool equal (const external_ref
*, const external_ref
*);
8909 external_ref_hasher::hash (const external_ref
*r
)
8911 dw_die_ref die
= r
->type
;
8914 /* We can't use the address of the DIE for hashing, because
8915 that will make the order of the stub DIEs non-deterministic. */
8916 if (! die
->comdat_type_p
)
8917 /* We have a symbol; use it to compute a hash. */
8918 h
= htab_hash_string (die
->die_id
.die_symbol
);
8921 /* We have a type signature; use a subset of the bits as the hash.
8922 The 8-byte signature is at least as large as hashval_t. */
8923 comdat_type_node
*type_node
= die
->die_id
.die_type_node
;
8924 memcpy (&h
, type_node
->signature
, sizeof (h
));
8930 external_ref_hasher::equal (const external_ref
*r1
, const external_ref
*r2
)
8932 return r1
->type
== r2
->type
;
8935 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
8937 /* Return a pointer to the external_ref for references to DIE. */
8939 static struct external_ref
*
8940 lookup_external_ref (external_ref_hash_type
*map
, dw_die_ref die
)
8942 struct external_ref ref
, *ref_p
;
8943 external_ref
**slot
;
8946 slot
= map
->find_slot (&ref
, INSERT
);
8947 if (*slot
!= HTAB_EMPTY_ENTRY
)
8950 ref_p
= XCNEW (struct external_ref
);
8956 /* Subroutine of optimize_external_refs, below.
8958 If we see a type skeleton, record it as our stub. If we see external
8959 references, remember how many we've seen. */
8962 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type
*map
)
8967 struct external_ref
*ref_p
;
8969 if (is_type_die (die
)
8970 && (c
= get_AT_ref (die
, DW_AT_signature
)))
8972 /* This is a local skeleton; use it for local references. */
8973 ref_p
= lookup_external_ref (map
, c
);
8977 /* Scan the DIE references, and remember any that refer to DIEs from
8978 other CUs (i.e. those which are not marked). */
8979 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8980 if (AT_class (a
) == dw_val_class_die_ref
8981 && (c
= AT_ref (a
))->die_mark
== 0
8984 ref_p
= lookup_external_ref (map
, c
);
8988 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
8991 /* htab_traverse callback function for optimize_external_refs, below. SLOT
8992 points to an external_ref, DATA is the CU we're processing. If we don't
8993 already have a local stub, and we have multiple refs, build a stub. */
8996 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
8998 struct external_ref
*ref_p
= *slot
;
9000 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
9002 /* We have multiple references to this type, so build a small stub.
9003 Both of these forms are a bit dodgy from the perspective of the
9004 DWARF standard, since technically they should have names. */
9005 dw_die_ref cu
= data
;
9006 dw_die_ref type
= ref_p
->type
;
9007 dw_die_ref stub
= NULL
;
9009 if (type
->comdat_type_p
)
9011 /* If we refer to this type via sig8, use AT_signature. */
9012 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
9013 add_AT_die_ref (stub
, DW_AT_signature
, type
);
9017 /* Otherwise, use a typedef with no name. */
9018 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
9019 add_AT_die_ref (stub
, DW_AT_type
, type
);
9028 /* DIE is a unit; look through all the DIE references to see if there are
9029 any external references to types, and if so, create local stubs for
9030 them which will be applied in build_abbrev_table. This is useful because
9031 references to local DIEs are smaller. */
9033 static external_ref_hash_type
*
9034 optimize_external_refs (dw_die_ref die
)
9036 external_ref_hash_type
*map
= new external_ref_hash_type (10);
9037 optimize_external_refs_1 (die
, map
);
9038 map
->traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
9042 /* The following 3 variables are temporaries that are computed only during the
9043 build_abbrev_table call and used and released during the following
9044 optimize_abbrev_table call. */
9046 /* First abbrev_id that can be optimized based on usage. */
9047 static unsigned int abbrev_opt_start
;
9049 /* Maximum abbrev_id of a base type plus one (we can't optimize DIEs with
9050 abbrev_id smaller than this, because they must be already sized
9051 during build_abbrev_table). */
9052 static unsigned int abbrev_opt_base_type_end
;
9054 /* Vector of usage counts during build_abbrev_table. Indexed by
9055 abbrev_id - abbrev_opt_start. */
9056 static vec
<unsigned int> abbrev_usage_count
;
9058 /* Vector of all DIEs added with die_abbrev >= abbrev_opt_start. */
9059 static vec
<dw_die_ref
> sorted_abbrev_dies
;
9061 /* The format of each DIE (and its attribute value pairs) is encoded in an
9062 abbreviation table. This routine builds the abbreviation table and assigns
9063 a unique abbreviation id for each abbreviation entry. The children of each
9064 die are visited recursively. */
9067 build_abbrev_table (dw_die_ref die
, external_ref_hash_type
*extern_map
)
9069 unsigned int abbrev_id
= 0;
9075 /* Scan the DIE references, and replace any that refer to
9076 DIEs from other CUs (i.e. those which are not marked) with
9077 the local stubs we built in optimize_external_refs. */
9078 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9079 if (AT_class (a
) == dw_val_class_die_ref
9080 && (c
= AT_ref (a
))->die_mark
== 0)
9082 struct external_ref
*ref_p
;
9083 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
9086 && (ref_p
= lookup_external_ref (extern_map
, c
))
9087 && ref_p
->stub
&& ref_p
->stub
!= die
)
9089 gcc_assert (a
->dw_attr
!= DW_AT_signature
);
9090 change_AT_die_ref (a
, ref_p
->stub
);
9093 /* We aren't changing this reference, so mark it external. */
9094 set_AT_ref_external (a
, 1);
9097 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
9099 dw_attr_node
*die_a
, *abbrev_a
;
9105 if (abbrev
->die_tag
!= die
->die_tag
)
9107 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
9110 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
9113 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
9115 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
9116 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
9117 || (value_format (abbrev_a
) != value_format (die_a
)))
9127 if (abbrev_id
>= vec_safe_length (abbrev_die_table
))
9129 vec_safe_push (abbrev_die_table
, die
);
9130 if (abbrev_opt_start
)
9131 abbrev_usage_count
.safe_push (0);
9133 if (abbrev_opt_start
&& abbrev_id
>= abbrev_opt_start
)
9135 abbrev_usage_count
[abbrev_id
- abbrev_opt_start
]++;
9136 sorted_abbrev_dies
.safe_push (die
);
9139 die
->die_abbrev
= abbrev_id
;
9140 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
9143 /* Callback function for sorted_abbrev_dies vector sorting. We sort
9144 by die_abbrev's usage count, from the most commonly used
9145 abbreviation to the least. */
9148 die_abbrev_cmp (const void *p1
, const void *p2
)
9150 dw_die_ref die1
= *(const dw_die_ref
*) p1
;
9151 dw_die_ref die2
= *(const dw_die_ref
*) p2
;
9153 gcc_checking_assert (die1
->die_abbrev
>= abbrev_opt_start
);
9154 gcc_checking_assert (die2
->die_abbrev
>= abbrev_opt_start
);
9156 if (die1
->die_abbrev
>= abbrev_opt_base_type_end
9157 && die2
->die_abbrev
>= abbrev_opt_base_type_end
)
9159 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
9160 > abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
9162 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
9163 < abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
9167 /* Stabilize the sort. */
9168 if (die1
->die_abbrev
< die2
->die_abbrev
)
9170 if (die1
->die_abbrev
> die2
->die_abbrev
)
9176 /* Convert dw_val_class_const and dw_val_class_unsigned_const class attributes
9177 of DIEs in between sorted_abbrev_dies[first_id] and abbrev_dies[end_id - 1]
9178 into dw_val_class_const_implicit or
9179 dw_val_class_unsigned_const_implicit. */
9182 optimize_implicit_const (unsigned int first_id
, unsigned int end
,
9183 vec
<bool> &implicit_consts
)
9185 /* It never makes sense if there is just one DIE using the abbreviation. */
9186 if (end
< first_id
+ 2)
9191 dw_die_ref die
= sorted_abbrev_dies
[first_id
];
9192 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9193 if (implicit_consts
[ix
])
9195 enum dw_val_class new_class
= dw_val_class_none
;
9196 switch (AT_class (a
))
9198 case dw_val_class_unsigned_const
:
9199 if ((HOST_WIDE_INT
) AT_unsigned (a
) < 0)
9202 /* The .debug_abbrev section will grow by
9203 size_of_sleb128 (AT_unsigned (a)) and we avoid the constants
9204 in all the DIEs using that abbreviation. */
9205 if (constant_size (AT_unsigned (a
)) * (end
- first_id
)
9206 <= (unsigned) size_of_sleb128 (AT_unsigned (a
)))
9209 new_class
= dw_val_class_unsigned_const_implicit
;
9212 case dw_val_class_const
:
9213 new_class
= dw_val_class_const_implicit
;
9216 case dw_val_class_file
:
9217 new_class
= dw_val_class_file_implicit
;
9223 for (i
= first_id
; i
< end
; i
++)
9224 (*sorted_abbrev_dies
[i
]->die_attr
)[ix
].dw_attr_val
.val_class
9229 /* Attempt to optimize abbreviation table from abbrev_opt_start
9230 abbreviation above. */
9233 optimize_abbrev_table (void)
9235 if (abbrev_opt_start
9236 && vec_safe_length (abbrev_die_table
) > abbrev_opt_start
9237 && (dwarf_version
>= 5 || vec_safe_length (abbrev_die_table
) > 127))
9239 auto_vec
<bool, 32> implicit_consts
;
9240 sorted_abbrev_dies
.qsort (die_abbrev_cmp
);
9242 unsigned int abbrev_id
= abbrev_opt_start
- 1;
9243 unsigned int first_id
= ~0U;
9244 unsigned int last_abbrev_id
= 0;
9247 if (abbrev_opt_base_type_end
> abbrev_opt_start
)
9248 abbrev_id
= abbrev_opt_base_type_end
- 1;
9249 /* Reassign abbreviation ids from abbrev_opt_start above, so that
9250 most commonly used abbreviations come first. */
9251 FOR_EACH_VEC_ELT (sorted_abbrev_dies
, i
, die
)
9256 /* If calc_base_type_die_sizes has been called, the CU and
9257 base types after it can't be optimized, because we've already
9258 calculated their DIE offsets. We've sorted them first. */
9259 if (die
->die_abbrev
< abbrev_opt_base_type_end
)
9261 if (die
->die_abbrev
!= last_abbrev_id
)
9263 last_abbrev_id
= die
->die_abbrev
;
9264 if (dwarf_version
>= 5 && first_id
!= ~0U)
9265 optimize_implicit_const (first_id
, i
, implicit_consts
);
9267 (*abbrev_die_table
)[abbrev_id
] = die
;
9268 if (dwarf_version
>= 5)
9271 implicit_consts
.truncate (0);
9273 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9274 switch (AT_class (a
))
9276 case dw_val_class_const
:
9277 case dw_val_class_unsigned_const
:
9278 case dw_val_class_file
:
9279 implicit_consts
.safe_push (true);
9282 implicit_consts
.safe_push (false);
9287 else if (dwarf_version
>= 5)
9289 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9290 if (!implicit_consts
[ix
])
9294 dw_attr_node
*other_a
9295 = &(*(*abbrev_die_table
)[abbrev_id
]->die_attr
)[ix
];
9296 if (!dw_val_equal_p (&a
->dw_attr_val
,
9297 &other_a
->dw_attr_val
))
9298 implicit_consts
[ix
] = false;
9301 die
->die_abbrev
= abbrev_id
;
9303 gcc_assert (abbrev_id
== vec_safe_length (abbrev_die_table
) - 1);
9304 if (dwarf_version
>= 5 && first_id
!= ~0U)
9305 optimize_implicit_const (first_id
, i
, implicit_consts
);
9308 abbrev_opt_start
= 0;
9309 abbrev_opt_base_type_end
= 0;
9310 abbrev_usage_count
.release ();
9311 sorted_abbrev_dies
.release ();
9314 /* Return the power-of-two number of bytes necessary to represent VALUE. */
9317 constant_size (unsigned HOST_WIDE_INT value
)
9324 log
= floor_log2 (value
);
9327 log
= 1 << (floor_log2 (log
) + 1);
9332 /* Return the size of a DIE as it is represented in the
9333 .debug_info section. */
9335 static unsigned long
9336 size_of_die (dw_die_ref die
)
9338 unsigned long size
= 0;
9341 enum dwarf_form form
;
9343 size
+= size_of_uleb128 (die
->die_abbrev
);
9344 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9346 switch (AT_class (a
))
9348 case dw_val_class_addr
:
9349 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9351 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9352 size
+= size_of_uleb128 (AT_index (a
));
9355 size
+= DWARF2_ADDR_SIZE
;
9357 case dw_val_class_offset
:
9358 size
+= DWARF_OFFSET_SIZE
;
9360 case dw_val_class_loc
:
9362 unsigned long lsize
= size_of_locs (AT_loc (a
));
9365 if (dwarf_version
>= 4)
9366 size
+= size_of_uleb128 (lsize
);
9368 size
+= constant_size (lsize
);
9372 case dw_val_class_loc_list
:
9373 if (dwarf_split_debug_info
&& dwarf_version
>= 5)
9375 gcc_assert (AT_loc_list (a
)->num_assigned
);
9376 size
+= size_of_uleb128 (AT_loc_list (a
)->hash
);
9379 size
+= DWARF_OFFSET_SIZE
;
9381 case dw_val_class_view_list
:
9382 size
+= DWARF_OFFSET_SIZE
;
9384 case dw_val_class_range_list
:
9385 if (value_format (a
) == DW_FORM_rnglistx
)
9387 gcc_assert (rnglist_idx
);
9388 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
9389 size
+= size_of_uleb128 (r
->idx
);
9392 size
+= DWARF_OFFSET_SIZE
;
9394 case dw_val_class_const
:
9395 size
+= size_of_sleb128 (AT_int (a
));
9397 case dw_val_class_unsigned_const
:
9399 int csize
= constant_size (AT_unsigned (a
));
9400 if (dwarf_version
== 3
9401 && a
->dw_attr
== DW_AT_data_member_location
9403 size
+= size_of_uleb128 (AT_unsigned (a
));
9408 case dw_val_class_symview
:
9409 if (symview_upper_bound
<= 0xff)
9411 else if (symview_upper_bound
<= 0xffff)
9413 else if (symview_upper_bound
<= 0xffffffff)
9418 case dw_val_class_const_implicit
:
9419 case dw_val_class_unsigned_const_implicit
:
9420 case dw_val_class_file_implicit
:
9421 /* These occupy no size in the DIE, just an extra sleb128 in
9424 case dw_val_class_const_double
:
9425 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
9426 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
9429 case dw_val_class_wide_int
:
9430 size
+= (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9431 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
9432 if (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9433 * HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
9436 case dw_val_class_vec
:
9437 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
9438 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
9439 + a
->dw_attr_val
.v
.val_vec
.length
9440 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
9442 case dw_val_class_flag
:
9443 if (dwarf_version
>= 4)
9444 /* Currently all add_AT_flag calls pass in 1 as last argument,
9445 so DW_FORM_flag_present can be used. If that ever changes,
9446 we'll need to use DW_FORM_flag and have some optimization
9447 in build_abbrev_table that will change those to
9448 DW_FORM_flag_present if it is set to 1 in all DIEs using
9449 the same abbrev entry. */
9450 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9454 case dw_val_class_die_ref
:
9455 if (AT_ref_external (a
))
9457 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
9458 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
9459 is sized by target address length, whereas in DWARF3
9460 it's always sized as an offset. */
9461 if (AT_ref (a
)->comdat_type_p
)
9462 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
9463 else if (dwarf_version
== 2)
9464 size
+= DWARF2_ADDR_SIZE
;
9466 size
+= DWARF_OFFSET_SIZE
;
9469 size
+= DWARF_OFFSET_SIZE
;
9471 case dw_val_class_fde_ref
:
9472 size
+= DWARF_OFFSET_SIZE
;
9474 case dw_val_class_lbl_id
:
9475 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9477 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9478 size
+= size_of_uleb128 (AT_index (a
));
9481 size
+= DWARF2_ADDR_SIZE
;
9483 case dw_val_class_lineptr
:
9484 case dw_val_class_macptr
:
9485 case dw_val_class_loclistsptr
:
9486 size
+= DWARF_OFFSET_SIZE
;
9488 case dw_val_class_str
:
9489 form
= AT_string_form (a
);
9490 if (form
== DW_FORM_strp
|| form
== DW_FORM_line_strp
)
9491 size
+= DWARF_OFFSET_SIZE
;
9492 else if (form
== dwarf_FORM (DW_FORM_strx
))
9493 size
+= size_of_uleb128 (AT_index (a
));
9495 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
9497 case dw_val_class_file
:
9498 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
9500 case dw_val_class_data8
:
9503 case dw_val_class_vms_delta
:
9504 size
+= DWARF_OFFSET_SIZE
;
9506 case dw_val_class_high_pc
:
9507 size
+= DWARF2_ADDR_SIZE
;
9509 case dw_val_class_discr_value
:
9510 size
+= size_of_discr_value (&a
->dw_attr_val
.v
.val_discr_value
);
9512 case dw_val_class_discr_list
:
9514 unsigned block_size
= size_of_discr_list (AT_discr_list (a
));
9516 /* This is a block, so we have the block length and then its
9518 size
+= constant_size (block_size
) + block_size
;
9529 /* Size the debugging information associated with a given DIE. Visits the
9530 DIE's children recursively. Updates the global variable next_die_offset, on
9531 each time through. Uses the current value of next_die_offset to update the
9532 die_offset field in each DIE. */
9535 calc_die_sizes (dw_die_ref die
)
9539 gcc_assert (die
->die_offset
== 0
9540 || (unsigned long int) die
->die_offset
== next_die_offset
);
9541 die
->die_offset
= next_die_offset
;
9542 next_die_offset
+= size_of_die (die
);
9544 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
9546 if (die
->die_child
!= NULL
)
9547 /* Count the null byte used to terminate sibling lists. */
9548 next_die_offset
+= 1;
9551 /* Size just the base type children at the start of the CU.
9552 This is needed because build_abbrev needs to size locs
9553 and sizing of type based stack ops needs to know die_offset
9554 values for the base types. */
9557 calc_base_type_die_sizes (void)
9559 unsigned long die_offset
= (dwarf_split_debug_info
9560 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
9561 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
9563 dw_die_ref base_type
;
9564 #if ENABLE_ASSERT_CHECKING
9565 dw_die_ref prev
= comp_unit_die ()->die_child
;
9568 die_offset
+= size_of_die (comp_unit_die ());
9569 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
9571 #if ENABLE_ASSERT_CHECKING
9572 gcc_assert (base_type
->die_offset
== 0
9573 && prev
->die_sib
== base_type
9574 && base_type
->die_child
== NULL
9575 && base_type
->die_abbrev
);
9578 if (abbrev_opt_start
9579 && base_type
->die_abbrev
>= abbrev_opt_base_type_end
)
9580 abbrev_opt_base_type_end
= base_type
->die_abbrev
+ 1;
9581 base_type
->die_offset
= die_offset
;
9582 die_offset
+= size_of_die (base_type
);
9586 /* Set the marks for a die and its children. We do this so
9587 that we know whether or not a reference needs to use FORM_ref_addr; only
9588 DIEs in the same CU will be marked. We used to clear out the offset
9589 and use that as the flag, but ran into ordering problems. */
9592 mark_dies (dw_die_ref die
)
9596 gcc_assert (!die
->die_mark
);
9599 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
9602 /* Clear the marks for a die and its children. */
9605 unmark_dies (dw_die_ref die
)
9609 if (! use_debug_types
)
9610 gcc_assert (die
->die_mark
);
9613 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
9616 /* Clear the marks for a die, its children and referred dies. */
9619 unmark_all_dies (dw_die_ref die
)
9629 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
9631 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9632 if (AT_class (a
) == dw_val_class_die_ref
)
9633 unmark_all_dies (AT_ref (a
));
9636 /* Calculate if the entry should appear in the final output file. It may be
9637 from a pruned a type. */
9640 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
9642 /* By limiting gnu pubnames to definitions only, gold can generate a
9643 gdb index without entries for declarations, which don't include
9644 enough information to be useful. */
9645 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
9648 if (table
== pubname_table
)
9650 /* Enumerator names are part of the pubname table, but the
9651 parent DW_TAG_enumeration_type die may have been pruned.
9652 Don't output them if that is the case. */
9653 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
9654 (p
->die
->die_parent
== NULL
9655 || !p
->die
->die_parent
->die_perennial_p
))
9658 /* Everything else in the pubname table is included. */
9662 /* The pubtypes table shouldn't include types that have been
9664 return (p
->die
->die_offset
!= 0
9665 || !flag_eliminate_unused_debug_types
);
9668 /* Return the size of the .debug_pubnames or .debug_pubtypes table
9669 generated for the compilation unit. */
9671 static unsigned long
9672 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9677 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
9679 size
= DWARF_PUBNAMES_HEADER_SIZE
;
9680 FOR_EACH_VEC_ELT (*names
, i
, p
)
9681 if (include_pubname_in_output (names
, p
))
9682 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1 + space_for_flags
;
9684 size
+= DWARF_OFFSET_SIZE
;
9688 /* Return the size of the information in the .debug_aranges section. */
9690 static unsigned long
9691 size_of_aranges (void)
9695 size
= DWARF_ARANGES_HEADER_SIZE
;
9697 /* Count the address/length pair for this compilation unit. */
9698 if (text_section_used
)
9699 size
+= 2 * DWARF2_ADDR_SIZE
;
9700 if (cold_text_section_used
)
9701 size
+= 2 * DWARF2_ADDR_SIZE
;
9702 if (have_multiple_function_sections
)
9707 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
9709 if (DECL_IGNORED_P (fde
->decl
))
9711 if (!fde
->in_std_section
)
9712 size
+= 2 * DWARF2_ADDR_SIZE
;
9713 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
9714 size
+= 2 * DWARF2_ADDR_SIZE
;
9718 /* Count the two zero words used to terminated the address range table. */
9719 size
+= 2 * DWARF2_ADDR_SIZE
;
9723 /* Select the encoding of an attribute value. */
9725 static enum dwarf_form
9726 value_format (dw_attr_node
*a
)
9728 switch (AT_class (a
))
9730 case dw_val_class_addr
:
9731 /* Only very few attributes allow DW_FORM_addr. */
9736 case DW_AT_entry_pc
:
9737 case DW_AT_trampoline
:
9738 return (AT_index (a
) == NOT_INDEXED
9739 ? DW_FORM_addr
: dwarf_FORM (DW_FORM_addrx
));
9743 switch (DWARF2_ADDR_SIZE
)
9746 return DW_FORM_data1
;
9748 return DW_FORM_data2
;
9750 return DW_FORM_data4
;
9752 return DW_FORM_data8
;
9756 case dw_val_class_loc_list
:
9757 if (dwarf_split_debug_info
9758 && dwarf_version
>= 5
9759 && AT_loc_list (a
)->num_assigned
)
9760 return DW_FORM_loclistx
;
9762 case dw_val_class_view_list
:
9763 case dw_val_class_range_list
:
9764 /* For range lists in DWARF 5, use DW_FORM_rnglistx from .debug_info.dwo
9765 but in .debug_info use DW_FORM_sec_offset, which is shorter if we
9766 care about sizes of .debug* sections in shared libraries and
9767 executables and don't take into account relocations that affect just
9768 relocatable objects - for DW_FORM_rnglistx we'd have to emit offset
9769 table in the .debug_rnglists section. */
9770 if (dwarf_split_debug_info
9771 && dwarf_version
>= 5
9772 && AT_class (a
) == dw_val_class_range_list
9774 && a
->dw_attr_val
.val_entry
!= RELOCATED_OFFSET
)
9775 return DW_FORM_rnglistx
;
9776 if (dwarf_version
>= 4)
9777 return DW_FORM_sec_offset
;
9779 case dw_val_class_vms_delta
:
9780 case dw_val_class_offset
:
9781 switch (DWARF_OFFSET_SIZE
)
9784 return DW_FORM_data4
;
9786 return DW_FORM_data8
;
9790 case dw_val_class_loc
:
9791 if (dwarf_version
>= 4)
9792 return DW_FORM_exprloc
;
9793 switch (constant_size (size_of_locs (AT_loc (a
))))
9796 return DW_FORM_block1
;
9798 return DW_FORM_block2
;
9800 return DW_FORM_block4
;
9804 case dw_val_class_const
:
9805 return DW_FORM_sdata
;
9806 case dw_val_class_unsigned_const
:
9807 switch (constant_size (AT_unsigned (a
)))
9810 return DW_FORM_data1
;
9812 return DW_FORM_data2
;
9814 /* In DWARF3 DW_AT_data_member_location with
9815 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
9816 constant, so we need to use DW_FORM_udata if we need
9817 a large constant. */
9818 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9819 return DW_FORM_udata
;
9820 return DW_FORM_data4
;
9822 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9823 return DW_FORM_udata
;
9824 return DW_FORM_data8
;
9828 case dw_val_class_const_implicit
:
9829 case dw_val_class_unsigned_const_implicit
:
9830 case dw_val_class_file_implicit
:
9831 return DW_FORM_implicit_const
;
9832 case dw_val_class_const_double
:
9833 switch (HOST_BITS_PER_WIDE_INT
)
9836 return DW_FORM_data2
;
9838 return DW_FORM_data4
;
9840 return DW_FORM_data8
;
9842 if (dwarf_version
>= 5)
9843 return DW_FORM_data16
;
9846 return DW_FORM_block1
;
9848 case dw_val_class_wide_int
:
9849 switch (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
)
9852 return DW_FORM_data1
;
9854 return DW_FORM_data2
;
9856 return DW_FORM_data4
;
9858 return DW_FORM_data8
;
9860 if (dwarf_version
>= 5)
9861 return DW_FORM_data16
;
9864 return DW_FORM_block1
;
9866 case dw_val_class_symview
:
9867 /* ??? We might use uleb128, but then we'd have to compute
9868 .debug_info offsets in the assembler. */
9869 if (symview_upper_bound
<= 0xff)
9870 return DW_FORM_data1
;
9871 else if (symview_upper_bound
<= 0xffff)
9872 return DW_FORM_data2
;
9873 else if (symview_upper_bound
<= 0xffffffff)
9874 return DW_FORM_data4
;
9876 return DW_FORM_data8
;
9877 case dw_val_class_vec
:
9878 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
9879 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
9882 return DW_FORM_block1
;
9884 return DW_FORM_block2
;
9886 return DW_FORM_block4
;
9890 case dw_val_class_flag
:
9891 if (dwarf_version
>= 4)
9893 /* Currently all add_AT_flag calls pass in 1 as last argument,
9894 so DW_FORM_flag_present can be used. If that ever changes,
9895 we'll need to use DW_FORM_flag and have some optimization
9896 in build_abbrev_table that will change those to
9897 DW_FORM_flag_present if it is set to 1 in all DIEs using
9898 the same abbrev entry. */
9899 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9900 return DW_FORM_flag_present
;
9902 return DW_FORM_flag
;
9903 case dw_val_class_die_ref
:
9904 if (AT_ref_external (a
))
9906 if (AT_ref (a
)->comdat_type_p
)
9907 return DW_FORM_ref_sig8
;
9909 return DW_FORM_ref_addr
;
9913 case dw_val_class_fde_ref
:
9914 return DW_FORM_data
;
9915 case dw_val_class_lbl_id
:
9916 return (AT_index (a
) == NOT_INDEXED
9917 ? DW_FORM_addr
: dwarf_FORM (DW_FORM_addrx
));
9918 case dw_val_class_lineptr
:
9919 case dw_val_class_macptr
:
9920 case dw_val_class_loclistsptr
:
9921 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
9922 case dw_val_class_str
:
9923 return AT_string_form (a
);
9924 case dw_val_class_file
:
9925 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
9928 return DW_FORM_data1
;
9930 return DW_FORM_data2
;
9932 return DW_FORM_data4
;
9937 case dw_val_class_data8
:
9938 return DW_FORM_data8
;
9940 case dw_val_class_high_pc
:
9941 switch (DWARF2_ADDR_SIZE
)
9944 return DW_FORM_data1
;
9946 return DW_FORM_data2
;
9948 return DW_FORM_data4
;
9950 return DW_FORM_data8
;
9955 case dw_val_class_discr_value
:
9956 return (a
->dw_attr_val
.v
.val_discr_value
.pos
9959 case dw_val_class_discr_list
:
9960 switch (constant_size (size_of_discr_list (AT_discr_list (a
))))
9963 return DW_FORM_block1
;
9965 return DW_FORM_block2
;
9967 return DW_FORM_block4
;
9977 /* Output the encoding of an attribute value. */
9980 output_value_format (dw_attr_node
*a
)
9982 enum dwarf_form form
= value_format (a
);
9984 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
9987 /* Given a die and id, produce the appropriate abbreviations. */
9990 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
9993 dw_attr_node
*a_attr
;
9995 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
9996 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
9997 dwarf_tag_name (abbrev
->die_tag
));
9999 if (abbrev
->die_child
!= NULL
)
10000 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
10002 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
10004 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
10006 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
10007 dwarf_attr_name (a_attr
->dw_attr
));
10008 output_value_format (a_attr
);
10009 if (value_format (a_attr
) == DW_FORM_implicit_const
)
10011 if (AT_class (a_attr
) == dw_val_class_file_implicit
)
10013 int f
= maybe_emit_file (a_attr
->dw_attr_val
.v
.val_file
);
10014 const char *filename
= a_attr
->dw_attr_val
.v
.val_file
->filename
;
10015 dw2_asm_output_data_sleb128 (f
, "(%s)", filename
);
10018 dw2_asm_output_data_sleb128 (a_attr
->dw_attr_val
.v
.val_int
, NULL
);
10022 dw2_asm_output_data (1, 0, NULL
);
10023 dw2_asm_output_data (1, 0, NULL
);
10027 /* Output the .debug_abbrev section which defines the DIE abbreviation
10031 output_abbrev_section (void)
10033 unsigned int abbrev_id
;
10036 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
10037 if (abbrev_id
!= 0)
10038 output_die_abbrevs (abbrev_id
, abbrev
);
10040 /* Terminate the table. */
10041 dw2_asm_output_data (1, 0, NULL
);
10044 /* Return a new location list, given the begin and end range, and the
10047 static inline dw_loc_list_ref
10048 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, var_loc_view vbegin
,
10049 const char *end
, var_loc_view vend
,
10050 const char *section
)
10052 dw_loc_list_ref retlist
= ggc_cleared_alloc
<dw_loc_list_node
> ();
10054 retlist
->begin
= begin
;
10055 retlist
->begin_entry
= NULL
;
10056 retlist
->end
= end
;
10057 retlist
->expr
= expr
;
10058 retlist
->section
= section
;
10059 retlist
->vbegin
= vbegin
;
10060 retlist
->vend
= vend
;
10065 /* Return true iff there's any nonzero view number in the loc list.
10067 ??? When views are not enabled, we'll often extend a single range
10068 to the entire function, so that we emit a single location
10069 expression rather than a location list. With views, even with a
10070 single range, we'll output a list if start or end have a nonzero
10071 view. If we change this, we may want to stop splitting a single
10072 range in dw_loc_list just because of a nonzero view, even if it
10073 straddles across hot/cold partitions. */
10076 loc_list_has_views (dw_loc_list_ref list
)
10078 if (!debug_variable_location_views
)
10081 for (dw_loc_list_ref loc
= list
;
10082 loc
!= NULL
; loc
= loc
->dw_loc_next
)
10083 if (!ZERO_VIEW_P (loc
->vbegin
) || !ZERO_VIEW_P (loc
->vend
))
10089 /* Generate a new internal symbol for this location list node, if it
10090 hasn't got one yet. */
10093 gen_llsym (dw_loc_list_ref list
)
10095 gcc_assert (!list
->ll_symbol
);
10096 list
->ll_symbol
= gen_internal_sym ("LLST");
10098 if (!loc_list_has_views (list
))
10101 if (dwarf2out_locviews_in_attribute ())
10103 /* Use the same label_num for the view list. */
10105 list
->vl_symbol
= gen_internal_sym ("LVUS");
10108 list
->vl_symbol
= list
->ll_symbol
;
10111 /* Generate a symbol for the list, but only if we really want to emit
10115 maybe_gen_llsym (dw_loc_list_ref list
)
10117 if (!list
|| (!list
->dw_loc_next
&& !loc_list_has_views (list
)))
10123 /* Determine whether or not to skip loc_list entry CURR. If SIZEP is
10124 NULL, don't consider size of the location expression. If we're not
10125 to skip it, and SIZEP is non-null, store the size of CURR->expr's
10126 representation in *SIZEP. */
10129 skip_loc_list_entry (dw_loc_list_ref curr
, unsigned long *sizep
= NULL
)
10131 /* Don't output an entry that starts and ends at the same address. */
10132 if (strcmp (curr
->begin
, curr
->end
) == 0
10133 && curr
->vbegin
== curr
->vend
&& !curr
->force
)
10139 unsigned long size
= size_of_locs (curr
->expr
);
10141 /* If the expression is too large, drop it on the floor. We could
10142 perhaps put it into DW_TAG_dwarf_procedure and refer to that
10143 in the expression, but >= 64KB expressions for a single value
10144 in a single range are unlikely very useful. */
10145 if (dwarf_version
< 5 && size
> 0xffff)
10153 /* Output a view pair loclist entry for CURR, if it requires one. */
10156 dwarf2out_maybe_output_loclist_view_pair (dw_loc_list_ref curr
)
10158 if (!dwarf2out_locviews_in_loclist ())
10161 if (ZERO_VIEW_P (curr
->vbegin
) && ZERO_VIEW_P (curr
->vend
))
10164 #ifdef DW_LLE_view_pair
10165 dw2_asm_output_data (1, DW_LLE_view_pair
, "DW_LLE_view_pair");
10167 if (dwarf2out_as_locview_support
)
10169 if (ZERO_VIEW_P (curr
->vbegin
))
10170 dw2_asm_output_data_uleb128 (0, "Location view begin");
10173 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10174 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vbegin
);
10175 dw2_asm_output_symname_uleb128 (label
, "Location view begin");
10178 if (ZERO_VIEW_P (curr
->vend
))
10179 dw2_asm_output_data_uleb128 (0, "Location view end");
10182 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10183 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vend
);
10184 dw2_asm_output_symname_uleb128 (label
, "Location view end");
10189 dw2_asm_output_data_uleb128 (curr
->vbegin
, "Location view begin");
10190 dw2_asm_output_data_uleb128 (curr
->vend
, "Location view end");
10192 #endif /* DW_LLE_view_pair */
10197 /* Output the location list given to us. */
10200 output_loc_list (dw_loc_list_ref list_head
)
10202 int vcount
= 0, lcount
= 0;
10204 if (list_head
->emitted
)
10206 list_head
->emitted
= true;
10208 if (list_head
->vl_symbol
&& dwarf2out_locviews_in_attribute ())
10210 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->vl_symbol
);
10212 for (dw_loc_list_ref curr
= list_head
; curr
!= NULL
;
10213 curr
= curr
->dw_loc_next
)
10215 unsigned long size
;
10217 if (skip_loc_list_entry (curr
, &size
))
10222 /* ?? dwarf_split_debug_info? */
10223 if (dwarf2out_as_locview_support
)
10225 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10227 if (!ZERO_VIEW_P (curr
->vbegin
))
10229 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vbegin
);
10230 dw2_asm_output_symname_uleb128 (label
,
10231 "View list begin (%s)",
10232 list_head
->vl_symbol
);
10235 dw2_asm_output_data_uleb128 (0,
10236 "View list begin (%s)",
10237 list_head
->vl_symbol
);
10239 if (!ZERO_VIEW_P (curr
->vend
))
10241 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", curr
->vend
);
10242 dw2_asm_output_symname_uleb128 (label
,
10243 "View list end (%s)",
10244 list_head
->vl_symbol
);
10247 dw2_asm_output_data_uleb128 (0,
10248 "View list end (%s)",
10249 list_head
->vl_symbol
);
10253 dw2_asm_output_data_uleb128 (curr
->vbegin
,
10254 "View list begin (%s)",
10255 list_head
->vl_symbol
);
10256 dw2_asm_output_data_uleb128 (curr
->vend
,
10257 "View list end (%s)",
10258 list_head
->vl_symbol
);
10263 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
10265 const char *last_section
= NULL
;
10266 const char *base_label
= NULL
;
10268 /* Walk the location list, and output each range + expression. */
10269 for (dw_loc_list_ref curr
= list_head
; curr
!= NULL
;
10270 curr
= curr
->dw_loc_next
)
10272 unsigned long size
;
10274 /* Skip this entry? If we skip it here, we must skip it in the
10275 view list above as well. */
10276 if (skip_loc_list_entry (curr
, &size
))
10281 if (dwarf_version
>= 5)
10283 if (dwarf_split_debug_info
)
10285 dwarf2out_maybe_output_loclist_view_pair (curr
);
10286 /* For -gsplit-dwarf, emit DW_LLE_starx_length, which has
10287 uleb128 index into .debug_addr and uleb128 length. */
10288 dw2_asm_output_data (1, DW_LLE_startx_length
,
10289 "DW_LLE_startx_length (%s)",
10290 list_head
->ll_symbol
);
10291 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10292 "Location list range start index "
10293 "(%s)", curr
->begin
);
10294 /* FIXME: This will ICE ifndef HAVE_AS_LEB128.
10295 For that case we probably need to emit DW_LLE_startx_endx,
10296 but we'd need 2 .debug_addr entries rather than just one. */
10297 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
10298 "Location list length (%s)",
10299 list_head
->ll_symbol
);
10301 else if (!have_multiple_function_sections
&& HAVE_AS_LEB128
)
10303 dwarf2out_maybe_output_loclist_view_pair (curr
);
10304 /* If all code is in .text section, the base address is
10305 already provided by the CU attributes. Use
10306 DW_LLE_offset_pair where both addresses are uleb128 encoded
10307 offsets against that base. */
10308 dw2_asm_output_data (1, DW_LLE_offset_pair
,
10309 "DW_LLE_offset_pair (%s)",
10310 list_head
->ll_symbol
);
10311 dw2_asm_output_delta_uleb128 (curr
->begin
, curr
->section
,
10312 "Location list begin address (%s)",
10313 list_head
->ll_symbol
);
10314 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->section
,
10315 "Location list end address (%s)",
10316 list_head
->ll_symbol
);
10318 else if (HAVE_AS_LEB128
)
10320 /* Otherwise, find out how many consecutive entries could share
10321 the same base entry. If just one, emit DW_LLE_start_length,
10322 otherwise emit DW_LLE_base_address for the base address
10323 followed by a series of DW_LLE_offset_pair. */
10324 if (last_section
== NULL
|| curr
->section
!= last_section
)
10326 dw_loc_list_ref curr2
;
10327 for (curr2
= curr
->dw_loc_next
; curr2
!= NULL
;
10328 curr2
= curr2
->dw_loc_next
)
10330 if (strcmp (curr2
->begin
, curr2
->end
) == 0
10335 if (curr2
== NULL
|| curr
->section
!= curr2
->section
)
10336 last_section
= NULL
;
10339 last_section
= curr
->section
;
10340 base_label
= curr
->begin
;
10341 dw2_asm_output_data (1, DW_LLE_base_address
,
10342 "DW_LLE_base_address (%s)",
10343 list_head
->ll_symbol
);
10344 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, base_label
,
10345 "Base address (%s)",
10346 list_head
->ll_symbol
);
10349 /* Only one entry with the same base address. Use
10350 DW_LLE_start_length with absolute address and uleb128
10352 if (last_section
== NULL
)
10354 dwarf2out_maybe_output_loclist_view_pair (curr
);
10355 dw2_asm_output_data (1, DW_LLE_start_length
,
10356 "DW_LLE_start_length (%s)",
10357 list_head
->ll_symbol
);
10358 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10359 "Location list begin address (%s)",
10360 list_head
->ll_symbol
);
10361 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
10362 "Location list length "
10363 "(%s)", list_head
->ll_symbol
);
10365 /* Otherwise emit DW_LLE_offset_pair, relative to above emitted
10366 DW_LLE_base_address. */
10369 dwarf2out_maybe_output_loclist_view_pair (curr
);
10370 dw2_asm_output_data (1, DW_LLE_offset_pair
,
10371 "DW_LLE_offset_pair (%s)",
10372 list_head
->ll_symbol
);
10373 dw2_asm_output_delta_uleb128 (curr
->begin
, base_label
,
10374 "Location list begin address "
10375 "(%s)", list_head
->ll_symbol
);
10376 dw2_asm_output_delta_uleb128 (curr
->end
, base_label
,
10377 "Location list end address "
10378 "(%s)", list_head
->ll_symbol
);
10381 /* The assembler does not support .uleb128 directive. Emit
10382 DW_LLE_start_end with a pair of absolute addresses. */
10385 dwarf2out_maybe_output_loclist_view_pair (curr
);
10386 dw2_asm_output_data (1, DW_LLE_start_end
,
10387 "DW_LLE_start_end (%s)",
10388 list_head
->ll_symbol
);
10389 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10390 "Location list begin address (%s)",
10391 list_head
->ll_symbol
);
10392 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10393 "Location list end address (%s)",
10394 list_head
->ll_symbol
);
10397 else if (dwarf_split_debug_info
)
10399 /* For -gsplit-dwarf -gdwarf-{2,3,4} emit index into .debug_addr
10400 and 4 byte length. */
10401 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
10402 "Location list start/length entry (%s)",
10403 list_head
->ll_symbol
);
10404 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
10405 "Location list range start index (%s)",
10407 /* The length field is 4 bytes. If we ever need to support
10408 an 8-byte length, we can add a new DW_LLE code or fall back
10409 to DW_LLE_GNU_start_end_entry. */
10410 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
10411 "Location list range length (%s)",
10412 list_head
->ll_symbol
);
10414 else if (!have_multiple_function_sections
)
10416 /* Pair of relative addresses against start of text section. */
10417 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
10418 "Location list begin address (%s)",
10419 list_head
->ll_symbol
);
10420 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
10421 "Location list end address (%s)",
10422 list_head
->ll_symbol
);
10426 /* Pair of absolute addresses. */
10427 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10428 "Location list begin address (%s)",
10429 list_head
->ll_symbol
);
10430 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10431 "Location list end address (%s)",
10432 list_head
->ll_symbol
);
10435 /* Output the block length for this list of location operations. */
10436 if (dwarf_version
>= 5)
10437 dw2_asm_output_data_uleb128 (size
, "Location expression size");
10440 gcc_assert (size
<= 0xffff);
10441 dw2_asm_output_data (2, size
, "Location expression size");
10444 output_loc_sequence (curr
->expr
, -1);
10447 /* And finally list termination. */
10448 if (dwarf_version
>= 5)
10449 dw2_asm_output_data (1, DW_LLE_end_of_list
,
10450 "DW_LLE_end_of_list (%s)", list_head
->ll_symbol
);
10451 else if (dwarf_split_debug_info
)
10452 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
10453 "Location list terminator (%s)",
10454 list_head
->ll_symbol
);
10457 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10458 "Location list terminator begin (%s)",
10459 list_head
->ll_symbol
);
10460 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10461 "Location list terminator end (%s)",
10462 list_head
->ll_symbol
);
10465 gcc_assert (!list_head
->vl_symbol
10466 || vcount
== lcount
* (dwarf2out_locviews_in_attribute () ? 1 : 0));
10469 /* Output a range_list offset into the .debug_ranges or .debug_rnglists
10470 section. Emit a relocated reference if val_entry is NULL, otherwise,
10471 emit an indirect reference. */
10474 output_range_list_offset (dw_attr_node
*a
)
10476 const char *name
= dwarf_attr_name (a
->dw_attr
);
10478 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
10480 if (dwarf_version
>= 5)
10482 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
10483 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, r
->label
,
10484 debug_ranges_section
, "%s", name
);
10488 char *p
= strchr (ranges_section_label
, '\0');
10489 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
10490 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
);
10491 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
10492 debug_ranges_section
, "%s", name
);
10496 else if (dwarf_version
>= 5)
10498 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
10499 gcc_assert (rnglist_idx
);
10500 dw2_asm_output_data_uleb128 (r
->idx
, "%s", name
);
10503 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
10504 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
,
10505 "%s (offset from %s)", name
, ranges_section_label
);
10508 /* Output the offset into the debug_loc section. */
10511 output_loc_list_offset (dw_attr_node
*a
)
10513 char *sym
= AT_loc_list (a
)->ll_symbol
;
10516 if (!dwarf_split_debug_info
)
10517 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
10518 "%s", dwarf_attr_name (a
->dw_attr
));
10519 else if (dwarf_version
>= 5)
10521 gcc_assert (AT_loc_list (a
)->num_assigned
);
10522 dw2_asm_output_data_uleb128 (AT_loc_list (a
)->hash
, "%s (%s)",
10523 dwarf_attr_name (a
->dw_attr
),
10527 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
10528 "%s", dwarf_attr_name (a
->dw_attr
));
10531 /* Output the offset into the debug_loc section. */
10534 output_view_list_offset (dw_attr_node
*a
)
10536 char *sym
= (*AT_loc_list_ptr (a
))->vl_symbol
;
10539 if (dwarf_split_debug_info
)
10540 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
10541 "%s", dwarf_attr_name (a
->dw_attr
));
10543 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
10544 "%s", dwarf_attr_name (a
->dw_attr
));
10547 /* Output an attribute's index or value appropriately. */
10550 output_attr_index_or_value (dw_attr_node
*a
)
10552 const char *name
= dwarf_attr_name (a
->dw_attr
);
10554 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
10556 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
10559 switch (AT_class (a
))
10561 case dw_val_class_addr
:
10562 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
10564 case dw_val_class_high_pc
:
10565 case dw_val_class_lbl_id
:
10566 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
10569 gcc_unreachable ();
10573 /* Output a type signature. */
10576 output_signature (const char *sig
, const char *name
)
10580 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
10581 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
10584 /* Output a discriminant value. */
10587 output_discr_value (dw_discr_value
*discr_value
, const char *name
)
10589 if (discr_value
->pos
)
10590 dw2_asm_output_data_uleb128 (discr_value
->v
.uval
, "%s", name
);
10592 dw2_asm_output_data_sleb128 (discr_value
->v
.sval
, "%s", name
);
10595 /* Output the DIE and its attributes. Called recursively to generate
10596 the definitions of each child DIE. */
10599 output_die (dw_die_ref die
)
10603 unsigned long size
;
10606 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
10607 (unsigned long)die
->die_offset
,
10608 dwarf_tag_name (die
->die_tag
));
10610 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
10612 const char *name
= dwarf_attr_name (a
->dw_attr
);
10614 switch (AT_class (a
))
10616 case dw_val_class_addr
:
10617 output_attr_index_or_value (a
);
10620 case dw_val_class_offset
:
10621 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
10625 case dw_val_class_range_list
:
10626 output_range_list_offset (a
);
10629 case dw_val_class_loc
:
10630 size
= size_of_locs (AT_loc (a
));
10632 /* Output the block length for this list of location operations. */
10633 if (dwarf_version
>= 4)
10634 dw2_asm_output_data_uleb128 (size
, "%s", name
);
10636 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
10638 output_loc_sequence (AT_loc (a
), -1);
10641 case dw_val_class_const
:
10642 /* ??? It would be slightly more efficient to use a scheme like is
10643 used for unsigned constants below, but gdb 4.x does not sign
10644 extend. Gdb 5.x does sign extend. */
10645 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
10648 case dw_val_class_unsigned_const
:
10650 int csize
= constant_size (AT_unsigned (a
));
10651 if (dwarf_version
== 3
10652 && a
->dw_attr
== DW_AT_data_member_location
10654 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
10656 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
10660 case dw_val_class_symview
:
10663 if (symview_upper_bound
<= 0xff)
10665 else if (symview_upper_bound
<= 0xffff)
10667 else if (symview_upper_bound
<= 0xffffffff)
10671 dw2_asm_output_addr (vsize
, a
->dw_attr_val
.v
.val_symbolic_view
,
10676 case dw_val_class_const_implicit
:
10677 if (flag_debug_asm
)
10678 fprintf (asm_out_file
, "\t\t\t%s %s ("
10679 HOST_WIDE_INT_PRINT_DEC
")\n",
10680 ASM_COMMENT_START
, name
, AT_int (a
));
10683 case dw_val_class_unsigned_const_implicit
:
10684 if (flag_debug_asm
)
10685 fprintf (asm_out_file
, "\t\t\t%s %s ("
10686 HOST_WIDE_INT_PRINT_HEX
")\n",
10687 ASM_COMMENT_START
, name
, AT_unsigned (a
));
10690 case dw_val_class_const_double
:
10692 unsigned HOST_WIDE_INT first
, second
;
10694 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
10695 dw2_asm_output_data (1,
10696 HOST_BITS_PER_DOUBLE_INT
10697 / HOST_BITS_PER_CHAR
,
10700 if (WORDS_BIG_ENDIAN
)
10702 first
= a
->dw_attr_val
.v
.val_double
.high
;
10703 second
= a
->dw_attr_val
.v
.val_double
.low
;
10707 first
= a
->dw_attr_val
.v
.val_double
.low
;
10708 second
= a
->dw_attr_val
.v
.val_double
.high
;
10711 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10712 first
, "%s", name
);
10713 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10718 case dw_val_class_wide_int
:
10721 int len
= get_full_len (*a
->dw_attr_val
.v
.val_wide
);
10722 int l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
10723 if (len
* HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
10724 dw2_asm_output_data (1, get_full_len (*a
->dw_attr_val
.v
.val_wide
)
10727 if (WORDS_BIG_ENDIAN
)
10728 for (i
= len
- 1; i
>= 0; --i
)
10730 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10735 for (i
= 0; i
< len
; ++i
)
10737 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10744 case dw_val_class_vec
:
10746 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
10747 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
10751 dw2_asm_output_data (constant_size (len
* elt_size
),
10752 len
* elt_size
, "%s", name
);
10753 if (elt_size
> sizeof (HOST_WIDE_INT
))
10758 for (i
= 0, p
= (unsigned char *) a
->dw_attr_val
.v
.val_vec
.array
;
10760 i
++, p
+= elt_size
)
10761 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
10762 "fp or vector constant word %u", i
);
10766 case dw_val_class_flag
:
10767 if (dwarf_version
>= 4)
10769 /* Currently all add_AT_flag calls pass in 1 as last argument,
10770 so DW_FORM_flag_present can be used. If that ever changes,
10771 we'll need to use DW_FORM_flag and have some optimization
10772 in build_abbrev_table that will change those to
10773 DW_FORM_flag_present if it is set to 1 in all DIEs using
10774 the same abbrev entry. */
10775 gcc_assert (AT_flag (a
) == 1);
10776 if (flag_debug_asm
)
10777 fprintf (asm_out_file
, "\t\t\t%s %s\n",
10778 ASM_COMMENT_START
, name
);
10781 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
10784 case dw_val_class_loc_list
:
10785 output_loc_list_offset (a
);
10788 case dw_val_class_view_list
:
10789 output_view_list_offset (a
);
10792 case dw_val_class_die_ref
:
10793 if (AT_ref_external (a
))
10795 if (AT_ref (a
)->comdat_type_p
)
10797 comdat_type_node
*type_node
10798 = AT_ref (a
)->die_id
.die_type_node
;
10800 gcc_assert (type_node
);
10801 output_signature (type_node
->signature
, name
);
10805 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
10809 /* In DWARF2, DW_FORM_ref_addr is sized by target address
10810 length, whereas in DWARF3 it's always sized as an
10812 if (dwarf_version
== 2)
10813 size
= DWARF2_ADDR_SIZE
;
10815 size
= DWARF_OFFSET_SIZE
;
10816 /* ??? We cannot unconditionally output die_offset if
10817 non-zero - others might create references to those
10819 And we do not clear its DIE offset after outputting it
10820 (and the label refers to the actual DIEs, not the
10821 DWARF CU unit header which is when using label + offset
10822 would be the correct thing to do).
10823 ??? This is the reason for the with_offset flag. */
10824 if (AT_ref (a
)->with_offset
)
10825 dw2_asm_output_offset (size
, sym
, AT_ref (a
)->die_offset
,
10826 debug_info_section
, "%s", name
);
10828 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
10834 gcc_assert (AT_ref (a
)->die_offset
);
10835 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
10840 case dw_val_class_fde_ref
:
10842 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
10844 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
10845 a
->dw_attr_val
.v
.val_fde_index
* 2);
10846 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
10851 case dw_val_class_vms_delta
:
10852 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
10853 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
10854 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
10857 dw2_asm_output_delta (DWARF_OFFSET_SIZE
,
10858 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
10863 case dw_val_class_lbl_id
:
10864 output_attr_index_or_value (a
);
10867 case dw_val_class_lineptr
:
10868 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10869 debug_line_section
, "%s", name
);
10872 case dw_val_class_macptr
:
10873 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10874 debug_macinfo_section
, "%s", name
);
10877 case dw_val_class_loclistsptr
:
10878 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10879 debug_loc_section
, "%s", name
);
10882 case dw_val_class_str
:
10883 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
10884 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
10885 a
->dw_attr_val
.v
.val_str
->label
,
10887 "%s: \"%s\"", name
, AT_string (a
));
10888 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_line_strp
)
10889 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
10890 a
->dw_attr_val
.v
.val_str
->label
,
10891 debug_line_str_section
,
10892 "%s: \"%s\"", name
, AT_string (a
));
10893 else if (a
->dw_attr_val
.v
.val_str
->form
== dwarf_FORM (DW_FORM_strx
))
10894 dw2_asm_output_data_uleb128 (AT_index (a
),
10895 "%s: \"%s\"", name
, AT_string (a
));
10897 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
10900 case dw_val_class_file
:
10902 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
10904 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
10905 a
->dw_attr_val
.v
.val_file
->filename
);
10909 case dw_val_class_file_implicit
:
10910 if (flag_debug_asm
)
10911 fprintf (asm_out_file
, "\t\t\t%s %s (%d, %s)\n",
10912 ASM_COMMENT_START
, name
,
10913 maybe_emit_file (a
->dw_attr_val
.v
.val_file
),
10914 a
->dw_attr_val
.v
.val_file
->filename
);
10917 case dw_val_class_data8
:
10921 for (i
= 0; i
< 8; i
++)
10922 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
10923 i
== 0 ? "%s" : NULL
, name
);
10927 case dw_val_class_high_pc
:
10928 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
10929 get_AT_low_pc (die
), "DW_AT_high_pc");
10932 case dw_val_class_discr_value
:
10933 output_discr_value (&a
->dw_attr_val
.v
.val_discr_value
, name
);
10936 case dw_val_class_discr_list
:
10938 dw_discr_list_ref list
= AT_discr_list (a
);
10939 const int size
= size_of_discr_list (list
);
10941 /* This is a block, so output its length first. */
10942 dw2_asm_output_data (constant_size (size
), size
,
10943 "%s: block size", name
);
10945 for (; list
!= NULL
; list
= list
->dw_discr_next
)
10947 /* One byte for the discriminant value descriptor, and then as
10948 many LEB128 numbers as required. */
10949 if (list
->dw_discr_range
)
10950 dw2_asm_output_data (1, DW_DSC_range
,
10951 "%s: DW_DSC_range", name
);
10953 dw2_asm_output_data (1, DW_DSC_label
,
10954 "%s: DW_DSC_label", name
);
10956 output_discr_value (&list
->dw_discr_lower_bound
, name
);
10957 if (list
->dw_discr_range
)
10958 output_discr_value (&list
->dw_discr_upper_bound
, name
);
10964 gcc_unreachable ();
10968 FOR_EACH_CHILD (die
, c
, output_die (c
));
10970 /* Add null byte to terminate sibling list. */
10971 if (die
->die_child
!= NULL
)
10972 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
10973 (unsigned long) die
->die_offset
);
10976 /* Output the dwarf version number. */
10979 output_dwarf_version ()
10981 /* ??? For now, if -gdwarf-6 is specified, we output version 5 with
10982 views in loclist. That will change eventually. */
10983 if (dwarf_version
== 6)
10988 warning (0, "%<-gdwarf-6%> is output as version 5 with "
10989 "incompatibilities");
10992 dw2_asm_output_data (2, 5, "DWARF version number");
10995 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
10998 /* Output the compilation unit that appears at the beginning of the
10999 .debug_info section, and precedes the DIE descriptions. */
11002 output_compilation_unit_header (enum dwarf_unit_type ut
)
11004 if (!XCOFF_DEBUGGING_INFO
)
11006 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11007 dw2_asm_output_data (4, 0xffffffff,
11008 "Initial length escape value indicating 64-bit DWARF extension");
11009 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
11010 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
11011 "Length of Compilation Unit Info");
11014 output_dwarf_version ();
11015 if (dwarf_version
>= 5)
11020 case DW_UT_compile
: name
= "DW_UT_compile"; break;
11021 case DW_UT_type
: name
= "DW_UT_type"; break;
11022 case DW_UT_split_compile
: name
= "DW_UT_split_compile"; break;
11023 case DW_UT_split_type
: name
= "DW_UT_split_type"; break;
11024 default: gcc_unreachable ();
11026 dw2_asm_output_data (1, ut
, "%s", name
);
11027 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11029 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
11030 debug_abbrev_section
,
11031 "Offset Into Abbrev. Section");
11032 if (dwarf_version
< 5)
11033 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11036 /* Output the compilation unit DIE and its children. */
11039 output_comp_unit (dw_die_ref die
, int output_if_empty
,
11040 const unsigned char *dwo_id
)
11042 const char *secname
, *oldsym
;
11045 /* Unless we are outputting main CU, we may throw away empty ones. */
11046 if (!output_if_empty
&& die
->die_child
== NULL
)
11049 /* Even if there are no children of this DIE, we must output the information
11050 about the compilation unit. Otherwise, on an empty translation unit, we
11051 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
11052 will then complain when examining the file. First mark all the DIEs in
11053 this CU so we know which get local refs. */
11056 external_ref_hash_type
*extern_map
= optimize_external_refs (die
);
11058 /* For now, optimize only the main CU, in order to optimize the rest
11059 we'd need to see all of them earlier. Leave the rest for post-linking
11061 if (die
== comp_unit_die ())
11062 abbrev_opt_start
= vec_safe_length (abbrev_die_table
);
11064 build_abbrev_table (die
, extern_map
);
11066 optimize_abbrev_table ();
11070 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11071 next_die_offset
= (dwo_id
11072 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11073 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
11074 calc_die_sizes (die
);
11076 oldsym
= die
->die_id
.die_symbol
;
11077 if (oldsym
&& die
->comdat_type_p
)
11079 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
11081 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
11083 die
->die_id
.die_symbol
= NULL
;
11084 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11088 switch_to_section (debug_info_section
);
11089 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
11090 info_section_emitted
= true;
11093 /* For LTO cross unit DIE refs we want a symbol on the start of the
11094 debuginfo section, not on the CU DIE. */
11095 if ((flag_generate_lto
|| flag_generate_offload
) && oldsym
)
11097 /* ??? No way to get visibility assembled without a decl. */
11098 tree decl
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
11099 get_identifier (oldsym
), char_type_node
);
11100 TREE_PUBLIC (decl
) = true;
11101 TREE_STATIC (decl
) = true;
11102 DECL_ARTIFICIAL (decl
) = true;
11103 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
11104 DECL_VISIBILITY_SPECIFIED (decl
) = true;
11105 targetm
.asm_out
.assemble_visibility (decl
, VISIBILITY_HIDDEN
);
11106 #ifdef ASM_WEAKEN_LABEL
11107 /* We prefer a .weak because that handles duplicates from duplicate
11108 archive members in a graceful way. */
11109 ASM_WEAKEN_LABEL (asm_out_file
, oldsym
);
11111 targetm
.asm_out
.globalize_label (asm_out_file
, oldsym
);
11113 ASM_OUTPUT_LABEL (asm_out_file
, oldsym
);
11116 /* Output debugging information. */
11117 output_compilation_unit_header (dwo_id
11118 ? DW_UT_split_compile
: DW_UT_compile
);
11119 if (dwarf_version
>= 5)
11121 if (dwo_id
!= NULL
)
11122 for (int i
= 0; i
< 8; i
++)
11123 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
11127 /* Leave the marks on the main CU, so we can check them in
11128 output_pubnames. */
11132 die
->die_id
.die_symbol
= oldsym
;
11136 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
11137 and .debug_pubtypes. This is configured per-target, but can be
11138 overridden by the -gpubnames or -gno-pubnames options. */
11141 want_pubnames (void)
11143 if (debug_info_level
<= DINFO_LEVEL_TERSE
11144 /* Names and types go to the early debug part only. */
11147 if (debug_generate_pub_sections
!= -1)
11148 return debug_generate_pub_sections
;
11149 return targetm
.want_debug_pub_sections
;
11152 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
11155 add_AT_pubnames (dw_die_ref die
)
11157 if (want_pubnames ())
11158 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
11161 /* Add a string attribute value to a skeleton DIE. */
11164 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
11168 struct indirect_string_node
*node
;
11170 if (! skeleton_debug_str_hash
)
11171 skeleton_debug_str_hash
11172 = hash_table
<indirect_string_hasher
>::create_ggc (10);
11174 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
11175 find_string_form (node
);
11176 if (node
->form
== dwarf_FORM (DW_FORM_strx
))
11177 node
->form
= DW_FORM_strp
;
11179 attr
.dw_attr
= attr_kind
;
11180 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
11181 attr
.dw_attr_val
.val_entry
= NULL
;
11182 attr
.dw_attr_val
.v
.val_str
= node
;
11183 add_dwarf_attr (die
, &attr
);
11186 /* Helper function to generate top-level dies for skeleton debug_info and
11190 add_top_level_skeleton_die_attrs (dw_die_ref die
)
11192 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
11193 const char *comp_dir
= comp_dir_string ();
11195 add_skeleton_AT_string (die
, dwarf_AT (DW_AT_dwo_name
), dwo_file_name
);
11196 if (comp_dir
!= NULL
)
11197 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
11198 add_AT_pubnames (die
);
11199 add_AT_lineptr (die
, dwarf_AT (DW_AT_addr_base
), debug_addr_section_label
);
11202 /* Output skeleton debug sections that point to the dwo file. */
11205 output_skeleton_debug_sections (dw_die_ref comp_unit
,
11206 const unsigned char *dwo_id
)
11208 /* These attributes will be found in the full debug_info section. */
11209 remove_AT (comp_unit
, DW_AT_producer
);
11210 remove_AT (comp_unit
, DW_AT_language
);
11212 switch_to_section (debug_skeleton_info_section
);
11213 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
11215 /* Produce the skeleton compilation-unit header. This one differs enough from
11216 a normal CU header that it's better not to call output_compilation_unit
11218 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11219 dw2_asm_output_data (4, 0xffffffff,
11220 "Initial length escape value indicating 64-bit "
11221 "DWARF extension");
11223 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
11224 DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
11225 - DWARF_INITIAL_LENGTH_SIZE
11226 + size_of_die (comp_unit
),
11227 "Length of Compilation Unit Info");
11228 output_dwarf_version ();
11229 if (dwarf_version
>= 5)
11231 dw2_asm_output_data (1, DW_UT_skeleton
, "DW_UT_skeleton");
11232 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11234 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_abbrev_section_label
,
11235 debug_skeleton_abbrev_section
,
11236 "Offset Into Abbrev. Section");
11237 if (dwarf_version
< 5)
11238 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11240 for (int i
= 0; i
< 8; i
++)
11241 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
11243 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
11244 output_die (comp_unit
);
11246 /* Build the skeleton debug_abbrev section. */
11247 switch_to_section (debug_skeleton_abbrev_section
);
11248 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
11250 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
11252 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
11255 /* Output a comdat type unit DIE and its children. */
11258 output_comdat_type_unit (comdat_type_node
*node
,
11259 bool early_lto_debug ATTRIBUTE_UNUSED
)
11261 const char *secname
;
11264 #if defined (OBJECT_FORMAT_ELF)
11268 /* First mark all the DIEs in this CU so we know which get local refs. */
11269 mark_dies (node
->root_die
);
11271 external_ref_hash_type
*extern_map
= optimize_external_refs (node
->root_die
);
11273 build_abbrev_table (node
->root_die
, extern_map
);
11278 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11279 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
11280 calc_die_sizes (node
->root_die
);
11282 #if defined (OBJECT_FORMAT_ELF)
11283 if (dwarf_version
>= 5)
11285 if (!dwarf_split_debug_info
)
11286 secname
= early_lto_debug
? DEBUG_LTO_INFO_SECTION
: DEBUG_INFO_SECTION
;
11288 secname
= (early_lto_debug
11289 ? DEBUG_LTO_DWO_INFO_SECTION
: DEBUG_DWO_INFO_SECTION
);
11291 else if (!dwarf_split_debug_info
)
11292 secname
= early_lto_debug
? ".gnu.debuglto_.debug_types" : ".debug_types";
11294 secname
= (early_lto_debug
11295 ? ".gnu.debuglto_.debug_types.dwo" : ".debug_types.dwo");
11297 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11298 sprintf (tmp
, dwarf_version
>= 5 ? "wi." : "wt.");
11299 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11300 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11301 comdat_key
= get_identifier (tmp
);
11302 targetm
.asm_out
.named_section (secname
,
11303 SECTION_DEBUG
| SECTION_LINKONCE
,
11306 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11307 sprintf (tmp
, (dwarf_version
>= 5
11308 ? ".gnu.linkonce.wi." : ".gnu.linkonce.wt."));
11309 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11310 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11312 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11315 /* Output debugging information. */
11316 output_compilation_unit_header (dwarf_split_debug_info
11317 ? DW_UT_split_type
: DW_UT_type
);
11318 output_signature (node
->signature
, "Type Signature");
11319 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
11320 "Offset to Type DIE");
11321 output_die (node
->root_die
);
11323 unmark_dies (node
->root_die
);
11326 /* Return the DWARF2/3 pubname associated with a decl. */
11328 static const char *
11329 dwarf2_name (tree decl
, int scope
)
11331 if (DECL_NAMELESS (decl
))
11333 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
11336 /* Add a new entry to .debug_pubnames if appropriate. */
11339 add_pubname_string (const char *str
, dw_die_ref die
)
11344 e
.name
= xstrdup (str
);
11345 vec_safe_push (pubname_table
, e
);
11349 add_pubname (tree decl
, dw_die_ref die
)
11351 if (!want_pubnames ())
11354 /* Don't add items to the table when we expect that the consumer will have
11355 just read the enclosing die. For example, if the consumer is looking at a
11356 class_member, it will either be inside the class already, or will have just
11357 looked up the class to find the member. Either way, searching the class is
11358 faster than searching the index. */
11359 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
11360 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
11362 const char *name
= dwarf2_name (decl
, 1);
11365 add_pubname_string (name
, die
);
11369 /* Add an enumerator to the pubnames section. */
11372 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
11376 gcc_assert (scope_name
);
11377 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
11379 vec_safe_push (pubname_table
, e
);
11382 /* Add a new entry to .debug_pubtypes if appropriate. */
11385 add_pubtype (tree decl
, dw_die_ref die
)
11389 if (!want_pubnames ())
11392 if ((TREE_PUBLIC (decl
)
11393 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
11394 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
11397 const char *scope_name
= "";
11398 const char *sep
= is_cxx () ? "::" : ".";
11401 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
11402 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
11404 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
11405 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
11406 scope_name
= concat (scope_name
, sep
, NULL
);
11412 name
= type_tag (decl
);
11414 name
= lang_hooks
.dwarf_name (decl
, 1);
11416 /* If we don't have a name for the type, there's no point in adding
11417 it to the table. */
11418 if (name
!= NULL
&& name
[0] != '\0')
11421 e
.name
= concat (scope_name
, name
, NULL
);
11422 vec_safe_push (pubtype_table
, e
);
11425 /* Although it might be more consistent to add the pubinfo for the
11426 enumerators as their dies are created, they should only be added if the
11427 enum type meets the criteria above. So rather than re-check the parent
11428 enum type whenever an enumerator die is created, just output them all
11429 here. This isn't protected by the name conditional because anonymous
11430 enums don't have names. */
11431 if (die
->die_tag
== DW_TAG_enumeration_type
)
11435 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
11440 /* Output a single entry in the pubnames table. */
11443 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
11445 dw_die_ref die
= entry
->die
;
11446 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
11448 dw2_asm_output_data (DWARF_OFFSET_SIZE
, die_offset
, "DIE offset");
11450 if (debug_generate_pub_sections
== 2)
11452 /* This logic follows gdb's method for determining the value of the flag
11454 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
11455 switch (die
->die_tag
)
11457 case DW_TAG_typedef
:
11458 case DW_TAG_base_type
:
11459 case DW_TAG_subrange_type
:
11460 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11461 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11463 case DW_TAG_enumerator
:
11464 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11465 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11467 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11469 case DW_TAG_subprogram
:
11470 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11471 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
11473 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11475 case DW_TAG_constant
:
11476 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11477 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11478 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11480 case DW_TAG_variable
:
11481 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
11482 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
11483 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
11485 case DW_TAG_namespace
:
11486 case DW_TAG_imported_declaration
:
11487 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11489 case DW_TAG_class_type
:
11490 case DW_TAG_interface_type
:
11491 case DW_TAG_structure_type
:
11492 case DW_TAG_union_type
:
11493 case DW_TAG_enumeration_type
:
11494 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
11496 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
11499 /* An unusual tag. Leave the flag-byte empty. */
11502 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
11503 "GDB-index flags");
11506 dw2_asm_output_nstring (entry
->name
, -1, "external name");
11510 /* Output the public names table used to speed up access to externally
11511 visible names; or the public types table used to find type definitions. */
11514 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
11517 unsigned long pubnames_length
= size_of_pubnames (names
);
11518 pubname_entry
*pub
;
11520 if (!XCOFF_DEBUGGING_INFO
)
11522 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11523 dw2_asm_output_data (4, 0xffffffff,
11524 "Initial length escape value indicating 64-bit DWARF extension");
11525 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
11526 "Pub Info Length");
11529 /* Version number for pubnames/pubtypes is independent of dwarf version. */
11530 dw2_asm_output_data (2, 2, "DWARF pubnames/pubtypes version");
11532 if (dwarf_split_debug_info
)
11533 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
11534 debug_skeleton_info_section
,
11535 "Offset of Compilation Unit Info");
11537 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
11538 debug_info_section
,
11539 "Offset of Compilation Unit Info");
11540 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
11541 "Compilation Unit Length");
11543 FOR_EACH_VEC_ELT (*names
, i
, pub
)
11545 if (include_pubname_in_output (names
, pub
))
11547 dw_offset die_offset
= pub
->die
->die_offset
;
11549 /* We shouldn't see pubnames for DIEs outside of the main CU. */
11550 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
11551 gcc_assert (pub
->die
->die_mark
);
11553 /* If we're putting types in their own .debug_types sections,
11554 the .debug_pubtypes table will still point to the compile
11555 unit (not the type unit), so we want to use the offset of
11556 the skeleton DIE (if there is one). */
11557 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
11559 comdat_type_node
*type_node
= pub
->die
->die_id
.die_type_node
;
11561 if (type_node
!= NULL
)
11562 die_offset
= (type_node
->skeleton_die
!= NULL
11563 ? type_node
->skeleton_die
->die_offset
11564 : comp_unit_die ()->die_offset
);
11567 output_pubname (die_offset
, pub
);
11571 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
11574 /* Output public names and types tables if necessary. */
11577 output_pubtables (void)
11579 if (!want_pubnames () || !info_section_emitted
)
11582 switch_to_section (debug_pubnames_section
);
11583 output_pubnames (pubname_table
);
11584 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
11585 It shouldn't hurt to emit it always, since pure DWARF2 consumers
11586 simply won't look for the section. */
11587 switch_to_section (debug_pubtypes_section
);
11588 output_pubnames (pubtype_table
);
11592 /* Output the information that goes into the .debug_aranges table.
11593 Namely, define the beginning and ending address range of the
11594 text section generated for this compilation unit. */
11597 output_aranges (void)
11600 unsigned long aranges_length
= size_of_aranges ();
11602 if (!XCOFF_DEBUGGING_INFO
)
11604 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11605 dw2_asm_output_data (4, 0xffffffff,
11606 "Initial length escape value indicating 64-bit DWARF extension");
11607 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
11608 "Length of Address Ranges Info");
11611 /* Version number for aranges is still 2, even up to DWARF5. */
11612 dw2_asm_output_data (2, 2, "DWARF aranges version");
11613 if (dwarf_split_debug_info
)
11614 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
11615 debug_skeleton_info_section
,
11616 "Offset of Compilation Unit Info");
11618 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
11619 debug_info_section
,
11620 "Offset of Compilation Unit Info");
11621 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
11622 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
11624 /* We need to align to twice the pointer size here. */
11625 if (DWARF_ARANGES_PAD_SIZE
)
11627 /* Pad using a 2 byte words so that padding is correct for any
11629 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
11630 2 * DWARF2_ADDR_SIZE
);
11631 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
11632 dw2_asm_output_data (2, 0, NULL
);
11635 /* It is necessary not to output these entries if the sections were
11636 not used; if the sections were not used, the length will be 0 and
11637 the address may end up as 0 if the section is discarded by ld
11638 --gc-sections, leaving an invalid (0, 0) entry that can be
11639 confused with the terminator. */
11640 if (text_section_used
)
11642 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
11643 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
11644 text_section_label
, "Length");
11646 if (cold_text_section_used
)
11648 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
11650 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
11651 cold_text_section_label
, "Length");
11654 if (have_multiple_function_sections
)
11659 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
11661 if (DECL_IGNORED_P (fde
->decl
))
11663 if (!fde
->in_std_section
)
11665 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
11667 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
11668 fde
->dw_fde_begin
, "Length");
11670 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
11672 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
11674 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
11675 fde
->dw_fde_second_begin
, "Length");
11680 /* Output the terminator words. */
11681 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11682 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11685 /* Add a new entry to .debug_ranges. Return its index into
11686 ranges_table vector. */
11688 static unsigned int
11689 add_ranges_num (int num
, bool maybe_new_sec
)
11691 dw_ranges r
= { NULL
, num
, 0, maybe_new_sec
};
11692 vec_safe_push (ranges_table
, r
);
11693 return vec_safe_length (ranges_table
) - 1;
11696 /* Add a new entry to .debug_ranges corresponding to a block, or a
11697 range terminator if BLOCK is NULL. MAYBE_NEW_SEC is true if
11698 this entry might be in a different section from previous range. */
11700 static unsigned int
11701 add_ranges (const_tree block
, bool maybe_new_sec
)
11703 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0, maybe_new_sec
);
11706 /* Note that (*rnglist_table)[offset] is either a head of a rnglist
11707 chain, or middle entry of a chain that will be directly referred to. */
11710 note_rnglist_head (unsigned int offset
)
11712 if (dwarf_version
< 5 || (*ranges_table
)[offset
].label
)
11714 (*ranges_table
)[offset
].label
= gen_internal_sym ("LLRL");
11717 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
11718 When using dwarf_split_debug_info, address attributes in dies destined
11719 for the final executable should be direct references--setting the
11720 parameter force_direct ensures this behavior. */
11723 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
11724 bool *added
, bool force_direct
)
11726 unsigned int in_use
= vec_safe_length (ranges_by_label
);
11727 unsigned int offset
;
11728 dw_ranges_by_label rbl
= { begin
, end
};
11729 vec_safe_push (ranges_by_label
, rbl
);
11730 offset
= add_ranges_num (-(int)in_use
- 1, true);
11733 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
11735 note_rnglist_head (offset
);
11739 /* Emit .debug_ranges section. */
11742 output_ranges (void)
11745 static const char *const start_fmt
= "Offset %#x";
11746 const char *fmt
= start_fmt
;
11749 switch_to_section (debug_ranges_section
);
11750 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11751 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11753 int block_num
= r
->num
;
11757 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11758 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11760 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11761 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11763 /* If all code is in the text section, then the compilation
11764 unit base address defaults to DW_AT_low_pc, which is the
11765 base of the text section. */
11766 if (!have_multiple_function_sections
)
11768 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
11769 text_section_label
,
11770 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11771 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
11772 text_section_label
, NULL
);
11775 /* Otherwise, the compilation unit base address is zero,
11776 which allows us to use absolute addresses, and not worry
11777 about whether the target supports cross-section
11781 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11782 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11783 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
11789 /* Negative block_num stands for an index into ranges_by_label. */
11790 else if (block_num
< 0)
11792 int lab_idx
= - block_num
- 1;
11794 if (!have_multiple_function_sections
)
11796 gcc_unreachable ();
11798 /* If we ever use add_ranges_by_labels () for a single
11799 function section, all we have to do is to take out
11800 the #if 0 above. */
11801 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11802 (*ranges_by_label
)[lab_idx
].begin
,
11803 text_section_label
,
11804 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11805 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11806 (*ranges_by_label
)[lab_idx
].end
,
11807 text_section_label
, NULL
);
11812 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11813 (*ranges_by_label
)[lab_idx
].begin
,
11814 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11815 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11816 (*ranges_by_label
)[lab_idx
].end
,
11822 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11823 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11829 /* Non-zero if .debug_line_str should be used for .debug_line section
11830 strings or strings that are likely shareable with those. */
11831 #define DWARF5_USE_DEBUG_LINE_STR \
11832 (!DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET \
11833 && (DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) != 0 \
11834 /* FIXME: there is no .debug_line_str.dwo section, \
11835 for -gsplit-dwarf we should use DW_FORM_strx instead. */ \
11836 && !dwarf_split_debug_info)
11838 /* Assign .debug_rnglists indexes. */
11841 index_rnglists (void)
11846 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11848 r
->idx
= rnglist_idx
++;
11851 /* Emit .debug_rnglists section. */
11854 output_rnglists (unsigned generation
)
11858 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
11859 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
11860 char basebuf
[MAX_ARTIFICIAL_LABEL_BYTES
];
11862 switch_to_section (debug_ranges_section
);
11863 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11864 /* There are up to 4 unique ranges labels per generation.
11865 See also init_sections_and_labels. */
11866 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_RANGES_SECTION_LABEL
,
11867 2 + generation
* 4);
11868 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_RANGES_SECTION_LABEL
,
11869 3 + generation
* 4);
11870 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11871 dw2_asm_output_data (4, 0xffffffff,
11872 "Initial length escape value indicating "
11873 "64-bit DWARF extension");
11874 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
11875 "Length of Range Lists");
11876 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
11877 output_dwarf_version ();
11878 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
11879 dw2_asm_output_data (1, 0, "Segment Size");
11880 /* Emit the offset table only for -gsplit-dwarf. If we don't care
11881 about relocation sizes and primarily care about the size of .debug*
11882 sections in linked shared libraries and executables, then
11883 the offset table plus corresponding DW_FORM_rnglistx uleb128 indexes
11884 into it are usually larger than just DW_FORM_sec_offset offsets
11885 into the .debug_rnglists section. */
11886 dw2_asm_output_data (4, dwarf_split_debug_info
? rnglist_idx
: 0,
11887 "Offset Entry Count");
11888 if (dwarf_split_debug_info
)
11890 ASM_OUTPUT_LABEL (asm_out_file
, ranges_base_label
);
11891 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11893 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, r
->label
,
11894 ranges_base_label
, NULL
);
11897 const char *lab
= "";
11898 unsigned int len
= vec_safe_length (ranges_table
);
11899 const char *base
= NULL
;
11900 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11902 int block_num
= r
->num
;
11906 ASM_OUTPUT_LABEL (asm_out_file
, r
->label
);
11909 if (HAVE_AS_LEB128
&& (r
->label
|| r
->maybe_new_sec
))
11913 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11914 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11916 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11917 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11919 if (HAVE_AS_LEB128
)
11921 /* If all code is in the text section, then the compilation
11922 unit base address defaults to DW_AT_low_pc, which is the
11923 base of the text section. */
11924 if (!have_multiple_function_sections
)
11926 dw2_asm_output_data (1, DW_RLE_offset_pair
,
11927 "DW_RLE_offset_pair (%s)", lab
);
11928 dw2_asm_output_delta_uleb128 (blabel
, text_section_label
,
11929 "Range begin address (%s)", lab
);
11930 dw2_asm_output_delta_uleb128 (elabel
, text_section_label
,
11931 "Range end address (%s)", lab
);
11936 dw_ranges
*r2
= NULL
;
11938 r2
= &(*ranges_table
)[i
+ 1];
11941 && r2
->label
== NULL
11942 && !r2
->maybe_new_sec
)
11944 dw2_asm_output_data (1, DW_RLE_base_address
,
11945 "DW_RLE_base_address (%s)", lab
);
11946 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11947 "Base address (%s)", lab
);
11948 strcpy (basebuf
, blabel
);
11954 dw2_asm_output_data (1, DW_RLE_offset_pair
,
11955 "DW_RLE_offset_pair (%s)", lab
);
11956 dw2_asm_output_delta_uleb128 (blabel
, base
,
11957 "Range begin address (%s)", lab
);
11958 dw2_asm_output_delta_uleb128 (elabel
, base
,
11959 "Range end address (%s)", lab
);
11962 dw2_asm_output_data (1, DW_RLE_start_length
,
11963 "DW_RLE_start_length (%s)", lab
);
11964 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11965 "Range begin address (%s)", lab
);
11966 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
11967 "Range length (%s)", lab
);
11971 dw2_asm_output_data (1, DW_RLE_start_end
,
11972 "DW_RLE_start_end (%s)", lab
);
11973 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11974 "Range begin address (%s)", lab
);
11975 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
11976 "Range end address (%s)", lab
);
11980 /* Negative block_num stands for an index into ranges_by_label. */
11981 else if (block_num
< 0)
11983 int lab_idx
= - block_num
- 1;
11984 const char *blabel
= (*ranges_by_label
)[lab_idx
].begin
;
11985 const char *elabel
= (*ranges_by_label
)[lab_idx
].end
;
11987 if (!have_multiple_function_sections
)
11988 gcc_unreachable ();
11989 if (HAVE_AS_LEB128
)
11991 dw2_asm_output_data (1, DW_RLE_start_length
,
11992 "DW_RLE_start_length (%s)", lab
);
11993 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11994 "Range begin address (%s)", lab
);
11995 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
11996 "Range length (%s)", lab
);
12000 dw2_asm_output_data (1, DW_RLE_start_end
,
12001 "DW_RLE_start_end (%s)", lab
);
12002 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
12003 "Range begin address (%s)", lab
);
12004 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
12005 "Range end address (%s)", lab
);
12009 dw2_asm_output_data (1, DW_RLE_end_of_list
,
12010 "DW_RLE_end_of_list (%s)", lab
);
12012 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12015 /* Data structure containing information about input files. */
12018 const char *path
; /* Complete file name. */
12019 const char *fname
; /* File name part. */
12020 int length
; /* Length of entire string. */
12021 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
12022 int dir_idx
; /* Index in directory table. */
12025 /* Data structure containing information about directories with source
12029 const char *path
; /* Path including directory name. */
12030 int length
; /* Path length. */
12031 int prefix
; /* Index of directory entry which is a prefix. */
12032 int count
; /* Number of files in this directory. */
12033 int dir_idx
; /* Index of directory used as base. */
12036 /* Callback function for file_info comparison. We sort by looking at
12037 the directories in the path. */
12040 file_info_cmp (const void *p1
, const void *p2
)
12042 const struct file_info
*const s1
= (const struct file_info
*) p1
;
12043 const struct file_info
*const s2
= (const struct file_info
*) p2
;
12044 const unsigned char *cp1
;
12045 const unsigned char *cp2
;
12047 /* Take care of file names without directories. We need to make sure that
12048 we return consistent values to qsort since some will get confused if
12049 we return the same value when identical operands are passed in opposite
12050 orders. So if neither has a directory, return 0 and otherwise return
12051 1 or -1 depending on which one has the directory. We want the one with
12052 the directory to sort after the one without, so all no directory files
12053 are at the start (normally only the compilation unit file). */
12054 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
12055 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
12057 cp1
= (const unsigned char *) s1
->path
;
12058 cp2
= (const unsigned char *) s2
->path
;
12064 /* Reached the end of the first path? If so, handle like above,
12065 but now we want longer directory prefixes before shorter ones. */
12066 if ((cp1
== (const unsigned char *) s1
->fname
)
12067 || (cp2
== (const unsigned char *) s2
->fname
))
12068 return ((cp1
== (const unsigned char *) s1
->fname
)
12069 - (cp2
== (const unsigned char *) s2
->fname
));
12071 /* Character of current path component the same? */
12072 else if (*cp1
!= *cp2
)
12073 return *cp1
- *cp2
;
12077 struct file_name_acquire_data
12079 struct file_info
*files
;
12084 /* Traversal function for the hash table. */
12087 file_name_acquire (dwarf_file_data
**slot
, file_name_acquire_data
*fnad
)
12089 struct dwarf_file_data
*d
= *slot
;
12090 struct file_info
*fi
;
12093 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
12095 if (! d
->emitted_number
)
12098 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
12100 fi
= fnad
->files
+ fnad
->used_files
++;
12102 /* Skip all leading "./". */
12104 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
12107 /* Create a new array entry. */
12109 fi
->length
= strlen (f
);
12112 /* Search for the file name part. */
12113 f
= strrchr (f
, DIR_SEPARATOR
);
12114 #if defined (DIR_SEPARATOR_2)
12116 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
12120 if (f
== NULL
|| f
< g
)
12126 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
12130 /* Helper function for output_file_names. Emit a FORM encoded
12131 string STR, with assembly comment start ENTRY_KIND and
12135 output_line_string (enum dwarf_form form
, const char *str
,
12136 const char *entry_kind
, unsigned int idx
)
12140 case DW_FORM_string
:
12141 dw2_asm_output_nstring (str
, -1, "%s: %#x", entry_kind
, idx
);
12143 case DW_FORM_line_strp
:
12144 if (!debug_line_str_hash
)
12145 debug_line_str_hash
12146 = hash_table
<indirect_string_hasher
>::create_ggc (10);
12148 struct indirect_string_node
*node
;
12149 node
= find_AT_string_in_table (str
, debug_line_str_hash
);
12150 set_indirect_string (node
);
12152 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
12153 debug_line_str_section
, "%s: %#x: \"%s\"",
12154 entry_kind
, 0, node
->str
);
12157 gcc_unreachable ();
12161 /* Output the directory table and the file name table. We try to minimize
12162 the total amount of memory needed. A heuristic is used to avoid large
12163 slowdowns with many input files. */
12166 output_file_names (void)
12168 struct file_name_acquire_data fnad
;
12170 struct file_info
*files
;
12171 struct dir_info
*dirs
;
12179 if (!last_emitted_file
)
12181 if (dwarf_version
>= 5)
12183 dw2_asm_output_data (1, 0, "Directory entry format count");
12184 dw2_asm_output_data_uleb128 (0, "Directories count");
12185 dw2_asm_output_data (1, 0, "File name entry format count");
12186 dw2_asm_output_data_uleb128 (0, "File names count");
12190 dw2_asm_output_data (1, 0, "End directory table");
12191 dw2_asm_output_data (1, 0, "End file name table");
12196 numfiles
= last_emitted_file
->emitted_number
;
12198 /* Allocate the various arrays we need. */
12199 files
= XALLOCAVEC (struct file_info
, numfiles
);
12200 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
12202 fnad
.files
= files
;
12203 fnad
.used_files
= 0;
12204 fnad
.max_files
= numfiles
;
12205 file_table
->traverse
<file_name_acquire_data
*, file_name_acquire
> (&fnad
);
12206 gcc_assert (fnad
.used_files
== fnad
.max_files
);
12208 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
12210 /* Find all the different directories used. */
12211 dirs
[0].path
= files
[0].path
;
12212 dirs
[0].length
= files
[0].fname
- files
[0].path
;
12213 dirs
[0].prefix
= -1;
12215 dirs
[0].dir_idx
= 0;
12216 files
[0].dir_idx
= 0;
12219 for (i
= 1; i
< numfiles
; i
++)
12220 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
12221 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
12222 dirs
[ndirs
- 1].length
) == 0)
12224 /* Same directory as last entry. */
12225 files
[i
].dir_idx
= ndirs
- 1;
12226 ++dirs
[ndirs
- 1].count
;
12232 /* This is a new directory. */
12233 dirs
[ndirs
].path
= files
[i
].path
;
12234 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
12235 dirs
[ndirs
].count
= 1;
12236 dirs
[ndirs
].dir_idx
= ndirs
;
12237 files
[i
].dir_idx
= ndirs
;
12239 /* Search for a prefix. */
12240 dirs
[ndirs
].prefix
= -1;
12241 for (j
= 0; j
< ndirs
; j
++)
12242 if (dirs
[j
].length
< dirs
[ndirs
].length
12243 && dirs
[j
].length
> 1
12244 && (dirs
[ndirs
].prefix
== -1
12245 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
12246 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
12247 dirs
[ndirs
].prefix
= j
;
12252 /* Now to the actual work. We have to find a subset of the directories which
12253 allow expressing the file name using references to the directory table
12254 with the least amount of characters. We do not do an exhaustive search
12255 where we would have to check out every combination of every single
12256 possible prefix. Instead we use a heuristic which provides nearly optimal
12257 results in most cases and never is much off. */
12258 saved
= XALLOCAVEC (int, ndirs
);
12259 savehere
= XALLOCAVEC (int, ndirs
);
12261 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
12262 for (i
= 0; i
< ndirs
; i
++)
12267 /* We can always save some space for the current directory. But this
12268 does not mean it will be enough to justify adding the directory. */
12269 savehere
[i
] = dirs
[i
].length
;
12270 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
12272 for (j
= i
+ 1; j
< ndirs
; j
++)
12275 if (saved
[j
] < dirs
[i
].length
)
12277 /* Determine whether the dirs[i] path is a prefix of the
12281 k
= dirs
[j
].prefix
;
12282 while (k
!= -1 && k
!= (int) i
)
12283 k
= dirs
[k
].prefix
;
12287 /* Yes it is. We can possibly save some memory by
12288 writing the filenames in dirs[j] relative to
12290 savehere
[j
] = dirs
[i
].length
;
12291 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
12296 /* Check whether we can save enough to justify adding the dirs[i]
12298 if (total
> dirs
[i
].length
+ 1)
12300 /* It's worthwhile adding. */
12301 for (j
= i
; j
< ndirs
; j
++)
12302 if (savehere
[j
] > 0)
12304 /* Remember how much we saved for this directory so far. */
12305 saved
[j
] = savehere
[j
];
12307 /* Remember the prefix directory. */
12308 dirs
[j
].dir_idx
= i
;
12313 /* Emit the directory name table. */
12314 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
12315 enum dwarf_form str_form
= DW_FORM_string
;
12316 enum dwarf_form idx_form
= DW_FORM_udata
;
12317 if (dwarf_version
>= 5)
12319 const char *comp_dir
= comp_dir_string ();
12320 if (comp_dir
== NULL
)
12322 dw2_asm_output_data (1, 1, "Directory entry format count");
12323 if (DWARF5_USE_DEBUG_LINE_STR
)
12324 str_form
= DW_FORM_line_strp
;
12325 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12326 dw2_asm_output_data_uleb128 (str_form
, "%s",
12327 get_DW_FORM_name (str_form
));
12328 dw2_asm_output_data_uleb128 (ndirs
+ idx_offset
, "Directories count");
12329 if (str_form
== DW_FORM_string
)
12331 dw2_asm_output_nstring (comp_dir
, -1, "Directory Entry: %#x", 0);
12332 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12333 dw2_asm_output_nstring (dirs
[i
].path
,
12335 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
12336 "Directory Entry: %#x", i
+ idx_offset
);
12340 output_line_string (str_form
, comp_dir
, "Directory Entry", 0);
12341 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12344 = ggc_alloc_string (dirs
[i
].path
,
12346 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
);
12347 output_line_string (str_form
, str
, "Directory Entry",
12348 (unsigned) i
+ idx_offset
);
12354 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
12355 dw2_asm_output_nstring (dirs
[i
].path
,
12357 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
12358 "Directory Entry: %#x", i
+ idx_offset
);
12360 dw2_asm_output_data (1, 0, "End directory table");
12363 /* We have to emit them in the order of emitted_number since that's
12364 used in the debug info generation. To do this efficiently we
12365 generate a back-mapping of the indices first. */
12366 backmap
= XALLOCAVEC (int, numfiles
);
12367 for (i
= 0; i
< numfiles
; i
++)
12368 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
12370 if (dwarf_version
>= 5)
12372 const char *filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
12373 if (filename0
== NULL
)
12375 /* DW_LNCT_directory_index can use DW_FORM_udata, DW_FORM_data1 and
12376 DW_FORM_data2. Choose one based on the number of directories
12377 and how much space would they occupy in each encoding.
12378 If we have at most 256 directories, all indexes fit into
12379 a single byte, so DW_FORM_data1 is most compact (if there
12380 are at most 128 directories, DW_FORM_udata would be as
12381 compact as that, but not shorter and slower to decode). */
12382 if (ndirs
+ idx_offset
<= 256)
12383 idx_form
= DW_FORM_data1
;
12384 /* If there are more than 65536 directories, we have to use
12385 DW_FORM_udata, DW_FORM_data2 can't refer to them.
12386 Otherwise, compute what space would occupy if all the indexes
12387 used DW_FORM_udata - sum - and compare that to how large would
12388 be DW_FORM_data2 encoding, and pick the more efficient one. */
12389 else if (ndirs
+ idx_offset
<= 65536)
12391 unsigned HOST_WIDE_INT sum
= 1;
12392 for (i
= 0; i
< numfiles
; i
++)
12394 int file_idx
= backmap
[i
];
12395 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
12396 sum
+= size_of_uleb128 (dir_idx
);
12398 if (sum
>= HOST_WIDE_INT_UC (2) * (numfiles
+ 1))
12399 idx_form
= DW_FORM_data2
;
12401 #ifdef VMS_DEBUGGING_INFO
12402 dw2_asm_output_data (1, 4, "File name entry format count");
12404 dw2_asm_output_data (1, 2, "File name entry format count");
12406 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
12407 dw2_asm_output_data_uleb128 (str_form
, "%s",
12408 get_DW_FORM_name (str_form
));
12409 dw2_asm_output_data_uleb128 (DW_LNCT_directory_index
,
12410 "DW_LNCT_directory_index");
12411 dw2_asm_output_data_uleb128 (idx_form
, "%s",
12412 get_DW_FORM_name (idx_form
));
12413 #ifdef VMS_DEBUGGING_INFO
12414 dw2_asm_output_data_uleb128 (DW_LNCT_timestamp
, "DW_LNCT_timestamp");
12415 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12416 dw2_asm_output_data_uleb128 (DW_LNCT_size
, "DW_LNCT_size");
12417 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
12419 dw2_asm_output_data_uleb128 (numfiles
+ 1, "File names count");
12421 output_line_string (str_form
, filename0
, "File Entry", 0);
12423 /* Include directory index. */
12424 if (idx_form
!= DW_FORM_udata
)
12425 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12428 dw2_asm_output_data_uleb128 (0, NULL
);
12430 #ifdef VMS_DEBUGGING_INFO
12431 dw2_asm_output_data_uleb128 (0, NULL
);
12432 dw2_asm_output_data_uleb128 (0, NULL
);
12436 /* Now write all the file names. */
12437 for (i
= 0; i
< numfiles
; i
++)
12439 int file_idx
= backmap
[i
];
12440 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
12442 #ifdef VMS_DEBUGGING_INFO
12443 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
12445 /* Setting these fields can lead to debugger miscomparisons,
12446 but VMS Debug requires them to be set correctly. */
12451 int maxfilelen
= (strlen (files
[file_idx
].path
)
12452 + dirs
[dir_idx
].length
12453 + MAX_VMS_VERSION_LEN
+ 1);
12454 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
12456 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
12457 snprintf (filebuf
, maxfilelen
, "%s;%d",
12458 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
12460 output_line_string (str_form
, filebuf
, "File Entry", (unsigned) i
+ 1);
12462 /* Include directory index. */
12463 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
12464 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12465 dir_idx
+ idx_offset
, NULL
);
12467 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
12469 /* Modification time. */
12470 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
12471 &cdt
, 0, 0, 0) == 0)
12474 /* File length in bytes. */
12475 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
12476 0, &siz
, 0, 0) == 0)
12479 output_line_string (str_form
,
12480 files
[file_idx
].path
+ dirs
[dir_idx
].length
,
12481 "File Entry", (unsigned) i
+ 1);
12483 /* Include directory index. */
12484 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
12485 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
12486 dir_idx
+ idx_offset
, NULL
);
12488 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
12490 if (dwarf_version
>= 5)
12493 /* Modification time. */
12494 dw2_asm_output_data_uleb128 (0, NULL
);
12496 /* File length in bytes. */
12497 dw2_asm_output_data_uleb128 (0, NULL
);
12498 #endif /* VMS_DEBUGGING_INFO */
12501 if (dwarf_version
< 5)
12502 dw2_asm_output_data (1, 0, "End file name table");
12506 /* Output one line number table into the .debug_line section. */
12509 output_one_line_info_table (dw_line_info_table
*table
)
12511 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12512 unsigned int current_line
= 1;
12513 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
12514 dw_line_info_entry
*ent
, *prev_addr
;
12520 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
12522 switch (ent
->opcode
)
12524 case LI_set_address
:
12525 /* ??? Unfortunately, we have little choice here currently, and
12526 must always use the most general form. GCC does not know the
12527 address delta itself, so we can't use DW_LNS_advance_pc. Many
12528 ports do have length attributes which will give an upper bound
12529 on the address range. We could perhaps use length attributes
12530 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
12531 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
12535 /* This can handle any delta. This takes
12536 4+DWARF2_ADDR_SIZE bytes. */
12537 dw2_asm_output_data (1, 0, "set address %s%s", line_label
,
12538 debug_variable_location_views
12539 ? ", reset view to 0" : "");
12540 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12541 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12542 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
12547 case LI_adv_address
:
12549 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
12550 char prev_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12551 ASM_GENERATE_INTERNAL_LABEL (prev_label
, LINE_CODE_LABEL
, prev_addr
->val
);
12555 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
, "fixed advance PC, increment view to %i", view
);
12556 dw2_asm_output_delta (2, line_label
, prev_label
,
12557 "from %s to %s", prev_label
, line_label
);
12564 if (ent
->val
== current_line
)
12566 /* We still need to start a new row, so output a copy insn. */
12567 dw2_asm_output_data (1, DW_LNS_copy
,
12568 "copy line %u", current_line
);
12572 int line_offset
= ent
->val
- current_line
;
12573 int line_delta
= line_offset
- DWARF_LINE_BASE
;
12575 current_line
= ent
->val
;
12576 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
12578 /* This can handle deltas from -10 to 234, using the current
12579 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
12580 This takes 1 byte. */
12581 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
12582 "line %u", current_line
);
12586 /* This can handle any delta. This takes at least 4 bytes,
12587 depending on the value being encoded. */
12588 dw2_asm_output_data (1, DW_LNS_advance_line
,
12589 "advance to line %u", current_line
);
12590 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
12591 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
12597 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
12598 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
12601 case LI_set_column
:
12602 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
12603 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
12606 case LI_negate_stmt
:
12607 current_is_stmt
= !current_is_stmt
;
12608 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
12609 "is_stmt %d", current_is_stmt
);
12612 case LI_set_prologue_end
:
12613 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
12614 "set prologue end");
12617 case LI_set_epilogue_begin
:
12618 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
12619 "set epilogue begin");
12622 case LI_set_discriminator
:
12623 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
12624 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
12625 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
12626 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
12631 /* Emit debug info for the address of the end of the table. */
12632 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
12633 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12634 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12635 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
12637 dw2_asm_output_data (1, 0, "end sequence");
12638 dw2_asm_output_data_uleb128 (1, NULL
);
12639 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
12642 /* Output the source line number correspondence information. This
12643 information goes into the .debug_line section. */
12646 output_line_info (bool prologue_only
)
12648 static unsigned int generation
;
12649 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
12650 char p1
[MAX_ARTIFICIAL_LABEL_BYTES
], p2
[MAX_ARTIFICIAL_LABEL_BYTES
];
12651 bool saw_one
= false;
12654 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, generation
);
12655 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, generation
);
12656 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, generation
);
12657 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, generation
++);
12659 if (!XCOFF_DEBUGGING_INFO
)
12661 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
12662 dw2_asm_output_data (4, 0xffffffff,
12663 "Initial length escape value indicating 64-bit DWARF extension");
12664 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
12665 "Length of Source Line Info");
12668 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
12670 output_dwarf_version ();
12671 if (dwarf_version
>= 5)
12673 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
12674 dw2_asm_output_data (1, 0, "Segment Size");
12676 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
12677 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
12679 /* Define the architecture-dependent minimum instruction length (in bytes).
12680 In this implementation of DWARF, this field is used for information
12681 purposes only. Since GCC generates assembly language, we have no
12682 a priori knowledge of how many instruction bytes are generated for each
12683 source line, and therefore can use only the DW_LNE_set_address and
12684 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
12685 this as '1', which is "correct enough" for all architectures,
12686 and don't let the target override. */
12687 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
12689 if (dwarf_version
>= 4)
12690 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
12691 "Maximum Operations Per Instruction");
12692 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
12693 "Default is_stmt_start flag");
12694 dw2_asm_output_data (1, DWARF_LINE_BASE
,
12695 "Line Base Value (Special Opcodes)");
12696 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
12697 "Line Range Value (Special Opcodes)");
12698 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
12699 "Special Opcode Base");
12701 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
12706 case DW_LNS_advance_pc
:
12707 case DW_LNS_advance_line
:
12708 case DW_LNS_set_file
:
12709 case DW_LNS_set_column
:
12710 case DW_LNS_fixed_advance_pc
:
12711 case DW_LNS_set_isa
:
12719 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
12723 /* Write out the information about the files we use. */
12724 output_file_names ();
12725 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
12728 /* Output the marker for the end of the line number info. */
12729 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12733 if (separate_line_info
)
12735 dw_line_info_table
*table
;
12738 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
12741 output_one_line_info_table (table
);
12745 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
12747 output_one_line_info_table (cold_text_section_line_info
);
12751 /* ??? Some Darwin linkers crash on a .debug_line section with no
12752 sequences. Further, merely a DW_LNE_end_sequence entry is not
12753 sufficient -- the address column must also be initialized.
12754 Make sure to output at least one set_address/end_sequence pair,
12755 choosing .text since that section is always present. */
12756 if (text_section_line_info
->in_use
|| !saw_one
)
12757 output_one_line_info_table (text_section_line_info
);
12759 /* Output the marker for the end of the line number info. */
12760 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12763 /* Return true if DW_AT_endianity should be emitted according to REVERSE. */
12766 need_endianity_attribute_p (bool reverse
)
12768 return reverse
&& (dwarf_version
>= 3 || !dwarf_strict
);
12771 /* Given a pointer to a tree node for some base type, return a pointer to
12772 a DIE that describes the given type. REVERSE is true if the type is
12773 to be interpreted in the reverse storage order wrt the target order.
12775 This routine must only be called for GCC type nodes that correspond to
12776 Dwarf base (fundamental) types. */
12779 base_type_die (tree type
, bool reverse
)
12781 dw_die_ref base_type_result
;
12782 enum dwarf_type encoding
;
12783 bool fpt_used
= false;
12784 struct fixed_point_type_info fpt_info
;
12785 tree type_bias
= NULL_TREE
;
12787 /* If this is a subtype that should not be emitted as a subrange type,
12788 use the base type. See subrange_type_for_debug_p. */
12789 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
12790 type
= TREE_TYPE (type
);
12792 switch (TREE_CODE (type
))
12795 if ((dwarf_version
>= 4 || !dwarf_strict
)
12796 && TYPE_NAME (type
)
12797 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
12798 && DECL_IS_BUILTIN (TYPE_NAME (type
))
12799 && DECL_NAME (TYPE_NAME (type
)))
12801 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
12802 if (strcmp (name
, "char16_t") == 0
12803 || strcmp (name
, "char32_t") == 0)
12805 encoding
= DW_ATE_UTF
;
12809 if ((dwarf_version
>= 3 || !dwarf_strict
)
12810 && lang_hooks
.types
.get_fixed_point_type_info
)
12812 memset (&fpt_info
, 0, sizeof (fpt_info
));
12813 if (lang_hooks
.types
.get_fixed_point_type_info (type
, &fpt_info
))
12816 encoding
= ((TYPE_UNSIGNED (type
))
12817 ? DW_ATE_unsigned_fixed
12818 : DW_ATE_signed_fixed
);
12822 if (TYPE_STRING_FLAG (type
))
12824 if (TYPE_UNSIGNED (type
))
12825 encoding
= DW_ATE_unsigned_char
;
12827 encoding
= DW_ATE_signed_char
;
12829 else if (TYPE_UNSIGNED (type
))
12830 encoding
= DW_ATE_unsigned
;
12832 encoding
= DW_ATE_signed
;
12835 && lang_hooks
.types
.get_type_bias
)
12836 type_bias
= lang_hooks
.types
.get_type_bias (type
);
12840 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
12842 if (dwarf_version
>= 3 || !dwarf_strict
)
12843 encoding
= DW_ATE_decimal_float
;
12845 encoding
= DW_ATE_lo_user
;
12848 encoding
= DW_ATE_float
;
12851 case FIXED_POINT_TYPE
:
12852 if (!(dwarf_version
>= 3 || !dwarf_strict
))
12853 encoding
= DW_ATE_lo_user
;
12854 else if (TYPE_UNSIGNED (type
))
12855 encoding
= DW_ATE_unsigned_fixed
;
12857 encoding
= DW_ATE_signed_fixed
;
12860 /* Dwarf2 doesn't know anything about complex ints, so use
12861 a user defined type for it. */
12863 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
12864 encoding
= DW_ATE_complex_float
;
12866 encoding
= DW_ATE_lo_user
;
12870 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
12871 encoding
= DW_ATE_boolean
;
12875 /* No other TREE_CODEs are Dwarf fundamental types. */
12876 gcc_unreachable ();
12879 base_type_result
= new_die_raw (DW_TAG_base_type
);
12881 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
12882 int_size_in_bytes (type
));
12883 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
12885 if (need_endianity_attribute_p (reverse
))
12886 add_AT_unsigned (base_type_result
, DW_AT_endianity
,
12887 BYTES_BIG_ENDIAN
? DW_END_little
: DW_END_big
);
12889 add_alignment_attribute (base_type_result
, type
);
12893 switch (fpt_info
.scale_factor_kind
)
12895 case fixed_point_scale_factor_binary
:
12896 add_AT_int (base_type_result
, DW_AT_binary_scale
,
12897 fpt_info
.scale_factor
.binary
);
12900 case fixed_point_scale_factor_decimal
:
12901 add_AT_int (base_type_result
, DW_AT_decimal_scale
,
12902 fpt_info
.scale_factor
.decimal
);
12905 case fixed_point_scale_factor_arbitrary
:
12906 /* Arbitrary scale factors cannot be described in standard DWARF,
12910 /* Describe the scale factor as a rational constant. */
12911 const dw_die_ref scale_factor
12912 = new_die (DW_TAG_constant
, comp_unit_die (), type
);
12914 add_AT_unsigned (scale_factor
, DW_AT_GNU_numerator
,
12915 fpt_info
.scale_factor
.arbitrary
.numerator
);
12916 add_AT_int (scale_factor
, DW_AT_GNU_denominator
,
12917 fpt_info
.scale_factor
.arbitrary
.denominator
);
12919 add_AT_die_ref (base_type_result
, DW_AT_small
, scale_factor
);
12924 gcc_unreachable ();
12929 add_scalar_info (base_type_result
, DW_AT_GNU_bias
, type_bias
,
12930 dw_scalar_form_constant
12931 | dw_scalar_form_exprloc
12932 | dw_scalar_form_reference
,
12935 return base_type_result
;
12938 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
12939 named 'auto' in its type: return true for it, false otherwise. */
12942 is_cxx_auto (tree type
)
12946 tree name
= TYPE_IDENTIFIER (type
);
12947 if (name
== get_identifier ("auto")
12948 || name
== get_identifier ("decltype(auto)"))
12954 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
12955 given input type is a Dwarf "fundamental" type. Otherwise return null. */
12958 is_base_type (tree type
)
12960 switch (TREE_CODE (type
))
12964 case FIXED_POINT_TYPE
:
12973 case QUAL_UNION_TYPE
:
12974 case ENUMERAL_TYPE
:
12975 case FUNCTION_TYPE
:
12978 case REFERENCE_TYPE
:
12986 if (is_cxx_auto (type
))
12988 gcc_unreachable ();
12994 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
12995 node, return the size in bits for the type if it is a constant, or else
12996 return the alignment for the type if the type's size is not constant, or
12997 else return BITS_PER_WORD if the type actually turns out to be an
12998 ERROR_MARK node. */
13000 static inline unsigned HOST_WIDE_INT
13001 simple_type_size_in_bits (const_tree type
)
13003 if (TREE_CODE (type
) == ERROR_MARK
)
13004 return BITS_PER_WORD
;
13005 else if (TYPE_SIZE (type
) == NULL_TREE
)
13007 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
13008 return tree_to_uhwi (TYPE_SIZE (type
));
13010 return TYPE_ALIGN (type
);
13013 /* Similarly, but return an offset_int instead of UHWI. */
13015 static inline offset_int
13016 offset_int_type_size_in_bits (const_tree type
)
13018 if (TREE_CODE (type
) == ERROR_MARK
)
13019 return BITS_PER_WORD
;
13020 else if (TYPE_SIZE (type
) == NULL_TREE
)
13022 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
13023 return wi::to_offset (TYPE_SIZE (type
));
13025 return TYPE_ALIGN (type
);
13028 /* Given a pointer to a tree node for a subrange type, return a pointer
13029 to a DIE that describes the given type. */
13032 subrange_type_die (tree type
, tree low
, tree high
, tree bias
,
13033 dw_die_ref context_die
)
13035 dw_die_ref subrange_die
;
13036 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
13038 if (context_die
== NULL
)
13039 context_die
= comp_unit_die ();
13041 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
13043 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
13045 /* The size of the subrange type and its base type do not match,
13046 so we need to generate a size attribute for the subrange type. */
13047 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
13050 add_alignment_attribute (subrange_die
, type
);
13053 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
, NULL
);
13055 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
, NULL
);
13056 if (bias
&& !dwarf_strict
)
13057 add_scalar_info (subrange_die
, DW_AT_GNU_bias
, bias
,
13058 dw_scalar_form_constant
13059 | dw_scalar_form_exprloc
13060 | dw_scalar_form_reference
,
13063 return subrange_die
;
13066 /* Returns the (const and/or volatile) cv_qualifiers associated with
13067 the decl node. This will normally be augmented with the
13068 cv_qualifiers of the underlying type in add_type_attribute. */
13071 decl_quals (const_tree decl
)
13073 return ((TREE_READONLY (decl
)
13074 /* The C++ front-end correctly marks reference-typed
13075 variables as readonly, but from a language (and debug
13076 info) standpoint they are not const-qualified. */
13077 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
13078 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
)
13079 | (TREE_THIS_VOLATILE (decl
)
13080 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
));
13083 /* Determine the TYPE whose qualifiers match the largest strict subset
13084 of the given TYPE_QUALS, and return its qualifiers. Ignore all
13085 qualifiers outside QUAL_MASK. */
13088 get_nearest_type_subqualifiers (tree type
, int type_quals
, int qual_mask
)
13091 int best_rank
= 0, best_qual
= 0, max_rank
;
13093 type_quals
&= qual_mask
;
13094 max_rank
= popcount_hwi (type_quals
) - 1;
13096 for (t
= TYPE_MAIN_VARIANT (type
); t
&& best_rank
< max_rank
;
13097 t
= TYPE_NEXT_VARIANT (t
))
13099 int q
= TYPE_QUALS (t
) & qual_mask
;
13101 if ((q
& type_quals
) == q
&& q
!= type_quals
13102 && check_base_type (t
, type
))
13104 int rank
= popcount_hwi (q
);
13106 if (rank
> best_rank
)
13117 struct dwarf_qual_info_t
{ int q
; enum dwarf_tag t
; };
13118 static const dwarf_qual_info_t dwarf_qual_info
[] =
13120 { TYPE_QUAL_CONST
, DW_TAG_const_type
},
13121 { TYPE_QUAL_VOLATILE
, DW_TAG_volatile_type
},
13122 { TYPE_QUAL_RESTRICT
, DW_TAG_restrict_type
},
13123 { TYPE_QUAL_ATOMIC
, DW_TAG_atomic_type
}
13125 static const unsigned int dwarf_qual_info_size
13126 = sizeof (dwarf_qual_info
) / sizeof (dwarf_qual_info
[0]);
13128 /* If DIE is a qualified DIE of some base DIE with the same parent,
13129 return the base DIE, otherwise return NULL. Set MASK to the
13130 qualifiers added compared to the returned DIE. */
13133 qualified_die_p (dw_die_ref die
, int *mask
, unsigned int depth
)
13136 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13137 if (die
->die_tag
== dwarf_qual_info
[i
].t
)
13139 if (i
== dwarf_qual_info_size
)
13141 if (vec_safe_length (die
->die_attr
) != 1)
13143 dw_die_ref type
= get_AT_ref (die
, DW_AT_type
);
13144 if (type
== NULL
|| type
->die_parent
!= die
->die_parent
)
13146 *mask
|= dwarf_qual_info
[i
].q
;
13149 dw_die_ref ret
= qualified_die_p (type
, mask
, depth
- 1);
13156 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
13157 entry that chains the modifiers specified by CV_QUALS in front of the
13158 given type. REVERSE is true if the type is to be interpreted in the
13159 reverse storage order wrt the target order. */
13162 modified_type_die (tree type
, int cv_quals
, bool reverse
,
13163 dw_die_ref context_die
)
13165 enum tree_code code
= TREE_CODE (type
);
13166 dw_die_ref mod_type_die
;
13167 dw_die_ref sub_die
= NULL
;
13168 tree item_type
= NULL
;
13169 tree qualified_type
;
13170 tree name
, low
, high
;
13171 dw_die_ref mod_scope
;
13172 /* Only these cv-qualifiers are currently handled. */
13173 const int cv_qual_mask
= (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
13174 | TYPE_QUAL_RESTRICT
| TYPE_QUAL_ATOMIC
|
13175 ENCODE_QUAL_ADDR_SPACE(~0U));
13176 const bool reverse_base_type
13177 = need_endianity_attribute_p (reverse
) && is_base_type (type
);
13179 if (code
== ERROR_MARK
)
13182 if (lang_hooks
.types
.get_debug_type
)
13184 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
13186 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
13187 return modified_type_die (debug_type
, cv_quals
, reverse
, context_die
);
13190 cv_quals
&= cv_qual_mask
;
13192 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
13193 tag modifier (and not an attribute) old consumers won't be able
13195 if (dwarf_version
< 3)
13196 cv_quals
&= ~TYPE_QUAL_RESTRICT
;
13198 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
13199 if (dwarf_version
< 5)
13200 cv_quals
&= ~TYPE_QUAL_ATOMIC
;
13202 /* See if we already have the appropriately qualified variant of
13204 qualified_type
= get_qualified_type (type
, cv_quals
);
13206 if (qualified_type
== sizetype
)
13208 /* Try not to expose the internal sizetype type's name. */
13209 if (TYPE_NAME (qualified_type
)
13210 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
13212 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
13214 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
13215 && (TYPE_PRECISION (t
)
13216 == TYPE_PRECISION (qualified_type
))
13217 && (TYPE_UNSIGNED (t
)
13218 == TYPE_UNSIGNED (qualified_type
)));
13219 qualified_type
= t
;
13221 else if (qualified_type
== sizetype
13222 && TREE_CODE (sizetype
) == TREE_CODE (size_type_node
)
13223 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (size_type_node
)
13224 && TYPE_UNSIGNED (sizetype
) == TYPE_UNSIGNED (size_type_node
))
13225 qualified_type
= size_type_node
;
13226 if (type
== sizetype
)
13227 type
= qualified_type
;
13230 /* If we do, then we can just use its DIE, if it exists. */
13231 if (qualified_type
)
13233 mod_type_die
= lookup_type_die (qualified_type
);
13235 /* DW_AT_endianity doesn't come from a qualifier on the type, so it is
13236 dealt with specially: the DIE with the attribute, if it exists, is
13237 placed immediately after the regular DIE for the same base type. */
13239 && (!reverse_base_type
13240 || ((mod_type_die
= mod_type_die
->die_sib
) != NULL
13241 && get_AT_unsigned (mod_type_die
, DW_AT_endianity
))))
13242 return mod_type_die
;
13245 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
13247 /* Handle C typedef types. */
13249 && TREE_CODE (name
) == TYPE_DECL
13250 && DECL_ORIGINAL_TYPE (name
)
13251 && !DECL_ARTIFICIAL (name
))
13253 tree dtype
= TREE_TYPE (name
);
13255 /* Skip the typedef for base types with DW_AT_endianity, no big deal. */
13256 if (qualified_type
== dtype
&& !reverse_base_type
)
13258 tree origin
= decl_ultimate_origin (name
);
13260 /* Typedef variants that have an abstract origin don't get their own
13261 type DIE (see gen_typedef_die), so fall back on the ultimate
13262 abstract origin instead. */
13263 if (origin
!= NULL
&& origin
!= name
)
13264 return modified_type_die (TREE_TYPE (origin
), cv_quals
, reverse
,
13267 /* For a named type, use the typedef. */
13268 gen_type_die (qualified_type
, context_die
);
13269 return lookup_type_die (qualified_type
);
13273 int dquals
= TYPE_QUALS_NO_ADDR_SPACE (dtype
);
13274 dquals
&= cv_qual_mask
;
13275 if ((dquals
& ~cv_quals
) != TYPE_UNQUALIFIED
13276 || (cv_quals
== dquals
&& DECL_ORIGINAL_TYPE (name
) != type
))
13277 /* cv-unqualified version of named type. Just use
13278 the unnamed type to which it refers. */
13279 return modified_type_die (DECL_ORIGINAL_TYPE (name
), cv_quals
,
13280 reverse
, context_die
);
13281 /* Else cv-qualified version of named type; fall through. */
13285 mod_scope
= scope_die_for (type
, context_die
);
13289 int sub_quals
= 0, first_quals
= 0;
13291 dw_die_ref first
= NULL
, last
= NULL
;
13293 /* Determine a lesser qualified type that most closely matches
13294 this one. Then generate DW_TAG_* entries for the remaining
13296 sub_quals
= get_nearest_type_subqualifiers (type
, cv_quals
,
13298 if (sub_quals
&& use_debug_types
)
13300 bool needed
= false;
13301 /* If emitting type units, make sure the order of qualifiers
13302 is canonical. Thus, start from unqualified type if
13303 an earlier qualifier is missing in sub_quals, but some later
13304 one is present there. */
13305 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13306 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
13308 else if (needed
&& (dwarf_qual_info
[i
].q
& cv_quals
))
13314 mod_type_die
= modified_type_die (type
, sub_quals
, reverse
, context_die
);
13315 if (mod_scope
&& mod_type_die
&& mod_type_die
->die_parent
== mod_scope
)
13317 /* As not all intermediate qualified DIEs have corresponding
13318 tree types, ensure that qualified DIEs in the same scope
13319 as their DW_AT_type are emitted after their DW_AT_type,
13320 only with other qualified DIEs for the same type possibly
13321 in between them. Determine the range of such qualified
13322 DIEs now (first being the base type, last being corresponding
13323 last qualified DIE for it). */
13324 unsigned int count
= 0;
13325 first
= qualified_die_p (mod_type_die
, &first_quals
,
13326 dwarf_qual_info_size
);
13328 first
= mod_type_die
;
13329 gcc_assert ((first_quals
& ~sub_quals
) == 0);
13330 for (count
= 0, last
= first
;
13331 count
< (1U << dwarf_qual_info_size
);
13332 count
++, last
= last
->die_sib
)
13335 if (last
== mod_scope
->die_child
)
13337 if (qualified_die_p (last
->die_sib
, &quals
, dwarf_qual_info_size
)
13343 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
13344 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
13347 if (first
&& first
!= last
)
13349 for (d
= first
->die_sib
; ; d
= d
->die_sib
)
13352 qualified_die_p (d
, &quals
, dwarf_qual_info_size
);
13353 if (quals
== (first_quals
| dwarf_qual_info
[i
].q
))
13369 d
= new_die_raw (dwarf_qual_info
[i
].t
);
13370 add_child_die_after (mod_scope
, d
, last
);
13374 d
= new_die (dwarf_qual_info
[i
].t
, mod_scope
, type
);
13376 add_AT_die_ref (d
, DW_AT_type
, mod_type_die
);
13378 first_quals
|= dwarf_qual_info
[i
].q
;
13381 else if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
)
13383 dwarf_tag tag
= DW_TAG_pointer_type
;
13384 if (code
== REFERENCE_TYPE
)
13386 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
13387 tag
= DW_TAG_rvalue_reference_type
;
13389 tag
= DW_TAG_reference_type
;
13391 mod_type_die
= new_die (tag
, mod_scope
, type
);
13393 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
13394 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
13395 add_alignment_attribute (mod_type_die
, type
);
13396 item_type
= TREE_TYPE (type
);
13398 addr_space_t as
= TYPE_ADDR_SPACE (item_type
);
13399 if (!ADDR_SPACE_GENERIC_P (as
))
13401 int action
= targetm
.addr_space
.debug (as
);
13404 /* Positive values indicate an address_class. */
13405 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, action
);
13409 /* Negative values indicate an (inverted) segment base reg. */
13411 = one_reg_loc_descriptor (~action
, VAR_INIT_STATUS_INITIALIZED
);
13412 add_AT_loc (mod_type_die
, DW_AT_segment
, d
);
13416 else if (code
== INTEGER_TYPE
13417 && TREE_TYPE (type
) != NULL_TREE
13418 && subrange_type_for_debug_p (type
, &low
, &high
))
13420 tree bias
= NULL_TREE
;
13421 if (lang_hooks
.types
.get_type_bias
)
13422 bias
= lang_hooks
.types
.get_type_bias (type
);
13423 mod_type_die
= subrange_type_die (type
, low
, high
, bias
, context_die
);
13424 item_type
= TREE_TYPE (type
);
13426 else if (is_base_type (type
))
13428 mod_type_die
= base_type_die (type
, reverse
);
13430 /* The DIE with DW_AT_endianity is placed right after the naked DIE. */
13431 if (reverse_base_type
)
13433 dw_die_ref after_die
13434 = modified_type_die (type
, cv_quals
, false, context_die
);
13435 add_child_die_after (comp_unit_die (), mod_type_die
, after_die
);
13438 add_child_die (comp_unit_die (), mod_type_die
);
13440 add_pubtype (type
, mod_type_die
);
13444 gen_type_die (type
, context_die
);
13446 /* We have to get the type_main_variant here (and pass that to the
13447 `lookup_type_die' routine) because the ..._TYPE node we have
13448 might simply be a *copy* of some original type node (where the
13449 copy was created to help us keep track of typedef names) and
13450 that copy might have a different TYPE_UID from the original
13452 if (TREE_CODE (type
) == FUNCTION_TYPE
13453 || TREE_CODE (type
) == METHOD_TYPE
)
13455 /* For function/method types, can't just use type_main_variant here,
13456 because that can have different ref-qualifiers for C++,
13457 but try to canonicalize. */
13458 tree main
= TYPE_MAIN_VARIANT (type
);
13459 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
13460 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
13461 && check_base_type (t
, main
)
13462 && check_lang_type (t
, type
))
13463 return lookup_type_die (t
);
13464 return lookup_type_die (type
);
13466 else if (TREE_CODE (type
) != VECTOR_TYPE
13467 && TREE_CODE (type
) != ARRAY_TYPE
)
13468 return lookup_type_die (type_main_variant (type
));
13470 /* Vectors have the debugging information in the type,
13471 not the main variant. */
13472 return lookup_type_die (type
);
13475 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
13476 don't output a DW_TAG_typedef, since there isn't one in the
13477 user's program; just attach a DW_AT_name to the type.
13478 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
13479 if the base type already has the same name. */
13481 && ((TREE_CODE (name
) != TYPE_DECL
13482 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
13483 || (cv_quals
== TYPE_UNQUALIFIED
)))
13484 || (TREE_CODE (name
) == TYPE_DECL
13485 && TREE_TYPE (name
) == qualified_type
13486 && DECL_NAME (name
))))
13488 if (TREE_CODE (name
) == TYPE_DECL
)
13489 /* Could just call add_name_and_src_coords_attributes here,
13490 but since this is a builtin type it doesn't have any
13491 useful source coordinates anyway. */
13492 name
= DECL_NAME (name
);
13493 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
13495 /* This probably indicates a bug. */
13496 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
13498 name
= TYPE_IDENTIFIER (type
);
13499 add_name_attribute (mod_type_die
,
13500 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
13503 if (qualified_type
&& !reverse_base_type
)
13504 equate_type_number_to_die (qualified_type
, mod_type_die
);
13507 /* We must do this after the equate_type_number_to_die call, in case
13508 this is a recursive type. This ensures that the modified_type_die
13509 recursion will terminate even if the type is recursive. Recursive
13510 types are possible in Ada. */
13511 sub_die
= modified_type_die (item_type
,
13512 TYPE_QUALS_NO_ADDR_SPACE (item_type
),
13516 if (sub_die
!= NULL
)
13517 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
13519 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
13520 if (TYPE_ARTIFICIAL (type
))
13521 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
13523 return mod_type_die
;
13526 /* Generate DIEs for the generic parameters of T.
13527 T must be either a generic type or a generic function.
13528 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
13531 gen_generic_params_dies (tree t
)
13535 dw_die_ref die
= NULL
;
13538 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
13542 die
= lookup_type_die (t
);
13543 else if (DECL_P (t
))
13544 die
= lookup_decl_die (t
);
13548 parms
= lang_hooks
.get_innermost_generic_parms (t
);
13550 /* T has no generic parameter. It means T is neither a generic type
13551 or function. End of story. */
13554 parms_num
= TREE_VEC_LENGTH (parms
);
13555 args
= lang_hooks
.get_innermost_generic_args (t
);
13556 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
13557 non_default
= int_cst_value (TREE_CHAIN (args
));
13559 non_default
= TREE_VEC_LENGTH (args
);
13560 for (i
= 0; i
< parms_num
; i
++)
13562 tree parm
, arg
, arg_pack_elems
;
13563 dw_die_ref parm_die
;
13565 parm
= TREE_VEC_ELT (parms
, i
);
13566 arg
= TREE_VEC_ELT (args
, i
);
13567 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
13568 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
13570 if (parm
&& TREE_VALUE (parm
) && arg
)
13572 /* If PARM represents a template parameter pack,
13573 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
13574 by DW_TAG_template_*_parameter DIEs for the argument
13575 pack elements of ARG. Note that ARG would then be
13576 an argument pack. */
13577 if (arg_pack_elems
)
13578 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
13582 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
13583 true /* emit name */, die
);
13584 if (i
>= non_default
)
13585 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
13590 /* Create and return a DIE for PARM which should be
13591 the representation of a generic type parameter.
13592 For instance, in the C++ front end, PARM would be a template parameter.
13593 ARG is the argument to PARM.
13594 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
13596 PARENT_DIE is the parent DIE which the new created DIE should be added to,
13597 as a child node. */
13600 generic_parameter_die (tree parm
, tree arg
,
13602 dw_die_ref parent_die
)
13604 dw_die_ref tmpl_die
= NULL
;
13605 const char *name
= NULL
;
13607 /* C++2a accepts class literals as template parameters, and var
13608 decls with initializers represent them. The VAR_DECLs would be
13609 rejected, but we can take the DECL_INITIAL constructor and
13610 attempt to expand it. */
13611 if (arg
&& VAR_P (arg
))
13612 arg
= DECL_INITIAL (arg
);
13614 if (!parm
|| !DECL_NAME (parm
) || !arg
)
13617 /* We support non-type generic parameters and arguments,
13618 type generic parameters and arguments, as well as
13619 generic generic parameters (a.k.a. template template parameters in C++)
13621 if (TREE_CODE (parm
) == PARM_DECL
)
13622 /* PARM is a nontype generic parameter */
13623 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
13624 else if (TREE_CODE (parm
) == TYPE_DECL
)
13625 /* PARM is a type generic parameter. */
13626 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
13627 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
13628 /* PARM is a generic generic parameter.
13629 Its DIE is a GNU extension. It shall have a
13630 DW_AT_name attribute to represent the name of the template template
13631 parameter, and a DW_AT_GNU_template_name attribute to represent the
13632 name of the template template argument. */
13633 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
13636 gcc_unreachable ();
13642 /* If PARM is a generic parameter pack, it means we are
13643 emitting debug info for a template argument pack element.
13644 In other terms, ARG is a template argument pack element.
13645 In that case, we don't emit any DW_AT_name attribute for
13649 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
13651 add_AT_string (tmpl_die
, DW_AT_name
, name
);
13654 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
13656 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
13657 TMPL_DIE should have a child DW_AT_type attribute that is set
13658 to the type of the argument to PARM, which is ARG.
13659 If PARM is a type generic parameter, TMPL_DIE should have a
13660 child DW_AT_type that is set to ARG. */
13661 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
13662 add_type_attribute (tmpl_die
, tmpl_type
,
13663 (TREE_THIS_VOLATILE (tmpl_type
)
13664 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
),
13665 false, parent_die
);
13669 /* So TMPL_DIE is a DIE representing a
13670 a generic generic template parameter, a.k.a template template
13671 parameter in C++ and arg is a template. */
13673 /* The DW_AT_GNU_template_name attribute of the DIE must be set
13674 to the name of the argument. */
13675 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
13677 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
13680 if (TREE_CODE (parm
) == PARM_DECL
)
13681 /* So PARM is a non-type generic parameter.
13682 DWARF3 5.6.8 says we must set a DW_AT_const_value child
13683 attribute of TMPL_DIE which value represents the value
13685 We must be careful here:
13686 The value of ARG might reference some function decls.
13687 We might currently be emitting debug info for a generic
13688 type and types are emitted before function decls, we don't
13689 know if the function decls referenced by ARG will actually be
13690 emitted after cgraph computations.
13691 So must defer the generation of the DW_AT_const_value to
13692 after cgraph is ready. */
13693 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
13699 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
13700 PARM_PACK must be a template parameter pack. The returned DIE
13701 will be child DIE of PARENT_DIE. */
13704 template_parameter_pack_die (tree parm_pack
,
13705 tree parm_pack_args
,
13706 dw_die_ref parent_die
)
13711 gcc_assert (parent_die
&& parm_pack
);
13713 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
13714 add_name_and_src_coords_attributes (die
, parm_pack
);
13715 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
13716 generic_parameter_die (parm_pack
,
13717 TREE_VEC_ELT (parm_pack_args
, j
),
13718 false /* Don't emit DW_AT_name */,
13723 /* Return the DBX register number described by a given RTL node. */
13725 static unsigned int
13726 dbx_reg_number (const_rtx rtl
)
13728 unsigned regno
= REGNO (rtl
);
13730 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
13732 #ifdef LEAF_REG_REMAP
13733 if (crtl
->uses_only_leaf_regs
)
13735 int leaf_reg
= LEAF_REG_REMAP (regno
);
13736 if (leaf_reg
!= -1)
13737 regno
= (unsigned) leaf_reg
;
13741 regno
= DBX_REGISTER_NUMBER (regno
);
13742 gcc_assert (regno
!= INVALID_REGNUM
);
13746 /* Optionally add a DW_OP_piece term to a location description expression.
13747 DW_OP_piece is only added if the location description expression already
13748 doesn't end with DW_OP_piece. */
13751 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
13753 dw_loc_descr_ref loc
;
13755 if (*list_head
!= NULL
)
13757 /* Find the end of the chain. */
13758 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
13761 if (loc
->dw_loc_opc
!= DW_OP_piece
)
13762 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
13766 /* Return a location descriptor that designates a machine register or
13767 zero if there is none. */
13769 static dw_loc_descr_ref
13770 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
13774 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
13777 /* We only use "frame base" when we're sure we're talking about the
13778 post-prologue local stack frame. We do this by *not* running
13779 register elimination until this point, and recognizing the special
13780 argument pointer and soft frame pointer rtx's.
13781 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
13782 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
13783 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
13785 dw_loc_descr_ref result
= NULL
;
13787 if (dwarf_version
>= 4 || !dwarf_strict
)
13789 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
13792 add_loc_descr (&result
,
13793 new_loc_descr (DW_OP_stack_value
, 0, 0));
13798 regs
= targetm
.dwarf_register_span (rtl
);
13800 if (REG_NREGS (rtl
) > 1 || regs
)
13801 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
13804 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
13805 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
13807 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
13811 /* Return a location descriptor that designates a machine register for
13812 a given hard register number. */
13814 static dw_loc_descr_ref
13815 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
13817 dw_loc_descr_ref reg_loc_descr
;
13821 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
13823 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
13825 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13826 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13828 return reg_loc_descr
;
13831 /* Given an RTL of a register, return a location descriptor that
13832 designates a value that spans more than one register. */
13834 static dw_loc_descr_ref
13835 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
13836 enum var_init_status initialized
)
13839 dw_loc_descr_ref loc_result
= NULL
;
13841 /* Simple, contiguous registers. */
13842 if (regs
== NULL_RTX
)
13844 unsigned reg
= REGNO (rtl
);
13847 #ifdef LEAF_REG_REMAP
13848 if (crtl
->uses_only_leaf_regs
)
13850 int leaf_reg
= LEAF_REG_REMAP (reg
);
13851 if (leaf_reg
!= -1)
13852 reg
= (unsigned) leaf_reg
;
13856 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
13857 nregs
= REG_NREGS (rtl
);
13859 /* At present we only track constant-sized pieces. */
13860 if (!GET_MODE_SIZE (GET_MODE (rtl
)).is_constant (&size
))
13867 dw_loc_descr_ref t
;
13869 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
13870 VAR_INIT_STATUS_INITIALIZED
);
13871 add_loc_descr (&loc_result
, t
);
13872 add_loc_descr_op_piece (&loc_result
, size
);
13878 /* Now onto stupid register sets in non contiguous locations. */
13880 gcc_assert (GET_CODE (regs
) == PARALLEL
);
13882 /* At present we only track constant-sized pieces. */
13883 if (!GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0))).is_constant (&size
))
13887 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
13889 dw_loc_descr_ref t
;
13891 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
13892 VAR_INIT_STATUS_INITIALIZED
);
13893 add_loc_descr (&loc_result
, t
);
13894 add_loc_descr_op_piece (&loc_result
, size
);
13897 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13898 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13902 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
13904 /* Return a location descriptor that designates a constant i,
13905 as a compound operation from constant (i >> shift), constant shift
13908 static dw_loc_descr_ref
13909 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
13911 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
13912 add_loc_descr (&ret
, int_loc_descriptor (shift
));
13913 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
13917 /* Return a location descriptor that designates constant POLY_I. */
13919 static dw_loc_descr_ref
13920 int_loc_descriptor (poly_int64 poly_i
)
13922 enum dwarf_location_atom op
;
13925 if (!poly_i
.is_constant (&i
))
13927 /* Create location descriptions for the non-constant part and
13928 add any constant offset at the end. */
13929 dw_loc_descr_ref ret
= NULL
;
13930 HOST_WIDE_INT constant
= poly_i
.coeffs
[0];
13931 for (unsigned int j
= 1; j
< NUM_POLY_INT_COEFFS
; ++j
)
13933 HOST_WIDE_INT coeff
= poly_i
.coeffs
[j
];
13936 dw_loc_descr_ref start
= ret
;
13937 unsigned int factor
;
13939 unsigned int regno
= targetm
.dwarf_poly_indeterminate_value
13940 (j
, &factor
, &bias
);
13942 /* Add COEFF * ((REGNO / FACTOR) - BIAS) to the value:
13943 add COEFF * (REGNO / FACTOR) now and subtract
13944 COEFF * BIAS from the final constant part. */
13945 constant
-= coeff
* bias
;
13946 add_loc_descr (&ret
, new_reg_loc_descr (regno
, 0));
13947 if (coeff
% factor
== 0)
13951 int amount
= exact_log2 (factor
);
13952 gcc_assert (amount
>= 0);
13953 add_loc_descr (&ret
, int_loc_descriptor (amount
));
13954 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
13958 add_loc_descr (&ret
, int_loc_descriptor (coeff
));
13959 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
13962 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
13965 loc_descr_plus_const (&ret
, constant
);
13969 /* Pick the smallest representation of a constant, rather than just
13970 defaulting to the LEB encoding. */
13973 int clz
= clz_hwi (i
);
13974 int ctz
= ctz_hwi (i
);
13976 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
13977 else if (i
<= 0xff)
13978 op
= DW_OP_const1u
;
13979 else if (i
<= 0xffff)
13980 op
= DW_OP_const2u
;
13981 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
13982 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
13983 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
13984 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
13985 while DW_OP_const4u is 5 bytes. */
13986 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
13987 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13988 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
13989 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
13990 while DW_OP_const4u is 5 bytes. */
13991 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
13993 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
13994 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
13997 /* As i >= 2**31, the double cast above will yield a negative number.
13998 Since wrapping is defined in DWARF expressions we can output big
13999 positive integers as small negative ones, regardless of the size
14002 Here, since the evaluator will handle 32-bit values and since i >=
14003 2**31, we know it's going to be interpreted as a negative literal:
14004 store it this way if we can do better than 5 bytes this way. */
14005 return int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
14007 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14008 op
= DW_OP_const4u
;
14010 /* Past this point, i >= 0x100000000 and thus DW_OP_constu will take at
14011 least 6 bytes: see if we can do better before falling back to it. */
14012 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14013 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
14014 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes. */
14015 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
14016 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
14017 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
14018 >= HOST_BITS_PER_WIDE_INT
)
14019 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
14020 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes. */
14021 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
14022 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
14023 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
14024 && size_of_uleb128 (i
) > 6)
14025 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
14026 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
14033 op
= DW_OP_const1s
;
14034 else if (i
>= -0x8000)
14035 op
= DW_OP_const2s
;
14036 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
14038 if (size_of_int_loc_descriptor (i
) < 5)
14040 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
14041 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14044 op
= DW_OP_const4s
;
14048 if (size_of_int_loc_descriptor (i
)
14049 < (unsigned long) 1 + size_of_sleb128 (i
))
14051 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
14052 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14059 return new_loc_descr (op
, i
, 0);
14062 /* Likewise, for unsigned constants. */
14064 static dw_loc_descr_ref
14065 uint_loc_descriptor (unsigned HOST_WIDE_INT i
)
14067 const unsigned HOST_WIDE_INT max_int
= INTTYPE_MAXIMUM (HOST_WIDE_INT
);
14068 const unsigned HOST_WIDE_INT max_uint
14069 = INTTYPE_MAXIMUM (unsigned HOST_WIDE_INT
);
14071 /* If possible, use the clever signed constants handling. */
14073 return int_loc_descriptor ((HOST_WIDE_INT
) i
);
14075 /* Here, we are left with positive numbers that cannot be represented as
14076 HOST_WIDE_INT, i.e.:
14077 max (HOST_WIDE_INT) < i <= max (unsigned HOST_WIDE_INT)
14079 Using DW_OP_const4/8/./u operation to encode them consumes a lot of bytes
14080 whereas may be better to output a negative integer: thanks to integer
14081 wrapping, we know that:
14082 x = x - 2 ** DWARF2_ADDR_SIZE
14083 = x - 2 * (max (HOST_WIDE_INT) + 1)
14084 So numbers close to max (unsigned HOST_WIDE_INT) could be represented as
14085 small negative integers. Let's try that in cases it will clearly improve
14086 the encoding: there is no gain turning DW_OP_const4u into
14088 if (DWARF2_ADDR_SIZE
* 8 == HOST_BITS_PER_WIDE_INT
14089 && ((DWARF2_ADDR_SIZE
== 4 && i
> max_uint
- 0x8000)
14090 || (DWARF2_ADDR_SIZE
== 8 && i
> max_uint
- 0x80000000)))
14092 const unsigned HOST_WIDE_INT first_shift
= i
- max_int
- 1;
14094 /* Now, -1 < first_shift <= max (HOST_WIDE_INT)
14095 i.e. 0 <= first_shift <= max (HOST_WIDE_INT). */
14096 const HOST_WIDE_INT second_shift
14097 = (HOST_WIDE_INT
) first_shift
- (HOST_WIDE_INT
) max_int
- 1;
14099 /* So we finally have:
14100 -max (HOST_WIDE_INT) - 1 <= second_shift <= -1.
14101 i.e. min (HOST_WIDE_INT) <= second_shift < 0. */
14102 return int_loc_descriptor (second_shift
);
14105 /* Last chance: fallback to a simple constant operation. */
14106 return new_loc_descr
14107 ((HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14113 /* Generate and return a location description that computes the unsigned
14114 comparison of the two stack top entries (a OP b where b is the top-most
14115 entry and a is the second one). The KIND of comparison can be LT_EXPR,
14116 LE_EXPR, GT_EXPR or GE_EXPR. */
14118 static dw_loc_descr_ref
14119 uint_comparison_loc_list (enum tree_code kind
)
14121 enum dwarf_location_atom op
, flip_op
;
14122 dw_loc_descr_ref ret
, bra_node
, jmp_node
, tmp
;
14139 gcc_unreachable ();
14142 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14143 jmp_node
= new_loc_descr (DW_OP_skip
, 0, 0);
14145 /* Until DWARFv4, operations all work on signed integers. It is nevertheless
14146 possible to perform unsigned comparisons: we just have to distinguish
14149 1. when a and b have the same sign (as signed integers); then we should
14150 return: a OP(signed) b;
14152 2. when a is a negative signed integer while b is a positive one, then a
14153 is a greater unsigned integer than b; likewise when a and b's roles
14156 So first, compare the sign of the two operands. */
14157 ret
= new_loc_descr (DW_OP_over
, 0, 0);
14158 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
14159 add_loc_descr (&ret
, new_loc_descr (DW_OP_xor
, 0, 0));
14160 /* If they have different signs (i.e. they have different sign bits), then
14161 the stack top value has now the sign bit set and thus it's smaller than
14163 add_loc_descr (&ret
, new_loc_descr (DW_OP_lit0
, 0, 0));
14164 add_loc_descr (&ret
, new_loc_descr (DW_OP_lt
, 0, 0));
14165 add_loc_descr (&ret
, bra_node
);
14167 /* We are in case 1. At this point, we know both operands have the same
14168 sign, to it's safe to use the built-in signed comparison. */
14169 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14170 add_loc_descr (&ret
, jmp_node
);
14172 /* We are in case 2. Here, we know both operands do not have the same sign,
14173 so we have to flip the signed comparison. */
14174 flip_op
= (kind
== LT_EXPR
|| kind
== LE_EXPR
) ? DW_OP_gt
: DW_OP_lt
;
14175 tmp
= new_loc_descr (flip_op
, 0, 0);
14176 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14177 bra_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14178 add_loc_descr (&ret
, tmp
);
14180 /* This dummy operation is necessary to make the two branches join. */
14181 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
14182 jmp_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14183 jmp_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
14184 add_loc_descr (&ret
, tmp
);
14189 /* Likewise, but takes the location description lists (might be destructive on
14190 them). Return NULL if either is NULL or if concatenation fails. */
14192 static dw_loc_list_ref
14193 loc_list_from_uint_comparison (dw_loc_list_ref left
, dw_loc_list_ref right
,
14194 enum tree_code kind
)
14196 if (left
== NULL
|| right
== NULL
)
14199 add_loc_list (&left
, right
);
14203 add_loc_descr_to_each (left
, uint_comparison_loc_list (kind
));
14207 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
14208 without actually allocating it. */
14210 static unsigned long
14211 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
14213 return size_of_int_loc_descriptor (i
>> shift
)
14214 + size_of_int_loc_descriptor (shift
)
14218 /* Return size_of_locs (int_loc_descriptor (i)) without
14219 actually allocating it. */
14221 static unsigned long
14222 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
14231 else if (i
<= 0xff)
14233 else if (i
<= 0xffff)
14237 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
14238 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
14239 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14241 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14242 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
14243 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14245 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
14246 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
14248 return size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
14249 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
14251 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
14252 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
14253 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
14254 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14256 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
14257 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
14258 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14260 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
14261 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
14263 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
14272 else if (i
>= -0x8000)
14274 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
14276 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
14278 s
= size_of_int_loc_descriptor (-i
) + 1;
14286 unsigned long r
= 1 + size_of_sleb128 (i
);
14287 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
14289 s
= size_of_int_loc_descriptor (-i
) + 1;
14298 /* Return loc description representing "address" of integer value.
14299 This can appear only as toplevel expression. */
14301 static dw_loc_descr_ref
14302 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
14305 dw_loc_descr_ref loc_result
= NULL
;
14307 if (!(dwarf_version
>= 4 || !dwarf_strict
))
14310 litsize
= size_of_int_loc_descriptor (i
);
14311 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
14312 is more compact. For DW_OP_stack_value we need:
14313 litsize + 1 (DW_OP_stack_value)
14314 and for DW_OP_implicit_value:
14315 1 (DW_OP_implicit_value) + 1 (length) + size. */
14316 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
14318 loc_result
= int_loc_descriptor (i
);
14319 add_loc_descr (&loc_result
,
14320 new_loc_descr (DW_OP_stack_value
, 0, 0));
14324 loc_result
= new_loc_descr (DW_OP_implicit_value
,
14326 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
14327 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
14331 /* Return a location descriptor that designates a base+offset location. */
14333 static dw_loc_descr_ref
14334 based_loc_descr (rtx reg
, poly_int64 offset
,
14335 enum var_init_status initialized
)
14337 unsigned int regno
;
14338 dw_loc_descr_ref result
;
14339 dw_fde_ref fde
= cfun
->fde
;
14341 /* We only use "frame base" when we're sure we're talking about the
14342 post-prologue local stack frame. We do this by *not* running
14343 register elimination until this point, and recognizing the special
14344 argument pointer and soft frame pointer rtx's. */
14345 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
14347 rtx elim
= (ira_use_lra_p
14348 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
14349 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
14353 /* Allow hard frame pointer here even if frame pointer
14354 isn't used since hard frame pointer is encoded with
14355 DW_OP_fbreg which uses the DW_AT_frame_base attribute,
14356 not hard frame pointer directly. */
14357 elim
= strip_offset_and_add (elim
, &offset
);
14358 gcc_assert (elim
== hard_frame_pointer_rtx
14359 || elim
== stack_pointer_rtx
);
14361 /* If drap register is used to align stack, use frame
14362 pointer + offset to access stack variables. If stack
14363 is aligned without drap, use stack pointer + offset to
14364 access stack variables. */
14365 if (crtl
->stack_realign_tried
14366 && reg
== frame_pointer_rtx
)
14369 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
14370 ? HARD_FRAME_POINTER_REGNUM
14372 return new_reg_loc_descr (base_reg
, offset
);
14375 gcc_assert (frame_pointer_fb_offset_valid
);
14376 offset
+= frame_pointer_fb_offset
;
14377 HOST_WIDE_INT const_offset
;
14378 if (offset
.is_constant (&const_offset
))
14379 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
14382 dw_loc_descr_ref ret
= new_loc_descr (DW_OP_fbreg
, 0, 0);
14383 loc_descr_plus_const (&ret
, offset
);
14389 regno
= REGNO (reg
);
14390 #ifdef LEAF_REG_REMAP
14391 if (crtl
->uses_only_leaf_regs
)
14393 int leaf_reg
= LEAF_REG_REMAP (regno
);
14394 if (leaf_reg
!= -1)
14395 regno
= (unsigned) leaf_reg
;
14398 regno
= DWARF_FRAME_REGNUM (regno
);
14400 HOST_WIDE_INT const_offset
;
14401 if (!optimize
&& fde
14402 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
)
14403 && offset
.is_constant (&const_offset
))
14405 /* Use cfa+offset to represent the location of arguments passed
14406 on the stack when drap is used to align stack.
14407 Only do this when not optimizing, for optimized code var-tracking
14408 is supposed to track where the arguments live and the register
14409 used as vdrap or drap in some spot might be used for something
14410 else in other part of the routine. */
14411 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
14414 result
= new_reg_loc_descr (regno
, offset
);
14416 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14417 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14422 /* Return true if this RTL expression describes a base+offset calculation. */
14425 is_based_loc (const_rtx rtl
)
14427 return (GET_CODE (rtl
) == PLUS
14428 && ((REG_P (XEXP (rtl
, 0))
14429 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
14430 && CONST_INT_P (XEXP (rtl
, 1)))));
14433 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
14436 static dw_loc_descr_ref
14437 tls_mem_loc_descriptor (rtx mem
)
14440 dw_loc_descr_ref loc_result
;
14442 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
14445 base
= get_base_address (MEM_EXPR (mem
));
14448 || !DECL_THREAD_LOCAL_P (base
))
14451 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1, NULL
);
14452 if (loc_result
== NULL
)
14455 if (maybe_ne (MEM_OFFSET (mem
), 0))
14456 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
14461 /* Output debug info about reason why we failed to expand expression as dwarf
14465 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
14467 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
14469 fprintf (dump_file
, "Failed to expand as dwarf: ");
14471 print_generic_expr (dump_file
, expr
, dump_flags
);
14474 fprintf (dump_file
, "\n");
14475 print_rtl (dump_file
, rtl
);
14477 fprintf (dump_file
, "\nReason: %s\n", reason
);
14481 /* Helper function for const_ok_for_output. */
14484 const_ok_for_output_1 (rtx rtl
)
14486 if (targetm
.const_not_ok_for_debug_p (rtl
))
14488 if (GET_CODE (rtl
) != UNSPEC
)
14490 expansion_failed (NULL_TREE
, rtl
,
14491 "Expression rejected for debug by the backend.\n");
14495 /* If delegitimize_address couldn't do anything with the UNSPEC, and
14496 the target hook doesn't explicitly allow it in debug info, assume
14497 we can't express it in the debug info. */
14498 /* Don't complain about TLS UNSPECs, those are just too hard to
14499 delegitimize. Note this could be a non-decl SYMBOL_REF such as
14500 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
14501 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
14503 && (XVECLEN (rtl
, 0) == 0
14504 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
14505 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
))
14506 inform (current_function_decl
14507 ? DECL_SOURCE_LOCATION (current_function_decl
)
14508 : UNKNOWN_LOCATION
,
14509 #if NUM_UNSPEC_VALUES > 0
14510 "non-delegitimized UNSPEC %s (%d) found in variable location",
14511 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
14512 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
14514 "non-delegitimized UNSPEC %d found in variable location",
14517 expansion_failed (NULL_TREE
, rtl
,
14518 "UNSPEC hasn't been delegitimized.\n");
14522 if (CONST_POLY_INT_P (rtl
))
14525 /* FIXME: Refer to PR60655. It is possible for simplification
14526 of rtl expressions in var tracking to produce such expressions.
14527 We should really identify / validate expressions
14528 enclosed in CONST that can be handled by assemblers on various
14529 targets and only handle legitimate cases here. */
14530 switch (GET_CODE (rtl
))
14539 /* Make sure SYMBOL_REFs/UNSPECs are at most in one of the
14541 subrtx_var_iterator::array_type array
;
14542 bool first
= false;
14543 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
14544 if (SYMBOL_REF_P (*iter
)
14546 || GET_CODE (*iter
) == UNSPEC
)
14553 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 1), ALL
)
14554 if (SYMBOL_REF_P (*iter
)
14556 || GET_CODE (*iter
) == UNSPEC
)
14562 /* Disallow negation of SYMBOL_REFs or UNSPECs when they
14563 appear in the second operand of MINUS. */
14564 subrtx_var_iterator::array_type array
;
14565 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 1), ALL
)
14566 if (SYMBOL_REF_P (*iter
)
14568 || GET_CODE (*iter
) == UNSPEC
)
14576 if (CONSTANT_POOL_ADDRESS_P (rtl
))
14579 get_pool_constant_mark (rtl
, &marked
);
14580 /* If all references to this pool constant were optimized away,
14581 it was not output and thus we can't represent it. */
14584 expansion_failed (NULL_TREE
, rtl
,
14585 "Constant was removed from constant pool.\n");
14590 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
14593 /* Avoid references to external symbols in debug info, on several targets
14594 the linker might even refuse to link when linking a shared library,
14595 and in many other cases the relocations for .debug_info/.debug_loc are
14596 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
14597 to be defined within the same shared library or executable are fine. */
14598 if (SYMBOL_REF_EXTERNAL_P (rtl
))
14600 tree decl
= SYMBOL_REF_DECL (rtl
);
14602 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
14604 expansion_failed (NULL_TREE
, rtl
,
14605 "Symbol not defined in current TU.\n");
14613 /* Return true if constant RTL can be emitted in DW_OP_addr or
14614 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
14615 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
14618 const_ok_for_output (rtx rtl
)
14620 if (GET_CODE (rtl
) == SYMBOL_REF
)
14621 return const_ok_for_output_1 (rtl
);
14623 if (GET_CODE (rtl
) == CONST
)
14625 subrtx_var_iterator::array_type array
;
14626 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
14627 if (!const_ok_for_output_1 (*iter
))
14635 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
14636 if possible, NULL otherwise. */
14639 base_type_for_mode (machine_mode mode
, bool unsignedp
)
14641 dw_die_ref type_die
;
14642 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
14646 switch (TREE_CODE (type
))
14654 type_die
= lookup_type_die (type
);
14656 type_die
= modified_type_die (type
, TYPE_UNQUALIFIED
, false,
14658 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
14663 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
14664 type matching MODE, or, if MODE is narrower than or as wide as
14665 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
14668 static dw_loc_descr_ref
14669 convert_descriptor_to_mode (scalar_int_mode mode
, dw_loc_descr_ref op
)
14671 machine_mode outer_mode
= mode
;
14672 dw_die_ref type_die
;
14673 dw_loc_descr_ref cvt
;
14675 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
14677 add_loc_descr (&op
, new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0));
14680 type_die
= base_type_for_mode (outer_mode
, 1);
14681 if (type_die
== NULL
)
14683 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14684 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14685 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14686 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14687 add_loc_descr (&op
, cvt
);
14691 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
14693 static dw_loc_descr_ref
14694 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
14695 dw_loc_descr_ref op1
)
14697 dw_loc_descr_ref ret
= op0
;
14698 add_loc_descr (&ret
, op1
);
14699 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14700 if (STORE_FLAG_VALUE
!= 1)
14702 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
14703 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
14708 /* Subroutine of scompare_loc_descriptor for the case in which we're
14709 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
14710 and in which OP_MODE is bigger than DWARF2_ADDR_SIZE. */
14712 static dw_loc_descr_ref
14713 scompare_loc_descriptor_wide (enum dwarf_location_atom op
,
14714 scalar_int_mode op_mode
,
14715 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
14717 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
14718 dw_loc_descr_ref cvt
;
14720 if (type_die
== NULL
)
14722 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14723 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14724 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14725 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14726 add_loc_descr (&op0
, cvt
);
14727 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14728 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14729 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14730 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14731 add_loc_descr (&op1
, cvt
);
14732 return compare_loc_descriptor (op
, op0
, op1
);
14735 /* Subroutine of scompare_loc_descriptor for the case in which we're
14736 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
14737 and in which OP_MODE is smaller than DWARF2_ADDR_SIZE. */
14739 static dw_loc_descr_ref
14740 scompare_loc_descriptor_narrow (enum dwarf_location_atom op
, rtx rtl
,
14741 scalar_int_mode op_mode
,
14742 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
14744 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
14745 /* For eq/ne, if the operands are known to be zero-extended,
14746 there is no need to do the fancy shifting up. */
14747 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
14749 dw_loc_descr_ref last0
, last1
;
14750 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
14752 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
14754 /* deref_size zero extends, and for constants we can check
14755 whether they are zero extended or not. */
14756 if (((last0
->dw_loc_opc
== DW_OP_deref_size
14757 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
14758 || (CONST_INT_P (XEXP (rtl
, 0))
14759 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
14760 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
14761 && ((last1
->dw_loc_opc
== DW_OP_deref_size
14762 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
14763 || (CONST_INT_P (XEXP (rtl
, 1))
14764 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
14765 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
14766 return compare_loc_descriptor (op
, op0
, op1
);
14768 /* EQ/NE comparison against constant in narrower type than
14769 DWARF2_ADDR_SIZE can be performed either as
14770 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
14773 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
14774 DW_OP_{eq,ne}. Pick whatever is shorter. */
14775 if (CONST_INT_P (XEXP (rtl
, 1))
14776 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
14777 && (size_of_int_loc_descriptor (shift
) + 1
14778 + size_of_int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
)
14779 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
14780 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
14781 & GET_MODE_MASK (op_mode
))))
14783 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
14784 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14785 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
14786 & GET_MODE_MASK (op_mode
));
14787 return compare_loc_descriptor (op
, op0
, op1
);
14790 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14791 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14792 if (CONST_INT_P (XEXP (rtl
, 1)))
14793 op1
= int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
);
14796 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14797 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14799 return compare_loc_descriptor (op
, op0
, op1
);
14802 /* Return location descriptor for unsigned comparison OP RTL. */
14804 static dw_loc_descr_ref
14805 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
14806 machine_mode mem_mode
)
14808 machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
14809 dw_loc_descr_ref op0
, op1
;
14811 if (op_mode
== VOIDmode
)
14812 op_mode
= GET_MODE (XEXP (rtl
, 1));
14813 if (op_mode
== VOIDmode
)
14816 scalar_int_mode int_op_mode
;
14818 && dwarf_version
< 5
14819 && (!is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
)
14820 || GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
))
14823 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
14824 VAR_INIT_STATUS_INITIALIZED
);
14825 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
14826 VAR_INIT_STATUS_INITIALIZED
);
14828 if (op0
== NULL
|| op1
== NULL
)
14831 if (is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
))
14833 if (GET_MODE_SIZE (int_op_mode
) < DWARF2_ADDR_SIZE
)
14834 return scompare_loc_descriptor_narrow (op
, rtl
, int_op_mode
, op0
, op1
);
14836 if (GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
)
14837 return scompare_loc_descriptor_wide (op
, int_op_mode
, op0
, op1
);
14839 return compare_loc_descriptor (op
, op0
, op1
);
14842 /* Return location descriptor for unsigned comparison OP RTL. */
14844 static dw_loc_descr_ref
14845 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
14846 machine_mode mem_mode
)
14848 dw_loc_descr_ref op0
, op1
;
14850 machine_mode test_op_mode
= GET_MODE (XEXP (rtl
, 0));
14851 if (test_op_mode
== VOIDmode
)
14852 test_op_mode
= GET_MODE (XEXP (rtl
, 1));
14854 scalar_int_mode op_mode
;
14855 if (!is_a
<scalar_int_mode
> (test_op_mode
, &op_mode
))
14859 && dwarf_version
< 5
14860 && GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
14863 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
14864 VAR_INIT_STATUS_INITIALIZED
);
14865 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
14866 VAR_INIT_STATUS_INITIALIZED
);
14868 if (op0
== NULL
|| op1
== NULL
)
14871 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
14873 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
14874 dw_loc_descr_ref last0
, last1
;
14875 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
14877 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
14879 if (CONST_INT_P (XEXP (rtl
, 0)))
14880 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
14881 /* deref_size zero extends, so no need to mask it again. */
14882 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
14883 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
14885 add_loc_descr (&op0
, int_loc_descriptor (mask
));
14886 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14888 if (CONST_INT_P (XEXP (rtl
, 1)))
14889 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
14890 /* deref_size zero extends, so no need to mask it again. */
14891 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
14892 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
14894 add_loc_descr (&op1
, int_loc_descriptor (mask
));
14895 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
14898 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
14900 HOST_WIDE_INT bias
= 1;
14901 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
14902 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14903 if (CONST_INT_P (XEXP (rtl
, 1)))
14904 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
14905 + INTVAL (XEXP (rtl
, 1)));
14907 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
14910 return compare_loc_descriptor (op
, op0
, op1
);
14913 /* Return location descriptor for {U,S}{MIN,MAX}. */
14915 static dw_loc_descr_ref
14916 minmax_loc_descriptor (rtx rtl
, machine_mode mode
,
14917 machine_mode mem_mode
)
14919 enum dwarf_location_atom op
;
14920 dw_loc_descr_ref op0
, op1
, ret
;
14921 dw_loc_descr_ref bra_node
, drop_node
;
14923 scalar_int_mode int_mode
;
14925 && dwarf_version
< 5
14926 && (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
14927 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
))
14930 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14931 VAR_INIT_STATUS_INITIALIZED
);
14932 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
14933 VAR_INIT_STATUS_INITIALIZED
);
14935 if (op0
== NULL
|| op1
== NULL
)
14938 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
14939 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
14940 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
14941 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
14943 /* Checked by the caller. */
14944 int_mode
= as_a
<scalar_int_mode
> (mode
);
14945 if (GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
14947 HOST_WIDE_INT mask
= GET_MODE_MASK (int_mode
);
14948 add_loc_descr (&op0
, int_loc_descriptor (mask
));
14949 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14950 add_loc_descr (&op1
, int_loc_descriptor (mask
));
14951 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
14953 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
14955 HOST_WIDE_INT bias
= 1;
14956 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
14957 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14958 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14961 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14962 && GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
14964 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (int_mode
)) * BITS_PER_UNIT
;
14965 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14966 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14967 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14968 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14970 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14971 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
14973 dw_die_ref type_die
= base_type_for_mode (int_mode
, 0);
14974 dw_loc_descr_ref cvt
;
14975 if (type_die
== NULL
)
14977 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14978 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14979 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14980 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14981 add_loc_descr (&op0
, cvt
);
14982 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14983 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14984 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14985 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14986 add_loc_descr (&op1
, cvt
);
14989 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
14994 add_loc_descr (&ret
, op1
);
14995 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14996 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14997 add_loc_descr (&ret
, bra_node
);
14998 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14999 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
15000 add_loc_descr (&ret
, drop_node
);
15001 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15002 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
15003 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
15004 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15005 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15006 ret
= convert_descriptor_to_mode (int_mode
, ret
);
15010 /* Helper function for mem_loc_descriptor. Perform OP binary op,
15011 but after converting arguments to type_die, afterwards
15012 convert back to unsigned. */
15014 static dw_loc_descr_ref
15015 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
15016 scalar_int_mode mode
, machine_mode mem_mode
)
15018 dw_loc_descr_ref cvt
, op0
, op1
;
15020 if (type_die
== NULL
)
15022 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15023 VAR_INIT_STATUS_INITIALIZED
);
15024 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15025 VAR_INIT_STATUS_INITIALIZED
);
15026 if (op0
== NULL
|| op1
== NULL
)
15028 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15029 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15030 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15031 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15032 add_loc_descr (&op0
, cvt
);
15033 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15034 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15035 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15036 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15037 add_loc_descr (&op1
, cvt
);
15038 add_loc_descr (&op0
, op1
);
15039 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
15040 return convert_descriptor_to_mode (mode
, op0
);
15043 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
15044 const0 is DW_OP_lit0 or corresponding typed constant,
15045 const1 is DW_OP_lit1 or corresponding typed constant
15046 and constMSB is constant with just the MSB bit set
15048 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
15049 L1: const0 DW_OP_swap
15050 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
15051 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15056 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
15057 L1: const0 DW_OP_swap
15058 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
15059 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15064 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
15065 L1: const1 DW_OP_swap
15066 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
15067 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
15071 static dw_loc_descr_ref
15072 clz_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15073 machine_mode mem_mode
)
15075 dw_loc_descr_ref op0
, ret
, tmp
;
15076 HOST_WIDE_INT valv
;
15077 dw_loc_descr_ref l1jump
, l1label
;
15078 dw_loc_descr_ref l2jump
, l2label
;
15079 dw_loc_descr_ref l3jump
, l3label
;
15080 dw_loc_descr_ref l4jump
, l4label
;
15083 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
15086 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15087 VAR_INIT_STATUS_INITIALIZED
);
15091 if (GET_CODE (rtl
) == CLZ
)
15093 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
15094 valv
= GET_MODE_BITSIZE (mode
);
15096 else if (GET_CODE (rtl
) == FFS
)
15098 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
15099 valv
= GET_MODE_BITSIZE (mode
);
15100 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15101 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15102 add_loc_descr (&ret
, l1jump
);
15103 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
15104 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
15105 VAR_INIT_STATUS_INITIALIZED
);
15108 add_loc_descr (&ret
, tmp
);
15109 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15110 add_loc_descr (&ret
, l4jump
);
15111 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
15112 ? const1_rtx
: const0_rtx
,
15114 VAR_INIT_STATUS_INITIALIZED
);
15115 if (l1label
== NULL
)
15117 add_loc_descr (&ret
, l1label
);
15118 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15119 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
15120 add_loc_descr (&ret
, l2label
);
15121 if (GET_CODE (rtl
) != CLZ
)
15123 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
15124 msb
= GEN_INT (HOST_WIDE_INT_1U
15125 << (GET_MODE_BITSIZE (mode
) - 1));
15127 msb
= immed_wide_int_const
15128 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode
) - 1,
15129 GET_MODE_PRECISION (mode
)), mode
);
15130 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
15131 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
15132 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
15133 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
15135 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
15136 VAR_INIT_STATUS_INITIALIZED
);
15139 add_loc_descr (&ret
, tmp
);
15140 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15141 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15142 add_loc_descr (&ret
, l3jump
);
15143 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15144 VAR_INIT_STATUS_INITIALIZED
);
15147 add_loc_descr (&ret
, tmp
);
15148 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
15149 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
15150 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15151 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
15152 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15153 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15154 add_loc_descr (&ret
, l2jump
);
15155 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
15156 add_loc_descr (&ret
, l3label
);
15157 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
15158 add_loc_descr (&ret
, l4label
);
15159 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15160 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15161 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15162 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15163 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15164 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
15165 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15166 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
15170 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
15171 const1 is DW_OP_lit1 or corresponding typed constant):
15173 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15174 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15178 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
15179 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
15182 static dw_loc_descr_ref
15183 popcount_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15184 machine_mode mem_mode
)
15186 dw_loc_descr_ref op0
, ret
, tmp
;
15187 dw_loc_descr_ref l1jump
, l1label
;
15188 dw_loc_descr_ref l2jump
, l2label
;
15190 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
15193 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15194 VAR_INIT_STATUS_INITIALIZED
);
15198 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15199 VAR_INIT_STATUS_INITIALIZED
);
15202 add_loc_descr (&ret
, tmp
);
15203 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15204 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
15205 add_loc_descr (&ret
, l1label
);
15206 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15207 add_loc_descr (&ret
, l2jump
);
15208 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15209 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
15210 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15211 VAR_INIT_STATUS_INITIALIZED
);
15214 add_loc_descr (&ret
, tmp
);
15215 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15216 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
15217 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
15218 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15219 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
15220 VAR_INIT_STATUS_INITIALIZED
);
15221 add_loc_descr (&ret
, tmp
);
15222 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15223 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15224 add_loc_descr (&ret
, l1jump
);
15225 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
15226 add_loc_descr (&ret
, l2label
);
15227 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15228 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15229 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15230 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15234 /* BSWAP (constS is initial shift count, either 56 or 24):
15236 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
15237 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
15238 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
15239 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
15240 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
15242 static dw_loc_descr_ref
15243 bswap_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15244 machine_mode mem_mode
)
15246 dw_loc_descr_ref op0
, ret
, tmp
;
15247 dw_loc_descr_ref l1jump
, l1label
;
15248 dw_loc_descr_ref l2jump
, l2label
;
15250 if (BITS_PER_UNIT
!= 8
15251 || (GET_MODE_BITSIZE (mode
) != 32
15252 && GET_MODE_BITSIZE (mode
) != 64))
15255 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15256 VAR_INIT_STATUS_INITIALIZED
);
15261 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
15263 VAR_INIT_STATUS_INITIALIZED
);
15266 add_loc_descr (&ret
, tmp
);
15267 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15268 VAR_INIT_STATUS_INITIALIZED
);
15271 add_loc_descr (&ret
, tmp
);
15272 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
15273 add_loc_descr (&ret
, l1label
);
15274 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
15276 VAR_INIT_STATUS_INITIALIZED
);
15277 add_loc_descr (&ret
, tmp
);
15278 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
15279 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15280 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15281 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
15282 VAR_INIT_STATUS_INITIALIZED
);
15285 add_loc_descr (&ret
, tmp
);
15286 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
15287 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
15288 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
15289 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
15290 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15291 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
15292 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
15293 VAR_INIT_STATUS_INITIALIZED
);
15294 add_loc_descr (&ret
, tmp
);
15295 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
15296 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
15297 add_loc_descr (&ret
, l2jump
);
15298 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
15299 VAR_INIT_STATUS_INITIALIZED
);
15300 add_loc_descr (&ret
, tmp
);
15301 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15302 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15303 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
15304 add_loc_descr (&ret
, l1jump
);
15305 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
15306 add_loc_descr (&ret
, l2label
);
15307 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15308 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
15309 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15310 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
15311 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15312 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
15316 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
15317 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15318 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
15319 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
15321 ROTATERT is similar:
15322 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
15323 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
15324 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
15326 static dw_loc_descr_ref
15327 rotate_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
15328 machine_mode mem_mode
)
15330 rtx rtlop1
= XEXP (rtl
, 1);
15331 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
15334 if (is_narrower_int_mode (GET_MODE (rtlop1
), mode
))
15335 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
15336 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15337 VAR_INIT_STATUS_INITIALIZED
);
15338 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
15339 VAR_INIT_STATUS_INITIALIZED
);
15340 if (op0
== NULL
|| op1
== NULL
)
15342 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
15343 for (i
= 0; i
< 2; i
++)
15345 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
15346 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
15348 VAR_INIT_STATUS_INITIALIZED
);
15349 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
15350 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
15352 : HOST_BITS_PER_WIDE_INT
== 64
15353 ? DW_OP_const8u
: DW_OP_constu
,
15354 GET_MODE_MASK (mode
), 0);
15357 if (mask
[i
] == NULL
)
15359 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
15362 add_loc_descr (&ret
, op1
);
15363 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
15364 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
15365 if (GET_CODE (rtl
) == ROTATERT
)
15367 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
15368 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
15369 GET_MODE_BITSIZE (mode
), 0));
15371 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
15372 if (mask
[0] != NULL
)
15373 add_loc_descr (&ret
, mask
[0]);
15374 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
15375 if (mask
[1] != NULL
)
15377 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15378 add_loc_descr (&ret
, mask
[1]);
15379 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
15381 if (GET_CODE (rtl
) == ROTATE
)
15383 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
15384 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
15385 GET_MODE_BITSIZE (mode
), 0));
15387 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
15388 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
15392 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
15393 for DEBUG_PARAMETER_REF RTL. */
15395 static dw_loc_descr_ref
15396 parameter_ref_descriptor (rtx rtl
)
15398 dw_loc_descr_ref ret
;
15403 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
15404 /* With LTO during LTRANS we get the late DIE that refers to the early
15405 DIE, thus we add another indirection here. This seems to confuse
15406 gdb enough to make gcc.dg/guality/pr68860-1.c FAIL with LTO. */
15407 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
15408 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
15411 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15412 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
15413 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15417 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
15418 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
15423 /* The following routine converts the RTL for a variable or parameter
15424 (resident in memory) into an equivalent Dwarf representation of a
15425 mechanism for getting the address of that same variable onto the top of a
15426 hypothetical "address evaluation" stack.
15428 When creating memory location descriptors, we are effectively transforming
15429 the RTL for a memory-resident object into its Dwarf postfix expression
15430 equivalent. This routine recursively descends an RTL tree, turning
15431 it into Dwarf postfix code as it goes.
15433 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
15435 MEM_MODE is the mode of the memory reference, needed to handle some
15436 autoincrement addressing modes.
15438 Return 0 if we can't represent the location. */
15441 mem_loc_descriptor (rtx rtl
, machine_mode mode
,
15442 machine_mode mem_mode
,
15443 enum var_init_status initialized
)
15445 dw_loc_descr_ref mem_loc_result
= NULL
;
15446 enum dwarf_location_atom op
;
15447 dw_loc_descr_ref op0
, op1
;
15448 rtx inner
= NULL_RTX
;
15451 if (mode
== VOIDmode
)
15452 mode
= GET_MODE (rtl
);
15454 /* Note that for a dynamically sized array, the location we will generate a
15455 description of here will be the lowest numbered location which is
15456 actually within the array. That's *not* necessarily the same as the
15457 zeroth element of the array. */
15459 rtl
= targetm
.delegitimize_address (rtl
);
15461 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
15464 scalar_int_mode int_mode
= BImode
, inner_mode
, op1_mode
;
15465 switch (GET_CODE (rtl
))
15470 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
15473 /* The case of a subreg may arise when we have a local (register)
15474 variable or a formal (register) parameter which doesn't quite fill
15475 up an entire register. For now, just assume that it is
15476 legitimate to make the Dwarf info refer to the whole register which
15477 contains the given subreg. */
15478 if (!subreg_lowpart_p (rtl
))
15480 inner
= SUBREG_REG (rtl
);
15483 if (inner
== NULL_RTX
)
15484 inner
= XEXP (rtl
, 0);
15485 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15486 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
15487 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15488 #ifdef POINTERS_EXTEND_UNSIGNED
15489 || (int_mode
== Pmode
&& mem_mode
!= VOIDmode
)
15492 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
)
15494 mem_loc_result
= mem_loc_descriptor (inner
,
15496 mem_mode
, initialized
);
15499 if (dwarf_strict
&& dwarf_version
< 5)
15501 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15502 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
15503 ? GET_MODE_SIZE (int_mode
) <= GET_MODE_SIZE (inner_mode
)
15504 : known_eq (GET_MODE_SIZE (mode
), GET_MODE_SIZE (GET_MODE (inner
))))
15506 dw_die_ref type_die
;
15507 dw_loc_descr_ref cvt
;
15509 mem_loc_result
= mem_loc_descriptor (inner
,
15511 mem_mode
, initialized
);
15512 if (mem_loc_result
== NULL
)
15514 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15515 if (type_die
== NULL
)
15517 mem_loc_result
= NULL
;
15520 if (maybe_ne (GET_MODE_SIZE (mode
), GET_MODE_SIZE (GET_MODE (inner
))))
15521 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15523 cvt
= new_loc_descr (dwarf_OP (DW_OP_reinterpret
), 0, 0);
15524 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15525 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15526 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15527 add_loc_descr (&mem_loc_result
, cvt
);
15528 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15529 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
15531 /* Convert it to untyped afterwards. */
15532 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15533 add_loc_descr (&mem_loc_result
, cvt
);
15539 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15540 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
15541 && rtl
!= arg_pointer_rtx
15542 && rtl
!= frame_pointer_rtx
15543 #ifdef POINTERS_EXTEND_UNSIGNED
15544 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
15548 dw_die_ref type_die
;
15549 unsigned int dbx_regnum
;
15551 if (dwarf_strict
&& dwarf_version
< 5)
15553 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
15555 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15556 if (type_die
== NULL
)
15559 dbx_regnum
= dbx_reg_number (rtl
);
15560 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
15562 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_regval_type
),
15564 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
15565 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
15566 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
15569 /* Whenever a register number forms a part of the description of the
15570 method for calculating the (dynamic) address of a memory resident
15571 object, DWARF rules require the register number be referred to as
15572 a "base register". This distinction is not based in any way upon
15573 what category of register the hardware believes the given register
15574 belongs to. This is strictly DWARF terminology we're dealing with
15575 here. Note that in cases where the location of a memory-resident
15576 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
15577 OP_CONST (0)) the actual DWARF location descriptor that we generate
15578 may just be OP_BASEREG (basereg). This may look deceptively like
15579 the object in question was allocated to a register (rather than in
15580 memory) so DWARF consumers need to be aware of the subtle
15581 distinction between OP_REG and OP_BASEREG. */
15582 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
15583 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
15584 else if (stack_realign_drap
15586 && crtl
->args
.internal_arg_pointer
== rtl
15587 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
15589 /* If RTL is internal_arg_pointer, which has been optimized
15590 out, use DRAP instead. */
15591 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
15592 VAR_INIT_STATUS_INITIALIZED
);
15598 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15599 || !is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
))
15601 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
15602 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
15605 else if (GET_CODE (rtl
) == ZERO_EXTEND
15606 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15607 && GET_MODE_BITSIZE (inner_mode
) < HOST_BITS_PER_WIDE_INT
15608 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
15609 to expand zero extend as two shifts instead of
15611 && GET_MODE_SIZE (inner_mode
) <= 4)
15613 mem_loc_result
= op0
;
15614 add_loc_descr (&mem_loc_result
,
15615 int_loc_descriptor (GET_MODE_MASK (inner_mode
)));
15616 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
15618 else if (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
15620 int shift
= DWARF2_ADDR_SIZE
- GET_MODE_SIZE (inner_mode
);
15621 shift
*= BITS_PER_UNIT
;
15622 if (GET_CODE (rtl
) == SIGN_EXTEND
)
15626 mem_loc_result
= op0
;
15627 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
15628 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
15629 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
15630 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15632 else if (!dwarf_strict
|| dwarf_version
>= 5)
15634 dw_die_ref type_die1
, type_die2
;
15635 dw_loc_descr_ref cvt
;
15637 type_die1
= base_type_for_mode (inner_mode
,
15638 GET_CODE (rtl
) == ZERO_EXTEND
);
15639 if (type_die1
== NULL
)
15641 type_die2
= base_type_for_mode (int_mode
, 1);
15642 if (type_die2
== NULL
)
15644 mem_loc_result
= op0
;
15645 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15646 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15647 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
15648 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15649 add_loc_descr (&mem_loc_result
, cvt
);
15650 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15651 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15652 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
15653 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15654 add_loc_descr (&mem_loc_result
, cvt
);
15660 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
15661 if (new_rtl
!= rtl
)
15663 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
15665 if (mem_loc_result
!= NULL
)
15666 return mem_loc_result
;
15669 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
15670 get_address_mode (rtl
), mode
,
15671 VAR_INIT_STATUS_INITIALIZED
);
15672 if (mem_loc_result
== NULL
)
15673 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
15674 if (mem_loc_result
!= NULL
)
15676 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15677 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15679 dw_die_ref type_die
;
15680 dw_loc_descr_ref deref
;
15681 HOST_WIDE_INT size
;
15683 if (dwarf_strict
&& dwarf_version
< 5)
15685 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
15688 = base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15689 if (type_die
== NULL
)
15691 deref
= new_loc_descr (dwarf_OP (DW_OP_deref_type
), size
, 0);
15692 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
15693 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
15694 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
15695 add_loc_descr (&mem_loc_result
, deref
);
15697 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
15698 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
15700 add_loc_descr (&mem_loc_result
,
15701 new_loc_descr (DW_OP_deref_size
,
15702 GET_MODE_SIZE (int_mode
), 0));
15707 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
15710 /* Some ports can transform a symbol ref into a label ref, because
15711 the symbol ref is too far away and has to be dumped into a constant
15716 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15717 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
15718 #ifdef POINTERS_EXTEND_UNSIGNED
15719 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
15724 if (GET_CODE (rtl
) == UNSPEC
)
15726 /* If delegitimize_address couldn't do anything with the UNSPEC, we
15727 can't express it in the debug info. This can happen e.g. with some
15728 TLS UNSPECs. Allow UNSPECs formerly from CONST that the backend
15730 bool not_ok
= false;
15731 subrtx_var_iterator::array_type array
;
15732 FOR_EACH_SUBRTX_VAR (iter
, array
, rtl
, ALL
)
15733 if (*iter
!= rtl
&& !CONSTANT_P (*iter
))
15742 FOR_EACH_SUBRTX_VAR (iter
, array
, rtl
, ALL
)
15743 if (!const_ok_for_output_1 (*iter
))
15752 rtl
= gen_rtx_CONST (GET_MODE (rtl
), rtl
);
15756 if (GET_CODE (rtl
) == SYMBOL_REF
15757 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
15759 dw_loc_descr_ref temp
;
15761 /* If this is not defined, we have no way to emit the data. */
15762 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
15765 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
15767 /* We check for DWARF 5 here because gdb did not implement
15768 DW_OP_form_tls_address until after 7.12. */
15769 mem_loc_result
= new_loc_descr ((dwarf_version
>= 5
15770 ? DW_OP_form_tls_address
15771 : DW_OP_GNU_push_tls_address
),
15773 add_loc_descr (&mem_loc_result
, temp
);
15778 if (!const_ok_for_output (rtl
))
15780 if (GET_CODE (rtl
) == CONST
)
15781 switch (GET_CODE (XEXP (rtl
, 0)))
15785 goto try_const_unop
;
15788 goto try_const_unop
;
15791 arg
= XEXP (XEXP (rtl
, 0), 0);
15792 if (!CONSTANT_P (arg
))
15793 arg
= gen_rtx_CONST (int_mode
, arg
);
15794 op0
= mem_loc_descriptor (arg
, int_mode
, mem_mode
,
15798 mem_loc_result
= op0
;
15799 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15803 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
,
15804 mem_mode
, initialized
);
15811 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
15812 vec_safe_push (used_rtx_array
, rtl
);
15818 case DEBUG_IMPLICIT_PTR
:
15819 expansion_failed (NULL_TREE
, rtl
,
15820 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
15824 if (dwarf_strict
&& dwarf_version
< 5)
15826 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
15828 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15829 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15830 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
15831 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15834 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
15835 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
15837 op0
= one_reg_loc_descriptor (dbx_regnum
,
15838 VAR_INIT_STATUS_INITIALIZED
);
15841 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
15842 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
15844 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
15845 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15846 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
15850 gcc_unreachable ();
15853 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_entry_value
), 0, 0);
15854 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15855 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
15858 case DEBUG_PARAMETER_REF
:
15859 mem_loc_result
= parameter_ref_descriptor (rtl
);
15863 /* Extract the PLUS expression nested inside and fall into
15864 PLUS code below. */
15865 rtl
= XEXP (rtl
, 1);
15870 /* Turn these into a PLUS expression and fall into the PLUS code
15872 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
15873 gen_int_mode (GET_CODE (rtl
) == PRE_INC
15874 ? GET_MODE_UNIT_SIZE (mem_mode
)
15875 : -GET_MODE_UNIT_SIZE (mem_mode
),
15882 if (is_based_loc (rtl
)
15883 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15884 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15885 || XEXP (rtl
, 0) == arg_pointer_rtx
15886 || XEXP (rtl
, 0) == frame_pointer_rtx
))
15887 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
15888 INTVAL (XEXP (rtl
, 1)),
15889 VAR_INIT_STATUS_INITIALIZED
);
15892 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15893 VAR_INIT_STATUS_INITIALIZED
);
15894 if (mem_loc_result
== 0)
15897 if (CONST_INT_P (XEXP (rtl
, 1))
15898 && (GET_MODE_SIZE (as_a
<scalar_int_mode
> (mode
))
15899 <= DWARF2_ADDR_SIZE
))
15900 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
15903 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15904 VAR_INIT_STATUS_INITIALIZED
);
15907 add_loc_descr (&mem_loc_result
, op1
);
15908 add_loc_descr (&mem_loc_result
,
15909 new_loc_descr (DW_OP_plus
, 0, 0));
15914 /* If a pseudo-reg is optimized away, it is possible for it to
15915 be replaced with a MEM containing a multiply or shift. */
15925 if ((!dwarf_strict
|| dwarf_version
>= 5)
15926 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15927 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15929 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
15930 base_type_for_mode (mode
, 0),
15931 int_mode
, mem_mode
);
15954 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
))
15956 op0
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
, mem_mode
,
15957 VAR_INIT_STATUS_INITIALIZED
);
15959 rtx rtlop1
= XEXP (rtl
, 1);
15960 if (is_a
<scalar_int_mode
> (GET_MODE (rtlop1
), &op1_mode
)
15961 && GET_MODE_BITSIZE (op1_mode
) < GET_MODE_BITSIZE (int_mode
))
15962 rtlop1
= gen_rtx_ZERO_EXTEND (int_mode
, rtlop1
);
15963 op1
= mem_loc_descriptor (rtlop1
, int_mode
, mem_mode
,
15964 VAR_INIT_STATUS_INITIALIZED
);
15967 if (op0
== 0 || op1
== 0)
15970 mem_loc_result
= op0
;
15971 add_loc_descr (&mem_loc_result
, op1
);
15972 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15988 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15989 VAR_INIT_STATUS_INITIALIZED
);
15990 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15991 VAR_INIT_STATUS_INITIALIZED
);
15993 if (op0
== 0 || op1
== 0)
15996 mem_loc_result
= op0
;
15997 add_loc_descr (&mem_loc_result
, op1
);
15998 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16002 if ((!dwarf_strict
|| dwarf_version
>= 5)
16003 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16004 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
16006 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
16007 base_type_for_mode (mode
, 0),
16008 int_mode
, mem_mode
);
16012 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
16013 VAR_INIT_STATUS_INITIALIZED
);
16014 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16015 VAR_INIT_STATUS_INITIALIZED
);
16017 if (op0
== 0 || op1
== 0)
16020 mem_loc_result
= op0
;
16021 add_loc_descr (&mem_loc_result
, op1
);
16022 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
16023 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
16024 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
16025 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
16026 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
16030 if ((!dwarf_strict
|| dwarf_version
>= 5)
16031 && is_a
<scalar_int_mode
> (mode
, &int_mode
))
16033 if (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
16038 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
16039 base_type_for_mode (int_mode
, 1),
16040 int_mode
, mem_mode
);
16057 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
16058 VAR_INIT_STATUS_INITIALIZED
);
16063 mem_loc_result
= op0
;
16064 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16068 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
16069 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16070 #ifdef POINTERS_EXTEND_UNSIGNED
16071 || (int_mode
== Pmode
16072 && mem_mode
!= VOIDmode
16073 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
16077 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
16080 if ((!dwarf_strict
|| dwarf_version
>= 5)
16081 && (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
16082 || GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_DOUBLE_INT
))
16084 dw_die_ref type_die
= base_type_for_mode (int_mode
, 1);
16085 scalar_int_mode amode
;
16086 if (type_die
== NULL
)
16088 if (INTVAL (rtl
) >= 0
16089 && (int_mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
, 0)
16091 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
16092 /* const DW_OP_convert <XXX> vs.
16093 DW_OP_const_type <XXX, 1, const>. */
16094 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
16095 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (int_mode
))
16097 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
16098 op0
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16099 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16100 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16101 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16102 add_loc_descr (&mem_loc_result
, op0
);
16103 return mem_loc_result
;
16105 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0,
16107 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16108 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16109 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16110 if (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
)
16111 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
16114 mem_loc_result
->dw_loc_oprnd2
.val_class
16115 = dw_val_class_const_double
;
16116 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
16117 = double_int::from_shwi (INTVAL (rtl
));
16123 if (!dwarf_strict
|| dwarf_version
>= 5)
16125 dw_die_ref type_die
;
16127 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
16128 CONST_DOUBLE rtx could represent either a large integer
16129 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
16130 the value is always a floating point constant.
16132 When it is an integer, a CONST_DOUBLE is used whenever
16133 the constant requires 2 HWIs to be adequately represented.
16134 We output CONST_DOUBLEs as blocks. */
16135 if (mode
== VOIDmode
16136 || (GET_MODE (rtl
) == VOIDmode
16137 && maybe_ne (GET_MODE_BITSIZE (mode
),
16138 HOST_BITS_PER_DOUBLE_INT
)))
16140 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16141 if (type_die
== NULL
)
16143 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
16144 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16145 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16146 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16147 #if TARGET_SUPPORTS_WIDE_INT == 0
16148 if (!SCALAR_FLOAT_MODE_P (mode
))
16150 mem_loc_result
->dw_loc_oprnd2
.val_class
16151 = dw_val_class_const_double
;
16152 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
16153 = rtx_to_double_int (rtl
);
16158 scalar_float_mode float_mode
= as_a
<scalar_float_mode
> (mode
);
16159 unsigned int length
= GET_MODE_SIZE (float_mode
);
16160 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
16162 insert_float (rtl
, array
);
16163 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16164 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
16165 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
16166 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16171 case CONST_WIDE_INT
:
16172 if (!dwarf_strict
|| dwarf_version
>= 5)
16174 dw_die_ref type_die
;
16176 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
16177 if (type_die
== NULL
)
16179 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
16180 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16181 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16182 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16183 mem_loc_result
->dw_loc_oprnd2
.val_class
16184 = dw_val_class_wide_int
;
16185 mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
16186 *mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, mode
);
16190 case CONST_POLY_INT
:
16191 mem_loc_result
= int_loc_descriptor (rtx_to_poly_int64 (rtl
));
16195 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
16199 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
16203 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
16207 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
16211 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
16215 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
16219 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
16223 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
16227 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
16231 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
16236 if (!SCALAR_INT_MODE_P (mode
))
16241 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
16246 if (CONST_INT_P (XEXP (rtl
, 1))
16247 && CONST_INT_P (XEXP (rtl
, 2))
16248 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
16249 && is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
)
16250 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16251 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
16252 && ((unsigned) INTVAL (XEXP (rtl
, 1))
16253 + (unsigned) INTVAL (XEXP (rtl
, 2))
16254 <= GET_MODE_BITSIZE (int_mode
)))
16257 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
16258 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16261 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
16265 mem_loc_result
= op0
;
16266 size
= INTVAL (XEXP (rtl
, 1));
16267 shift
= INTVAL (XEXP (rtl
, 2));
16268 if (BITS_BIG_ENDIAN
)
16269 shift
= GET_MODE_BITSIZE (inner_mode
) - shift
- size
;
16270 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
16272 add_loc_descr (&mem_loc_result
,
16273 int_loc_descriptor (DWARF2_ADDR_SIZE
16275 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
16277 if (size
!= (int) DWARF2_ADDR_SIZE
)
16279 add_loc_descr (&mem_loc_result
,
16280 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
16281 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
16288 dw_loc_descr_ref op2
, bra_node
, drop_node
;
16289 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
16290 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
16291 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
16292 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16293 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
16294 VAR_INIT_STATUS_INITIALIZED
);
16295 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
16296 VAR_INIT_STATUS_INITIALIZED
);
16297 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
16300 mem_loc_result
= op1
;
16301 add_loc_descr (&mem_loc_result
, op2
);
16302 add_loc_descr (&mem_loc_result
, op0
);
16303 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
16304 add_loc_descr (&mem_loc_result
, bra_node
);
16305 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
16306 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
16307 add_loc_descr (&mem_loc_result
, drop_node
);
16308 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
16309 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
16314 case FLOAT_TRUNCATE
:
16316 case UNSIGNED_FLOAT
:
16319 if (!dwarf_strict
|| dwarf_version
>= 5)
16321 dw_die_ref type_die
;
16322 dw_loc_descr_ref cvt
;
16324 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
16325 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
16328 if (is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &int_mode
)
16329 && (GET_CODE (rtl
) == FLOAT
16330 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
))
16332 type_die
= base_type_for_mode (int_mode
,
16333 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
16334 if (type_die
== NULL
)
16336 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16337 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16338 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16339 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16340 add_loc_descr (&op0
, cvt
);
16342 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
16343 if (type_die
== NULL
)
16345 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
16346 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16347 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
16348 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16349 add_loc_descr (&op0
, cvt
);
16350 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16351 && (GET_CODE (rtl
) == FIX
16352 || GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
))
16354 op0
= convert_descriptor_to_mode (int_mode
, op0
);
16358 mem_loc_result
= op0
;
16365 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16366 mem_loc_result
= clz_loc_descriptor (rtl
, int_mode
, mem_mode
);
16371 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16372 mem_loc_result
= popcount_loc_descriptor (rtl
, int_mode
, mem_mode
);
16376 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16377 mem_loc_result
= bswap_loc_descriptor (rtl
, int_mode
, mem_mode
);
16382 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
16383 mem_loc_result
= rotate_loc_descriptor (rtl
, int_mode
, mem_mode
);
16387 /* In theory, we could implement the above. */
16388 /* DWARF cannot represent the unsigned compare operations
16413 case FRACT_CONVERT
:
16414 case UNSIGNED_FRACT_CONVERT
:
16416 case UNSIGNED_SAT_FRACT
:
16422 case VEC_DUPLICATE
:
16426 case STRICT_LOW_PART
:
16435 resolve_one_addr (&rtl
);
16438 /* RTL sequences inside PARALLEL record a series of DWARF operations for
16439 the expression. An UNSPEC rtx represents a raw DWARF operation,
16440 new_loc_descr is called for it to build the operation directly.
16441 Otherwise mem_loc_descriptor is called recursively. */
16445 dw_loc_descr_ref exp_result
= NULL
;
16447 for (; index
< XVECLEN (rtl
, 0); index
++)
16449 rtx elem
= XVECEXP (rtl
, 0, index
);
16450 if (GET_CODE (elem
) == UNSPEC
)
16452 /* Each DWARF operation UNSPEC contain two operands, if
16453 one operand is not used for the operation, const0_rtx is
16455 gcc_assert (XVECLEN (elem
, 0) == 2);
16457 HOST_WIDE_INT dw_op
= XINT (elem
, 1);
16458 HOST_WIDE_INT oprnd1
= INTVAL (XVECEXP (elem
, 0, 0));
16459 HOST_WIDE_INT oprnd2
= INTVAL (XVECEXP (elem
, 0, 1));
16461 = new_loc_descr ((enum dwarf_location_atom
) dw_op
, oprnd1
,
16466 = mem_loc_descriptor (elem
, mode
, mem_mode
,
16467 VAR_INIT_STATUS_INITIALIZED
);
16469 if (!mem_loc_result
)
16470 mem_loc_result
= exp_result
;
16472 add_loc_descr (&mem_loc_result
, exp_result
);
16481 print_rtl (stderr
, rtl
);
16482 gcc_unreachable ();
16487 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
16488 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
16490 return mem_loc_result
;
16493 /* Return a descriptor that describes the concatenation of two locations.
16494 This is typically a complex variable. */
16496 static dw_loc_descr_ref
16497 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
16499 /* At present we only track constant-sized pieces. */
16500 unsigned int size0
, size1
;
16501 if (!GET_MODE_SIZE (GET_MODE (x0
)).is_constant (&size0
)
16502 || !GET_MODE_SIZE (GET_MODE (x1
)).is_constant (&size1
))
16505 dw_loc_descr_ref cc_loc_result
= NULL
;
16506 dw_loc_descr_ref x0_ref
16507 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16508 dw_loc_descr_ref x1_ref
16509 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16511 if (x0_ref
== 0 || x1_ref
== 0)
16514 cc_loc_result
= x0_ref
;
16515 add_loc_descr_op_piece (&cc_loc_result
, size0
);
16517 add_loc_descr (&cc_loc_result
, x1_ref
);
16518 add_loc_descr_op_piece (&cc_loc_result
, size1
);
16520 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
16521 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
16523 return cc_loc_result
;
16526 /* Return a descriptor that describes the concatenation of N
16529 static dw_loc_descr_ref
16530 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
16533 dw_loc_descr_ref cc_loc_result
= NULL
;
16534 unsigned int n
= XVECLEN (concatn
, 0);
16537 for (i
= 0; i
< n
; ++i
)
16539 dw_loc_descr_ref ref
;
16540 rtx x
= XVECEXP (concatn
, 0, i
);
16542 /* At present we only track constant-sized pieces. */
16543 if (!GET_MODE_SIZE (GET_MODE (x
)).is_constant (&size
))
16546 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
16550 add_loc_descr (&cc_loc_result
, ref
);
16551 add_loc_descr_op_piece (&cc_loc_result
, size
);
16554 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
16555 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
16557 return cc_loc_result
;
16560 /* Helper function for loc_descriptor. Return DW_OP_implicit_pointer
16561 for DEBUG_IMPLICIT_PTR RTL. */
16563 static dw_loc_descr_ref
16564 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
16566 dw_loc_descr_ref ret
;
16569 if (dwarf_strict
&& dwarf_version
< 5)
16571 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
16572 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
16573 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
16574 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
16575 ret
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
16576 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
16579 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
16580 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
16581 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
16585 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
16586 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
16591 /* Output a proper Dwarf location descriptor for a variable or parameter
16592 which is either allocated in a register or in a memory location. For a
16593 register, we just generate an OP_REG and the register number. For a
16594 memory location we provide a Dwarf postfix expression describing how to
16595 generate the (dynamic) address of the object onto the address stack.
16597 MODE is mode of the decl if this loc_descriptor is going to be used in
16598 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
16599 allowed, VOIDmode otherwise.
16601 If we don't know how to describe it, return 0. */
16603 static dw_loc_descr_ref
16604 loc_descriptor (rtx rtl
, machine_mode mode
,
16605 enum var_init_status initialized
)
16607 dw_loc_descr_ref loc_result
= NULL
;
16608 scalar_int_mode int_mode
;
16610 switch (GET_CODE (rtl
))
16613 /* The case of a subreg may arise when we have a local (register)
16614 variable or a formal (register) parameter which doesn't quite fill
16615 up an entire register. For now, just assume that it is
16616 legitimate to make the Dwarf info refer to the whole register which
16617 contains the given subreg. */
16618 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
16619 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
16620 GET_MODE (SUBREG_REG (rtl
)), initialized
);
16626 loc_result
= reg_loc_descriptor (rtl
, initialized
);
16630 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
16631 GET_MODE (rtl
), initialized
);
16632 if (loc_result
== NULL
)
16633 loc_result
= tls_mem_loc_descriptor (rtl
);
16634 if (loc_result
== NULL
)
16636 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
16637 if (new_rtl
!= rtl
)
16638 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
16643 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
16648 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
16653 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
16655 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
16656 if (GET_CODE (loc
) == EXPR_LIST
)
16657 loc
= XEXP (loc
, 0);
16658 loc_result
= loc_descriptor (loc
, mode
, initialized
);
16662 rtl
= XEXP (rtl
, 1);
16667 rtvec par_elems
= XVEC (rtl
, 0);
16668 int num_elem
= GET_NUM_ELEM (par_elems
);
16672 /* Create the first one, so we have something to add to. */
16673 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
16674 VOIDmode
, initialized
);
16675 if (loc_result
== NULL
)
16677 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
16678 /* At present we only track constant-sized pieces. */
16679 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
16681 add_loc_descr_op_piece (&loc_result
, size
);
16682 for (i
= 1; i
< num_elem
; i
++)
16684 dw_loc_descr_ref temp
;
16686 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
16687 VOIDmode
, initialized
);
16690 add_loc_descr (&loc_result
, temp
);
16691 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
16692 /* At present we only track constant-sized pieces. */
16693 if (!GET_MODE_SIZE (mode
).is_constant (&size
))
16695 add_loc_descr_op_piece (&loc_result
, size
);
16701 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
16703 int_mode
= as_a
<scalar_int_mode
> (mode
);
16704 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (int_mode
),
16710 if (mode
== VOIDmode
)
16711 mode
= GET_MODE (rtl
);
16713 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16715 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
16717 /* Note that a CONST_DOUBLE rtx could represent either an integer
16718 or a floating-point constant. A CONST_DOUBLE is used whenever
16719 the constant requires more than one word in order to be
16720 adequately represented. We output CONST_DOUBLEs as blocks. */
16721 scalar_mode smode
= as_a
<scalar_mode
> (mode
);
16722 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16723 GET_MODE_SIZE (smode
), 0);
16724 #if TARGET_SUPPORTS_WIDE_INT == 0
16725 if (!SCALAR_FLOAT_MODE_P (smode
))
16727 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
16728 loc_result
->dw_loc_oprnd2
.v
.val_double
16729 = rtx_to_double_int (rtl
);
16734 unsigned int length
= GET_MODE_SIZE (smode
);
16735 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
16737 insert_float (rtl
, array
);
16738 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16739 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
16740 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
16741 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16746 case CONST_WIDE_INT
:
16747 if (mode
== VOIDmode
)
16748 mode
= GET_MODE (rtl
);
16750 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16752 int_mode
= as_a
<scalar_int_mode
> (mode
);
16753 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16754 GET_MODE_SIZE (int_mode
), 0);
16755 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_wide_int
;
16756 loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
16757 *loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, int_mode
);
16762 if (mode
== VOIDmode
)
16763 mode
= GET_MODE (rtl
);
16765 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16767 unsigned int length
;
16768 if (!CONST_VECTOR_NUNITS (rtl
).is_constant (&length
))
16771 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
16772 unsigned char *array
16773 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
16776 machine_mode imode
= GET_MODE_INNER (mode
);
16778 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
16779 switch (GET_MODE_CLASS (mode
))
16781 case MODE_VECTOR_INT
:
16782 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
16784 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
16785 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
16789 case MODE_VECTOR_FLOAT
:
16790 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
16792 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
16793 insert_float (elt
, p
);
16798 gcc_unreachable ();
16801 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16802 length
* elt_size
, 0);
16803 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16804 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
16805 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
16806 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16811 if (mode
== VOIDmode
16812 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
16813 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
16814 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
16816 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
16821 if (!const_ok_for_output (rtl
))
16825 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16826 && GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
16827 && (dwarf_version
>= 4 || !dwarf_strict
))
16829 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
16830 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16831 vec_safe_push (used_rtx_array
, rtl
);
16835 case DEBUG_IMPLICIT_PTR
:
16836 loc_result
= implicit_ptr_descriptor (rtl
, 0);
16840 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
16841 && CONST_INT_P (XEXP (rtl
, 1)))
16844 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
16850 if ((is_a
<scalar_int_mode
> (mode
, &int_mode
)
16851 && GET_MODE (rtl
) == int_mode
16852 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16853 && dwarf_version
>= 4)
16854 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
16856 /* Value expression. */
16857 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
16859 add_loc_descr (&loc_result
,
16860 new_loc_descr (DW_OP_stack_value
, 0, 0));
16868 /* We need to figure out what section we should use as the base for the
16869 address ranges where a given location is valid.
16870 1. If this particular DECL has a section associated with it, use that.
16871 2. If this function has a section associated with it, use that.
16872 3. Otherwise, use the text section.
16873 XXX: If you split a variable across multiple sections, we won't notice. */
16875 static const char *
16876 secname_for_decl (const_tree decl
)
16878 const char *secname
;
16880 if (VAR_OR_FUNCTION_DECL_P (decl
)
16881 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
) || TREE_STATIC (decl
))
16882 && DECL_SECTION_NAME (decl
))
16883 secname
= DECL_SECTION_NAME (decl
);
16884 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
16886 if (in_cold_section_p
)
16888 section
*sec
= current_function_section ();
16889 if (sec
->common
.flags
& SECTION_NAMED
)
16890 return sec
->named
.name
;
16892 secname
= DECL_SECTION_NAME (current_function_decl
);
16894 else if (cfun
&& in_cold_section_p
)
16895 secname
= crtl
->subsections
.cold_section_label
;
16897 secname
= text_section_label
;
16902 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
16905 decl_by_reference_p (tree decl
)
16907 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
16909 && DECL_BY_REFERENCE (decl
));
16912 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
16915 static dw_loc_descr_ref
16916 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
16917 enum var_init_status initialized
)
16919 int have_address
= 0;
16920 dw_loc_descr_ref descr
;
16923 if (want_address
!= 2)
16925 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
16927 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
16929 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
16930 if (GET_CODE (varloc
) == EXPR_LIST
)
16931 varloc
= XEXP (varloc
, 0);
16932 mode
= GET_MODE (varloc
);
16933 if (MEM_P (varloc
))
16935 rtx addr
= XEXP (varloc
, 0);
16936 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
16937 mode
, initialized
);
16942 rtx x
= avoid_constant_pool_reference (varloc
);
16944 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
16949 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
16956 if (GET_CODE (varloc
) == VAR_LOCATION
)
16957 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
16959 mode
= DECL_MODE (loc
);
16960 descr
= loc_descriptor (varloc
, mode
, initialized
);
16967 if (want_address
== 2 && !have_address
16968 && (dwarf_version
>= 4 || !dwarf_strict
))
16970 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
16972 expansion_failed (loc
, NULL_RTX
,
16973 "DWARF address size mismatch");
16976 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16979 /* Show if we can't fill the request for an address. */
16980 if (want_address
&& !have_address
)
16982 expansion_failed (loc
, NULL_RTX
,
16983 "Want address and only have value");
16987 /* If we've got an address and don't want one, dereference. */
16988 if (!want_address
&& have_address
)
16990 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
16991 enum dwarf_location_atom op
;
16993 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
16995 expansion_failed (loc
, NULL_RTX
,
16996 "DWARF address size mismatch");
16999 else if (size
== DWARF2_ADDR_SIZE
)
17002 op
= DW_OP_deref_size
;
17004 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
17010 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
17011 if it is not possible. */
17013 static dw_loc_descr_ref
17014 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
17016 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
17017 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
17018 else if (dwarf_version
>= 3 || !dwarf_strict
)
17019 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
17024 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
17025 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
17027 static dw_loc_descr_ref
17028 dw_sra_loc_expr (tree decl
, rtx loc
)
17031 unsigned HOST_WIDE_INT padsize
= 0;
17032 dw_loc_descr_ref descr
, *descr_tail
;
17033 unsigned HOST_WIDE_INT decl_size
;
17035 enum var_init_status initialized
;
17037 if (DECL_SIZE (decl
) == NULL
17038 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
17041 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
17043 descr_tail
= &descr
;
17045 for (p
= loc
; p
; p
= XEXP (p
, 1))
17047 unsigned HOST_WIDE_INT bitsize
= decl_piece_bitsize (p
);
17048 rtx loc_note
= *decl_piece_varloc_ptr (p
);
17049 dw_loc_descr_ref cur_descr
;
17050 dw_loc_descr_ref
*tail
, last
= NULL
;
17051 unsigned HOST_WIDE_INT opsize
= 0;
17053 if (loc_note
== NULL_RTX
17054 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
17056 padsize
+= bitsize
;
17059 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
17060 varloc
= NOTE_VAR_LOCATION (loc_note
);
17061 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
17062 if (cur_descr
== NULL
)
17064 padsize
+= bitsize
;
17068 /* Check that cur_descr either doesn't use
17069 DW_OP_*piece operations, or their sum is equal
17070 to bitsize. Otherwise we can't embed it. */
17071 for (tail
= &cur_descr
; *tail
!= NULL
;
17072 tail
= &(*tail
)->dw_loc_next
)
17073 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
17075 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
17079 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
17081 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
17085 if (last
!= NULL
&& opsize
!= bitsize
)
17087 padsize
+= bitsize
;
17088 /* Discard the current piece of the descriptor and release any
17089 addr_table entries it uses. */
17090 remove_loc_list_addr_table_entries (cur_descr
);
17094 /* If there is a hole, add DW_OP_*piece after empty DWARF
17095 expression, which means that those bits are optimized out. */
17098 if (padsize
> decl_size
)
17100 remove_loc_list_addr_table_entries (cur_descr
);
17101 goto discard_descr
;
17103 decl_size
-= padsize
;
17104 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
17105 if (*descr_tail
== NULL
)
17107 remove_loc_list_addr_table_entries (cur_descr
);
17108 goto discard_descr
;
17110 descr_tail
= &(*descr_tail
)->dw_loc_next
;
17113 *descr_tail
= cur_descr
;
17115 if (bitsize
> decl_size
)
17116 goto discard_descr
;
17117 decl_size
-= bitsize
;
17120 HOST_WIDE_INT offset
= 0;
17121 if (GET_CODE (varloc
) == VAR_LOCATION
17122 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
17124 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
17125 if (GET_CODE (varloc
) == EXPR_LIST
)
17126 varloc
= XEXP (varloc
, 0);
17130 if (GET_CODE (varloc
) == CONST
17131 || GET_CODE (varloc
) == SIGN_EXTEND
17132 || GET_CODE (varloc
) == ZERO_EXTEND
)
17133 varloc
= XEXP (varloc
, 0);
17134 else if (GET_CODE (varloc
) == SUBREG
)
17135 varloc
= SUBREG_REG (varloc
);
17140 /* DW_OP_bit_size offset should be zero for register
17141 or implicit location descriptions and empty location
17142 descriptions, but for memory addresses needs big endian
17144 if (MEM_P (varloc
))
17146 unsigned HOST_WIDE_INT memsize
;
17147 if (!poly_uint64 (MEM_SIZE (varloc
)).is_constant (&memsize
))
17148 goto discard_descr
;
17149 memsize
*= BITS_PER_UNIT
;
17150 if (memsize
!= bitsize
)
17152 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
17153 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
17154 goto discard_descr
;
17155 if (memsize
< bitsize
)
17156 goto discard_descr
;
17157 if (BITS_BIG_ENDIAN
)
17158 offset
= memsize
- bitsize
;
17162 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
17163 if (*descr_tail
== NULL
)
17164 goto discard_descr
;
17165 descr_tail
= &(*descr_tail
)->dw_loc_next
;
17169 /* If there were any non-empty expressions, add padding till the end of
17171 if (descr
!= NULL
&& decl_size
!= 0)
17173 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
17174 if (*descr_tail
== NULL
)
17175 goto discard_descr
;
17180 /* Discard the descriptor and release any addr_table entries it uses. */
17181 remove_loc_list_addr_table_entries (descr
);
17185 /* Return the dwarf representation of the location list LOC_LIST of
17186 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
17189 static dw_loc_list_ref
17190 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
17192 const char *endname
, *secname
;
17193 var_loc_view endview
;
17195 enum var_init_status initialized
;
17196 struct var_loc_node
*node
;
17197 dw_loc_descr_ref descr
;
17198 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
17199 dw_loc_list_ref list
= NULL
;
17200 dw_loc_list_ref
*listp
= &list
;
17202 /* Now that we know what section we are using for a base,
17203 actually construct the list of locations.
17204 The first location information is what is passed to the
17205 function that creates the location list, and the remaining
17206 locations just get added on to that list.
17207 Note that we only know the start address for a location
17208 (IE location changes), so to build the range, we use
17209 the range [current location start, next location start].
17210 This means we have to special case the last node, and generate
17211 a range of [last location start, end of function label]. */
17213 if (cfun
&& crtl
->has_bb_partition
)
17215 bool save_in_cold_section_p
= in_cold_section_p
;
17216 in_cold_section_p
= first_function_block_is_cold
;
17217 if (loc_list
->last_before_switch
== NULL
)
17218 in_cold_section_p
= !in_cold_section_p
;
17219 secname
= secname_for_decl (decl
);
17220 in_cold_section_p
= save_in_cold_section_p
;
17223 secname
= secname_for_decl (decl
);
17225 for (node
= loc_list
->first
; node
; node
= node
->next
)
17227 bool range_across_switch
= false;
17228 if (GET_CODE (node
->loc
) == EXPR_LIST
17229 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
17231 if (GET_CODE (node
->loc
) == EXPR_LIST
)
17234 /* This requires DW_OP_{,bit_}piece, which is not usable
17235 inside DWARF expressions. */
17236 if (want_address
== 2)
17237 descr
= dw_sra_loc_expr (decl
, node
->loc
);
17241 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
17242 varloc
= NOTE_VAR_LOCATION (node
->loc
);
17243 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
17247 /* If section switch happens in between node->label
17248 and node->next->label (or end of function) and
17249 we can't emit it as a single entry list,
17250 emit two ranges, first one ending at the end
17251 of first partition and second one starting at the
17252 beginning of second partition. */
17253 if (node
== loc_list
->last_before_switch
17254 && (node
!= loc_list
->first
|| loc_list
->first
->next
17255 /* If we are to emit a view number, we will emit
17256 a loclist rather than a single location
17257 expression for the entire function (see
17258 loc_list_has_views), so we have to split the
17259 range that straddles across partitions. */
17260 || !ZERO_VIEW_P (node
->view
))
17261 && current_function_decl
)
17263 endname
= cfun
->fde
->dw_fde_end
;
17265 range_across_switch
= true;
17267 /* The variable has a location between NODE->LABEL and
17268 NODE->NEXT->LABEL. */
17269 else if (node
->next
)
17270 endname
= node
->next
->label
, endview
= node
->next
->view
;
17271 /* If the variable has a location at the last label
17272 it keeps its location until the end of function. */
17273 else if (!current_function_decl
)
17274 endname
= text_end_label
, endview
= 0;
17277 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
17278 current_function_funcdef_no
);
17279 endname
= ggc_strdup (label_id
);
17283 *listp
= new_loc_list (descr
, node
->label
, node
->view
,
17284 endname
, endview
, secname
);
17285 if (TREE_CODE (decl
) == PARM_DECL
17286 && node
== loc_list
->first
17287 && NOTE_P (node
->loc
)
17288 && strcmp (node
->label
, endname
) == 0)
17289 (*listp
)->force
= true;
17290 listp
= &(*listp
)->dw_loc_next
;
17295 && crtl
->has_bb_partition
17296 && node
== loc_list
->last_before_switch
)
17298 bool save_in_cold_section_p
= in_cold_section_p
;
17299 in_cold_section_p
= !first_function_block_is_cold
;
17300 secname
= secname_for_decl (decl
);
17301 in_cold_section_p
= save_in_cold_section_p
;
17304 if (range_across_switch
)
17306 if (GET_CODE (node
->loc
) == EXPR_LIST
)
17307 descr
= dw_sra_loc_expr (decl
, node
->loc
);
17310 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
17311 varloc
= NOTE_VAR_LOCATION (node
->loc
);
17312 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
17315 gcc_assert (descr
);
17316 /* The variable has a location between NODE->LABEL and
17317 NODE->NEXT->LABEL. */
17319 endname
= node
->next
->label
, endview
= node
->next
->view
;
17321 endname
= cfun
->fde
->dw_fde_second_end
, endview
= 0;
17322 *listp
= new_loc_list (descr
, cfun
->fde
->dw_fde_second_begin
, 0,
17323 endname
, endview
, secname
);
17324 listp
= &(*listp
)->dw_loc_next
;
17328 /* Try to avoid the overhead of a location list emitting a location
17329 expression instead, but only if we didn't have more than one
17330 location entry in the first place. If some entries were not
17331 representable, we don't want to pretend a single entry that was
17332 applies to the entire scope in which the variable is
17334 if (list
&& loc_list
->first
->next
)
17337 maybe_gen_llsym (list
);
17342 /* Return if the loc_list has only single element and thus can be represented
17343 as location description. */
17346 single_element_loc_list_p (dw_loc_list_ref list
)
17348 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
17349 return !list
->ll_symbol
;
17352 /* Duplicate a single element of location list. */
17354 static inline dw_loc_descr_ref
17355 copy_loc_descr (dw_loc_descr_ref ref
)
17357 dw_loc_descr_ref copy
= ggc_alloc
<dw_loc_descr_node
> ();
17358 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
17362 /* To each location in list LIST append loc descr REF. */
17365 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
17367 dw_loc_descr_ref copy
;
17368 add_loc_descr (&list
->expr
, ref
);
17369 list
= list
->dw_loc_next
;
17372 copy
= copy_loc_descr (ref
);
17373 add_loc_descr (&list
->expr
, copy
);
17374 while (copy
->dw_loc_next
)
17375 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
17376 list
= list
->dw_loc_next
;
17380 /* To each location in list LIST prepend loc descr REF. */
17383 prepend_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
17385 dw_loc_descr_ref copy
;
17386 dw_loc_descr_ref ref_end
= list
->expr
;
17387 add_loc_descr (&ref
, list
->expr
);
17389 list
= list
->dw_loc_next
;
17392 dw_loc_descr_ref end
= list
->expr
;
17393 list
->expr
= copy
= copy_loc_descr (ref
);
17394 while (copy
->dw_loc_next
!= ref_end
)
17395 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
17396 copy
->dw_loc_next
= end
;
17397 list
= list
->dw_loc_next
;
17401 /* Given two lists RET and LIST
17402 produce location list that is result of adding expression in LIST
17403 to expression in RET on each position in program.
17404 Might be destructive on both RET and LIST.
17406 TODO: We handle only simple cases of RET or LIST having at most one
17407 element. General case would involve sorting the lists in program order
17408 and merging them that will need some additional work.
17409 Adding that will improve quality of debug info especially for SRA-ed
17413 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
17422 if (!list
->dw_loc_next
)
17424 add_loc_descr_to_each (*ret
, list
->expr
);
17427 if (!(*ret
)->dw_loc_next
)
17429 prepend_loc_descr_to_each (list
, (*ret
)->expr
);
17433 expansion_failed (NULL_TREE
, NULL_RTX
,
17434 "Don't know how to merge two non-trivial"
17435 " location lists.\n");
17440 /* LOC is constant expression. Try a luck, look it up in constant
17441 pool and return its loc_descr of its address. */
17443 static dw_loc_descr_ref
17444 cst_pool_loc_descr (tree loc
)
17446 /* Get an RTL for this, if something has been emitted. */
17447 rtx rtl
= lookup_constant_def (loc
);
17449 if (!rtl
|| !MEM_P (rtl
))
17454 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
17456 /* TODO: We might get more coverage if we was actually delaying expansion
17457 of all expressions till end of compilation when constant pools are fully
17459 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
17461 expansion_failed (loc
, NULL_RTX
,
17462 "CST value in contant pool but not marked.");
17465 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
17466 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
17469 /* Return dw_loc_list representing address of addr_expr LOC
17470 by looking for inner INDIRECT_REF expression and turning
17471 it into simple arithmetics.
17473 See loc_list_from_tree for the meaning of CONTEXT. */
17475 static dw_loc_list_ref
17476 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
,
17477 loc_descr_context
*context
)
17480 poly_int64 bitsize
, bitpos
, bytepos
;
17482 int unsignedp
, reversep
, volatilep
= 0;
17483 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
17485 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
17486 &bitsize
, &bitpos
, &offset
, &mode
,
17487 &unsignedp
, &reversep
, &volatilep
);
17489 if (!multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
))
17491 expansion_failed (loc
, NULL_RTX
, "bitfield access");
17494 if (!INDIRECT_REF_P (obj
))
17496 expansion_failed (obj
,
17497 NULL_RTX
, "no indirect ref in inner refrence");
17500 if (!offset
&& known_eq (bitpos
, 0))
17501 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1,
17504 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
17505 && (dwarf_version
>= 4 || !dwarf_strict
))
17507 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0, context
);
17512 /* Variable offset. */
17513 list_ret1
= loc_list_from_tree (offset
, 0, context
);
17514 if (list_ret1
== 0)
17516 add_loc_list (&list_ret
, list_ret1
);
17519 add_loc_descr_to_each (list_ret
,
17520 new_loc_descr (DW_OP_plus
, 0, 0));
17522 HOST_WIDE_INT value
;
17523 if (bytepos
.is_constant (&value
) && value
> 0)
17524 add_loc_descr_to_each (list_ret
,
17525 new_loc_descr (DW_OP_plus_uconst
, value
, 0));
17526 else if (maybe_ne (bytepos
, 0))
17527 loc_list_plus_const (list_ret
, bytepos
);
17528 add_loc_descr_to_each (list_ret
,
17529 new_loc_descr (DW_OP_stack_value
, 0, 0));
17534 /* Set LOC to the next operation that is not a DW_OP_nop operation. In the case
17535 all operations from LOC are nops, move to the last one. Insert in NOPS all
17536 operations that are skipped. */
17539 loc_descr_to_next_no_nop (dw_loc_descr_ref
&loc
,
17540 hash_set
<dw_loc_descr_ref
> &nops
)
17542 while (loc
->dw_loc_next
!= NULL
&& loc
->dw_loc_opc
== DW_OP_nop
)
17545 loc
= loc
->dw_loc_next
;
17549 /* Helper for loc_descr_without_nops: free the location description operation
17553 free_loc_descr (const dw_loc_descr_ref
&loc
, void *data ATTRIBUTE_UNUSED
)
17559 /* Remove all DW_OP_nop operations from LOC except, if it exists, the one that
17563 loc_descr_without_nops (dw_loc_descr_ref
&loc
)
17565 if (loc
->dw_loc_opc
== DW_OP_nop
&& loc
->dw_loc_next
== NULL
)
17568 /* Set of all DW_OP_nop operations we remove. */
17569 hash_set
<dw_loc_descr_ref
> nops
;
17571 /* First, strip all prefix NOP operations in order to keep the head of the
17572 operations list. */
17573 loc_descr_to_next_no_nop (loc
, nops
);
17575 for (dw_loc_descr_ref cur
= loc
; cur
!= NULL
;)
17577 /* For control flow operations: strip "prefix" nops in destination
17579 if (cur
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
)
17580 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd1
.v
.val_loc
, nops
);
17581 if (cur
->dw_loc_oprnd2
.val_class
== dw_val_class_loc
)
17582 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd2
.v
.val_loc
, nops
);
17584 /* Do the same for the operations that follow, then move to the next
17586 if (cur
->dw_loc_next
!= NULL
)
17587 loc_descr_to_next_no_nop (cur
->dw_loc_next
, nops
);
17588 cur
= cur
->dw_loc_next
;
17591 nops
.traverse
<void *, free_loc_descr
> (NULL
);
17595 struct dwarf_procedure_info
;
17597 /* Helper structure for location descriptions generation. */
17598 struct loc_descr_context
17600 /* The type that is implicitly referenced by DW_OP_push_object_address, or
17601 NULL_TREE if DW_OP_push_object_address in invalid for this location
17602 description. This is used when processing PLACEHOLDER_EXPR nodes. */
17604 /* The ..._DECL node that should be translated as a
17605 DW_OP_push_object_address operation. */
17607 /* Information about the DWARF procedure we are currently generating. NULL if
17608 we are not generating a DWARF procedure. */
17609 struct dwarf_procedure_info
*dpi
;
17610 /* True if integral PLACEHOLDER_EXPR stands for the first argument passed
17611 by consumer. Used for DW_TAG_generic_subrange attributes. */
17612 bool placeholder_arg
;
17613 /* True if PLACEHOLDER_EXPR has been seen. */
17614 bool placeholder_seen
;
17617 /* DWARF procedures generation
17619 DWARF expressions (aka. location descriptions) are used to encode variable
17620 things such as sizes or offsets. Such computations can have redundant parts
17621 that can be factorized in order to reduce the size of the output debug
17622 information. This is the whole point of DWARF procedures.
17624 Thanks to stor-layout.c, size and offset expressions in GENERIC trees are
17625 already factorized into functions ("size functions") in order to handle very
17626 big and complex types. Such functions are quite simple: they have integral
17627 arguments, they return an integral result and their body contains only a
17628 return statement with arithmetic expressions. This is the only kind of
17629 function we are interested in translating into DWARF procedures, here.
17631 DWARF expressions and DWARF procedure are executed using a stack, so we have
17632 to define some calling convention for them to interact. Let's say that:
17634 - Before calling a DWARF procedure, DWARF expressions must push on the stack
17635 all arguments in reverse order (right-to-left) so that when the DWARF
17636 procedure execution starts, the first argument is the top of the stack.
17638 - Then, when returning, the DWARF procedure must have consumed all arguments
17639 on the stack, must have pushed the result and touched nothing else.
17641 - Each integral argument and the result are integral types can be hold in a
17644 - We call "frame offset" the number of stack slots that are "under DWARF
17645 procedure control": it includes the arguments slots, the temporaries and
17646 the result slot. Thus, it is equal to the number of arguments when the
17647 procedure execution starts and must be equal to one (the result) when it
17650 /* Helper structure used when generating operations for a DWARF procedure. */
17651 struct dwarf_procedure_info
17653 /* The FUNCTION_DECL node corresponding to the DWARF procedure that is
17654 currently translated. */
17656 /* The number of arguments FNDECL takes. */
17657 unsigned args_count
;
17660 /* Return a pointer to a newly created DIE node for a DWARF procedure. Add
17661 LOCATION as its DW_AT_location attribute. If FNDECL is not NULL_TREE,
17662 equate it to this DIE. */
17665 new_dwarf_proc_die (dw_loc_descr_ref location
, tree fndecl
,
17666 dw_die_ref parent_die
)
17668 dw_die_ref dwarf_proc_die
;
17670 if ((dwarf_version
< 3 && dwarf_strict
)
17671 || location
== NULL
)
17674 dwarf_proc_die
= new_die (DW_TAG_dwarf_procedure
, parent_die
, fndecl
);
17676 equate_decl_number_to_die (fndecl
, dwarf_proc_die
);
17677 add_AT_loc (dwarf_proc_die
, DW_AT_location
, location
);
17678 return dwarf_proc_die
;
17681 /* Return whether TYPE is a supported type as a DWARF procedure argument
17682 type or return type (we handle only scalar types and pointer types that
17683 aren't wider than the DWARF expression evaluation stack. */
17686 is_handled_procedure_type (tree type
)
17688 return ((INTEGRAL_TYPE_P (type
)
17689 || TREE_CODE (type
) == OFFSET_TYPE
17690 || TREE_CODE (type
) == POINTER_TYPE
)
17691 && int_size_in_bytes (type
) <= DWARF2_ADDR_SIZE
);
17694 /* Helper for resolve_args_picking: do the same but stop when coming across
17695 visited nodes. For each node we visit, register in FRAME_OFFSETS the frame
17696 offset *before* evaluating the corresponding operation. */
17699 resolve_args_picking_1 (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
17700 struct dwarf_procedure_info
*dpi
,
17701 hash_map
<dw_loc_descr_ref
, unsigned> &frame_offsets
)
17703 /* The "frame_offset" identifier is already used to name a macro... */
17704 unsigned frame_offset_
= initial_frame_offset
;
17705 dw_loc_descr_ref l
;
17707 for (l
= loc
; l
!= NULL
;)
17710 unsigned &l_frame_offset
= frame_offsets
.get_or_insert (l
, &existed
);
17712 /* If we already met this node, there is nothing to compute anymore. */
17715 /* Make sure that the stack size is consistent wherever the execution
17716 flow comes from. */
17717 gcc_assert ((unsigned) l_frame_offset
== frame_offset_
);
17720 l_frame_offset
= frame_offset_
;
17722 /* If needed, relocate the picking offset with respect to the frame
17724 if (l
->frame_offset_rel
)
17726 unsigned HOST_WIDE_INT off
;
17727 switch (l
->dw_loc_opc
)
17730 off
= l
->dw_loc_oprnd1
.v
.val_unsigned
;
17739 gcc_unreachable ();
17741 /* frame_offset_ is the size of the current stack frame, including
17742 incoming arguments. Besides, the arguments are pushed
17743 right-to-left. Thus, in order to access the Nth argument from
17744 this operation node, the picking has to skip temporaries *plus*
17745 one stack slot per argument (0 for the first one, 1 for the second
17748 The targetted argument number (N) is already set as the operand,
17749 and the number of temporaries can be computed with:
17750 frame_offsets_ - dpi->args_count */
17751 off
+= frame_offset_
- dpi
->args_count
;
17753 /* DW_OP_pick handles only offsets from 0 to 255 (inclusive)... */
17759 l
->dw_loc_opc
= DW_OP_dup
;
17760 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
17764 l
->dw_loc_opc
= DW_OP_over
;
17765 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
17769 l
->dw_loc_opc
= DW_OP_pick
;
17770 l
->dw_loc_oprnd1
.v
.val_unsigned
= off
;
17774 /* Update frame_offset according to the effect the current operation has
17776 switch (l
->dw_loc_opc
)
17784 case DW_OP_plus_uconst
:
17820 case DW_OP_deref_size
:
17822 case DW_OP_bit_piece
:
17823 case DW_OP_implicit_value
:
17824 case DW_OP_stack_value
:
17828 case DW_OP_const1u
:
17829 case DW_OP_const1s
:
17830 case DW_OP_const2u
:
17831 case DW_OP_const2s
:
17832 case DW_OP_const4u
:
17833 case DW_OP_const4s
:
17834 case DW_OP_const8u
:
17835 case DW_OP_const8s
:
17906 case DW_OP_push_object_address
:
17907 case DW_OP_call_frame_cfa
:
17908 case DW_OP_GNU_variable_value
:
17909 case DW_OP_GNU_addr_index
:
17910 case DW_OP_GNU_const_index
:
17935 case DW_OP_xderef_size
:
17941 case DW_OP_call_ref
:
17943 dw_die_ref dwarf_proc
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
17944 int *stack_usage
= dwarf_proc_stack_usage_map
->get (dwarf_proc
);
17946 if (stack_usage
== NULL
)
17948 frame_offset_
+= *stack_usage
;
17952 case DW_OP_implicit_pointer
:
17953 case DW_OP_entry_value
:
17954 case DW_OP_const_type
:
17955 case DW_OP_regval_type
:
17956 case DW_OP_deref_type
:
17957 case DW_OP_convert
:
17958 case DW_OP_reinterpret
:
17959 case DW_OP_form_tls_address
:
17960 case DW_OP_GNU_push_tls_address
:
17961 case DW_OP_GNU_uninit
:
17962 case DW_OP_GNU_encoded_addr
:
17963 case DW_OP_GNU_implicit_pointer
:
17964 case DW_OP_GNU_entry_value
:
17965 case DW_OP_GNU_const_type
:
17966 case DW_OP_GNU_regval_type
:
17967 case DW_OP_GNU_deref_type
:
17968 case DW_OP_GNU_convert
:
17969 case DW_OP_GNU_reinterpret
:
17970 case DW_OP_GNU_parameter_ref
:
17971 /* loc_list_from_tree will probably not output these operations for
17972 size functions, so assume they will not appear here. */
17973 /* Fall through... */
17976 gcc_unreachable ();
17979 /* Now, follow the control flow (except subroutine calls). */
17980 switch (l
->dw_loc_opc
)
17983 if (!resolve_args_picking_1 (l
->dw_loc_next
, frame_offset_
, dpi
,
17986 /* Fall through. */
17989 l
= l
->dw_loc_oprnd1
.v
.val_loc
;
17992 case DW_OP_stack_value
:
17996 l
= l
->dw_loc_next
;
18004 /* Make a DFS over operations reachable through LOC (i.e. follow branch
18005 operations) in order to resolve the operand of DW_OP_pick operations that
18006 target DWARF procedure arguments (DPI). INITIAL_FRAME_OFFSET is the frame
18007 offset *before* LOC is executed. Return if all relocations were
18011 resolve_args_picking (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
18012 struct dwarf_procedure_info
*dpi
)
18014 /* Associate to all visited operations the frame offset *before* evaluating
18016 hash_map
<dw_loc_descr_ref
, unsigned> frame_offsets
;
18018 return resolve_args_picking_1 (loc
, initial_frame_offset
, dpi
,
18022 /* Try to generate a DWARF procedure that computes the same result as FNDECL.
18023 Return NULL if it is not possible. */
18026 function_to_dwarf_procedure (tree fndecl
)
18028 struct loc_descr_context ctx
;
18029 struct dwarf_procedure_info dpi
;
18030 dw_die_ref dwarf_proc_die
;
18031 tree tree_body
= DECL_SAVED_TREE (fndecl
);
18032 dw_loc_descr_ref loc_body
, epilogue
;
18037 /* Do not generate multiple DWARF procedures for the same function
18039 dwarf_proc_die
= lookup_decl_die (fndecl
);
18040 if (dwarf_proc_die
!= NULL
)
18041 return dwarf_proc_die
;
18043 /* DWARF procedures are available starting with the DWARFv3 standard. */
18044 if (dwarf_version
< 3 && dwarf_strict
)
18047 /* We handle only functions for which we still have a body, that return a
18048 supported type and that takes arguments with supported types. Note that
18049 there is no point translating functions that return nothing. */
18050 if (tree_body
== NULL_TREE
18051 || DECL_RESULT (fndecl
) == NULL_TREE
18052 || !is_handled_procedure_type (TREE_TYPE (DECL_RESULT (fndecl
))))
18055 for (cursor
= DECL_ARGUMENTS (fndecl
);
18056 cursor
!= NULL_TREE
;
18057 cursor
= TREE_CHAIN (cursor
))
18058 if (!is_handled_procedure_type (TREE_TYPE (cursor
)))
18061 /* Match only "expr" in: RETURN_EXPR (MODIFY_EXPR (RESULT_DECL, expr)). */
18062 if (TREE_CODE (tree_body
) != RETURN_EXPR
)
18064 tree_body
= TREE_OPERAND (tree_body
, 0);
18065 if (TREE_CODE (tree_body
) != MODIFY_EXPR
18066 || TREE_OPERAND (tree_body
, 0) != DECL_RESULT (fndecl
))
18068 tree_body
= TREE_OPERAND (tree_body
, 1);
18070 /* Try to translate the body expression itself. Note that this will probably
18071 cause an infinite recursion if its call graph has a cycle. This is very
18072 unlikely for size functions, however, so don't bother with such things at
18074 ctx
.context_type
= NULL_TREE
;
18075 ctx
.base_decl
= NULL_TREE
;
18077 ctx
.placeholder_arg
= false;
18078 ctx
.placeholder_seen
= false;
18079 dpi
.fndecl
= fndecl
;
18080 dpi
.args_count
= list_length (DECL_ARGUMENTS (fndecl
));
18081 loc_body
= loc_descriptor_from_tree (tree_body
, 0, &ctx
);
18085 /* After evaluating all operands in "loc_body", we should still have on the
18086 stack all arguments plus the desired function result (top of the stack).
18087 Generate code in order to keep only the result in our stack frame. */
18089 for (i
= 0; i
< dpi
.args_count
; ++i
)
18091 dw_loc_descr_ref op_couple
= new_loc_descr (DW_OP_swap
, 0, 0);
18092 op_couple
->dw_loc_next
= new_loc_descr (DW_OP_drop
, 0, 0);
18093 op_couple
->dw_loc_next
->dw_loc_next
= epilogue
;
18094 epilogue
= op_couple
;
18096 add_loc_descr (&loc_body
, epilogue
);
18097 if (!resolve_args_picking (loc_body
, dpi
.args_count
, &dpi
))
18100 /* Trailing nops from loc_descriptor_from_tree (if any) cannot be removed
18101 because they are considered useful. Now there is an epilogue, they are
18102 not anymore, so give it another try. */
18103 loc_descr_without_nops (loc_body
);
18105 /* fndecl may be used both as a regular DW_TAG_subprogram DIE and as
18106 a DW_TAG_dwarf_procedure, so we may have a conflict, here. It's unlikely,
18107 though, given that size functions do not come from source, so they should
18108 not have a dedicated DW_TAG_subprogram DIE. */
18110 = new_dwarf_proc_die (loc_body
, fndecl
,
18111 get_context_die (DECL_CONTEXT (fndecl
)));
18113 /* The called DWARF procedure consumes one stack slot per argument and
18114 returns one stack slot. */
18115 dwarf_proc_stack_usage_map
->put (dwarf_proc_die
, 1 - dpi
.args_count
);
18117 return dwarf_proc_die
;
18121 /* Generate Dwarf location list representing LOC.
18122 If WANT_ADDRESS is false, expression computing LOC will be computed
18123 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
18124 if WANT_ADDRESS is 2, expression computing address useable in location
18125 will be returned (i.e. DW_OP_reg can be used
18126 to refer to register values).
18128 CONTEXT provides information to customize the location descriptions
18129 generation. Its context_type field specifies what type is implicitly
18130 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
18131 will not be generated.
18133 Its DPI field determines whether we are generating a DWARF expression for a
18134 DWARF procedure, so PARM_DECL references are processed specifically.
18136 If CONTEXT is NULL, the behavior is the same as if context_type, base_decl
18137 and dpi fields were null. */
18139 static dw_loc_list_ref
18140 loc_list_from_tree_1 (tree loc
, int want_address
,
18141 struct loc_descr_context
*context
)
18143 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
18144 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
18145 int have_address
= 0;
18146 enum dwarf_location_atom op
;
18148 /* ??? Most of the time we do not take proper care for sign/zero
18149 extending the values properly. Hopefully this won't be a real
18152 if (context
!= NULL
18153 && context
->base_decl
== loc
18154 && want_address
== 0)
18156 if (dwarf_version
>= 3 || !dwarf_strict
)
18157 return new_loc_list (new_loc_descr (DW_OP_push_object_address
, 0, 0),
18158 NULL
, 0, NULL
, 0, NULL
);
18163 switch (TREE_CODE (loc
))
18166 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
18169 case PLACEHOLDER_EXPR
:
18170 /* This case involves extracting fields from an object to determine the
18171 position of other fields. It is supposed to appear only as the first
18172 operand of COMPONENT_REF nodes and to reference precisely the type
18173 that the context allows. */
18174 if (context
!= NULL
18175 && TREE_TYPE (loc
) == context
->context_type
18176 && want_address
>= 1)
18178 if (dwarf_version
>= 3 || !dwarf_strict
)
18180 ret
= new_loc_descr (DW_OP_push_object_address
, 0, 0);
18187 /* For DW_TAG_generic_subrange attributes, PLACEHOLDER_EXPR stands for
18188 the single argument passed by consumer. */
18189 else if (context
!= NULL
18190 && context
->placeholder_arg
18191 && INTEGRAL_TYPE_P (TREE_TYPE (loc
))
18192 && want_address
== 0)
18194 ret
= new_loc_descr (DW_OP_pick
, 0, 0);
18195 ret
->frame_offset_rel
= 1;
18196 context
->placeholder_seen
= true;
18200 expansion_failed (loc
, NULL_RTX
,
18201 "PLACEHOLDER_EXPR for an unexpected type");
18206 const int nargs
= call_expr_nargs (loc
);
18207 tree callee
= get_callee_fndecl (loc
);
18209 dw_die_ref dwarf_proc
;
18211 if (callee
== NULL_TREE
)
18212 goto call_expansion_failed
;
18214 /* We handle only functions that return an integer. */
18215 if (!is_handled_procedure_type (TREE_TYPE (TREE_TYPE (callee
))))
18216 goto call_expansion_failed
;
18218 dwarf_proc
= function_to_dwarf_procedure (callee
);
18219 if (dwarf_proc
== NULL
)
18220 goto call_expansion_failed
;
18222 /* Evaluate arguments right-to-left so that the first argument will
18223 be the top-most one on the stack. */
18224 for (i
= nargs
- 1; i
>= 0; --i
)
18226 dw_loc_descr_ref loc_descr
18227 = loc_descriptor_from_tree (CALL_EXPR_ARG (loc
, i
), 0,
18230 if (loc_descr
== NULL
)
18231 goto call_expansion_failed
;
18233 add_loc_descr (&ret
, loc_descr
);
18236 ret1
= new_loc_descr (DW_OP_call4
, 0, 0);
18237 ret1
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18238 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.die
= dwarf_proc
;
18239 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18240 add_loc_descr (&ret
, ret1
);
18243 call_expansion_failed
:
18244 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
18245 /* There are no opcodes for these operations. */
18249 case PREINCREMENT_EXPR
:
18250 case PREDECREMENT_EXPR
:
18251 case POSTINCREMENT_EXPR
:
18252 case POSTDECREMENT_EXPR
:
18253 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
18254 /* There are no opcodes for these operations. */
18258 /* If we already want an address, see if there is INDIRECT_REF inside
18259 e.g. for &this->field. */
18262 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
18263 (loc
, want_address
== 2, context
);
18266 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
18267 && (ret
= cst_pool_loc_descr (loc
)))
18270 /* Otherwise, process the argument and look for the address. */
18271 if (!list_ret
&& !ret
)
18272 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 1, context
);
18276 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
18282 if (DECL_THREAD_LOCAL_P (loc
))
18285 enum dwarf_location_atom tls_op
;
18286 enum dtprel_bool dtprel
= dtprel_false
;
18288 if (targetm
.have_tls
)
18290 /* If this is not defined, we have no way to emit the
18292 if (!targetm
.asm_out
.output_dwarf_dtprel
)
18295 /* The way DW_OP_GNU_push_tls_address is specified, we
18296 can only look up addresses of objects in the current
18297 module. We used DW_OP_addr as first op, but that's
18298 wrong, because DW_OP_addr is relocated by the debug
18299 info consumer, while DW_OP_GNU_push_tls_address
18300 operand shouldn't be. */
18301 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
18303 dtprel
= dtprel_true
;
18304 /* We check for DWARF 5 here because gdb did not implement
18305 DW_OP_form_tls_address until after 7.12. */
18306 tls_op
= (dwarf_version
>= 5 ? DW_OP_form_tls_address
18307 : DW_OP_GNU_push_tls_address
);
18311 if (!targetm
.emutls
.debug_form_tls_address
18312 || !(dwarf_version
>= 3 || !dwarf_strict
))
18314 /* We stuffed the control variable into the DECL_VALUE_EXPR
18315 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
18316 no longer appear in gimple code. We used the control
18317 variable in specific so that we could pick it up here. */
18318 loc
= DECL_VALUE_EXPR (loc
);
18319 tls_op
= DW_OP_form_tls_address
;
18322 rtl
= rtl_for_decl_location (loc
);
18323 if (rtl
== NULL_RTX
)
18328 rtl
= XEXP (rtl
, 0);
18329 if (! CONSTANT_P (rtl
))
18332 ret
= new_addr_loc_descr (rtl
, dtprel
);
18333 ret1
= new_loc_descr (tls_op
, 0, 0);
18334 add_loc_descr (&ret
, ret1
);
18342 if (context
!= NULL
&& context
->dpi
!= NULL
18343 && DECL_CONTEXT (loc
) == context
->dpi
->fndecl
)
18345 /* We are generating code for a DWARF procedure and we want to access
18346 one of its arguments: find the appropriate argument offset and let
18347 the resolve_args_picking pass compute the offset that complies
18348 with the stack frame size. */
18352 for (cursor
= DECL_ARGUMENTS (context
->dpi
->fndecl
);
18353 cursor
!= NULL_TREE
&& cursor
!= loc
;
18354 cursor
= TREE_CHAIN (cursor
), ++i
)
18356 /* If we are translating a DWARF procedure, all referenced parameters
18357 must belong to the current function. */
18358 gcc_assert (cursor
!= NULL_TREE
);
18360 ret
= new_loc_descr (DW_OP_pick
, i
, 0);
18361 ret
->frame_offset_rel
= 1;
18367 if (DECL_HAS_VALUE_EXPR_P (loc
))
18368 return loc_list_from_tree_1 (DECL_VALUE_EXPR (loc
),
18369 want_address
, context
);
18372 case FUNCTION_DECL
:
18375 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
18377 if (loc_list
&& loc_list
->first
)
18379 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
18380 have_address
= want_address
!= 0;
18383 rtl
= rtl_for_decl_location (loc
);
18384 if (rtl
== NULL_RTX
)
18386 if (TREE_CODE (loc
) != FUNCTION_DECL
18388 && current_function_decl
18389 && want_address
!= 1
18390 && ! DECL_IGNORED_P (loc
)
18391 && (INTEGRAL_TYPE_P (TREE_TYPE (loc
))
18392 || POINTER_TYPE_P (TREE_TYPE (loc
)))
18393 && DECL_CONTEXT (loc
) == current_function_decl
18394 && (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (loc
)))
18395 <= DWARF2_ADDR_SIZE
))
18397 dw_die_ref ref
= lookup_decl_die (loc
);
18398 ret
= new_loc_descr (DW_OP_GNU_variable_value
, 0, 0);
18401 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
18402 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
18403 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
18407 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
18408 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= loc
;
18412 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
18415 else if (CONST_INT_P (rtl
))
18417 HOST_WIDE_INT val
= INTVAL (rtl
);
18418 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18419 val
&= GET_MODE_MASK (DECL_MODE (loc
));
18420 ret
= int_loc_descriptor (val
);
18422 else if (GET_CODE (rtl
) == CONST_STRING
)
18424 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
18427 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
18428 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
18431 machine_mode mode
, mem_mode
;
18433 /* Certain constructs can only be represented at top-level. */
18434 if (want_address
== 2)
18436 ret
= loc_descriptor (rtl
, VOIDmode
,
18437 VAR_INIT_STATUS_INITIALIZED
);
18442 mode
= GET_MODE (rtl
);
18443 mem_mode
= VOIDmode
;
18447 mode
= get_address_mode (rtl
);
18448 rtl
= XEXP (rtl
, 0);
18451 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
18452 VAR_INIT_STATUS_INITIALIZED
);
18455 expansion_failed (loc
, rtl
,
18456 "failed to produce loc descriptor for rtl");
18462 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
18469 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18473 case TARGET_MEM_REF
:
18475 case DEBUG_EXPR_DECL
:
18478 case COMPOUND_EXPR
:
18479 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), want_address
,
18483 case VIEW_CONVERT_EXPR
:
18486 case NON_LVALUE_EXPR
:
18487 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), want_address
,
18490 case COMPONENT_REF
:
18491 case BIT_FIELD_REF
:
18493 case ARRAY_RANGE_REF
:
18494 case REALPART_EXPR
:
18495 case IMAGPART_EXPR
:
18498 poly_int64 bitsize
, bitpos
, bytepos
;
18500 int unsignedp
, reversep
, volatilep
= 0;
18502 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
18503 &unsignedp
, &reversep
, &volatilep
);
18505 gcc_assert (obj
!= loc
);
18507 list_ret
= loc_list_from_tree_1 (obj
,
18509 && known_eq (bitpos
, 0)
18510 && !offset
? 2 : 1,
18512 /* TODO: We can extract value of the small expression via shifting even
18513 for nonzero bitpos. */
18516 if (!multiple_p (bitpos
, BITS_PER_UNIT
, &bytepos
)
18517 || !multiple_p (bitsize
, BITS_PER_UNIT
))
18519 expansion_failed (loc
, NULL_RTX
,
18520 "bitfield access");
18524 if (offset
!= NULL_TREE
)
18526 /* Variable offset. */
18527 list_ret1
= loc_list_from_tree_1 (offset
, 0, context
);
18528 if (list_ret1
== 0)
18530 add_loc_list (&list_ret
, list_ret1
);
18533 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
18536 HOST_WIDE_INT value
;
18537 if (bytepos
.is_constant (&value
) && value
> 0)
18538 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
,
18540 else if (maybe_ne (bytepos
, 0))
18541 loc_list_plus_const (list_ret
, bytepos
);
18548 if ((want_address
|| !tree_fits_shwi_p (loc
))
18549 && (ret
= cst_pool_loc_descr (loc
)))
18551 else if (want_address
== 2
18552 && tree_fits_shwi_p (loc
)
18553 && (ret
= address_of_int_loc_descriptor
18554 (int_size_in_bytes (TREE_TYPE (loc
)),
18555 tree_to_shwi (loc
))))
18557 else if (tree_fits_shwi_p (loc
))
18558 ret
= int_loc_descriptor (tree_to_shwi (loc
));
18559 else if (tree_fits_uhwi_p (loc
))
18560 ret
= uint_loc_descriptor (tree_to_uhwi (loc
));
18563 expansion_failed (loc
, NULL_RTX
,
18564 "Integer operand is not host integer");
18573 if ((ret
= cst_pool_loc_descr (loc
)))
18575 else if (TREE_CODE (loc
) == CONSTRUCTOR
)
18577 tree type
= TREE_TYPE (loc
);
18578 unsigned HOST_WIDE_INT size
= int_size_in_bytes (type
);
18579 unsigned HOST_WIDE_INT offset
= 0;
18580 unsigned HOST_WIDE_INT cnt
;
18581 constructor_elt
*ce
;
18583 if (TREE_CODE (type
) == RECORD_TYPE
)
18585 /* This is very limited, but it's enough to output
18586 pointers to member functions, as long as the
18587 referenced function is defined in the current
18588 translation unit. */
18589 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (loc
), cnt
, ce
)
18591 tree val
= ce
->value
;
18593 tree field
= ce
->index
;
18598 if (!field
|| DECL_BIT_FIELD (field
))
18600 expansion_failed (loc
, NULL_RTX
,
18601 "bitfield in record type constructor");
18602 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
18607 HOST_WIDE_INT fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
18608 unsigned HOST_WIDE_INT pos
= int_byte_position (field
);
18609 gcc_assert (pos
+ fieldsize
<= size
);
18612 expansion_failed (loc
, NULL_RTX
,
18613 "out-of-order fields in record constructor");
18614 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
18620 ret1
= new_loc_descr (DW_OP_piece
, pos
- offset
, 0);
18621 add_loc_descr (&ret
, ret1
);
18624 if (val
&& fieldsize
!= 0)
18626 ret1
= loc_descriptor_from_tree (val
, want_address
, context
);
18629 expansion_failed (loc
, NULL_RTX
,
18630 "unsupported expression in field");
18631 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
18635 add_loc_descr (&ret
, ret1
);
18639 ret1
= new_loc_descr (DW_OP_piece
, fieldsize
, 0);
18640 add_loc_descr (&ret
, ret1
);
18641 offset
= pos
+ fieldsize
;
18645 if (offset
!= size
)
18647 ret1
= new_loc_descr (DW_OP_piece
, size
- offset
, 0);
18648 add_loc_descr (&ret
, ret1
);
18652 have_address
= !!want_address
;
18655 expansion_failed (loc
, NULL_RTX
,
18656 "constructor of non-record type");
18659 /* We can construct small constants here using int_loc_descriptor. */
18660 expansion_failed (loc
, NULL_RTX
,
18661 "constructor or constant not in constant pool");
18664 case TRUTH_AND_EXPR
:
18665 case TRUTH_ANDIF_EXPR
:
18670 case TRUTH_XOR_EXPR
:
18675 case TRUTH_OR_EXPR
:
18676 case TRUTH_ORIF_EXPR
:
18681 case FLOOR_DIV_EXPR
:
18682 case CEIL_DIV_EXPR
:
18683 case ROUND_DIV_EXPR
:
18684 case TRUNC_DIV_EXPR
:
18685 case EXACT_DIV_EXPR
:
18686 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18695 case FLOOR_MOD_EXPR
:
18696 case CEIL_MOD_EXPR
:
18697 case ROUND_MOD_EXPR
:
18698 case TRUNC_MOD_EXPR
:
18699 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
18704 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18705 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
18706 if (list_ret
== 0 || list_ret1
== 0)
18709 add_loc_list (&list_ret
, list_ret1
);
18712 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
18713 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
18714 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
18715 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
18716 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
18728 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
18731 case POINTER_PLUS_EXPR
:
18734 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
18736 /* Big unsigned numbers can fit in HOST_WIDE_INT but it may be
18737 smarter to encode their opposite. The DW_OP_plus_uconst operation
18738 takes 1 + X bytes, X being the size of the ULEB128 addend. On the
18739 other hand, a "<push literal>; DW_OP_minus" pattern takes 1 + Y
18740 bytes, Y being the size of the operation that pushes the opposite
18741 of the addend. So let's choose the smallest representation. */
18742 const tree tree_addend
= TREE_OPERAND (loc
, 1);
18743 offset_int wi_addend
;
18744 HOST_WIDE_INT shwi_addend
;
18745 dw_loc_descr_ref loc_naddend
;
18747 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18751 /* Try to get the literal to push. It is the opposite of the addend,
18752 so as we rely on wrapping during DWARF evaluation, first decode
18753 the literal as a "DWARF-sized" signed number. */
18754 wi_addend
= wi::to_offset (tree_addend
);
18755 wi_addend
= wi::sext (wi_addend
, DWARF2_ADDR_SIZE
* 8);
18756 shwi_addend
= wi_addend
.to_shwi ();
18757 loc_naddend
= (shwi_addend
!= INTTYPE_MINIMUM (HOST_WIDE_INT
))
18758 ? int_loc_descriptor (-shwi_addend
)
18761 if (loc_naddend
!= NULL
18762 && ((unsigned) size_of_uleb128 (shwi_addend
)
18763 > size_of_loc_descr (loc_naddend
)))
18765 add_loc_descr_to_each (list_ret
, loc_naddend
);
18766 add_loc_descr_to_each (list_ret
,
18767 new_loc_descr (DW_OP_minus
, 0, 0));
18771 for (dw_loc_descr_ref loc_cur
= loc_naddend
; loc_cur
!= NULL
; )
18773 loc_naddend
= loc_cur
;
18774 loc_cur
= loc_cur
->dw_loc_next
;
18775 ggc_free (loc_naddend
);
18777 loc_list_plus_const (list_ret
, wi_addend
.to_shwi ());
18787 goto do_comp_binop
;
18791 goto do_comp_binop
;
18795 goto do_comp_binop
;
18799 goto do_comp_binop
;
18802 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
18804 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0, context
);
18805 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
18806 list_ret
= loc_list_from_uint_comparison (list_ret
, list_ret1
,
18822 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18823 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
18824 if (list_ret
== 0 || list_ret1
== 0)
18827 add_loc_list (&list_ret
, list_ret1
);
18830 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
18833 case TRUTH_NOT_EXPR
:
18847 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18851 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
18857 const enum tree_code code
=
18858 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
18860 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
18861 build2 (code
, integer_type_node
,
18862 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
18863 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
18870 dw_loc_descr_ref lhs
18871 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
18872 dw_loc_list_ref rhs
18873 = loc_list_from_tree_1 (TREE_OPERAND (loc
, 2), 0, context
);
18874 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
18876 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18877 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
18880 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
18881 add_loc_descr_to_each (list_ret
, bra_node
);
18883 add_loc_list (&list_ret
, rhs
);
18884 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
18885 add_loc_descr_to_each (list_ret
, jump_node
);
18887 add_loc_descr_to_each (list_ret
, lhs
);
18888 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
18889 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
18891 /* ??? Need a node to point the skip at. Use a nop. */
18892 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
18893 add_loc_descr_to_each (list_ret
, tmp
);
18894 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
18895 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
18899 case FIX_TRUNC_EXPR
:
18903 /* Leave front-end specific codes as simply unknown. This comes
18904 up, for instance, with the C STMT_EXPR. */
18905 if ((unsigned int) TREE_CODE (loc
)
18906 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
18908 expansion_failed (loc
, NULL_RTX
,
18909 "language specific tree node");
18913 /* Otherwise this is a generic code; we should just lists all of
18914 these explicitly. We forgot one. */
18916 gcc_unreachable ();
18918 /* In a release build, we want to degrade gracefully: better to
18919 generate incomplete debugging information than to crash. */
18923 if (!ret
&& !list_ret
)
18926 if (want_address
== 2 && !have_address
18927 && (dwarf_version
>= 4 || !dwarf_strict
))
18929 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
18931 expansion_failed (loc
, NULL_RTX
,
18932 "DWARF address size mismatch");
18936 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
18938 add_loc_descr_to_each (list_ret
,
18939 new_loc_descr (DW_OP_stack_value
, 0, 0));
18942 /* Show if we can't fill the request for an address. */
18943 if (want_address
&& !have_address
)
18945 expansion_failed (loc
, NULL_RTX
,
18946 "Want address and only have value");
18950 gcc_assert (!ret
|| !list_ret
);
18952 /* If we've got an address and don't want one, dereference. */
18953 if (!want_address
&& have_address
)
18955 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
18957 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
18959 expansion_failed (loc
, NULL_RTX
,
18960 "DWARF address size mismatch");
18963 else if (size
== DWARF2_ADDR_SIZE
)
18966 op
= DW_OP_deref_size
;
18969 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
18971 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
18974 list_ret
= new_loc_list (ret
, NULL
, 0, NULL
, 0, NULL
);
18979 /* Likewise, but strip useless DW_OP_nop operations in the resulting
18982 static dw_loc_list_ref
18983 loc_list_from_tree (tree loc
, int want_address
,
18984 struct loc_descr_context
*context
)
18986 dw_loc_list_ref result
= loc_list_from_tree_1 (loc
, want_address
, context
);
18988 for (dw_loc_list_ref loc_cur
= result
;
18989 loc_cur
!= NULL
; loc_cur
= loc_cur
->dw_loc_next
)
18990 loc_descr_without_nops (loc_cur
->expr
);
18994 /* Same as above but return only single location expression. */
18995 static dw_loc_descr_ref
18996 loc_descriptor_from_tree (tree loc
, int want_address
,
18997 struct loc_descr_context
*context
)
18999 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
, context
);
19002 if (ret
->dw_loc_next
)
19004 expansion_failed (loc
, NULL_RTX
,
19005 "Location list where only loc descriptor needed");
19011 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
19012 pointer to the declared type for the relevant field variable, or return
19013 `integer_type_node' if the given node turns out to be an
19014 ERROR_MARK node. */
19017 field_type (const_tree decl
)
19021 if (TREE_CODE (decl
) == ERROR_MARK
)
19022 return integer_type_node
;
19024 type
= DECL_BIT_FIELD_TYPE (decl
);
19025 if (type
== NULL_TREE
)
19026 type
= TREE_TYPE (decl
);
19031 /* Given a pointer to a tree node, return the alignment in bits for
19032 it, or else return BITS_PER_WORD if the node actually turns out to
19033 be an ERROR_MARK node. */
19035 static inline unsigned
19036 simple_type_align_in_bits (const_tree type
)
19038 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
19041 static inline unsigned
19042 simple_decl_align_in_bits (const_tree decl
)
19044 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
19047 /* Return the result of rounding T up to ALIGN. */
19049 static inline offset_int
19050 round_up_to_align (const offset_int
&t
, unsigned int align
)
19052 return wi::udiv_trunc (t
+ align
- 1, align
) * align
;
19055 /* Compute the size of TYPE in bytes. If possible, return NULL and store the
19056 size as an integer constant in CST_SIZE. Otherwise, if possible, return a
19057 DWARF expression that computes the size. Return NULL and set CST_SIZE to -1
19058 if we fail to return the size in one of these two forms. */
19060 static dw_loc_descr_ref
19061 type_byte_size (const_tree type
, HOST_WIDE_INT
*cst_size
)
19064 struct loc_descr_context ctx
;
19066 /* Return a constant integer in priority, if possible. */
19067 *cst_size
= int_size_in_bytes (type
);
19068 if (*cst_size
!= -1)
19071 ctx
.context_type
= const_cast<tree
> (type
);
19072 ctx
.base_decl
= NULL_TREE
;
19074 ctx
.placeholder_arg
= false;
19075 ctx
.placeholder_seen
= false;
19077 type
= TYPE_MAIN_VARIANT (type
);
19078 tree_size
= TYPE_SIZE_UNIT (type
);
19079 return ((tree_size
!= NULL_TREE
)
19080 ? loc_descriptor_from_tree (tree_size
, 0, &ctx
)
19084 /* Helper structure for RECORD_TYPE processing. */
19087 /* Root RECORD_TYPE. It is needed to generate data member location
19088 descriptions in variable-length records (VLR), but also to cope with
19089 variants, which are composed of nested structures multiplexed with
19090 QUAL_UNION_TYPE nodes. Each time such a structure is passed to a
19091 function processing a FIELD_DECL, it is required to be non null. */
19093 /* When generating a variant part in a RECORD_TYPE (i.e. a nested
19094 QUAL_UNION_TYPE), this holds an expression that computes the offset for
19095 this variant part as part of the root record (in storage units). For
19096 regular records, it must be NULL_TREE. */
19097 tree variant_part_offset
;
19100 /* Given a pointer to a FIELD_DECL, compute the byte offset of the lowest
19101 addressed byte of the "containing object" for the given FIELD_DECL. If
19102 possible, return a native constant through CST_OFFSET (in which case NULL is
19103 returned); otherwise return a DWARF expression that computes the offset.
19105 Set *CST_OFFSET to 0 and return NULL if we are unable to determine what
19106 that offset is, either because the argument turns out to be a pointer to an
19107 ERROR_MARK node, or because the offset expression is too complex for us.
19109 CTX is required: see the comment for VLR_CONTEXT. */
19111 static dw_loc_descr_ref
19112 field_byte_offset (const_tree decl
, struct vlr_context
*ctx
,
19113 HOST_WIDE_INT
*cst_offset
)
19116 dw_loc_list_ref loc_result
;
19120 if (TREE_CODE (decl
) == ERROR_MARK
)
19123 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
19125 /* We cannot handle variable bit offsets at the moment, so abort if it's the
19127 if (TREE_CODE (DECL_FIELD_BIT_OFFSET (decl
)) != INTEGER_CST
)
19130 /* We used to handle only constant offsets in all cases. Now, we handle
19131 properly dynamic byte offsets only when PCC bitfield type doesn't
19133 if (PCC_BITFIELD_TYPE_MATTERS
19134 && TREE_CODE (DECL_FIELD_OFFSET (decl
)) == INTEGER_CST
)
19136 offset_int object_offset_in_bits
;
19137 offset_int object_offset_in_bytes
;
19138 offset_int bitpos_int
;
19140 tree field_size_tree
;
19141 offset_int deepest_bitpos
;
19142 offset_int field_size_in_bits
;
19143 unsigned int type_align_in_bits
;
19144 unsigned int decl_align_in_bits
;
19145 offset_int type_size_in_bits
;
19147 bitpos_int
= wi::to_offset (bit_position (decl
));
19148 type
= field_type (decl
);
19149 type_size_in_bits
= offset_int_type_size_in_bits (type
);
19150 type_align_in_bits
= simple_type_align_in_bits (type
);
19152 field_size_tree
= DECL_SIZE (decl
);
19154 /* The size could be unspecified if there was an error, or for
19155 a flexible array member. */
19156 if (!field_size_tree
)
19157 field_size_tree
= bitsize_zero_node
;
19159 /* If the size of the field is not constant, use the type size. */
19160 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
19161 field_size_in_bits
= wi::to_offset (field_size_tree
);
19163 field_size_in_bits
= type_size_in_bits
;
19165 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
19167 /* The GCC front-end doesn't make any attempt to keep track of the
19168 starting bit offset (relative to the start of the containing
19169 structure type) of the hypothetical "containing object" for a
19170 bit-field. Thus, when computing the byte offset value for the
19171 start of the "containing object" of a bit-field, we must deduce
19172 this information on our own. This can be rather tricky to do in
19173 some cases. For example, handling the following structure type
19174 definition when compiling for an i386/i486 target (which only
19175 aligns long long's to 32-bit boundaries) can be very tricky:
19177 struct S { int field1; long long field2:31; };
19179 Fortunately, there is a simple rule-of-thumb which can be used
19180 in such cases. When compiling for an i386/i486, GCC will
19181 allocate 8 bytes for the structure shown above. It decides to
19182 do this based upon one simple rule for bit-field allocation.
19183 GCC allocates each "containing object" for each bit-field at
19184 the first (i.e. lowest addressed) legitimate alignment boundary
19185 (based upon the required minimum alignment for the declared
19186 type of the field) which it can possibly use, subject to the
19187 condition that there is still enough available space remaining
19188 in the containing object (when allocated at the selected point)
19189 to fully accommodate all of the bits of the bit-field itself.
19191 This simple rule makes it obvious why GCC allocates 8 bytes for
19192 each object of the structure type shown above. When looking
19193 for a place to allocate the "containing object" for `field2',
19194 the compiler simply tries to allocate a 64-bit "containing
19195 object" at each successive 32-bit boundary (starting at zero)
19196 until it finds a place to allocate that 64- bit field such that
19197 at least 31 contiguous (and previously unallocated) bits remain
19198 within that selected 64 bit field. (As it turns out, for the
19199 example above, the compiler finds it is OK to allocate the
19200 "containing object" 64-bit field at bit-offset zero within the
19203 Here we attempt to work backwards from the limited set of facts
19204 we're given, and we try to deduce from those facts, where GCC
19205 must have believed that the containing object started (within
19206 the structure type). The value we deduce is then used (by the
19207 callers of this routine) to generate DW_AT_location and
19208 DW_AT_bit_offset attributes for fields (both bit-fields and, in
19209 the case of DW_AT_location, regular fields as well). */
19211 /* Figure out the bit-distance from the start of the structure to
19212 the "deepest" bit of the bit-field. */
19213 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
19215 /* This is the tricky part. Use some fancy footwork to deduce
19216 where the lowest addressed bit of the containing object must
19218 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
19220 /* Round up to type_align by default. This works best for
19222 object_offset_in_bits
19223 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
19225 if (wi::gtu_p (object_offset_in_bits
, bitpos_int
))
19227 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
19229 /* Round up to decl_align instead. */
19230 object_offset_in_bits
19231 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
19234 object_offset_in_bytes
19235 = wi::lrshift (object_offset_in_bits
, LOG2_BITS_PER_UNIT
);
19236 if (ctx
->variant_part_offset
== NULL_TREE
)
19238 *cst_offset
= object_offset_in_bytes
.to_shwi ();
19241 tree_result
= wide_int_to_tree (sizetype
, object_offset_in_bytes
);
19244 tree_result
= byte_position (decl
);
19246 if (ctx
->variant_part_offset
!= NULL_TREE
)
19247 tree_result
= fold_build2 (PLUS_EXPR
, TREE_TYPE (tree_result
),
19248 ctx
->variant_part_offset
, tree_result
);
19250 /* If the byte offset is a constant, it's simplier to handle a native
19251 constant rather than a DWARF expression. */
19252 if (TREE_CODE (tree_result
) == INTEGER_CST
)
19254 *cst_offset
= wi::to_offset (tree_result
).to_shwi ();
19257 struct loc_descr_context loc_ctx
= {
19258 ctx
->struct_type
, /* context_type */
19259 NULL_TREE
, /* base_decl */
19261 false, /* placeholder_arg */
19262 false /* placeholder_seen */
19264 loc_result
= loc_list_from_tree (tree_result
, 0, &loc_ctx
);
19266 /* We want a DWARF expression: abort if we only have a location list with
19267 multiple elements. */
19268 if (!loc_result
|| !single_element_loc_list_p (loc_result
))
19271 return loc_result
->expr
;
19274 /* The following routines define various Dwarf attributes and any data
19275 associated with them. */
19277 /* Add a location description attribute value to a DIE.
19279 This emits location attributes suitable for whole variables and
19280 whole parameters. Note that the location attributes for struct fields are
19281 generated by the routine `data_member_location_attribute' below. */
19284 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
19285 dw_loc_list_ref descr
)
19287 bool check_no_locviews
= true;
19290 if (single_element_loc_list_p (descr
))
19291 add_AT_loc (die
, attr_kind
, descr
->expr
);
19294 add_AT_loc_list (die
, attr_kind
, descr
);
19295 gcc_assert (descr
->ll_symbol
);
19296 if (attr_kind
== DW_AT_location
&& descr
->vl_symbol
19297 && dwarf2out_locviews_in_attribute ())
19299 add_AT_view_list (die
, DW_AT_GNU_locviews
);
19300 check_no_locviews
= false;
19304 if (check_no_locviews
)
19305 gcc_assert (!get_AT (die
, DW_AT_GNU_locviews
));
19308 /* Add DW_AT_accessibility attribute to DIE if needed. */
19311 add_accessibility_attribute (dw_die_ref die
, tree decl
)
19313 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
19314 children, otherwise the default is DW_ACCESS_public. In DWARF2
19315 the default has always been DW_ACCESS_public. */
19316 if (TREE_PROTECTED (decl
))
19317 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
19318 else if (TREE_PRIVATE (decl
))
19320 if (dwarf_version
== 2
19321 || die
->die_parent
== NULL
19322 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
19323 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
19325 else if (dwarf_version
> 2
19327 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
19328 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
19331 /* Attach the specialized form of location attribute used for data members of
19332 struct and union types. In the special case of a FIELD_DECL node which
19333 represents a bit-field, the "offset" part of this special location
19334 descriptor must indicate the distance in bytes from the lowest-addressed
19335 byte of the containing struct or union type to the lowest-addressed byte of
19336 the "containing object" for the bit-field. (See the `field_byte_offset'
19339 For any given bit-field, the "containing object" is a hypothetical object
19340 (of some integral or enum type) within which the given bit-field lives. The
19341 type of this hypothetical "containing object" is always the same as the
19342 declared type of the individual bit-field itself (for GCC anyway... the
19343 DWARF spec doesn't actually mandate this). Note that it is the size (in
19344 bytes) of the hypothetical "containing object" which will be given in the
19345 DW_AT_byte_size attribute for this bit-field. (See the
19346 `byte_size_attribute' function below.) It is also used when calculating the
19347 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
19350 CTX is required: see the comment for VLR_CONTEXT. */
19353 add_data_member_location_attribute (dw_die_ref die
,
19355 struct vlr_context
*ctx
)
19357 HOST_WIDE_INT offset
;
19358 dw_loc_descr_ref loc_descr
= 0;
19360 if (TREE_CODE (decl
) == TREE_BINFO
)
19362 /* We're working on the TAG_inheritance for a base class. */
19363 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
19365 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
19366 aren't at a fixed offset from all (sub)objects of the same
19367 type. We need to extract the appropriate offset from our
19368 vtable. The following dwarf expression means
19370 BaseAddr = ObAddr + *((*ObAddr) - Offset)
19372 This is specific to the V3 ABI, of course. */
19374 dw_loc_descr_ref tmp
;
19376 /* Make a copy of the object address. */
19377 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
19378 add_loc_descr (&loc_descr
, tmp
);
19380 /* Extract the vtable address. */
19381 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
19382 add_loc_descr (&loc_descr
, tmp
);
19384 /* Calculate the address of the offset. */
19385 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
19386 gcc_assert (offset
< 0);
19388 tmp
= int_loc_descriptor (-offset
);
19389 add_loc_descr (&loc_descr
, tmp
);
19390 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
19391 add_loc_descr (&loc_descr
, tmp
);
19393 /* Extract the offset. */
19394 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
19395 add_loc_descr (&loc_descr
, tmp
);
19397 /* Add it to the object address. */
19398 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
19399 add_loc_descr (&loc_descr
, tmp
);
19402 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
19406 loc_descr
= field_byte_offset (decl
, ctx
, &offset
);
19408 /* If loc_descr is available then we know the field offset is dynamic.
19409 However, GDB does not handle dynamic field offsets very well at the
19411 if (loc_descr
!= NULL
&& gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
)
19417 /* Data member location evalutation starts with the base address on the
19418 stack. Compute the field offset and add it to this base address. */
19419 else if (loc_descr
!= NULL
)
19420 add_loc_descr (&loc_descr
, new_loc_descr (DW_OP_plus
, 0, 0));
19425 /* While DW_AT_data_bit_offset has been added already in DWARF4,
19426 e.g. GDB only added support to it in November 2016. For DWARF5
19427 we need newer debug info consumers anyway. We might change this
19428 to dwarf_version >= 4 once most consumers catched up. */
19429 if (dwarf_version
>= 5
19430 && TREE_CODE (decl
) == FIELD_DECL
19431 && DECL_BIT_FIELD_TYPE (decl
))
19433 tree off
= bit_position (decl
);
19434 if (tree_fits_uhwi_p (off
) && get_AT (die
, DW_AT_bit_size
))
19436 remove_AT (die
, DW_AT_byte_size
);
19437 remove_AT (die
, DW_AT_bit_offset
);
19438 add_AT_unsigned (die
, DW_AT_data_bit_offset
, tree_to_uhwi (off
));
19442 if (dwarf_version
> 2)
19444 /* Don't need to output a location expression, just the constant. */
19446 add_AT_int (die
, DW_AT_data_member_location
, offset
);
19448 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
19453 enum dwarf_location_atom op
;
19455 /* The DWARF2 standard says that we should assume that the structure
19456 address is already on the stack, so we can specify a structure
19457 field address by using DW_OP_plus_uconst. */
19458 op
= DW_OP_plus_uconst
;
19459 loc_descr
= new_loc_descr (op
, offset
, 0);
19463 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
19466 /* Writes integer values to dw_vec_const array. */
19469 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
19473 *dest
++ = val
& 0xff;
19479 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
19481 static HOST_WIDE_INT
19482 extract_int (const unsigned char *src
, unsigned int size
)
19484 HOST_WIDE_INT val
= 0;
19490 val
|= *--src
& 0xff;
19496 /* Writes wide_int values to dw_vec_const array. */
19499 insert_wide_int (const wide_int
&val
, unsigned char *dest
, int elt_size
)
19503 if (elt_size
<= HOST_BITS_PER_WIDE_INT
/BITS_PER_UNIT
)
19505 insert_int ((HOST_WIDE_INT
) val
.elt (0), elt_size
, dest
);
19509 /* We'd have to extend this code to support odd sizes. */
19510 gcc_assert (elt_size
% (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
) == 0);
19512 int n
= elt_size
/ (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
19514 if (WORDS_BIG_ENDIAN
)
19515 for (i
= n
- 1; i
>= 0; i
--)
19517 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
19518 dest
+= sizeof (HOST_WIDE_INT
);
19521 for (i
= 0; i
< n
; i
++)
19523 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
19524 dest
+= sizeof (HOST_WIDE_INT
);
19528 /* Writes floating point values to dw_vec_const array. */
19531 insert_float (const_rtx rtl
, unsigned char *array
)
19535 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
19537 real_to_target (val
, CONST_DOUBLE_REAL_VALUE (rtl
), mode
);
19539 /* real_to_target puts 32-bit pieces in each long. Pack them. */
19540 for (i
= 0; i
< GET_MODE_SIZE (mode
) / 4; i
++)
19542 insert_int (val
[i
], 4, array
);
19547 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
19548 does not have a "location" either in memory or in a register. These
19549 things can arise in GNU C when a constant is passed as an actual parameter
19550 to an inlined function. They can also arise in C++ where declared
19551 constants do not necessarily get memory "homes". */
19554 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
19556 switch (GET_CODE (rtl
))
19560 HOST_WIDE_INT val
= INTVAL (rtl
);
19563 add_AT_int (die
, DW_AT_const_value
, val
);
19565 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
19569 case CONST_WIDE_INT
:
19571 wide_int w1
= rtx_mode_t (rtl
, MAX_MODE_INT
);
19572 unsigned int prec
= MIN (wi::min_precision (w1
, UNSIGNED
),
19573 (unsigned int)CONST_WIDE_INT_NUNITS (rtl
) * HOST_BITS_PER_WIDE_INT
);
19574 wide_int w
= wi::zext (w1
, prec
);
19575 add_AT_wide (die
, DW_AT_const_value
, w
);
19580 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
19581 floating-point constant. A CONST_DOUBLE is used whenever the
19582 constant requires more than one word in order to be adequately
19584 if (TARGET_SUPPORTS_WIDE_INT
== 0
19585 && !SCALAR_FLOAT_MODE_P (GET_MODE (rtl
)))
19586 add_AT_double (die
, DW_AT_const_value
,
19587 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
19590 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
19591 unsigned int length
= GET_MODE_SIZE (mode
);
19592 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
19594 insert_float (rtl
, array
);
19595 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
19601 unsigned int length
;
19602 if (!CONST_VECTOR_NUNITS (rtl
).is_constant (&length
))
19605 machine_mode mode
= GET_MODE (rtl
);
19606 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
19607 unsigned char *array
19608 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
19611 machine_mode imode
= GET_MODE_INNER (mode
);
19613 switch (GET_MODE_CLASS (mode
))
19615 case MODE_VECTOR_INT
:
19616 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
19618 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
19619 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
19623 case MODE_VECTOR_FLOAT
:
19624 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
19626 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
19627 insert_float (elt
, p
);
19632 gcc_unreachable ();
19635 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
19640 if (dwarf_version
>= 4 || !dwarf_strict
)
19642 dw_loc_descr_ref loc_result
;
19643 resolve_one_addr (&rtl
);
19645 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
19646 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
19647 add_AT_loc (die
, DW_AT_location
, loc_result
);
19648 vec_safe_push (used_rtx_array
, rtl
);
19654 if (CONSTANT_P (XEXP (rtl
, 0)))
19655 return add_const_value_attribute (die
, XEXP (rtl
, 0));
19658 if (!const_ok_for_output (rtl
))
19662 if (dwarf_version
>= 4 || !dwarf_strict
)
19667 /* In cases where an inlined instance of an inline function is passed
19668 the address of an `auto' variable (which is local to the caller) we
19669 can get a situation where the DECL_RTL of the artificial local
19670 variable (for the inlining) which acts as a stand-in for the
19671 corresponding formal parameter (of the inline function) will look
19672 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
19673 exactly a compile-time constant expression, but it isn't the address
19674 of the (artificial) local variable either. Rather, it represents the
19675 *value* which the artificial local variable always has during its
19676 lifetime. We currently have no way to represent such quasi-constant
19677 values in Dwarf, so for now we just punt and generate nothing. */
19688 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
19689 && MEM_READONLY_P (rtl
)
19690 && GET_MODE (rtl
) == BLKmode
)
19692 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
19698 /* No other kinds of rtx should be possible here. */
19699 gcc_unreachable ();
19704 /* Determine whether the evaluation of EXPR references any variables
19705 or functions which aren't otherwise used (and therefore may not be
19708 reference_to_unused (tree
* tp
, int * walk_subtrees
,
19709 void * data ATTRIBUTE_UNUSED
)
19711 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
19712 *walk_subtrees
= 0;
19714 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
19715 && ! TREE_ASM_WRITTEN (*tp
))
19717 /* ??? The C++ FE emits debug information for using decls, so
19718 putting gcc_unreachable here falls over. See PR31899. For now
19719 be conservative. */
19720 else if (!symtab
->global_info_ready
&& VAR_OR_FUNCTION_DECL_P (*tp
))
19722 else if (VAR_P (*tp
))
19724 varpool_node
*node
= varpool_node::get (*tp
);
19725 if (!node
|| !node
->definition
)
19728 else if (TREE_CODE (*tp
) == FUNCTION_DECL
19729 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
19731 /* The call graph machinery must have finished analyzing,
19732 optimizing and gimplifying the CU by now.
19733 So if *TP has no call graph node associated
19734 to it, it means *TP will not be emitted. */
19735 if (!cgraph_node::get (*tp
))
19738 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
19744 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
19745 for use in a later add_const_value_attribute call. */
19748 rtl_for_decl_init (tree init
, tree type
)
19750 rtx rtl
= NULL_RTX
;
19754 /* If a variable is initialized with a string constant without embedded
19755 zeros, build CONST_STRING. */
19756 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
19758 tree enttype
= TREE_TYPE (type
);
19759 tree domain
= TYPE_DOMAIN (type
);
19760 scalar_int_mode mode
;
19762 if (is_int_mode (TYPE_MODE (enttype
), &mode
)
19763 && GET_MODE_SIZE (mode
) == 1
19765 && TYPE_MAX_VALUE (domain
)
19766 && TREE_CODE (TYPE_MAX_VALUE (domain
)) == INTEGER_CST
19767 && integer_zerop (TYPE_MIN_VALUE (domain
))
19768 && compare_tree_int (TYPE_MAX_VALUE (domain
),
19769 TREE_STRING_LENGTH (init
) - 1) == 0
19770 && ((size_t) TREE_STRING_LENGTH (init
)
19771 == strlen (TREE_STRING_POINTER (init
)) + 1))
19773 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
19774 ggc_strdup (TREE_STRING_POINTER (init
)));
19775 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
19776 MEM_READONLY_P (rtl
) = 1;
19779 /* Other aggregates, and complex values, could be represented using
19781 else if (AGGREGATE_TYPE_P (type
)
19782 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
19783 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
19784 || TREE_CODE (type
) == COMPLEX_TYPE
)
19786 /* Vectors only work if their mode is supported by the target.
19787 FIXME: generic vectors ought to work too. */
19788 else if (TREE_CODE (type
) == VECTOR_TYPE
19789 && !VECTOR_MODE_P (TYPE_MODE (type
)))
19791 /* If the initializer is something that we know will expand into an
19792 immediate RTL constant, expand it now. We must be careful not to
19793 reference variables which won't be output. */
19794 else if (initializer_constant_valid_p (init
, type
)
19795 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
19797 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
19799 if (TREE_CODE (type
) == VECTOR_TYPE
)
19800 switch (TREE_CODE (init
))
19805 if (TREE_CONSTANT (init
))
19807 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
19808 bool constant_p
= true;
19810 unsigned HOST_WIDE_INT ix
;
19812 /* Even when ctor is constant, it might contain non-*_CST
19813 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
19814 belong into VECTOR_CST nodes. */
19815 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
19816 if (!CONSTANT_CLASS_P (value
))
19818 constant_p
= false;
19824 init
= build_vector_from_ctor (type
, elts
);
19834 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
19836 /* If expand_expr returns a MEM, it wasn't immediate. */
19837 gcc_assert (!rtl
|| !MEM_P (rtl
));
19843 /* Generate RTL for the variable DECL to represent its location. */
19846 rtl_for_decl_location (tree decl
)
19850 /* Here we have to decide where we are going to say the parameter "lives"
19851 (as far as the debugger is concerned). We only have a couple of
19852 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
19854 DECL_RTL normally indicates where the parameter lives during most of the
19855 activation of the function. If optimization is enabled however, this
19856 could be either NULL or else a pseudo-reg. Both of those cases indicate
19857 that the parameter doesn't really live anywhere (as far as the code
19858 generation parts of GCC are concerned) during most of the function's
19859 activation. That will happen (for example) if the parameter is never
19860 referenced within the function.
19862 We could just generate a location descriptor here for all non-NULL
19863 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
19864 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
19865 where DECL_RTL is NULL or is a pseudo-reg.
19867 Note however that we can only get away with using DECL_INCOMING_RTL as
19868 a backup substitute for DECL_RTL in certain limited cases. In cases
19869 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
19870 we can be sure that the parameter was passed using the same type as it is
19871 declared to have within the function, and that its DECL_INCOMING_RTL
19872 points us to a place where a value of that type is passed.
19874 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
19875 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
19876 because in these cases DECL_INCOMING_RTL points us to a value of some
19877 type which is *different* from the type of the parameter itself. Thus,
19878 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
19879 such cases, the debugger would end up (for example) trying to fetch a
19880 `float' from a place which actually contains the first part of a
19881 `double'. That would lead to really incorrect and confusing
19882 output at debug-time.
19884 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
19885 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
19886 are a couple of exceptions however. On little-endian machines we can
19887 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
19888 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
19889 an integral type that is smaller than TREE_TYPE (decl). These cases arise
19890 when (on a little-endian machine) a non-prototyped function has a
19891 parameter declared to be of type `short' or `char'. In such cases,
19892 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
19893 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
19894 passed `int' value. If the debugger then uses that address to fetch
19895 a `short' or a `char' (on a little-endian machine) the result will be
19896 the correct data, so we allow for such exceptional cases below.
19898 Note that our goal here is to describe the place where the given formal
19899 parameter lives during most of the function's activation (i.e. between the
19900 end of the prologue and the start of the epilogue). We'll do that as best
19901 as we can. Note however that if the given formal parameter is modified
19902 sometime during the execution of the function, then a stack backtrace (at
19903 debug-time) will show the function as having been called with the *new*
19904 value rather than the value which was originally passed in. This happens
19905 rarely enough that it is not a major problem, but it *is* a problem, and
19906 I'd like to fix it.
19908 A future version of dwarf2out.c may generate two additional attributes for
19909 any given DW_TAG_formal_parameter DIE which will describe the "passed
19910 type" and the "passed location" for the given formal parameter in addition
19911 to the attributes we now generate to indicate the "declared type" and the
19912 "active location" for each parameter. This additional set of attributes
19913 could be used by debuggers for stack backtraces. Separately, note that
19914 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
19915 This happens (for example) for inlined-instances of inline function formal
19916 parameters which are never referenced. This really shouldn't be
19917 happening. All PARM_DECL nodes should get valid non-NULL
19918 DECL_INCOMING_RTL values. FIXME. */
19920 /* Use DECL_RTL as the "location" unless we find something better. */
19921 rtl
= DECL_RTL_IF_SET (decl
);
19923 /* When generating abstract instances, ignore everything except
19924 constants, symbols living in memory, and symbols living in
19925 fixed registers. */
19926 if (! reload_completed
)
19929 && (CONSTANT_P (rtl
)
19931 && CONSTANT_P (XEXP (rtl
, 0)))
19934 && TREE_STATIC (decl
))))
19936 rtl
= targetm
.delegitimize_address (rtl
);
19941 else if (TREE_CODE (decl
) == PARM_DECL
)
19943 if (rtl
== NULL_RTX
19944 || is_pseudo_reg (rtl
)
19946 && is_pseudo_reg (XEXP (rtl
, 0))
19947 && DECL_INCOMING_RTL (decl
)
19948 && MEM_P (DECL_INCOMING_RTL (decl
))
19949 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
19951 tree declared_type
= TREE_TYPE (decl
);
19952 tree passed_type
= DECL_ARG_TYPE (decl
);
19953 machine_mode dmode
= TYPE_MODE (declared_type
);
19954 machine_mode pmode
= TYPE_MODE (passed_type
);
19956 /* This decl represents a formal parameter which was optimized out.
19957 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
19958 all cases where (rtl == NULL_RTX) just below. */
19959 if (dmode
== pmode
)
19960 rtl
= DECL_INCOMING_RTL (decl
);
19961 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
19962 && SCALAR_INT_MODE_P (dmode
)
19963 && known_le (GET_MODE_SIZE (dmode
), GET_MODE_SIZE (pmode
))
19964 && DECL_INCOMING_RTL (decl
))
19966 rtx inc
= DECL_INCOMING_RTL (decl
);
19969 else if (MEM_P (inc
))
19971 if (BYTES_BIG_ENDIAN
)
19972 rtl
= adjust_address_nv (inc
, dmode
,
19973 GET_MODE_SIZE (pmode
)
19974 - GET_MODE_SIZE (dmode
));
19981 /* If the parm was passed in registers, but lives on the stack, then
19982 make a big endian correction if the mode of the type of the
19983 parameter is not the same as the mode of the rtl. */
19984 /* ??? This is the same series of checks that are made in dbxout.c before
19985 we reach the big endian correction code there. It isn't clear if all
19986 of these checks are necessary here, but keeping them all is the safe
19988 else if (MEM_P (rtl
)
19989 && XEXP (rtl
, 0) != const0_rtx
19990 && ! CONSTANT_P (XEXP (rtl
, 0))
19991 /* Not passed in memory. */
19992 && !MEM_P (DECL_INCOMING_RTL (decl
))
19993 /* Not passed by invisible reference. */
19994 && (!REG_P (XEXP (rtl
, 0))
19995 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
19996 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
19997 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
19998 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
20001 /* Big endian correction check. */
20002 && BYTES_BIG_ENDIAN
20003 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
20004 && known_lt (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))),
20007 machine_mode addr_mode
= get_address_mode (rtl
);
20008 poly_int64 offset
= (UNITS_PER_WORD
20009 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
20011 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
20012 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
20015 else if (VAR_P (decl
)
20018 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
)))
20020 machine_mode addr_mode
= get_address_mode (rtl
);
20021 poly_int64 offset
= byte_lowpart_offset (TYPE_MODE (TREE_TYPE (decl
)),
20024 /* If a variable is declared "register" yet is smaller than
20025 a register, then if we store the variable to memory, it
20026 looks like we're storing a register-sized value, when in
20027 fact we are not. We need to adjust the offset of the
20028 storage location to reflect the actual value's bytes,
20029 else gdb will not be able to display it. */
20030 if (maybe_ne (offset
, 0))
20031 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
20032 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
20035 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
20036 and will have been substituted directly into all expressions that use it.
20037 C does not have such a concept, but C++ and other languages do. */
20038 if (!rtl
&& VAR_P (decl
) && DECL_INITIAL (decl
))
20039 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
20042 rtl
= targetm
.delegitimize_address (rtl
);
20044 /* If we don't look past the constant pool, we risk emitting a
20045 reference to a constant pool entry that isn't referenced from
20046 code, and thus is not emitted. */
20048 rtl
= avoid_constant_pool_reference (rtl
);
20050 /* Try harder to get a rtl. If this symbol ends up not being emitted
20051 in the current CU, resolve_addr will remove the expression referencing
20053 if (rtl
== NULL_RTX
20054 && !(early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
20056 && !DECL_EXTERNAL (decl
)
20057 && TREE_STATIC (decl
)
20058 && DECL_NAME (decl
)
20059 && !DECL_HARD_REGISTER (decl
)
20060 && DECL_MODE (decl
) != VOIDmode
)
20062 rtl
= make_decl_rtl_for_debug (decl
);
20064 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
20065 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
20072 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
20073 returned. If so, the decl for the COMMON block is returned, and the
20074 value is the offset into the common block for the symbol. */
20077 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
20079 tree val_expr
, cvar
;
20081 poly_int64 bitsize
, bitpos
;
20083 HOST_WIDE_INT cbitpos
;
20084 int unsignedp
, reversep
, volatilep
= 0;
20086 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
20087 it does not have a value (the offset into the common area), or if it
20088 is thread local (as opposed to global) then it isn't common, and shouldn't
20089 be handled as such. */
20091 || !TREE_STATIC (decl
)
20092 || !DECL_HAS_VALUE_EXPR_P (decl
)
20096 val_expr
= DECL_VALUE_EXPR (decl
);
20097 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
20100 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
, &mode
,
20101 &unsignedp
, &reversep
, &volatilep
);
20103 if (cvar
== NULL_TREE
20105 || DECL_ARTIFICIAL (cvar
)
20106 || !TREE_PUBLIC (cvar
)
20107 /* We don't expect to have to cope with variable offsets,
20108 since at present all static data must have a constant size. */
20109 || !bitpos
.is_constant (&cbitpos
))
20113 if (offset
!= NULL
)
20115 if (!tree_fits_shwi_p (offset
))
20117 *value
= tree_to_shwi (offset
);
20120 *value
+= cbitpos
/ BITS_PER_UNIT
;
20125 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
20126 data attribute for a variable or a parameter. We generate the
20127 DW_AT_const_value attribute only in those cases where the given variable
20128 or parameter does not have a true "location" either in memory or in a
20129 register. This can happen (for example) when a constant is passed as an
20130 actual argument in a call to an inline function. (It's possible that
20131 these things can crop up in other ways also.) Note that one type of
20132 constant value which can be passed into an inlined function is a constant
20133 pointer. This can happen for example if an actual argument in an inlined
20134 function call evaluates to a compile-time constant address.
20136 CACHE_P is true if it is worth caching the location list for DECL,
20137 so that future calls can reuse it rather than regenerate it from scratch.
20138 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
20139 since we will need to refer to them each time the function is inlined. */
20142 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
)
20145 dw_loc_list_ref list
;
20146 var_loc_list
*loc_list
;
20147 cached_dw_loc_list
*cache
;
20152 if (TREE_CODE (decl
) == ERROR_MARK
)
20155 if (get_AT (die
, DW_AT_location
)
20156 || get_AT (die
, DW_AT_const_value
))
20159 gcc_assert (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
20160 || TREE_CODE (decl
) == RESULT_DECL
);
20162 /* Try to get some constant RTL for this decl, and use that as the value of
20165 rtl
= rtl_for_decl_location (decl
);
20166 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
20167 && add_const_value_attribute (die
, rtl
))
20170 /* See if we have single element location list that is equivalent to
20171 a constant value. That way we are better to use add_const_value_attribute
20172 rather than expanding constant value equivalent. */
20173 loc_list
= lookup_decl_loc (decl
);
20176 && loc_list
->first
->next
== NULL
20177 && NOTE_P (loc_list
->first
->loc
)
20178 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
20179 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
20181 struct var_loc_node
*node
;
20183 node
= loc_list
->first
;
20184 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
20185 if (GET_CODE (rtl
) == EXPR_LIST
)
20186 rtl
= XEXP (rtl
, 0);
20187 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
20188 && add_const_value_attribute (die
, rtl
))
20191 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
20192 list several times. See if we've already cached the contents. */
20194 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
20198 cache
= cached_dw_loc_list_table
->find_with_hash (decl
, DECL_UID (decl
));
20200 list
= cache
->loc_list
;
20204 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2,
20206 /* It is usually worth caching this result if the decl is from
20207 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
20208 if (cache_p
&& list
&& list
->dw_loc_next
)
20210 cached_dw_loc_list
**slot
20211 = cached_dw_loc_list_table
->find_slot_with_hash (decl
,
20214 cache
= ggc_cleared_alloc
<cached_dw_loc_list
> ();
20215 cache
->decl_id
= DECL_UID (decl
);
20216 cache
->loc_list
= list
;
20222 add_AT_location_description (die
, DW_AT_location
, list
);
20225 /* None of that worked, so it must not really have a location;
20226 try adding a constant value attribute from the DECL_INITIAL. */
20227 return tree_add_const_value_attribute_for_decl (die
, decl
);
20230 /* Helper function for tree_add_const_value_attribute. Natively encode
20231 initializer INIT into an array. Return true if successful. */
20234 native_encode_initializer (tree init
, unsigned char *array
, int size
)
20238 if (init
== NULL_TREE
)
20242 switch (TREE_CODE (init
))
20245 type
= TREE_TYPE (init
);
20246 if (TREE_CODE (type
) == ARRAY_TYPE
)
20248 tree enttype
= TREE_TYPE (type
);
20249 scalar_int_mode mode
;
20251 if (!is_int_mode (TYPE_MODE (enttype
), &mode
)
20252 || GET_MODE_SIZE (mode
) != 1)
20254 if (int_size_in_bytes (type
) != size
)
20256 if (size
> TREE_STRING_LENGTH (init
))
20258 memcpy (array
, TREE_STRING_POINTER (init
),
20259 TREE_STRING_LENGTH (init
));
20260 memset (array
+ TREE_STRING_LENGTH (init
),
20261 '\0', size
- TREE_STRING_LENGTH (init
));
20264 memcpy (array
, TREE_STRING_POINTER (init
), size
);
20269 type
= TREE_TYPE (init
);
20270 if (int_size_in_bytes (type
) != size
)
20272 if (TREE_CODE (type
) == ARRAY_TYPE
)
20274 HOST_WIDE_INT min_index
;
20275 unsigned HOST_WIDE_INT cnt
;
20276 int curpos
= 0, fieldsize
;
20277 constructor_elt
*ce
;
20279 if (TYPE_DOMAIN (type
) == NULL_TREE
20280 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
20283 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
20284 if (fieldsize
<= 0)
20287 min_index
= tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)));
20288 memset (array
, '\0', size
);
20289 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
20291 tree val
= ce
->value
;
20292 tree index
= ce
->index
;
20294 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
20295 pos
= (tree_to_shwi (TREE_OPERAND (index
, 0)) - min_index
)
20298 pos
= (tree_to_shwi (index
) - min_index
) * fieldsize
;
20303 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
20306 curpos
= pos
+ fieldsize
;
20307 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
20309 int count
= tree_to_shwi (TREE_OPERAND (index
, 1))
20310 - tree_to_shwi (TREE_OPERAND (index
, 0));
20311 while (count
-- > 0)
20314 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
20315 curpos
+= fieldsize
;
20318 gcc_assert (curpos
<= size
);
20322 else if (TREE_CODE (type
) == RECORD_TYPE
20323 || TREE_CODE (type
) == UNION_TYPE
)
20325 tree field
= NULL_TREE
;
20326 unsigned HOST_WIDE_INT cnt
;
20327 constructor_elt
*ce
;
20329 if (int_size_in_bytes (type
) != size
)
20332 if (TREE_CODE (type
) == RECORD_TYPE
)
20333 field
= TYPE_FIELDS (type
);
20335 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
20337 tree val
= ce
->value
;
20338 int pos
, fieldsize
;
20340 if (ce
->index
!= 0)
20346 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
20349 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
20350 && TYPE_DOMAIN (TREE_TYPE (field
))
20351 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
20353 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
20354 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field
)))
20356 fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
20357 pos
= int_byte_position (field
);
20358 gcc_assert (pos
+ fieldsize
<= size
);
20359 if (val
&& fieldsize
!= 0
20360 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
20366 case VIEW_CONVERT_EXPR
:
20367 case NON_LVALUE_EXPR
:
20368 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
20370 return native_encode_expr (init
, array
, size
) == size
;
20374 /* Attach a DW_AT_const_value attribute to DIE. The value of the
20375 attribute is the const value T. */
20378 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
20381 tree type
= TREE_TYPE (t
);
20384 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
20388 gcc_assert (!DECL_P (init
));
20390 if (TREE_CODE (init
) == INTEGER_CST
)
20392 if (tree_fits_uhwi_p (init
))
20394 add_AT_unsigned (die
, DW_AT_const_value
, tree_to_uhwi (init
));
20397 if (tree_fits_shwi_p (init
))
20399 add_AT_int (die
, DW_AT_const_value
, tree_to_shwi (init
));
20405 rtl
= rtl_for_decl_init (init
, type
);
20407 return add_const_value_attribute (die
, rtl
);
20409 /* If the host and target are sane, try harder. */
20410 if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
20411 && initializer_constant_valid_p (init
, type
))
20413 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
20414 if (size
> 0 && (int) size
== size
)
20416 unsigned char *array
= ggc_cleared_vec_alloc
<unsigned char> (size
);
20418 if (native_encode_initializer (init
, array
, size
))
20420 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
20429 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
20430 attribute is the const value of T, where T is an integral constant
20431 variable with static storage duration
20432 (so it can't be a PARM_DECL or a RESULT_DECL). */
20435 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
20439 || (!VAR_P (decl
) && TREE_CODE (decl
) != CONST_DECL
)
20440 || (VAR_P (decl
) && !TREE_STATIC (decl
)))
20443 if (TREE_READONLY (decl
)
20444 && ! TREE_THIS_VOLATILE (decl
)
20445 && DECL_INITIAL (decl
))
20450 /* Don't add DW_AT_const_value if abstract origin already has one. */
20451 if (get_AT (var_die
, DW_AT_const_value
))
20454 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
20457 /* Convert the CFI instructions for the current function into a
20458 location list. This is used for DW_AT_frame_base when we targeting
20459 a dwarf2 consumer that does not support the dwarf3
20460 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
20463 static dw_loc_list_ref
20464 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
20468 dw_loc_list_ref list
, *list_tail
;
20470 dw_cfa_location last_cfa
, next_cfa
;
20471 const char *start_label
, *last_label
, *section
;
20472 dw_cfa_location remember
;
20475 gcc_assert (fde
!= NULL
);
20477 section
= secname_for_decl (current_function_decl
);
20481 memset (&next_cfa
, 0, sizeof (next_cfa
));
20482 next_cfa
.reg
= INVALID_REGNUM
;
20483 remember
= next_cfa
;
20485 start_label
= fde
->dw_fde_begin
;
20487 /* ??? Bald assumption that the CIE opcode list does not contain
20488 advance opcodes. */
20489 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
20490 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
20492 last_cfa
= next_cfa
;
20493 last_label
= start_label
;
20495 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
20497 /* If the first partition contained no CFI adjustments, the
20498 CIE opcodes apply to the whole first partition. */
20499 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20500 fde
->dw_fde_begin
, 0, fde
->dw_fde_end
, 0, section
);
20501 list_tail
=&(*list_tail
)->dw_loc_next
;
20502 start_label
= last_label
= fde
->dw_fde_second_begin
;
20505 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
20507 switch (cfi
->dw_cfi_opc
)
20509 case DW_CFA_set_loc
:
20510 case DW_CFA_advance_loc1
:
20511 case DW_CFA_advance_loc2
:
20512 case DW_CFA_advance_loc4
:
20513 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
20515 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20516 start_label
, 0, last_label
, 0, section
);
20518 list_tail
= &(*list_tail
)->dw_loc_next
;
20519 last_cfa
= next_cfa
;
20520 start_label
= last_label
;
20522 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
20525 case DW_CFA_advance_loc
:
20526 /* The encoding is complex enough that we should never emit this. */
20527 gcc_unreachable ();
20530 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
20533 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
20535 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
20537 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20538 start_label
, 0, last_label
, 0, section
);
20540 list_tail
= &(*list_tail
)->dw_loc_next
;
20541 last_cfa
= next_cfa
;
20542 start_label
= last_label
;
20544 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20545 start_label
, 0, fde
->dw_fde_end
, 0, section
);
20546 list_tail
= &(*list_tail
)->dw_loc_next
;
20547 start_label
= last_label
= fde
->dw_fde_second_begin
;
20551 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
20553 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
20554 start_label
, 0, last_label
, 0, section
);
20555 list_tail
= &(*list_tail
)->dw_loc_next
;
20556 start_label
= last_label
;
20559 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
20561 fde
->dw_fde_second_begin
20562 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
, 0,
20565 maybe_gen_llsym (list
);
20570 /* Compute a displacement from the "steady-state frame pointer" to the
20571 frame base (often the same as the CFA), and store it in
20572 frame_pointer_fb_offset. OFFSET is added to the displacement
20573 before the latter is negated. */
20576 compute_frame_pointer_to_fb_displacement (poly_int64 offset
)
20580 #ifdef FRAME_POINTER_CFA_OFFSET
20581 reg
= frame_pointer_rtx
;
20582 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
20584 reg
= arg_pointer_rtx
;
20585 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
20588 elim
= (ira_use_lra_p
20589 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
20590 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
20591 elim
= strip_offset_and_add (elim
, &offset
);
20593 frame_pointer_fb_offset
= -offset
;
20595 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
20596 in which to eliminate. This is because it's stack pointer isn't
20597 directly accessible as a register within the ISA. To work around
20598 this, assume that while we cannot provide a proper value for
20599 frame_pointer_fb_offset, we won't need one either. We can use
20600 hard frame pointer in debug info even if frame pointer isn't used
20601 since hard frame pointer in debug info is encoded with DW_OP_fbreg
20602 which uses the DW_AT_frame_base attribute, not hard frame pointer
20604 frame_pointer_fb_offset_valid
20605 = (elim
== hard_frame_pointer_rtx
|| elim
== stack_pointer_rtx
);
20608 /* Generate a DW_AT_name attribute given some string value to be included as
20609 the value of the attribute. */
20612 add_name_attribute (dw_die_ref die
, const char *name_string
)
20614 if (name_string
!= NULL
&& *name_string
!= 0)
20616 if (demangle_name_func
)
20617 name_string
= (*demangle_name_func
) (name_string
);
20619 add_AT_string (die
, DW_AT_name
, name_string
);
20623 /* Generate a DW_AT_description attribute given some string value to be included
20624 as the value of the attribute. */
20627 add_desc_attribute (dw_die_ref die
, const char *name_string
)
20629 if (!flag_describe_dies
|| (dwarf_version
< 3 && dwarf_strict
))
20632 if (name_string
== NULL
|| *name_string
== 0)
20635 if (demangle_name_func
)
20636 name_string
= (*demangle_name_func
) (name_string
);
20638 add_AT_string (die
, DW_AT_description
, name_string
);
20641 /* Generate a DW_AT_description attribute given some decl to be included
20642 as the value of the attribute. */
20645 add_desc_attribute (dw_die_ref die
, tree decl
)
20649 if (!flag_describe_dies
|| (dwarf_version
< 3 && dwarf_strict
))
20652 if (decl
== NULL_TREE
|| !DECL_P (decl
))
20654 decl_name
= DECL_NAME (decl
);
20656 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
20658 const char *name
= dwarf2_name (decl
, 0);
20659 add_desc_attribute (die
, name
? name
: IDENTIFIER_POINTER (decl_name
));
20663 char *desc
= print_generic_expr_to_str (decl
);
20664 add_desc_attribute (die
, desc
);
20669 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
20670 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
20671 of TYPE accordingly.
20673 ??? This is a temporary measure until after we're able to generate
20674 regular DWARF for the complex Ada type system. */
20677 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
20678 dw_die_ref context_die
)
20681 dw_die_ref dtype_die
;
20683 if (!lang_hooks
.types
.descriptive_type
)
20686 dtype
= lang_hooks
.types
.descriptive_type (type
);
20690 dtype_die
= lookup_type_die (dtype
);
20693 gen_type_die (dtype
, context_die
);
20694 dtype_die
= lookup_type_die (dtype
);
20695 gcc_assert (dtype_die
);
20698 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
20701 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
20703 static const char *
20704 comp_dir_string (void)
20707 char *wd_plus_sep
= NULL
;
20708 static const char *cached_wd
= NULL
;
20710 if (cached_wd
!= NULL
)
20713 wd
= get_src_pwd ();
20717 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
20719 size_t wdlen
= strlen (wd
);
20720 wd_plus_sep
= XNEWVEC (char, wdlen
+ 2);
20721 strcpy (wd_plus_sep
, wd
);
20722 wd_plus_sep
[wdlen
] = DIR_SEPARATOR
;
20723 wd_plus_sep
[wdlen
+ 1] = 0;
20727 cached_wd
= remap_debug_filename (wd
);
20729 /* remap_debug_filename can just pass through wd or return a new gc string.
20730 These two types can't be both stored in a GTY(())-tagged string, but since
20731 the cached value lives forever just copy it if needed. */
20732 if (cached_wd
!= wd
)
20734 cached_wd
= xstrdup (cached_wd
);
20735 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
&& wd_plus_sep
!= NULL
)
20736 free (wd_plus_sep
);
20742 /* Generate a DW_AT_comp_dir attribute for DIE. */
20745 add_comp_dir_attribute (dw_die_ref die
)
20747 const char * wd
= comp_dir_string ();
20749 add_AT_string (die
, DW_AT_comp_dir
, wd
);
20752 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
20753 pointer computation, ...), output a representation for that bound according
20754 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
20755 loc_list_from_tree for the meaning of CONTEXT. */
20758 add_scalar_info (dw_die_ref die
, enum dwarf_attribute attr
, tree value
,
20759 int forms
, struct loc_descr_context
*context
)
20761 dw_die_ref context_die
, decl_die
= NULL
;
20762 dw_loc_list_ref list
;
20763 bool strip_conversions
= true;
20764 bool placeholder_seen
= false;
20766 while (strip_conversions
)
20767 switch (TREE_CODE (value
))
20774 case VIEW_CONVERT_EXPR
:
20775 value
= TREE_OPERAND (value
, 0);
20779 strip_conversions
= false;
20783 /* If possible and permitted, output the attribute as a constant. */
20784 if ((forms
& dw_scalar_form_constant
) != 0
20785 && TREE_CODE (value
) == INTEGER_CST
)
20787 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (value
));
20789 /* If HOST_WIDE_INT is big enough then represent the bound as
20790 a constant value. We need to choose a form based on
20791 whether the type is signed or unsigned. We cannot just
20792 call add_AT_unsigned if the value itself is positive
20793 (add_AT_unsigned might add the unsigned value encoded as
20794 DW_FORM_data[1248]). Some DWARF consumers will lookup the
20795 bounds type and then sign extend any unsigned values found
20796 for signed types. This is needed only for
20797 DW_AT_{lower,upper}_bound, since for most other attributes,
20798 consumers will treat DW_FORM_data[1248] as unsigned values,
20799 regardless of the underlying type. */
20800 if (prec
<= HOST_BITS_PER_WIDE_INT
20801 || tree_fits_uhwi_p (value
))
20803 if (TYPE_UNSIGNED (TREE_TYPE (value
)))
20804 add_AT_unsigned (die
, attr
, TREE_INT_CST_LOW (value
));
20806 add_AT_int (die
, attr
, TREE_INT_CST_LOW (value
));
20809 /* Otherwise represent the bound as an unsigned value with
20810 the precision of its type. The precision and signedness
20811 of the type will be necessary to re-interpret it
20813 add_AT_wide (die
, attr
, wi::to_wide (value
));
20817 /* Otherwise, if it's possible and permitted too, output a reference to
20819 if ((forms
& dw_scalar_form_reference
) != 0)
20821 tree decl
= NULL_TREE
;
20823 /* Some type attributes reference an outer type. For instance, the upper
20824 bound of an array may reference an embedding record (this happens in
20826 if (TREE_CODE (value
) == COMPONENT_REF
20827 && TREE_CODE (TREE_OPERAND (value
, 0)) == PLACEHOLDER_EXPR
20828 && TREE_CODE (TREE_OPERAND (value
, 1)) == FIELD_DECL
)
20829 decl
= TREE_OPERAND (value
, 1);
20831 else if (VAR_P (value
)
20832 || TREE_CODE (value
) == PARM_DECL
20833 || TREE_CODE (value
) == RESULT_DECL
)
20836 if (decl
!= NULL_TREE
)
20838 decl_die
= lookup_decl_die (decl
);
20840 /* ??? Can this happen, or should the variable have been bound
20841 first? Probably it can, since I imagine that we try to create
20842 the types of parameters in the order in which they exist in
20843 the list, and won't have created a forward reference to a
20844 later parameter. */
20845 if (decl_die
!= NULL
)
20847 if (get_AT (decl_die
, DW_AT_location
)
20848 || get_AT (decl_die
, DW_AT_data_member_location
)
20849 || get_AT (decl_die
, DW_AT_const_value
))
20851 add_AT_die_ref (die
, attr
, decl_die
);
20858 /* Last chance: try to create a stack operation procedure to evaluate the
20859 value. Do nothing if even that is not possible or permitted. */
20860 if ((forms
& dw_scalar_form_exprloc
) == 0)
20863 list
= loc_list_from_tree (value
, 2, context
);
20864 if (context
&& context
->placeholder_arg
)
20866 placeholder_seen
= context
->placeholder_seen
;
20867 context
->placeholder_seen
= false;
20869 if (list
== NULL
|| single_element_loc_list_p (list
))
20871 /* If this attribute is not a reference nor constant, it is
20872 a DWARF expression rather than location description. For that
20873 loc_list_from_tree (value, 0, &context) is needed. */
20874 dw_loc_list_ref list2
= loc_list_from_tree (value
, 0, context
);
20875 if (list2
&& single_element_loc_list_p (list2
))
20877 if (placeholder_seen
)
20879 struct dwarf_procedure_info dpi
;
20880 dpi
.fndecl
= NULL_TREE
;
20881 dpi
.args_count
= 1;
20882 if (!resolve_args_picking (list2
->expr
, 1, &dpi
))
20885 add_AT_loc (die
, attr
, list2
->expr
);
20890 /* If that failed to give a single element location list, fall back to
20891 outputting this as a reference... still if permitted. */
20893 || (forms
& dw_scalar_form_reference
) == 0
20894 || placeholder_seen
)
20899 if (current_function_decl
== 0)
20900 context_die
= comp_unit_die ();
20902 context_die
= lookup_decl_die (current_function_decl
);
20904 decl_die
= new_die (DW_TAG_variable
, context_die
, value
);
20905 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
20906 add_type_attribute (decl_die
, TREE_TYPE (value
), TYPE_QUAL_CONST
, false,
20910 add_AT_location_description (decl_die
, DW_AT_location
, list
);
20911 add_AT_die_ref (die
, attr
, decl_die
);
20914 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
20918 lower_bound_default (void)
20920 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
20926 case DW_LANG_C_plus_plus
:
20927 case DW_LANG_C_plus_plus_11
:
20928 case DW_LANG_C_plus_plus_14
:
20930 case DW_LANG_ObjC_plus_plus
:
20932 case DW_LANG_Fortran77
:
20933 case DW_LANG_Fortran90
:
20934 case DW_LANG_Fortran95
:
20935 case DW_LANG_Fortran03
:
20936 case DW_LANG_Fortran08
:
20940 case DW_LANG_Python
:
20941 return dwarf_version
>= 4 ? 0 : -1;
20942 case DW_LANG_Ada95
:
20943 case DW_LANG_Ada83
:
20944 case DW_LANG_Cobol74
:
20945 case DW_LANG_Cobol85
:
20946 case DW_LANG_Modula2
:
20948 return dwarf_version
>= 4 ? 1 : -1;
20954 /* Given a tree node describing an array bound (either lower or upper) output
20955 a representation for that bound. */
20958 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
,
20959 tree bound
, struct loc_descr_context
*context
)
20964 switch (TREE_CODE (bound
))
20966 /* Strip all conversions. */
20968 case VIEW_CONVERT_EXPR
:
20969 bound
= TREE_OPERAND (bound
, 0);
20972 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
20973 are even omitted when they are the default. */
20975 /* If the value for this bound is the default one, we can even omit the
20977 if (bound_attr
== DW_AT_lower_bound
20978 && tree_fits_shwi_p (bound
)
20979 && (dflt
= lower_bound_default ()) != -1
20980 && tree_to_shwi (bound
) == dflt
)
20986 /* Because of the complex interaction there can be with other GNAT
20987 encodings, GDB isn't ready yet to handle proper DWARF description
20988 for self-referencial subrange bounds: let GNAT encodings do the
20989 magic in such a case. */
20991 && gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
20992 && contains_placeholder_p (bound
))
20995 add_scalar_info (subrange_die
, bound_attr
, bound
,
20996 dw_scalar_form_constant
20997 | dw_scalar_form_exprloc
20998 | dw_scalar_form_reference
,
21004 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
21005 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
21006 Note that the block of subscript information for an array type also
21007 includes information about the element type of the given array type.
21009 This function reuses previously set type and bound information if
21013 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
21015 unsigned dimension_number
;
21017 dw_die_ref child
= type_die
->die_child
;
21019 for (dimension_number
= 0;
21020 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
21021 type
= TREE_TYPE (type
), dimension_number
++)
21023 tree domain
= TYPE_DOMAIN (type
);
21025 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
21028 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
21029 and (in GNU C only) variable bounds. Handle all three forms
21032 /* Find and reuse a previously generated DW_TAG_subrange_type if
21035 For multi-dimensional arrays, as we iterate through the
21036 various dimensions in the enclosing for loop above, we also
21037 iterate through the DIE children and pick at each
21038 DW_TAG_subrange_type previously generated (if available).
21039 Each child DW_TAG_subrange_type DIE describes the range of
21040 the current dimension. At this point we should have as many
21041 DW_TAG_subrange_type's as we have dimensions in the
21043 dw_die_ref subrange_die
= NULL
;
21047 child
= child
->die_sib
;
21048 if (child
->die_tag
== DW_TAG_subrange_type
)
21049 subrange_die
= child
;
21050 if (child
== type_die
->die_child
)
21052 /* If we wrapped around, stop looking next time. */
21056 if (child
->die_tag
== DW_TAG_subrange_type
)
21060 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
21064 /* We have an array type with specified bounds. */
21065 lower
= TYPE_MIN_VALUE (domain
);
21066 upper
= TYPE_MAX_VALUE (domain
);
21068 /* Define the index type. */
21069 if (TREE_TYPE (domain
)
21070 && !get_AT (subrange_die
, DW_AT_type
))
21072 /* ??? This is probably an Ada unnamed subrange type. Ignore the
21073 TREE_TYPE field. We can't emit debug info for this
21074 because it is an unnamed integral type. */
21075 if (TREE_CODE (domain
) == INTEGER_TYPE
21076 && TYPE_NAME (domain
) == NULL_TREE
21077 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
21078 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
21081 add_type_attribute (subrange_die
, TREE_TYPE (domain
),
21082 TYPE_UNQUALIFIED
, false, type_die
);
21085 /* ??? If upper is NULL, the array has unspecified length,
21086 but it does have a lower bound. This happens with Fortran
21088 Since the debugger is definitely going to need to know N
21089 to produce useful results, go ahead and output the lower
21090 bound solo, and hope the debugger can cope. */
21092 if (!get_AT (subrange_die
, DW_AT_lower_bound
))
21093 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
, NULL
);
21094 if (!get_AT (subrange_die
, DW_AT_upper_bound
)
21095 && !get_AT (subrange_die
, DW_AT_count
))
21098 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
, NULL
);
21099 else if ((is_c () || is_cxx ()) && COMPLETE_TYPE_P (type
))
21100 /* Zero-length array. */
21101 add_bound_info (subrange_die
, DW_AT_count
,
21102 build_int_cst (TREE_TYPE (lower
), 0), NULL
);
21106 /* Otherwise we have an array type with an unspecified length. The
21107 DWARF-2 spec does not say how to handle this; let's just leave out the
21112 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
21115 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
21117 dw_die_ref decl_die
;
21118 HOST_WIDE_INT size
;
21119 dw_loc_descr_ref size_expr
= NULL
;
21121 switch (TREE_CODE (tree_node
))
21126 case ENUMERAL_TYPE
:
21129 case QUAL_UNION_TYPE
:
21130 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
21131 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
21133 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
21136 size_expr
= type_byte_size (tree_node
, &size
);
21139 /* For a data member of a struct or union, the DW_AT_byte_size is
21140 generally given as the number of bytes normally allocated for an
21141 object of the *declared* type of the member itself. This is true
21142 even for bit-fields. */
21143 size
= int_size_in_bytes (field_type (tree_node
));
21146 gcc_unreachable ();
21149 /* Support for dynamically-sized objects was introduced by DWARFv3.
21150 At the moment, GDB does not handle variable byte sizes very well,
21152 if ((dwarf_version
>= 3 || !dwarf_strict
)
21153 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
21154 && size_expr
!= NULL
)
21155 add_AT_loc (die
, DW_AT_byte_size
, size_expr
);
21157 /* Note that `size' might be -1 when we get to this point. If it is, that
21158 indicates that the byte size of the entity in question is variable and
21159 that we could not generate a DWARF expression that computes it. */
21161 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
21164 /* Add a DW_AT_alignment attribute to DIE with TREE_NODE's non-default
21168 add_alignment_attribute (dw_die_ref die
, tree tree_node
)
21170 if (dwarf_version
< 5 && dwarf_strict
)
21175 if (DECL_P (tree_node
))
21177 if (!DECL_USER_ALIGN (tree_node
))
21180 align
= DECL_ALIGN_UNIT (tree_node
);
21182 else if (TYPE_P (tree_node
))
21184 if (!TYPE_USER_ALIGN (tree_node
))
21187 align
= TYPE_ALIGN_UNIT (tree_node
);
21190 gcc_unreachable ();
21192 add_AT_unsigned (die
, DW_AT_alignment
, align
);
21195 /* For a FIELD_DECL node which represents a bit-field, output an attribute
21196 which specifies the distance in bits from the highest order bit of the
21197 "containing object" for the bit-field to the highest order bit of the
21200 For any given bit-field, the "containing object" is a hypothetical object
21201 (of some integral or enum type) within which the given bit-field lives. The
21202 type of this hypothetical "containing object" is always the same as the
21203 declared type of the individual bit-field itself. The determination of the
21204 exact location of the "containing object" for a bit-field is rather
21205 complicated. It's handled by the `field_byte_offset' function (above).
21207 CTX is required: see the comment for VLR_CONTEXT.
21209 Note that it is the size (in bytes) of the hypothetical "containing object"
21210 which will be given in the DW_AT_byte_size attribute for this bit-field.
21211 (See `byte_size_attribute' above). */
21214 add_bit_offset_attribute (dw_die_ref die
, tree decl
, struct vlr_context
*ctx
)
21216 HOST_WIDE_INT object_offset_in_bytes
;
21217 tree original_type
= DECL_BIT_FIELD_TYPE (decl
);
21218 HOST_WIDE_INT bitpos_int
;
21219 HOST_WIDE_INT highest_order_object_bit_offset
;
21220 HOST_WIDE_INT highest_order_field_bit_offset
;
21221 HOST_WIDE_INT bit_offset
;
21223 field_byte_offset (decl
, ctx
, &object_offset_in_bytes
);
21225 /* Must be a field and a bit field. */
21226 gcc_assert (original_type
&& TREE_CODE (decl
) == FIELD_DECL
);
21228 /* We can't yet handle bit-fields whose offsets are variable, so if we
21229 encounter such things, just return without generating any attribute
21230 whatsoever. Likewise for variable or too large size. */
21231 if (! tree_fits_shwi_p (bit_position (decl
))
21232 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
21235 bitpos_int
= int_bit_position (decl
);
21237 /* Note that the bit offset is always the distance (in bits) from the
21238 highest-order bit of the "containing object" to the highest-order bit of
21239 the bit-field itself. Since the "high-order end" of any object or field
21240 is different on big-endian and little-endian machines, the computation
21241 below must take account of these differences. */
21242 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
21243 highest_order_field_bit_offset
= bitpos_int
;
21245 if (! BYTES_BIG_ENDIAN
)
21247 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
21248 highest_order_object_bit_offset
+=
21249 simple_type_size_in_bits (original_type
);
21253 = (! BYTES_BIG_ENDIAN
21254 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
21255 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
21257 if (bit_offset
< 0)
21258 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
21260 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
21263 /* For a FIELD_DECL node which represents a bit field, output an attribute
21264 which specifies the length in bits of the given field. */
21267 add_bit_size_attribute (dw_die_ref die
, tree decl
)
21269 /* Must be a field and a bit field. */
21270 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
21271 && DECL_BIT_FIELD_TYPE (decl
));
21273 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
21274 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
21277 /* If the compiled language is ANSI C, then add a 'prototyped'
21278 attribute, if arg types are given for the parameters of a function. */
21281 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
21283 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
21290 if (prototype_p (func_type
))
21291 add_AT_flag (die
, DW_AT_prototyped
, 1);
21298 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
21299 by looking in the type declaration, the object declaration equate table or
21300 the block mapping. */
21303 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
21305 dw_die_ref origin_die
= NULL
;
21307 /* For late LTO debug output we want to refer directly to the abstract
21308 DIE in the early debug rather to the possibly existing concrete
21309 instance and avoid creating that just for this purpose. */
21310 sym_off_pair
*desc
;
21312 && external_die_map
21313 && (desc
= external_die_map
->get (origin
)))
21315 add_AT_external_die_ref (die
, DW_AT_abstract_origin
,
21316 desc
->sym
, desc
->off
);
21320 if (DECL_P (origin
))
21321 origin_die
= lookup_decl_die (origin
);
21322 else if (TYPE_P (origin
))
21323 origin_die
= lookup_type_die (origin
);
21324 else if (TREE_CODE (origin
) == BLOCK
)
21325 origin_die
= lookup_block_die (origin
);
21327 /* XXX: Functions that are never lowered don't always have correct block
21328 trees (in the case of java, they simply have no block tree, in some other
21329 languages). For these functions, there is nothing we can really do to
21330 output correct debug info for inlined functions in all cases. Rather
21331 than die, we'll just produce deficient debug info now, in that we will
21332 have variables without a proper abstract origin. In the future, when all
21333 functions are lowered, we should re-add a gcc_assert (origin_die)
21337 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
21340 /* We do not currently support the pure_virtual attribute. */
21343 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
21345 if (DECL_VINDEX (func_decl
))
21347 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
21349 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
21350 add_AT_loc (die
, DW_AT_vtable_elem_location
,
21351 new_loc_descr (DW_OP_constu
,
21352 tree_to_shwi (DECL_VINDEX (func_decl
)),
21355 /* GNU extension: Record what type this method came from originally. */
21356 if (debug_info_level
> DINFO_LEVEL_TERSE
21357 && DECL_CONTEXT (func_decl
))
21358 add_AT_die_ref (die
, DW_AT_containing_type
,
21359 lookup_type_die (DECL_CONTEXT (func_decl
)));
21363 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
21364 given decl. This used to be a vendor extension until after DWARF 4
21365 standardized it. */
21368 add_linkage_attr (dw_die_ref die
, tree decl
)
21370 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
21372 /* Mimic what assemble_name_raw does with a leading '*'. */
21373 if (name
[0] == '*')
21376 if (dwarf_version
>= 4)
21377 add_AT_string (die
, DW_AT_linkage_name
, name
);
21379 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
21382 /* Add source coordinate attributes for the given decl. */
21385 add_src_coords_attributes (dw_die_ref die
, tree decl
)
21387 expanded_location s
;
21389 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
21391 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
21392 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
21393 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
21394 if (debug_column_info
&& s
.column
)
21395 add_AT_unsigned (die
, DW_AT_decl_column
, s
.column
);
21398 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
21401 add_linkage_name_raw (dw_die_ref die
, tree decl
)
21403 /* Defer until we have an assembler name set. */
21404 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
21406 limbo_die_node
*asm_name
;
21408 asm_name
= ggc_cleared_alloc
<limbo_die_node
> ();
21409 asm_name
->die
= die
;
21410 asm_name
->created_for
= decl
;
21411 asm_name
->next
= deferred_asm_name
;
21412 deferred_asm_name
= asm_name
;
21414 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
21415 add_linkage_attr (die
, decl
);
21418 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl if desired. */
21421 add_linkage_name (dw_die_ref die
, tree decl
)
21423 if (debug_info_level
> DINFO_LEVEL_NONE
21424 && VAR_OR_FUNCTION_DECL_P (decl
)
21425 && TREE_PUBLIC (decl
)
21426 && !(VAR_P (decl
) && DECL_REGISTER (decl
))
21427 && die
->die_tag
!= DW_TAG_member
)
21428 add_linkage_name_raw (die
, decl
);
21431 /* Add a DW_AT_name attribute and source coordinate attribute for the
21432 given decl, but only if it actually has a name. */
21435 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
,
21436 bool no_linkage_name
)
21440 decl_name
= DECL_NAME (decl
);
21441 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
21443 const char *name
= dwarf2_name (decl
, 0);
21445 add_name_attribute (die
, name
);
21447 add_desc_attribute (die
, decl
);
21449 if (! DECL_ARTIFICIAL (decl
))
21450 add_src_coords_attributes (die
, decl
);
21452 if (!no_linkage_name
)
21453 add_linkage_name (die
, decl
);
21456 add_desc_attribute (die
, decl
);
21458 #ifdef VMS_DEBUGGING_INFO
21459 /* Get the function's name, as described by its RTL. This may be different
21460 from the DECL_NAME name used in the source file. */
21461 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
21463 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
21464 XEXP (DECL_RTL (decl
), 0), false);
21465 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
21467 #endif /* VMS_DEBUGGING_INFO */
21470 /* Add VALUE as a DW_AT_discr_value attribute to DIE. */
21473 add_discr_value (dw_die_ref die
, dw_discr_value
*value
)
21477 attr
.dw_attr
= DW_AT_discr_value
;
21478 attr
.dw_attr_val
.val_class
= dw_val_class_discr_value
;
21479 attr
.dw_attr_val
.val_entry
= NULL
;
21480 attr
.dw_attr_val
.v
.val_discr_value
.pos
= value
->pos
;
21482 attr
.dw_attr_val
.v
.val_discr_value
.v
.uval
= value
->v
.uval
;
21484 attr
.dw_attr_val
.v
.val_discr_value
.v
.sval
= value
->v
.sval
;
21485 add_dwarf_attr (die
, &attr
);
21488 /* Add DISCR_LIST as a DW_AT_discr_list to DIE. */
21491 add_discr_list (dw_die_ref die
, dw_discr_list_ref discr_list
)
21495 attr
.dw_attr
= DW_AT_discr_list
;
21496 attr
.dw_attr_val
.val_class
= dw_val_class_discr_list
;
21497 attr
.dw_attr_val
.val_entry
= NULL
;
21498 attr
.dw_attr_val
.v
.val_discr_list
= discr_list
;
21499 add_dwarf_attr (die
, &attr
);
21502 static inline dw_discr_list_ref
21503 AT_discr_list (dw_attr_node
*attr
)
21505 return attr
->dw_attr_val
.v
.val_discr_list
;
21508 #ifdef VMS_DEBUGGING_INFO
21509 /* Output the debug main pointer die for VMS */
21512 dwarf2out_vms_debug_main_pointer (void)
21514 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
21517 /* Allocate the VMS debug main subprogram die. */
21518 die
= new_die_raw (DW_TAG_subprogram
);
21519 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
21520 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
21521 current_function_funcdef_no
);
21522 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
21524 /* Make it the first child of comp_unit_die (). */
21525 die
->die_parent
= comp_unit_die ();
21526 if (comp_unit_die ()->die_child
)
21528 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
21529 comp_unit_die ()->die_child
->die_sib
= die
;
21533 die
->die_sib
= die
;
21534 comp_unit_die ()->die_child
= die
;
21537 #endif /* VMS_DEBUGGING_INFO */
21539 /* walk_tree helper function for uses_local_type, below. */
21542 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
21545 *walk_subtrees
= 0;
21548 tree name
= TYPE_NAME (*tp
);
21549 if (name
&& DECL_P (name
) && decl_function_context (name
))
21555 /* If TYPE involves a function-local type (including a local typedef to a
21556 non-local type), returns that type; otherwise returns NULL_TREE. */
21559 uses_local_type (tree type
)
21561 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
21565 /* Return the DIE for the scope that immediately contains this type.
21566 Non-named types that do not involve a function-local type get global
21567 scope. Named types nested in namespaces or other types get their
21568 containing scope. All other types (i.e. function-local named types) get
21569 the current active scope. */
21572 scope_die_for (tree t
, dw_die_ref context_die
)
21574 dw_die_ref scope_die
= NULL
;
21575 tree containing_scope
;
21577 /* Non-types always go in the current scope. */
21578 gcc_assert (TYPE_P (t
));
21580 /* Use the scope of the typedef, rather than the scope of the type
21582 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
21583 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
21585 containing_scope
= TYPE_CONTEXT (t
);
21587 /* Use the containing namespace if there is one. */
21588 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
21590 if (context_die
== lookup_decl_die (containing_scope
))
21592 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
21593 context_die
= get_context_die (containing_scope
);
21595 containing_scope
= NULL_TREE
;
21598 /* Ignore function type "scopes" from the C frontend. They mean that
21599 a tagged type is local to a parmlist of a function declarator, but
21600 that isn't useful to DWARF. */
21601 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
21602 containing_scope
= NULL_TREE
;
21604 if (SCOPE_FILE_SCOPE_P (containing_scope
))
21606 /* If T uses a local type keep it local as well, to avoid references
21607 to function-local DIEs from outside the function. */
21608 if (current_function_decl
&& uses_local_type (t
))
21609 scope_die
= context_die
;
21611 scope_die
= comp_unit_die ();
21613 else if (TYPE_P (containing_scope
))
21615 /* For types, we can just look up the appropriate DIE. */
21616 if (debug_info_level
> DINFO_LEVEL_TERSE
)
21617 scope_die
= get_context_die (containing_scope
);
21620 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
21621 if (scope_die
== NULL
)
21622 scope_die
= comp_unit_die ();
21626 scope_die
= context_die
;
21631 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
21634 local_scope_p (dw_die_ref context_die
)
21636 for (; context_die
; context_die
= context_die
->die_parent
)
21637 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
21638 || context_die
->die_tag
== DW_TAG_subprogram
)
21644 /* Returns nonzero if CONTEXT_DIE is a class. */
21647 class_scope_p (dw_die_ref context_die
)
21649 return (context_die
21650 && (context_die
->die_tag
== DW_TAG_structure_type
21651 || context_die
->die_tag
== DW_TAG_class_type
21652 || context_die
->die_tag
== DW_TAG_interface_type
21653 || context_die
->die_tag
== DW_TAG_union_type
));
21656 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
21657 whether or not to treat a DIE in this context as a declaration. */
21660 class_or_namespace_scope_p (dw_die_ref context_die
)
21662 return (class_scope_p (context_die
)
21663 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
21666 /* Many forms of DIEs require a "type description" attribute. This
21667 routine locates the proper "type descriptor" die for the type given
21668 by 'type' plus any additional qualifiers given by 'cv_quals', and
21669 adds a DW_AT_type attribute below the given die. */
21672 add_type_attribute (dw_die_ref object_die
, tree type
, int cv_quals
,
21673 bool reverse
, dw_die_ref context_die
)
21675 enum tree_code code
= TREE_CODE (type
);
21676 dw_die_ref type_die
= NULL
;
21678 /* ??? If this type is an unnamed subrange type of an integral, floating-point
21679 or fixed-point type, use the inner type. This is because we have no
21680 support for unnamed types in base_type_die. This can happen if this is
21681 an Ada subrange type. Correct solution is emit a subrange type die. */
21682 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
21683 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
21684 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
21686 if (code
== ERROR_MARK
21687 /* Handle a special case. For functions whose return type is void, we
21688 generate *no* type attribute. (Note that no object may have type
21689 `void', so this only applies to function return types). */
21690 || code
== VOID_TYPE
)
21693 type_die
= modified_type_die (type
,
21694 cv_quals
| TYPE_QUALS (type
),
21698 if (type_die
!= NULL
)
21699 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
21702 /* Given an object die, add the calling convention attribute for the
21703 function call type. */
21705 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
21707 enum dwarf_calling_convention value
= DW_CC_normal
;
21709 value
= ((enum dwarf_calling_convention
)
21710 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
21713 && id_equal (DECL_ASSEMBLER_NAME (decl
), "MAIN__"))
21715 /* DWARF 2 doesn't provide a way to identify a program's source-level
21716 entry point. DW_AT_calling_convention attributes are only meant
21717 to describe functions' calling conventions. However, lacking a
21718 better way to signal the Fortran main program, we used this for
21719 a long time, following existing custom. Now, DWARF 4 has
21720 DW_AT_main_subprogram, which we add below, but some tools still
21721 rely on the old way, which we thus keep. */
21722 value
= DW_CC_program
;
21724 if (dwarf_version
>= 4 || !dwarf_strict
)
21725 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
21728 /* Only add the attribute if the backend requests it, and
21729 is not DW_CC_normal. */
21730 if (value
&& (value
!= DW_CC_normal
))
21731 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
21734 /* Given a tree pointer to a struct, class, union, or enum type node, return
21735 a pointer to the (string) tag name for the given type, or zero if the type
21736 was declared without a tag. */
21738 static const char *
21739 type_tag (const_tree type
)
21741 const char *name
= 0;
21743 if (TYPE_NAME (type
) != 0)
21747 /* Find the IDENTIFIER_NODE for the type name. */
21748 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
21749 && !TYPE_NAMELESS (type
))
21750 t
= TYPE_NAME (type
);
21752 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
21753 a TYPE_DECL node, regardless of whether or not a `typedef' was
21755 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
21756 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
21758 /* We want to be extra verbose. Don't call dwarf_name if
21759 DECL_NAME isn't set. The default hook for decl_printable_name
21760 doesn't like that, and in this context it's correct to return
21761 0, instead of "<anonymous>" or the like. */
21762 if (DECL_NAME (TYPE_NAME (type
))
21763 && !DECL_NAMELESS (TYPE_NAME (type
)))
21764 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
21767 /* Now get the name as a string, or invent one. */
21768 if (!name
&& t
!= 0)
21769 name
= IDENTIFIER_POINTER (t
);
21772 return (name
== 0 || *name
== '\0') ? 0 : name
;
21775 /* Return the type associated with a data member, make a special check
21776 for bit field types. */
21779 member_declared_type (const_tree member
)
21781 return (DECL_BIT_FIELD_TYPE (member
)
21782 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
21785 /* Get the decl's label, as described by its RTL. This may be different
21786 from the DECL_NAME name used in the source file. */
21789 static const char *
21790 decl_start_label (tree decl
)
21793 const char *fnname
;
21795 x
= DECL_RTL (decl
);
21796 gcc_assert (MEM_P (x
));
21799 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
21801 fnname
= XSTR (x
, 0);
21806 /* For variable-length arrays that have been previously generated, but
21807 may be incomplete due to missing subscript info, fill the subscript
21808 info. Return TRUE if this is one of those cases. */
21810 fill_variable_array_bounds (tree type
)
21812 if (TREE_ASM_WRITTEN (type
)
21813 && TREE_CODE (type
) == ARRAY_TYPE
21814 && variably_modified_type_p (type
, NULL
))
21816 dw_die_ref array_die
= lookup_type_die (type
);
21819 add_subscript_info (array_die
, type
, !is_ada ());
21825 /* These routines generate the internal representation of the DIE's for
21826 the compilation unit. Debugging information is collected by walking
21827 the declaration trees passed in from dwarf2out_decl(). */
21830 gen_array_type_die (tree type
, dw_die_ref context_die
)
21832 dw_die_ref array_die
;
21834 /* GNU compilers represent multidimensional array types as sequences of one
21835 dimensional array types whose element types are themselves array types.
21836 We sometimes squish that down to a single array_type DIE with multiple
21837 subscripts in the Dwarf debugging info. The draft Dwarf specification
21838 say that we are allowed to do this kind of compression in C, because
21839 there is no difference between an array of arrays and a multidimensional
21840 array. We don't do this for Ada to remain as close as possible to the
21841 actual representation, which is especially important against the language
21842 flexibilty wrt arrays of variable size. */
21844 bool collapse_nested_arrays
= !is_ada ();
21846 if (fill_variable_array_bounds (type
))
21849 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
21852 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
21853 DW_TAG_string_type doesn't have DW_AT_type attribute). */
21854 if (TREE_CODE (type
) == ARRAY_TYPE
21855 && TYPE_STRING_FLAG (type
)
21857 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
21859 HOST_WIDE_INT size
;
21861 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
21862 add_name_attribute (array_die
, type_tag (type
));
21863 equate_type_number_to_die (type
, array_die
);
21864 size
= int_size_in_bytes (type
);
21866 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
21867 /* ??? We can't annotate types late, but for LTO we may not
21868 generate a location early either (gfortran.dg/save_6.f90). */
21869 else if (! (early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
21870 && TYPE_DOMAIN (type
) != NULL_TREE
21871 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
)
21873 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
21874 tree rszdecl
= szdecl
;
21876 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
21877 if (!DECL_P (szdecl
))
21879 if (TREE_CODE (szdecl
) == INDIRECT_REF
21880 && DECL_P (TREE_OPERAND (szdecl
, 0)))
21882 rszdecl
= TREE_OPERAND (szdecl
, 0);
21883 if (int_size_in_bytes (TREE_TYPE (rszdecl
))
21884 != DWARF2_ADDR_SIZE
)
21892 dw_loc_list_ref loc
21893 = loc_list_from_tree (rszdecl
, szdecl
== rszdecl
? 2 : 0,
21897 add_AT_location_description (array_die
, DW_AT_string_length
,
21899 if (size
!= DWARF2_ADDR_SIZE
)
21900 add_AT_unsigned (array_die
, dwarf_version
>= 5
21901 ? DW_AT_string_length_byte_size
21902 : DW_AT_byte_size
, size
);
21909 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
21910 add_name_attribute (array_die
, type_tag (type
));
21911 equate_type_number_to_die (type
, array_die
);
21913 if (TREE_CODE (type
) == VECTOR_TYPE
)
21914 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
21916 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
21918 && TREE_CODE (type
) == ARRAY_TYPE
21919 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
21920 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
21921 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
21924 /* We default the array ordering. Debuggers will probably do the right
21925 things even if DW_AT_ordering is not present. It's not even an issue
21926 until we start to get into multidimensional arrays anyway. If a debugger
21927 is ever caught doing the Wrong Thing for multi-dimensional arrays,
21928 then we'll have to put the DW_AT_ordering attribute back in. (But if
21929 and when we find out that we need to put these in, we will only do so
21930 for multidimensional arrays. */
21931 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
21934 if (TREE_CODE (type
) == VECTOR_TYPE
)
21936 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
21937 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
21938 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
, NULL
);
21939 add_bound_info (subrange_die
, DW_AT_upper_bound
,
21940 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1), NULL
);
21943 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
21945 /* Add representation of the type of the elements of this array type and
21946 emit the corresponding DIE if we haven't done it already. */
21947 element_type
= TREE_TYPE (type
);
21948 if (collapse_nested_arrays
)
21949 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
21951 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
21953 element_type
= TREE_TYPE (element_type
);
21956 add_type_attribute (array_die
, element_type
, TYPE_UNQUALIFIED
,
21957 TREE_CODE (type
) == ARRAY_TYPE
21958 && TYPE_REVERSE_STORAGE_ORDER (type
),
21961 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
21962 if (TYPE_ARTIFICIAL (type
))
21963 add_AT_flag (array_die
, DW_AT_artificial
, 1);
21965 if (get_AT (array_die
, DW_AT_name
))
21966 add_pubtype (type
, array_die
);
21968 add_alignment_attribute (array_die
, type
);
21971 /* This routine generates DIE for array with hidden descriptor, details
21972 are filled into *info by a langhook. */
21975 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
21976 dw_die_ref context_die
)
21978 const dw_die_ref scope_die
= scope_die_for (type
, context_die
);
21979 const dw_die_ref array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
21980 struct loc_descr_context context
= { type
, info
->base_decl
, NULL
,
21982 enum dwarf_tag subrange_tag
= DW_TAG_subrange_type
;
21985 add_name_attribute (array_die
, type_tag (type
));
21986 equate_type_number_to_die (type
, array_die
);
21988 if (info
->ndimensions
> 1)
21989 switch (info
->ordering
)
21991 case array_descr_ordering_row_major
:
21992 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
21994 case array_descr_ordering_column_major
:
21995 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
22001 if (dwarf_version
>= 3 || !dwarf_strict
)
22003 if (info
->data_location
)
22004 add_scalar_info (array_die
, DW_AT_data_location
, info
->data_location
,
22005 dw_scalar_form_exprloc
, &context
);
22006 if (info
->associated
)
22007 add_scalar_info (array_die
, DW_AT_associated
, info
->associated
,
22008 dw_scalar_form_constant
22009 | dw_scalar_form_exprloc
22010 | dw_scalar_form_reference
, &context
);
22011 if (info
->allocated
)
22012 add_scalar_info (array_die
, DW_AT_allocated
, info
->allocated
,
22013 dw_scalar_form_constant
22014 | dw_scalar_form_exprloc
22015 | dw_scalar_form_reference
, &context
);
22018 const enum dwarf_attribute attr
22019 = (info
->stride_in_bits
) ? DW_AT_bit_stride
: DW_AT_byte_stride
;
22021 = (info
->stride_in_bits
)
22022 ? dw_scalar_form_constant
22023 : (dw_scalar_form_constant
22024 | dw_scalar_form_exprloc
22025 | dw_scalar_form_reference
);
22027 add_scalar_info (array_die
, attr
, info
->stride
, forms
, &context
);
22030 if (dwarf_version
>= 5)
22034 add_scalar_info (array_die
, DW_AT_rank
, info
->rank
,
22035 dw_scalar_form_constant
22036 | dw_scalar_form_exprloc
, &context
);
22037 subrange_tag
= DW_TAG_generic_subrange
;
22038 context
.placeholder_arg
= true;
22042 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
22044 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
22046 dw_die_ref subrange_die
= new_die (subrange_tag
, array_die
, NULL
);
22048 if (info
->dimen
[dim
].bounds_type
)
22049 add_type_attribute (subrange_die
,
22050 info
->dimen
[dim
].bounds_type
, TYPE_UNQUALIFIED
,
22051 false, context_die
);
22052 if (info
->dimen
[dim
].lower_bound
)
22053 add_bound_info (subrange_die
, DW_AT_lower_bound
,
22054 info
->dimen
[dim
].lower_bound
, &context
);
22055 if (info
->dimen
[dim
].upper_bound
)
22056 add_bound_info (subrange_die
, DW_AT_upper_bound
,
22057 info
->dimen
[dim
].upper_bound
, &context
);
22058 if ((dwarf_version
>= 3 || !dwarf_strict
) && info
->dimen
[dim
].stride
)
22059 add_scalar_info (subrange_die
, DW_AT_byte_stride
,
22060 info
->dimen
[dim
].stride
,
22061 dw_scalar_form_constant
22062 | dw_scalar_form_exprloc
22063 | dw_scalar_form_reference
,
22067 gen_type_die (info
->element_type
, context_die
);
22068 add_type_attribute (array_die
, info
->element_type
, TYPE_UNQUALIFIED
,
22069 TREE_CODE (type
) == ARRAY_TYPE
22070 && TYPE_REVERSE_STORAGE_ORDER (type
),
22073 if (get_AT (array_die
, DW_AT_name
))
22074 add_pubtype (type
, array_die
);
22076 add_alignment_attribute (array_die
, type
);
22081 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
22083 tree origin
= decl_ultimate_origin (decl
);
22084 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
22086 if (origin
!= NULL
)
22087 add_abstract_origin_attribute (decl_die
, origin
);
22090 add_name_and_src_coords_attributes (decl_die
, decl
);
22091 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
22092 TYPE_UNQUALIFIED
, false, context_die
);
22095 if (DECL_ABSTRACT_P (decl
))
22096 equate_decl_number_to_die (decl
, decl_die
);
22098 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
22102 /* Walk through the list of incomplete types again, trying once more to
22103 emit full debugging info for them. */
22106 retry_incomplete_types (void)
22111 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
22112 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
22113 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
22114 vec_safe_truncate (incomplete_types
, 0);
22117 /* Determine what tag to use for a record type. */
22119 static enum dwarf_tag
22120 record_type_tag (tree type
)
22122 if (! lang_hooks
.types
.classify_record
)
22123 return DW_TAG_structure_type
;
22125 switch (lang_hooks
.types
.classify_record (type
))
22127 case RECORD_IS_STRUCT
:
22128 return DW_TAG_structure_type
;
22130 case RECORD_IS_CLASS
:
22131 return DW_TAG_class_type
;
22133 case RECORD_IS_INTERFACE
:
22134 if (dwarf_version
>= 3 || !dwarf_strict
)
22135 return DW_TAG_interface_type
;
22136 return DW_TAG_structure_type
;
22139 gcc_unreachable ();
22143 /* Generate a DIE to represent an enumeration type. Note that these DIEs
22144 include all of the information about the enumeration values also. Each
22145 enumerated type name/value is listed as a child of the enumerated type
22149 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
22151 dw_die_ref type_die
= lookup_type_die (type
);
22152 dw_die_ref orig_type_die
= type_die
;
22154 if (type_die
== NULL
)
22156 type_die
= new_die (DW_TAG_enumeration_type
,
22157 scope_die_for (type
, context_die
), type
);
22158 equate_type_number_to_die (type
, type_die
);
22159 add_name_attribute (type_die
, type_tag (type
));
22160 if ((dwarf_version
>= 4 || !dwarf_strict
)
22161 && ENUM_IS_SCOPED (type
))
22162 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
22163 if (ENUM_IS_OPAQUE (type
) && TYPE_SIZE (type
))
22164 add_AT_flag (type_die
, DW_AT_declaration
, 1);
22166 add_AT_unsigned (type_die
, DW_AT_encoding
,
22167 TYPE_UNSIGNED (type
)
22171 else if (! TYPE_SIZE (type
) || ENUM_IS_OPAQUE (type
))
22174 remove_AT (type_die
, DW_AT_declaration
);
22176 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
22177 given enum type is incomplete, do not generate the DW_AT_byte_size
22178 attribute or the DW_AT_element_list attribute. */
22179 if (TYPE_SIZE (type
))
22183 if (!ENUM_IS_OPAQUE (type
))
22184 TREE_ASM_WRITTEN (type
) = 1;
22185 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_byte_size
))
22186 add_byte_size_attribute (type_die
, type
);
22187 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_alignment
))
22188 add_alignment_attribute (type_die
, type
);
22189 if ((dwarf_version
>= 3 || !dwarf_strict
)
22190 && (!orig_type_die
|| !get_AT (type_die
, DW_AT_type
)))
22192 tree underlying
= lang_hooks
.types
.enum_underlying_base_type (type
);
22193 add_type_attribute (type_die
, underlying
, TYPE_UNQUALIFIED
, false,
22196 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
22198 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_decl_file
))
22199 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
22200 if (!orig_type_die
|| !get_AT (type_die
, DW_AT_accessibility
))
22201 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
22204 /* If the first reference to this type was as the return type of an
22205 inline function, then it may not have a parent. Fix this now. */
22206 if (type_die
->die_parent
== NULL
)
22207 add_child_die (scope_die_for (type
, context_die
), type_die
);
22209 for (link
= TYPE_VALUES (type
);
22210 link
!= NULL
; link
= TREE_CHAIN (link
))
22212 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
22213 tree value
= TREE_VALUE (link
);
22215 gcc_assert (!ENUM_IS_OPAQUE (type
));
22216 add_name_attribute (enum_die
,
22217 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
22219 if (TREE_CODE (value
) == CONST_DECL
)
22220 value
= DECL_INITIAL (value
);
22222 if (simple_type_size_in_bits (TREE_TYPE (value
))
22223 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
22225 /* For constant forms created by add_AT_unsigned DWARF
22226 consumers (GDB, elfutils, etc.) always zero extend
22227 the value. Only when the actual value is negative
22228 do we need to use add_AT_int to generate a constant
22229 form that can represent negative values. */
22230 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
22231 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
22232 add_AT_unsigned (enum_die
, DW_AT_const_value
,
22233 (unsigned HOST_WIDE_INT
) val
);
22235 add_AT_int (enum_die
, DW_AT_const_value
, val
);
22238 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
22239 that here. TODO: This should be re-worked to use correct
22240 signed/unsigned double tags for all cases. */
22241 add_AT_wide (enum_die
, DW_AT_const_value
, wi::to_wide (value
));
22244 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
22245 if (TYPE_ARTIFICIAL (type
)
22246 && (!orig_type_die
|| !get_AT (type_die
, DW_AT_artificial
)))
22247 add_AT_flag (type_die
, DW_AT_artificial
, 1);
22250 add_AT_flag (type_die
, DW_AT_declaration
, 1);
22252 add_pubtype (type
, type_die
);
22257 /* Generate a DIE to represent either a real live formal parameter decl or to
22258 represent just the type of some formal parameter position in some function
22261 Note that this routine is a bit unusual because its argument may be a
22262 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
22263 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
22264 node. If it's the former then this function is being called to output a
22265 DIE to represent a formal parameter object (or some inlining thereof). If
22266 it's the latter, then this function is only being called to output a
22267 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
22268 argument type of some subprogram type.
22269 If EMIT_NAME_P is true, name and source coordinate attributes
22273 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
22274 dw_die_ref context_die
)
22276 tree node_or_origin
= node
? node
: origin
;
22277 tree ultimate_origin
;
22278 dw_die_ref parm_die
= NULL
;
22280 if (DECL_P (node_or_origin
))
22282 parm_die
= lookup_decl_die (node
);
22284 /* If the contexts differ, we may not be talking about the same
22286 ??? When in LTO the DIE parent is the "abstract" copy and the
22287 context_die is the specification "copy". But this whole block
22288 should eventually be no longer needed. */
22289 if (parm_die
&& parm_die
->die_parent
!= context_die
&& !in_lto_p
)
22291 if (!DECL_ABSTRACT_P (node
))
22293 /* This can happen when creating an inlined instance, in
22294 which case we need to create a new DIE that will get
22295 annotated with DW_AT_abstract_origin. */
22299 gcc_unreachable ();
22302 if (parm_die
&& parm_die
->die_parent
== NULL
)
22304 /* Check that parm_die already has the right attributes that
22305 we would have added below. If any attributes are
22306 missing, fall through to add them. */
22307 if (! DECL_ABSTRACT_P (node_or_origin
)
22308 && !get_AT (parm_die
, DW_AT_location
)
22309 && !get_AT (parm_die
, DW_AT_const_value
))
22310 /* We are missing location info, and are about to add it. */
22314 add_child_die (context_die
, parm_die
);
22320 /* If we have a previously generated DIE, use it, unless this is an
22321 concrete instance (origin != NULL), in which case we need a new
22322 DIE with a corresponding DW_AT_abstract_origin. */
22324 if (parm_die
&& origin
== NULL
)
22325 reusing_die
= true;
22328 parm_die
= new_die (DW_TAG_formal_parameter
, context_die
, node
);
22329 reusing_die
= false;
22332 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
22334 case tcc_declaration
:
22335 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
22336 if (node
|| ultimate_origin
)
22337 origin
= ultimate_origin
;
22342 if (origin
!= NULL
)
22343 add_abstract_origin_attribute (parm_die
, origin
);
22344 else if (emit_name_p
)
22345 add_name_and_src_coords_attributes (parm_die
, node
);
22347 || (! DECL_ABSTRACT_P (node_or_origin
)
22348 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
22349 decl_function_context
22350 (node_or_origin
))))
22352 tree type
= TREE_TYPE (node_or_origin
);
22353 if (decl_by_reference_p (node_or_origin
))
22354 add_type_attribute (parm_die
, TREE_TYPE (type
),
22356 false, context_die
);
22358 add_type_attribute (parm_die
, type
,
22359 decl_quals (node_or_origin
),
22360 false, context_die
);
22362 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
22363 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22365 if (node
&& node
!= origin
)
22366 equate_decl_number_to_die (node
, parm_die
);
22367 if (! DECL_ABSTRACT_P (node_or_origin
))
22368 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
22374 /* We were called with some kind of a ..._TYPE node. */
22375 add_type_attribute (parm_die
, node_or_origin
, TYPE_UNQUALIFIED
, false,
22380 gcc_unreachable ();
22386 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
22387 children DW_TAG_formal_parameter DIEs representing the arguments of the
22390 PARM_PACK must be a function parameter pack.
22391 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
22392 must point to the subsequent arguments of the function PACK_ARG belongs to.
22393 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
22394 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
22395 following the last one for which a DIE was generated. */
22398 gen_formal_parameter_pack_die (tree parm_pack
,
22400 dw_die_ref subr_die
,
22404 dw_die_ref parm_pack_die
;
22406 gcc_assert (parm_pack
22407 && lang_hooks
.function_parameter_pack_p (parm_pack
)
22410 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
22411 add_src_coords_attributes (parm_pack_die
, parm_pack
);
22413 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
22415 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
22418 gen_formal_parameter_die (arg
, NULL
,
22419 false /* Don't emit name attribute. */,
22424 return parm_pack_die
;
22427 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
22428 at the end of an (ANSI prototyped) formal parameters list. */
22431 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
22433 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
22436 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
22437 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
22438 parameters as specified in some function type specification (except for
22439 those which appear as part of a function *definition*). */
22442 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
22445 tree formal_type
= NULL
;
22446 tree first_parm_type
;
22449 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
22451 arg
= DECL_ARGUMENTS (function_or_method_type
);
22452 function_or_method_type
= TREE_TYPE (function_or_method_type
);
22457 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
22459 /* Make our first pass over the list of formal parameter types and output a
22460 DW_TAG_formal_parameter DIE for each one. */
22461 for (link
= first_parm_type
; link
; )
22463 dw_die_ref parm_die
;
22465 formal_type
= TREE_VALUE (link
);
22466 if (formal_type
== void_type_node
)
22469 /* Output a (nameless) DIE to represent the formal parameter itself. */
22470 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
22471 true /* Emit name attribute. */,
22473 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
22474 && link
== first_parm_type
)
22476 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22477 if (dwarf_version
>= 3 || !dwarf_strict
)
22478 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
22480 else if (arg
&& DECL_ARTIFICIAL (arg
))
22481 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
22483 link
= TREE_CHAIN (link
);
22485 arg
= DECL_CHAIN (arg
);
22488 /* If this function type has an ellipsis, add a
22489 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
22490 if (formal_type
!= void_type_node
)
22491 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
22493 /* Make our second (and final) pass over the list of formal parameter types
22494 and output DIEs to represent those types (as necessary). */
22495 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
22496 link
&& TREE_VALUE (link
);
22497 link
= TREE_CHAIN (link
))
22498 gen_type_die (TREE_VALUE (link
), context_die
);
22501 /* We want to generate the DIE for TYPE so that we can generate the
22502 die for MEMBER, which has been defined; we will need to refer back
22503 to the member declaration nested within TYPE. If we're trying to
22504 generate minimal debug info for TYPE, processing TYPE won't do the
22505 trick; we need to attach the member declaration by hand. */
22508 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
22510 gen_type_die (type
, context_die
);
22512 /* If we're trying to avoid duplicate debug info, we may not have
22513 emitted the member decl for this function. Emit it now. */
22514 if (TYPE_STUB_DECL (type
)
22515 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
22516 && ! lookup_decl_die (member
))
22518 dw_die_ref type_die
;
22519 gcc_assert (!decl_ultimate_origin (member
));
22521 type_die
= lookup_type_die_strip_naming_typedef (type
);
22522 if (TREE_CODE (member
) == FUNCTION_DECL
)
22523 gen_subprogram_die (member
, type_die
);
22524 else if (TREE_CODE (member
) == FIELD_DECL
)
22526 /* Ignore the nameless fields that are used to skip bits but handle
22527 C++ anonymous unions and structs. */
22528 if (DECL_NAME (member
) != NULL_TREE
22529 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
22530 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
22532 struct vlr_context vlr_ctx
= {
22533 DECL_CONTEXT (member
), /* struct_type */
22534 NULL_TREE
/* variant_part_offset */
22536 gen_type_die (member_declared_type (member
), type_die
);
22537 gen_field_die (member
, &vlr_ctx
, type_die
);
22541 gen_variable_die (member
, NULL_TREE
, type_die
);
22545 /* Forward declare these functions, because they are mutually recursive
22546 with their set_block_* pairing functions. */
22547 static void set_decl_origin_self (tree
);
22549 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
22550 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
22551 that it points to the node itself, thus indicating that the node is its
22552 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
22553 the given node is NULL, recursively descend the decl/block tree which
22554 it is the root of, and for each other ..._DECL or BLOCK node contained
22555 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
22556 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
22557 values to point to themselves. */
22560 set_block_origin_self (tree stmt
)
22562 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
22564 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
22569 for (local_decl
= BLOCK_VARS (stmt
);
22570 local_decl
!= NULL_TREE
;
22571 local_decl
= DECL_CHAIN (local_decl
))
22572 /* Do not recurse on nested functions since the inlining status
22573 of parent and child can be different as per the DWARF spec. */
22574 if (TREE_CODE (local_decl
) != FUNCTION_DECL
22575 && !DECL_EXTERNAL (local_decl
))
22576 set_decl_origin_self (local_decl
);
22582 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
22583 subblock
!= NULL_TREE
;
22584 subblock
= BLOCK_CHAIN (subblock
))
22585 set_block_origin_self (subblock
); /* Recurse. */
22590 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
22591 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
22592 node to so that it points to the node itself, thus indicating that the
22593 node represents its own (abstract) origin. Additionally, if the
22594 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
22595 the decl/block tree of which the given node is the root of, and for
22596 each other ..._DECL or BLOCK node contained therein whose
22597 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
22598 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
22599 point to themselves. */
22602 set_decl_origin_self (tree decl
)
22604 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
22606 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
22607 if (TREE_CODE (decl
) == FUNCTION_DECL
)
22611 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
22612 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
22613 if (DECL_INITIAL (decl
) != NULL_TREE
22614 && DECL_INITIAL (decl
) != error_mark_node
)
22615 set_block_origin_self (DECL_INITIAL (decl
));
22620 /* Mark the early DIE for DECL as the abstract instance. */
22623 dwarf2out_abstract_function (tree decl
)
22625 dw_die_ref old_die
;
22627 /* Make sure we have the actual abstract inline, not a clone. */
22628 decl
= DECL_ORIGIN (decl
);
22630 if (DECL_IGNORED_P (decl
))
22633 /* In LTO we're all set. We already created abstract instances
22634 early and we want to avoid creating a concrete instance of that
22635 if we don't output it. */
22639 old_die
= lookup_decl_die (decl
);
22640 gcc_assert (old_die
!= NULL
);
22641 if (get_AT (old_die
, DW_AT_inline
))
22642 /* We've already generated the abstract instance. */
22645 /* Go ahead and put DW_AT_inline on the DIE. */
22646 if (DECL_DECLARED_INLINE_P (decl
))
22648 if (cgraph_function_possibly_inlined_p (decl
))
22649 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_inlined
);
22651 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
22655 if (cgraph_function_possibly_inlined_p (decl
))
22656 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_inlined
);
22658 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_not_inlined
);
22661 if (DECL_DECLARED_INLINE_P (decl
)
22662 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
22663 add_AT_flag (old_die
, DW_AT_artificial
, 1);
22665 set_decl_origin_self (decl
);
22668 /* Helper function of premark_used_types() which gets called through
22671 Marks the DIE of a given type in *SLOT as perennial, so it never gets
22672 marked as unused by prune_unused_types. */
22675 premark_used_types_helper (tree
const &type
, void *)
22679 die
= lookup_type_die (type
);
22681 die
->die_perennial_p
= 1;
22685 /* Helper function of premark_types_used_by_global_vars which gets called
22686 through htab_traverse.
22688 Marks the DIE of a given type in *SLOT as perennial, so it never gets
22689 marked as unused by prune_unused_types. The DIE of the type is marked
22690 only if the global variable using the type will actually be emitted. */
22693 premark_types_used_by_global_vars_helper (types_used_by_vars_entry
**slot
,
22696 struct types_used_by_vars_entry
*entry
;
22699 entry
= (struct types_used_by_vars_entry
*) *slot
;
22700 gcc_assert (entry
->type
!= NULL
22701 && entry
->var_decl
!= NULL
);
22702 die
= lookup_type_die (entry
->type
);
22705 /* Ask cgraph if the global variable really is to be emitted.
22706 If yes, then we'll keep the DIE of ENTRY->TYPE. */
22707 varpool_node
*node
= varpool_node::get (entry
->var_decl
);
22708 if (node
&& node
->definition
)
22710 die
->die_perennial_p
= 1;
22711 /* Keep the parent DIEs as well. */
22712 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
22713 die
->die_perennial_p
= 1;
22719 /* Mark all members of used_types_hash as perennial. */
22722 premark_used_types (struct function
*fun
)
22724 if (fun
&& fun
->used_types_hash
)
22725 fun
->used_types_hash
->traverse
<void *, premark_used_types_helper
> (NULL
);
22728 /* Mark all members of types_used_by_vars_entry as perennial. */
22731 premark_types_used_by_global_vars (void)
22733 if (types_used_by_vars_hash
)
22734 types_used_by_vars_hash
22735 ->traverse
<void *, premark_types_used_by_global_vars_helper
> (NULL
);
22738 /* Mark all variables used by the symtab as perennial. */
22741 premark_used_variables (void)
22743 /* Mark DIEs in the symtab as used. */
22745 FOR_EACH_VARIABLE (var
)
22747 dw_die_ref die
= lookup_decl_die (var
->decl
);
22749 die
->die_perennial_p
= 1;
22753 /* Generate a DW_TAG_call_site DIE in function DECL under SUBR_DIE
22754 for CA_LOC call arg loc node. */
22757 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
22758 struct call_arg_loc_node
*ca_loc
)
22760 dw_die_ref stmt_die
= NULL
, die
;
22761 tree block
= ca_loc
->block
;
22764 && block
!= DECL_INITIAL (decl
)
22765 && TREE_CODE (block
) == BLOCK
)
22767 stmt_die
= lookup_block_die (block
);
22770 block
= BLOCK_SUPERCONTEXT (block
);
22772 if (stmt_die
== NULL
)
22773 stmt_die
= subr_die
;
22774 die
= new_die (dwarf_TAG (DW_TAG_call_site
), stmt_die
, NULL_TREE
);
22775 add_AT_lbl_id (die
, dwarf_AT (DW_AT_call_return_pc
), ca_loc
->label
);
22776 if (ca_loc
->tail_call_p
)
22777 add_AT_flag (die
, dwarf_AT (DW_AT_call_tail_call
), 1);
22778 if (ca_loc
->symbol_ref
)
22780 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
22782 add_AT_die_ref (die
, dwarf_AT (DW_AT_call_origin
), tdie
);
22784 add_AT_addr (die
, dwarf_AT (DW_AT_call_origin
), ca_loc
->symbol_ref
,
22790 /* Generate a DIE to represent a declared function (either file-scope or
22794 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
22796 tree origin
= decl_ultimate_origin (decl
);
22797 dw_die_ref subr_die
;
22798 dw_die_ref old_die
= lookup_decl_die (decl
);
22800 /* This function gets called multiple times for different stages of
22801 the debug process. For example, for func() in this code:
22805 void func() { ... }
22808 ...we get called 4 times. Twice in early debug and twice in
22814 1. Once while generating func() within the namespace. This is
22815 the declaration. The declaration bit below is set, as the
22816 context is the namespace.
22818 A new DIE will be generated with DW_AT_declaration set.
22820 2. Once for func() itself. This is the specification. The
22821 declaration bit below is clear as the context is the CU.
22823 We will use the cached DIE from (1) to create a new DIE with
22824 DW_AT_specification pointing to the declaration in (1).
22826 Late debug via rest_of_handle_final()
22827 -------------------------------------
22829 3. Once generating func() within the namespace. This is also the
22830 declaration, as in (1), but this time we will early exit below
22831 as we have a cached DIE and a declaration needs no additional
22832 annotations (no locations), as the source declaration line
22835 4. Once for func() itself. As in (2), this is the specification,
22836 but this time we will re-use the cached DIE, and just annotate
22837 it with the location information that should now be available.
22839 For something without namespaces, but with abstract instances, we
22840 are also called a multiple times:
22845 Base (); // constructor declaration (1)
22848 Base::Base () { } // constructor specification (2)
22853 1. Once for the Base() constructor by virtue of it being a
22854 member of the Base class. This is done via
22855 rest_of_type_compilation.
22857 This is a declaration, so a new DIE will be created with
22860 2. Once for the Base() constructor definition, but this time
22861 while generating the abstract instance of the base
22862 constructor (__base_ctor) which is being generated via early
22863 debug of reachable functions.
22865 Even though we have a cached version of the declaration (1),
22866 we will create a DW_AT_specification of the declaration DIE
22869 3. Once for the __base_ctor itself, but this time, we generate
22870 an DW_AT_abstract_origin version of the DW_AT_specification in
22873 Late debug via rest_of_handle_final
22874 -----------------------------------
22876 4. One final time for the __base_ctor (which will have a cached
22877 DIE with DW_AT_abstract_origin created in (3). This time,
22878 we will just annotate the location information now
22881 int declaration
= (current_function_decl
!= decl
22882 || class_or_namespace_scope_p (context_die
));
22884 /* A declaration that has been previously dumped needs no
22885 additional information. */
22886 if (old_die
&& declaration
)
22889 /* Now that the C++ front end lazily declares artificial member fns, we
22890 might need to retrofit the declaration into its class. */
22891 if (!declaration
&& !origin
&& !old_die
22892 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
22893 && !class_or_namespace_scope_p (context_die
)
22894 && debug_info_level
> DINFO_LEVEL_TERSE
)
22895 old_die
= force_decl_die (decl
);
22897 /* A concrete instance, tag a new DIE with DW_AT_abstract_origin. */
22898 if (origin
!= NULL
)
22900 gcc_assert (!declaration
|| local_scope_p (context_die
));
22902 /* Fixup die_parent for the abstract instance of a nested
22903 inline function. */
22904 if (old_die
&& old_die
->die_parent
== NULL
)
22905 add_child_die (context_die
, old_die
);
22907 if (old_die
&& get_AT_ref (old_die
, DW_AT_abstract_origin
))
22909 /* If we have a DW_AT_abstract_origin we have a working
22911 subr_die
= old_die
;
22915 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22916 add_abstract_origin_attribute (subr_die
, origin
);
22917 /* This is where the actual code for a cloned function is.
22918 Let's emit linkage name attribute for it. This helps
22919 debuggers to e.g, set breakpoints into
22920 constructors/destructors when the user asks "break
22922 add_linkage_name (subr_die
, decl
);
22925 /* A cached copy, possibly from early dwarf generation. Reuse as
22926 much as possible. */
22929 if (!get_AT_flag (old_die
, DW_AT_declaration
)
22930 /* We can have a normal definition following an inline one in the
22931 case of redefinition of GNU C extern inlines.
22932 It seems reasonable to use AT_specification in this case. */
22933 && !get_AT (old_die
, DW_AT_inline
))
22935 /* Detect and ignore this case, where we are trying to output
22936 something we have already output. */
22937 if (get_AT (old_die
, DW_AT_low_pc
)
22938 || get_AT (old_die
, DW_AT_ranges
))
22941 /* If we have no location information, this must be a
22942 partially generated DIE from early dwarf generation.
22943 Fall through and generate it. */
22946 /* If the definition comes from the same place as the declaration,
22947 maybe use the old DIE. We always want the DIE for this function
22948 that has the *_pc attributes to be under comp_unit_die so the
22949 debugger can find it. We also need to do this for abstract
22950 instances of inlines, since the spec requires the out-of-line copy
22951 to have the same parent. For local class methods, this doesn't
22952 apply; we just use the old DIE. */
22953 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
22954 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
22955 if (((is_unit_die (old_die
->die_parent
)
22956 /* This condition fixes the inconsistency/ICE with the
22957 following Fortran test (or some derivative thereof) while
22958 building libgfortran:
22962 logical function funky (FLAG)
22967 || (old_die
->die_parent
22968 && old_die
->die_parent
->die_tag
== DW_TAG_module
)
22969 || local_scope_p (old_die
->die_parent
)
22970 || context_die
== NULL
)
22971 && (DECL_ARTIFICIAL (decl
)
22972 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
22973 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
22974 == (unsigned) s
.line
)
22975 && (!debug_column_info
22977 || (get_AT_unsigned (old_die
, DW_AT_decl_column
)
22978 == (unsigned) s
.column
)))))
22979 /* With LTO if there's an abstract instance for
22980 the old DIE, this is a concrete instance and
22981 thus re-use the DIE. */
22982 || get_AT (old_die
, DW_AT_abstract_origin
))
22984 subr_die
= old_die
;
22986 /* Clear out the declaration attribute, but leave the
22987 parameters so they can be augmented with location
22988 information later. Unless this was a declaration, in
22989 which case, wipe out the nameless parameters and recreate
22990 them further down. */
22991 if (remove_AT (subr_die
, DW_AT_declaration
))
22994 remove_AT (subr_die
, DW_AT_object_pointer
);
22995 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
22998 /* Make a specification pointing to the previously built
23002 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
23003 add_AT_specification (subr_die
, old_die
);
23004 add_pubname (decl
, subr_die
);
23005 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
23006 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
23007 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
23008 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
23009 if (debug_column_info
23011 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
23012 != (unsigned) s
.column
))
23013 add_AT_unsigned (subr_die
, DW_AT_decl_column
, s
.column
);
23015 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
23016 emit the real type on the definition die. */
23017 if (is_cxx () && debug_info_level
> DINFO_LEVEL_TERSE
)
23019 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
23020 if (die
== auto_die
|| die
== decltype_auto_die
)
23021 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
23022 TYPE_UNQUALIFIED
, false, context_die
);
23025 /* When we process the method declaration, we haven't seen
23026 the out-of-class defaulted definition yet, so we have to
23028 if ((dwarf_version
>= 5 || ! dwarf_strict
)
23029 && !get_AT (subr_die
, DW_AT_defaulted
))
23032 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23034 if (defaulted
!= -1)
23036 /* Other values must have been handled before. */
23037 gcc_assert (defaulted
== DW_DEFAULTED_out_of_class
);
23038 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
23043 /* Create a fresh DIE for anything else. */
23046 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
23048 if (TREE_PUBLIC (decl
))
23049 add_AT_flag (subr_die
, DW_AT_external
, 1);
23051 add_name_and_src_coords_attributes (subr_die
, decl
);
23052 add_pubname (decl
, subr_die
);
23053 if (debug_info_level
> DINFO_LEVEL_TERSE
)
23055 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
23056 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
23057 TYPE_UNQUALIFIED
, false, context_die
);
23060 add_pure_or_virtual_attribute (subr_die
, decl
);
23061 if (DECL_ARTIFICIAL (decl
))
23062 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
23064 if (TREE_THIS_VOLATILE (decl
) && (dwarf_version
>= 5 || !dwarf_strict
))
23065 add_AT_flag (subr_die
, DW_AT_noreturn
, 1);
23067 add_alignment_attribute (subr_die
, decl
);
23069 add_accessibility_attribute (subr_die
, decl
);
23072 /* Unless we have an existing non-declaration DIE, equate the new
23074 if (!old_die
|| is_declaration_die (old_die
))
23075 equate_decl_number_to_die (decl
, subr_die
);
23079 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
23081 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
23083 /* If this is an explicit function declaration then generate
23084 a DW_AT_explicit attribute. */
23085 if ((dwarf_version
>= 3 || !dwarf_strict
)
23086 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23087 DW_AT_explicit
) == 1)
23088 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
23090 /* If this is a C++11 deleted special function member then generate
23091 a DW_AT_deleted attribute. */
23092 if ((dwarf_version
>= 5 || !dwarf_strict
)
23093 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23094 DW_AT_deleted
) == 1)
23095 add_AT_flag (subr_die
, DW_AT_deleted
, 1);
23097 /* If this is a C++11 defaulted special function member then
23098 generate a DW_AT_defaulted attribute. */
23099 if (dwarf_version
>= 5 || !dwarf_strict
)
23102 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23104 if (defaulted
!= -1)
23105 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
23108 /* If this is a C++11 non-static member function with & ref-qualifier
23109 then generate a DW_AT_reference attribute. */
23110 if ((dwarf_version
>= 5 || !dwarf_strict
)
23111 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23112 DW_AT_reference
) == 1)
23113 add_AT_flag (subr_die
, DW_AT_reference
, 1);
23115 /* If this is a C++11 non-static member function with &&
23116 ref-qualifier then generate a DW_AT_reference attribute. */
23117 if ((dwarf_version
>= 5 || !dwarf_strict
)
23118 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
23119 DW_AT_rvalue_reference
)
23121 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
23124 /* For non DECL_EXTERNALs, if range information is available, fill
23125 the DIE with it. */
23126 else if (!DECL_EXTERNAL (decl
) && !early_dwarf
)
23128 HOST_WIDE_INT cfa_fb_offset
;
23130 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
23132 if (!crtl
->has_bb_partition
)
23134 dw_fde_ref fde
= fun
->fde
;
23135 if (fde
->dw_fde_begin
)
23137 /* We have already generated the labels. */
23138 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
23139 fde
->dw_fde_end
, false);
23143 /* Create start/end labels and add the range. */
23144 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
23145 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
23146 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
23147 current_function_funcdef_no
);
23148 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
23149 current_function_funcdef_no
);
23150 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
23154 #if VMS_DEBUGGING_INFO
23155 /* HP OpenVMS Industry Standard 64: DWARF Extensions
23156 Section 2.3 Prologue and Epilogue Attributes:
23157 When a breakpoint is set on entry to a function, it is generally
23158 desirable for execution to be suspended, not on the very first
23159 instruction of the function, but rather at a point after the
23160 function's frame has been set up, after any language defined local
23161 declaration processing has been completed, and before execution of
23162 the first statement of the function begins. Debuggers generally
23163 cannot properly determine where this point is. Similarly for a
23164 breakpoint set on exit from a function. The prologue and epilogue
23165 attributes allow a compiler to communicate the location(s) to use. */
23168 if (fde
->dw_fde_vms_end_prologue
)
23169 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
23170 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
23172 if (fde
->dw_fde_vms_begin_epilogue
)
23173 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
23174 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
23181 /* Generate pubnames entries for the split function code ranges. */
23182 dw_fde_ref fde
= fun
->fde
;
23184 if (fde
->dw_fde_second_begin
)
23186 if (dwarf_version
>= 3 || !dwarf_strict
)
23188 /* We should use ranges for non-contiguous code section
23189 addresses. Use the actual code range for the initial
23190 section, since the HOT/COLD labels might precede an
23191 alignment offset. */
23192 bool range_list_added
= false;
23193 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
23194 fde
->dw_fde_end
, &range_list_added
,
23196 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
23197 fde
->dw_fde_second_end
,
23198 &range_list_added
, false);
23199 if (range_list_added
)
23204 /* There is no real support in DW2 for this .. so we make
23205 a work-around. First, emit the pub name for the segment
23206 containing the function label. Then make and emit a
23207 simplified subprogram DIE for the second segment with the
23208 name pre-fixed by __hot/cold_sect_of_. We use the same
23209 linkage name for the second die so that gdb will find both
23210 sections when given "b foo". */
23211 const char *name
= NULL
;
23212 tree decl_name
= DECL_NAME (decl
);
23213 dw_die_ref seg_die
;
23215 /* Do the 'primary' section. */
23216 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
23217 fde
->dw_fde_end
, false);
23219 /* Build a minimal DIE for the secondary section. */
23220 seg_die
= new_die (DW_TAG_subprogram
,
23221 subr_die
->die_parent
, decl
);
23223 if (TREE_PUBLIC (decl
))
23224 add_AT_flag (seg_die
, DW_AT_external
, 1);
23226 if (decl_name
!= NULL
23227 && IDENTIFIER_POINTER (decl_name
) != NULL
)
23229 name
= dwarf2_name (decl
, 1);
23230 if (! DECL_ARTIFICIAL (decl
))
23231 add_src_coords_attributes (seg_die
, decl
);
23233 add_linkage_name (seg_die
, decl
);
23235 gcc_assert (name
!= NULL
);
23236 add_pure_or_virtual_attribute (seg_die
, decl
);
23237 if (DECL_ARTIFICIAL (decl
))
23238 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
23240 name
= concat ("__second_sect_of_", name
, NULL
);
23241 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
23242 fde
->dw_fde_second_end
, false);
23243 add_name_attribute (seg_die
, name
);
23244 if (want_pubnames ())
23245 add_pubname_string (name
, seg_die
);
23249 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
23253 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
23255 /* We define the "frame base" as the function's CFA. This is more
23256 convenient for several reasons: (1) It's stable across the prologue
23257 and epilogue, which makes it better than just a frame pointer,
23258 (2) With dwarf3, there exists a one-byte encoding that allows us
23259 to reference the .debug_frame data by proxy, but failing that,
23260 (3) We can at least reuse the code inspection and interpretation
23261 code that determines the CFA position at various points in the
23263 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
23265 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
23266 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
23270 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
23271 if (list
->dw_loc_next
)
23272 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
23274 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
23277 /* Compute a displacement from the "steady-state frame pointer" to
23278 the CFA. The former is what all stack slots and argument slots
23279 will reference in the rtl; the latter is what we've told the
23280 debugger about. We'll need to adjust all frame_base references
23281 by this displacement. */
23282 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
23284 if (fun
->static_chain_decl
)
23286 /* DWARF requires here a location expression that computes the
23287 address of the enclosing subprogram's frame base. The machinery
23288 in tree-nested.c is supposed to store this specific address in the
23289 last field of the FRAME record. */
23290 const tree frame_type
23291 = TREE_TYPE (TREE_TYPE (fun
->static_chain_decl
));
23292 const tree fb_decl
= tree_last (TYPE_FIELDS (frame_type
));
23295 = build1 (INDIRECT_REF
, frame_type
, fun
->static_chain_decl
);
23296 fb_expr
= build3 (COMPONENT_REF
, TREE_TYPE (fb_decl
),
23297 fb_expr
, fb_decl
, NULL_TREE
);
23299 add_AT_location_description (subr_die
, DW_AT_static_link
,
23300 loc_list_from_tree (fb_expr
, 0, NULL
));
23303 resolve_variable_values ();
23306 /* Generate child dies for template paramaters. */
23307 if (early_dwarf
&& debug_info_level
> DINFO_LEVEL_TERSE
)
23308 gen_generic_params_dies (decl
);
23310 /* Now output descriptions of the arguments for this function. This gets
23311 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
23312 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
23313 `...' at the end of the formal parameter list. In order to find out if
23314 there was a trailing ellipsis or not, we must instead look at the type
23315 associated with the FUNCTION_DECL. This will be a node of type
23316 FUNCTION_TYPE. If the chain of type nodes hanging off of this
23317 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
23318 an ellipsis at the end. */
23320 /* In the case where we are describing a mere function declaration, all we
23321 need to do here (and all we *can* do here) is to describe the *types* of
23322 its formal parameters. */
23323 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
23325 else if (declaration
)
23326 gen_formal_types_die (decl
, subr_die
);
23329 /* Generate DIEs to represent all known formal parameters. */
23330 tree parm
= DECL_ARGUMENTS (decl
);
23331 tree generic_decl
= early_dwarf
23332 ? lang_hooks
.decls
.get_generic_function_decl (decl
) : NULL
;
23333 tree generic_decl_parm
= generic_decl
23334 ? DECL_ARGUMENTS (generic_decl
)
23337 /* Now we want to walk the list of parameters of the function and
23338 emit their relevant DIEs.
23340 We consider the case of DECL being an instance of a generic function
23341 as well as it being a normal function.
23343 If DECL is an instance of a generic function we walk the
23344 parameters of the generic function declaration _and_ the parameters of
23345 DECL itself. This is useful because we want to emit specific DIEs for
23346 function parameter packs and those are declared as part of the
23347 generic function declaration. In that particular case,
23348 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
23349 That DIE has children DIEs representing the set of arguments
23350 of the pack. Note that the set of pack arguments can be empty.
23351 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
23354 Otherwise, we just consider the parameters of DECL. */
23355 while (generic_decl_parm
|| parm
)
23357 if (generic_decl_parm
23358 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
23359 gen_formal_parameter_pack_die (generic_decl_parm
,
23364 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, NULL
, subr_die
);
23367 && parm
== DECL_ARGUMENTS (decl
)
23368 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
23370 && (dwarf_version
>= 3 || !dwarf_strict
))
23371 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
23373 parm
= DECL_CHAIN (parm
);
23376 if (generic_decl_parm
)
23377 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
23380 /* Decide whether we need an unspecified_parameters DIE at the end.
23381 There are 2 more cases to do this for: 1) the ansi ... declaration -
23382 this is detectable when the end of the arg list is not a
23383 void_type_node 2) an unprototyped function declaration (not a
23384 definition). This just means that we have no info about the
23385 parameters at all. */
23388 if (prototype_p (TREE_TYPE (decl
)))
23390 /* This is the prototyped case, check for.... */
23391 if (stdarg_p (TREE_TYPE (decl
)))
23392 gen_unspecified_parameters_die (decl
, subr_die
);
23394 else if (DECL_INITIAL (decl
) == NULL_TREE
)
23395 gen_unspecified_parameters_die (decl
, subr_die
);
23399 if (subr_die
!= old_die
)
23400 /* Add the calling convention attribute if requested. */
23401 add_calling_convention_attribute (subr_die
, decl
);
23403 /* Output Dwarf info for all of the stuff within the body of the function
23404 (if it has one - it may be just a declaration).
23406 OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
23407 a function. This BLOCK actually represents the outermost binding contour
23408 for the function, i.e. the contour in which the function's formal
23409 parameters and labels get declared. Curiously, it appears that the front
23410 end doesn't actually put the PARM_DECL nodes for the current function onto
23411 the BLOCK_VARS list for this outer scope, but are strung off of the
23412 DECL_ARGUMENTS list for the function instead.
23414 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
23415 the LABEL_DECL nodes for the function however, and we output DWARF info
23416 for those in decls_for_scope. Just within the `outer_scope' there will be
23417 a BLOCK node representing the function's outermost pair of curly braces,
23418 and any blocks used for the base and member initializers of a C++
23419 constructor function. */
23420 tree outer_scope
= DECL_INITIAL (decl
);
23421 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
23423 int call_site_note_count
= 0;
23424 int tail_call_site_note_count
= 0;
23426 /* Emit a DW_TAG_variable DIE for a named return value. */
23427 if (DECL_NAME (DECL_RESULT (decl
)))
23428 gen_decl_die (DECL_RESULT (decl
), NULL
, NULL
, subr_die
);
23430 /* The first time through decls_for_scope we will generate the
23431 DIEs for the locals. The second time, we fill in the
23433 decls_for_scope (outer_scope
, subr_die
);
23435 if (call_arg_locations
&& (!dwarf_strict
|| dwarf_version
>= 5))
23437 struct call_arg_loc_node
*ca_loc
;
23438 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
23440 dw_die_ref die
= NULL
;
23441 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
23443 tree arg_decl
= NULL_TREE
;
23445 for (arg
= (ca_loc
->call_arg_loc_note
!= NULL_RTX
23446 ? XEXP (ca_loc
->call_arg_loc_note
, 0)
23448 arg
; arg
= next_arg
)
23450 dw_loc_descr_ref reg
, val
;
23451 machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
23452 dw_die_ref cdie
, tdie
= NULL
;
23454 next_arg
= XEXP (arg
, 1);
23455 if (REG_P (XEXP (XEXP (arg
, 0), 0))
23457 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
23458 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
23459 && REGNO (XEXP (XEXP (arg
, 0), 0))
23460 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
23461 next_arg
= XEXP (next_arg
, 1);
23462 if (mode
== VOIDmode
)
23464 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
23465 if (mode
== VOIDmode
)
23466 mode
= GET_MODE (XEXP (arg
, 0));
23468 if (mode
== VOIDmode
|| mode
== BLKmode
)
23470 /* Get dynamic information about call target only if we
23471 have no static information: we cannot generate both
23472 DW_AT_call_origin and DW_AT_call_target
23474 if (ca_loc
->symbol_ref
== NULL_RTX
)
23476 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
23478 tloc
= XEXP (XEXP (arg
, 0), 1);
23481 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
23482 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
23484 tlocc
= XEXP (XEXP (arg
, 0), 1);
23489 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
23490 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
23491 VAR_INIT_STATUS_INITIALIZED
);
23492 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
23494 rtx mem
= XEXP (XEXP (arg
, 0), 0);
23495 reg
= mem_loc_descriptor (XEXP (mem
, 0),
23496 get_address_mode (mem
),
23498 VAR_INIT_STATUS_INITIALIZED
);
23500 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
23501 == DEBUG_PARAMETER_REF
)
23504 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
23505 tdie
= lookup_decl_die (tdecl
);
23513 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
23514 != DEBUG_PARAMETER_REF
)
23516 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
23518 VAR_INIT_STATUS_INITIALIZED
);
23522 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
23523 cdie
= new_die (dwarf_TAG (DW_TAG_call_site_parameter
), die
,
23525 add_desc_attribute (cdie
, arg_decl
);
23527 add_AT_loc (cdie
, DW_AT_location
, reg
);
23528 else if (tdie
!= NULL
)
23529 add_AT_die_ref (cdie
, dwarf_AT (DW_AT_call_parameter
),
23531 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_value
), val
);
23532 if (next_arg
!= XEXP (arg
, 1))
23534 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
23535 if (mode
== VOIDmode
)
23536 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
23537 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
23540 VAR_INIT_STATUS_INITIALIZED
);
23542 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_data_value
),
23547 && (ca_loc
->symbol_ref
|| tloc
))
23548 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
23549 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
23551 dw_loc_descr_ref tval
= NULL
;
23553 if (tloc
!= NULL_RTX
)
23554 tval
= mem_loc_descriptor (tloc
,
23555 GET_MODE (tloc
) == VOIDmode
23556 ? Pmode
: GET_MODE (tloc
),
23558 VAR_INIT_STATUS_INITIALIZED
);
23560 add_AT_loc (die
, dwarf_AT (DW_AT_call_target
), tval
);
23561 else if (tlocc
!= NULL_RTX
)
23563 tval
= mem_loc_descriptor (tlocc
,
23564 GET_MODE (tlocc
) == VOIDmode
23565 ? Pmode
: GET_MODE (tlocc
),
23567 VAR_INIT_STATUS_INITIALIZED
);
23570 dwarf_AT (DW_AT_call_target_clobbered
),
23576 call_site_note_count
++;
23577 if (ca_loc
->tail_call_p
)
23578 tail_call_site_note_count
++;
23582 call_arg_locations
= NULL
;
23583 call_arg_loc_last
= NULL
;
23584 if (tail_call_site_count
>= 0
23585 && tail_call_site_count
== tail_call_site_note_count
23586 && (!dwarf_strict
|| dwarf_version
>= 5))
23588 if (call_site_count
>= 0
23589 && call_site_count
== call_site_note_count
)
23590 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_calls
), 1);
23592 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_tail_calls
), 1);
23594 call_site_count
= -1;
23595 tail_call_site_count
= -1;
23598 /* Mark used types after we have created DIEs for the functions scopes. */
23599 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
23602 /* Returns a hash value for X (which really is a die_struct). */
23605 block_die_hasher::hash (die_struct
*d
)
23607 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
23610 /* Return nonzero if decl_id and die_parent of die_struct X is the same
23611 as decl_id and die_parent of die_struct Y. */
23614 block_die_hasher::equal (die_struct
*x
, die_struct
*y
)
23616 return x
->decl_id
== y
->decl_id
&& x
->die_parent
== y
->die_parent
;
23619 /* Hold information about markers for inlined entry points. */
23620 struct GTY ((for_user
)) inline_entry_data
23622 /* The block that's the inlined_function_outer_scope for an inlined
23626 /* The label at the inlined entry point. */
23627 const char *label_pfx
;
23628 unsigned int label_num
;
23630 /* The view number to be used as the inlined entry point. */
23634 struct inline_entry_data_hasher
: ggc_ptr_hash
<inline_entry_data
>
23636 typedef tree compare_type
;
23637 static inline hashval_t
hash (const inline_entry_data
*);
23638 static inline bool equal (const inline_entry_data
*, const_tree
);
23641 /* Hash table routines for inline_entry_data. */
23644 inline_entry_data_hasher::hash (const inline_entry_data
*data
)
23646 return htab_hash_pointer (data
->block
);
23650 inline_entry_data_hasher::equal (const inline_entry_data
*data
,
23653 return data
->block
== block
;
23656 /* Inlined entry points pending DIE creation in this compilation unit. */
23658 static GTY(()) hash_table
<inline_entry_data_hasher
> *inline_entry_data_table
;
23661 /* Return TRUE if DECL, which may have been previously generated as
23662 OLD_DIE, is a candidate for a DW_AT_specification. DECLARATION is
23663 true if decl (or its origin) is either an extern declaration or a
23664 class/namespace scoped declaration.
23666 The declare_in_namespace support causes us to get two DIEs for one
23667 variable, both of which are declarations. We want to avoid
23668 considering one to be a specification, so we must test for
23669 DECLARATION and DW_AT_declaration. */
23671 decl_will_get_specification_p (dw_die_ref old_die
, tree decl
, bool declaration
)
23673 return (old_die
&& TREE_STATIC (decl
) && !declaration
23674 && get_AT_flag (old_die
, DW_AT_declaration
) == 1);
23677 /* Return true if DECL is a local static. */
23680 local_function_static (tree decl
)
23682 gcc_assert (VAR_P (decl
));
23683 return TREE_STATIC (decl
)
23684 && DECL_CONTEXT (decl
)
23685 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
;
23688 /* Generate a DIE to represent a declared data object.
23689 Either DECL or ORIGIN must be non-null. */
23692 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
23694 HOST_WIDE_INT off
= 0;
23696 tree decl_or_origin
= decl
? decl
: origin
;
23697 tree ultimate_origin
;
23698 dw_die_ref var_die
;
23699 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
23700 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
23701 || class_or_namespace_scope_p (context_die
));
23702 bool specialization_p
= false;
23703 bool no_linkage_name
= false;
23705 /* While C++ inline static data members have definitions inside of the
23706 class, force the first DIE to be a declaration, then let gen_member_die
23707 reparent it to the class context and call gen_variable_die again
23708 to create the outside of the class DIE for the definition. */
23712 && DECL_CONTEXT (decl
)
23713 && TYPE_P (DECL_CONTEXT (decl
))
23714 && lang_hooks
.decls
.decl_dwarf_attribute (decl
, DW_AT_inline
) != -1)
23716 declaration
= true;
23717 if (dwarf_version
< 5)
23718 no_linkage_name
= true;
23721 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
23722 if (decl
|| ultimate_origin
)
23723 origin
= ultimate_origin
;
23724 com_decl
= fortran_common (decl_or_origin
, &off
);
23726 /* Symbol in common gets emitted as a child of the common block, in the form
23727 of a data member. */
23730 dw_die_ref com_die
;
23731 dw_loc_list_ref loc
= NULL
;
23732 die_node com_die_arg
;
23734 var_die
= lookup_decl_die (decl_or_origin
);
23737 if (! early_dwarf
&& get_AT (var_die
, DW_AT_location
) == NULL
)
23739 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2, NULL
);
23744 /* Optimize the common case. */
23745 if (single_element_loc_list_p (loc
)
23746 && loc
->expr
->dw_loc_opc
== DW_OP_addr
23747 && loc
->expr
->dw_loc_next
== NULL
23748 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
23751 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
23752 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
23753 = plus_constant (GET_MODE (x
), x
, off
);
23756 loc_list_plus_const (loc
, off
);
23758 add_AT_location_description (var_die
, DW_AT_location
, loc
);
23759 remove_AT (var_die
, DW_AT_declaration
);
23765 if (common_block_die_table
== NULL
)
23766 common_block_die_table
= hash_table
<block_die_hasher
>::create_ggc (10);
23768 com_die_arg
.decl_id
= DECL_UID (com_decl
);
23769 com_die_arg
.die_parent
= context_die
;
23770 com_die
= common_block_die_table
->find (&com_die_arg
);
23772 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
23773 if (com_die
== NULL
)
23776 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
23779 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
23780 add_name_and_src_coords_attributes (com_die
, com_decl
);
23783 add_AT_location_description (com_die
, DW_AT_location
, loc
);
23784 /* Avoid sharing the same loc descriptor between
23785 DW_TAG_common_block and DW_TAG_variable. */
23786 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
23788 else if (DECL_EXTERNAL (decl_or_origin
))
23789 add_AT_flag (com_die
, DW_AT_declaration
, 1);
23790 if (want_pubnames ())
23791 add_pubname_string (cnam
, com_die
); /* ??? needed? */
23792 com_die
->decl_id
= DECL_UID (com_decl
);
23793 slot
= common_block_die_table
->find_slot (com_die
, INSERT
);
23796 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
23798 add_AT_location_description (com_die
, DW_AT_location
, loc
);
23799 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
23800 remove_AT (com_die
, DW_AT_declaration
);
23802 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
23803 add_name_and_src_coords_attributes (var_die
, decl_or_origin
);
23804 add_type_attribute (var_die
, TREE_TYPE (decl_or_origin
),
23805 decl_quals (decl_or_origin
), false,
23807 add_alignment_attribute (var_die
, decl
);
23808 add_AT_flag (var_die
, DW_AT_external
, 1);
23813 /* Optimize the common case. */
23814 if (single_element_loc_list_p (loc
)
23815 && loc
->expr
->dw_loc_opc
== DW_OP_addr
23816 && loc
->expr
->dw_loc_next
== NULL
23817 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
23819 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
23820 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
23821 = plus_constant (GET_MODE (x
), x
, off
);
23824 loc_list_plus_const (loc
, off
);
23826 add_AT_location_description (var_die
, DW_AT_location
, loc
);
23828 else if (DECL_EXTERNAL (decl_or_origin
))
23829 add_AT_flag (var_die
, DW_AT_declaration
, 1);
23831 equate_decl_number_to_die (decl
, var_die
);
23839 /* A declaration that has been previously dumped, needs no
23840 further annotations, since it doesn't need location on
23841 the second pass. */
23844 else if (decl_will_get_specification_p (old_die
, decl
, declaration
)
23845 && !get_AT (old_die
, DW_AT_specification
))
23847 /* Fall-thru so we can make a new variable die along with a
23848 DW_AT_specification. */
23850 else if (origin
&& old_die
->die_parent
!= context_die
)
23852 /* If we will be creating an inlined instance, we need a
23853 new DIE that will get annotated with
23854 DW_AT_abstract_origin. */
23855 gcc_assert (!DECL_ABSTRACT_P (decl
));
23859 /* If a DIE was dumped early, it still needs location info.
23860 Skip to where we fill the location bits. */
23863 /* ??? In LTRANS we cannot annotate early created variably
23864 modified type DIEs without copying them and adjusting all
23865 references to them. Thus we dumped them again. Also add a
23866 reference to them but beware of -g0 compile and -g link
23867 in which case the reference will be already present. */
23868 tree type
= TREE_TYPE (decl_or_origin
);
23870 && ! get_AT (var_die
, DW_AT_type
)
23871 && variably_modified_type_p
23872 (type
, decl_function_context (decl_or_origin
)))
23874 if (decl_by_reference_p (decl_or_origin
))
23875 add_type_attribute (var_die
, TREE_TYPE (type
),
23876 TYPE_UNQUALIFIED
, false, context_die
);
23878 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
),
23879 false, context_die
);
23882 goto gen_variable_die_location
;
23886 /* For static data members, the declaration in the class is supposed
23887 to have DW_TAG_member tag in DWARF{3,4} and we emit it for compatibility
23888 also in DWARF2; the specification should still be DW_TAG_variable
23889 referencing the DW_TAG_member DIE. */
23890 if (declaration
&& class_scope_p (context_die
) && dwarf_version
< 5)
23891 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
23893 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
23895 if (origin
!= NULL
)
23896 add_abstract_origin_attribute (var_die
, origin
);
23898 /* Loop unrolling can create multiple blocks that refer to the same
23899 static variable, so we must test for the DW_AT_declaration flag.
23901 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
23902 copy decls and set the DECL_ABSTRACT_P flag on them instead of
23905 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
23906 else if (decl_will_get_specification_p (old_die
, decl
, declaration
))
23908 /* This is a definition of a C++ class level static. */
23909 add_AT_specification (var_die
, old_die
);
23910 specialization_p
= true;
23911 if (DECL_NAME (decl
))
23913 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
23914 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
23916 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
23917 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
23919 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
23920 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
23922 if (debug_column_info
23924 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
23925 != (unsigned) s
.column
))
23926 add_AT_unsigned (var_die
, DW_AT_decl_column
, s
.column
);
23928 if (old_die
->die_tag
== DW_TAG_member
)
23929 add_linkage_name (var_die
, decl
);
23933 add_name_and_src_coords_attributes (var_die
, decl
, no_linkage_name
);
23935 if ((origin
== NULL
&& !specialization_p
)
23937 && !DECL_ABSTRACT_P (decl_or_origin
)
23938 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
23939 decl_function_context
23940 (decl_or_origin
))))
23942 tree type
= TREE_TYPE (decl_or_origin
);
23944 if (decl_by_reference_p (decl_or_origin
))
23945 add_type_attribute (var_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
23948 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
), false,
23952 if (origin
== NULL
&& !specialization_p
)
23954 if (TREE_PUBLIC (decl
))
23955 add_AT_flag (var_die
, DW_AT_external
, 1);
23957 if (DECL_ARTIFICIAL (decl
))
23958 add_AT_flag (var_die
, DW_AT_artificial
, 1);
23960 add_alignment_attribute (var_die
, decl
);
23962 add_accessibility_attribute (var_die
, decl
);
23966 add_AT_flag (var_die
, DW_AT_declaration
, 1);
23968 if (decl
&& (DECL_ABSTRACT_P (decl
)
23969 || !old_die
|| is_declaration_die (old_die
)))
23970 equate_decl_number_to_die (decl
, var_die
);
23972 gen_variable_die_location
:
23974 && (! DECL_ABSTRACT_P (decl_or_origin
)
23975 /* Local static vars are shared between all clones/inlines,
23976 so emit DW_AT_location on the abstract DIE if DECL_RTL is
23978 || (VAR_P (decl_or_origin
)
23979 && TREE_STATIC (decl_or_origin
)
23980 && DECL_RTL_SET_P (decl_or_origin
))))
23983 add_pubname (decl_or_origin
, var_die
);
23985 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
23989 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
23991 if ((dwarf_version
>= 4 || !dwarf_strict
)
23992 && lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
23993 DW_AT_const_expr
) == 1
23994 && !get_AT (var_die
, DW_AT_const_expr
)
23995 && !specialization_p
)
23996 add_AT_flag (var_die
, DW_AT_const_expr
, 1);
24000 int inl
= lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
24003 && !get_AT (var_die
, DW_AT_inline
)
24004 && !specialization_p
)
24005 add_AT_unsigned (var_die
, DW_AT_inline
, inl
);
24009 /* Generate a DIE to represent a named constant. */
24012 gen_const_die (tree decl
, dw_die_ref context_die
)
24014 dw_die_ref const_die
;
24015 tree type
= TREE_TYPE (decl
);
24017 const_die
= lookup_decl_die (decl
);
24021 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
24022 equate_decl_number_to_die (decl
, const_die
);
24023 add_name_and_src_coords_attributes (const_die
, decl
);
24024 add_type_attribute (const_die
, type
, TYPE_QUAL_CONST
, false, context_die
);
24025 if (TREE_PUBLIC (decl
))
24026 add_AT_flag (const_die
, DW_AT_external
, 1);
24027 if (DECL_ARTIFICIAL (decl
))
24028 add_AT_flag (const_die
, DW_AT_artificial
, 1);
24029 tree_add_const_value_attribute_for_decl (const_die
, decl
);
24032 /* Generate a DIE to represent a label identifier. */
24035 gen_label_die (tree decl
, dw_die_ref context_die
)
24037 tree origin
= decl_ultimate_origin (decl
);
24038 dw_die_ref lbl_die
= lookup_decl_die (decl
);
24040 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
24044 lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
24045 equate_decl_number_to_die (decl
, lbl_die
);
24047 if (origin
!= NULL
)
24048 add_abstract_origin_attribute (lbl_die
, origin
);
24050 add_name_and_src_coords_attributes (lbl_die
, decl
);
24053 if (DECL_ABSTRACT_P (decl
))
24054 equate_decl_number_to_die (decl
, lbl_die
);
24055 else if (! early_dwarf
)
24057 insn
= DECL_RTL_IF_SET (decl
);
24059 /* Deleted labels are programmer specified labels which have been
24060 eliminated because of various optimizations. We still emit them
24061 here so that it is possible to put breakpoints on them. */
24065 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
24067 /* When optimization is enabled (via -O) some parts of the compiler
24068 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
24069 represent source-level labels which were explicitly declared by
24070 the user. This really shouldn't be happening though, so catch
24071 it if it ever does happen. */
24072 gcc_assert (!as_a
<rtx_insn
*> (insn
)->deleted ());
24074 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
24075 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
24079 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
24080 && CODE_LABEL_NUMBER (insn
) != -1)
24082 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
24083 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
24088 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
24089 attributes to the DIE for a block STMT, to describe where the inlined
24090 function was called from. This is similar to add_src_coords_attributes. */
24093 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
24095 /* We can end up with BUILTINS_LOCATION here. */
24096 if (RESERVED_LOCATION_P (BLOCK_SOURCE_LOCATION (stmt
)))
24099 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
24101 if (dwarf_version
>= 3 || !dwarf_strict
)
24103 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
24104 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
24105 if (debug_column_info
&& s
.column
)
24106 add_AT_unsigned (die
, DW_AT_call_column
, s
.column
);
24111 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
24112 Add low_pc and high_pc attributes to the DIE for a block STMT. */
24115 add_high_low_attributes (tree stmt
, dw_die_ref die
)
24117 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
24119 if (inline_entry_data
**iedp
24120 = !inline_entry_data_table
? NULL
24121 : inline_entry_data_table
->find_slot_with_hash (stmt
,
24122 htab_hash_pointer (stmt
),
24125 inline_entry_data
*ied
= *iedp
;
24126 gcc_assert (MAY_HAVE_DEBUG_MARKER_INSNS
);
24127 gcc_assert (debug_inline_points
);
24128 gcc_assert (inlined_function_outer_scope_p (stmt
));
24130 ASM_GENERATE_INTERNAL_LABEL (label
, ied
->label_pfx
, ied
->label_num
);
24131 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
24133 if (debug_variable_location_views
&& !ZERO_VIEW_P (ied
->view
)
24136 if (!output_asm_line_debug_info ())
24137 add_AT_unsigned (die
, DW_AT_GNU_entry_view
, ied
->view
);
24140 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", ied
->view
);
24141 /* FIXME: this will resolve to a small number. Could we
24142 possibly emit smaller data? Ideally we'd emit a
24143 uleb128, but that would make the size of DIEs
24144 impossible for the compiler to compute, since it's
24145 the assembler that computes the value of the view
24146 label in this case. Ideally, we'd have a single form
24147 encompassing both the address and the view, and
24148 indirecting them through a table might make things
24149 easier, but even that would be more wasteful,
24150 space-wise, than what we have now. */
24151 add_AT_symview (die
, DW_AT_GNU_entry_view
, label
);
24155 inline_entry_data_table
->clear_slot (iedp
);
24158 if (BLOCK_FRAGMENT_CHAIN (stmt
)
24159 && (dwarf_version
>= 3 || !dwarf_strict
))
24161 tree chain
, superblock
= NULL_TREE
;
24163 dw_attr_node
*attr
= NULL
;
24165 if (!debug_inline_points
&& inlined_function_outer_scope_p (stmt
))
24167 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
24168 BLOCK_NUMBER (stmt
));
24169 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
24172 /* Optimize duplicate .debug_ranges lists or even tails of
24173 lists. If this BLOCK has same ranges as its supercontext,
24174 lookup DW_AT_ranges attribute in the supercontext (and
24175 recursively so), verify that the ranges_table contains the
24176 right values and use it instead of adding a new .debug_range. */
24177 for (chain
= stmt
, pdie
= die
;
24178 BLOCK_SAME_RANGE (chain
);
24179 chain
= BLOCK_SUPERCONTEXT (chain
))
24181 dw_attr_node
*new_attr
;
24183 pdie
= pdie
->die_parent
;
24186 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
24188 new_attr
= get_AT (pdie
, DW_AT_ranges
);
24189 if (new_attr
== NULL
24190 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
24193 superblock
= BLOCK_SUPERCONTEXT (chain
);
24196 && ((*ranges_table
)[attr
->dw_attr_val
.v
.val_offset
].num
24197 == (int)BLOCK_NUMBER (superblock
))
24198 && BLOCK_FRAGMENT_CHAIN (superblock
))
24200 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
;
24201 unsigned long supercnt
= 0, thiscnt
= 0;
24202 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
24203 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
24206 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
].num
24207 == (int)BLOCK_NUMBER (chain
));
24209 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
+ 1].num
== 0);
24210 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
24211 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
24213 gcc_assert (supercnt
>= thiscnt
);
24214 add_AT_range_list (die
, DW_AT_ranges
, off
+ supercnt
- thiscnt
,
24216 note_rnglist_head (off
+ supercnt
- thiscnt
);
24220 unsigned int offset
= add_ranges (stmt
, true);
24221 add_AT_range_list (die
, DW_AT_ranges
, offset
, false);
24222 note_rnglist_head (offset
);
24224 bool prev_in_cold
= BLOCK_IN_COLD_SECTION_P (stmt
);
24225 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
24228 add_ranges (chain
, prev_in_cold
!= BLOCK_IN_COLD_SECTION_P (chain
));
24229 prev_in_cold
= BLOCK_IN_COLD_SECTION_P (chain
);
24230 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
24237 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
24238 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
24239 BLOCK_NUMBER (stmt
));
24240 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
24241 BLOCK_NUMBER (stmt
));
24242 add_AT_low_high_pc (die
, label
, label_high
, false);
24246 /* Generate a DIE for a lexical block. */
24249 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
)
24251 dw_die_ref old_die
= lookup_block_die (stmt
);
24252 dw_die_ref stmt_die
= NULL
;
24255 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
24256 equate_block_to_die (stmt
, stmt_die
);
24259 if (BLOCK_ABSTRACT_ORIGIN (stmt
))
24261 /* If this is an inlined or conrecte instance, create a new lexical
24262 die for anything below to attach DW_AT_abstract_origin to. */
24264 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
24266 tree origin
= block_ultimate_origin (stmt
);
24267 if (origin
!= NULL_TREE
&& (origin
!= stmt
|| old_die
))
24268 add_abstract_origin_attribute (stmt_die
, origin
);
24274 stmt_die
= old_die
;
24276 /* A non abstract block whose blocks have already been reordered
24277 should have the instruction range for this block. If so, set the
24278 high/low attributes. */
24279 if (!early_dwarf
&& TREE_ASM_WRITTEN (stmt
))
24281 gcc_assert (stmt_die
);
24282 add_high_low_attributes (stmt
, stmt_die
);
24285 decls_for_scope (stmt
, stmt_die
);
24288 /* Generate a DIE for an inlined subprogram. */
24291 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
)
24293 tree decl
= block_ultimate_origin (stmt
);
24295 /* Make sure any inlined functions are known to be inlineable. */
24296 gcc_checking_assert (DECL_ABSTRACT_P (decl
)
24297 || cgraph_function_possibly_inlined_p (decl
));
24299 dw_die_ref subr_die
= new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
24301 if (call_arg_locations
|| debug_inline_points
)
24302 equate_block_to_die (stmt
, subr_die
);
24303 add_abstract_origin_attribute (subr_die
, decl
);
24304 if (TREE_ASM_WRITTEN (stmt
))
24305 add_high_low_attributes (stmt
, subr_die
);
24306 add_call_src_coords_attributes (stmt
, subr_die
);
24308 /* The inliner creates an extra BLOCK for the parameter setup,
24309 we want to merge that with the actual outermost BLOCK of the
24310 inlined function to avoid duplicate locals in consumers.
24311 Do that by doing the recursion to subblocks on the single subblock
24313 bool unwrap_one
= false;
24314 if (BLOCK_SUBBLOCKS (stmt
) && !BLOCK_CHAIN (BLOCK_SUBBLOCKS (stmt
)))
24316 tree origin
= block_ultimate_origin (BLOCK_SUBBLOCKS (stmt
));
24318 && TREE_CODE (origin
) == BLOCK
24319 && BLOCK_SUPERCONTEXT (origin
) == decl
)
24322 decls_for_scope (stmt
, subr_die
, !unwrap_one
);
24324 decls_for_scope (BLOCK_SUBBLOCKS (stmt
), subr_die
);
24327 /* Generate a DIE for a field in a record, or structure. CTX is required: see
24328 the comment for VLR_CONTEXT. */
24331 gen_field_die (tree decl
, struct vlr_context
*ctx
, dw_die_ref context_die
)
24333 dw_die_ref decl_die
;
24335 if (TREE_TYPE (decl
) == error_mark_node
)
24338 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
24339 add_name_and_src_coords_attributes (decl_die
, decl
);
24340 add_type_attribute (decl_die
, member_declared_type (decl
), decl_quals (decl
),
24341 TYPE_REVERSE_STORAGE_ORDER (DECL_FIELD_CONTEXT (decl
)),
24344 if (DECL_BIT_FIELD_TYPE (decl
))
24346 add_byte_size_attribute (decl_die
, decl
);
24347 add_bit_size_attribute (decl_die
, decl
);
24348 add_bit_offset_attribute (decl_die
, decl
, ctx
);
24351 add_alignment_attribute (decl_die
, decl
);
24353 /* If we have a variant part offset, then we are supposed to process a member
24354 of a QUAL_UNION_TYPE, which is how we represent variant parts in
24356 gcc_assert (ctx
->variant_part_offset
== NULL_TREE
24357 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != QUAL_UNION_TYPE
);
24358 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
24359 add_data_member_location_attribute (decl_die
, decl
, ctx
);
24361 if (DECL_ARTIFICIAL (decl
))
24362 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
24364 add_accessibility_attribute (decl_die
, decl
);
24366 /* Equate decl number to die, so that we can look up this decl later on. */
24367 equate_decl_number_to_die (decl
, decl_die
);
24370 /* Generate a DIE for a pointer to a member type. TYPE can be an
24371 OFFSET_TYPE, for a pointer to data member, or a RECORD_TYPE, for a
24372 pointer to member function. */
24375 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
24377 if (lookup_type_die (type
))
24380 dw_die_ref ptr_die
= new_die (DW_TAG_ptr_to_member_type
,
24381 scope_die_for (type
, context_die
), type
);
24383 equate_type_number_to_die (type
, ptr_die
);
24384 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
24385 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
24386 add_type_attribute (ptr_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
24388 add_alignment_attribute (ptr_die
, type
);
24390 if (TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
24391 && TREE_CODE (TREE_TYPE (type
)) != METHOD_TYPE
)
24393 dw_loc_descr_ref op
= new_loc_descr (DW_OP_plus
, 0, 0);
24394 add_AT_loc (ptr_die
, DW_AT_use_location
, op
);
24398 static char *producer_string
;
24400 /* Return a heap allocated producer string including command line options
24401 if -grecord-gcc-switches. */
24404 gen_producer_string (void)
24407 auto_vec
<const char *> switches
;
24408 const char *language_string
= lang_hooks
.name
;
24409 char *producer
, *tail
;
24411 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
24412 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
24414 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
24415 switch (save_decoded_options
[j
].opt_index
)
24422 case OPT_auxbase_strip
:
24431 case OPT_SPECIAL_unknown
:
24432 case OPT_SPECIAL_ignore
:
24433 case OPT_SPECIAL_deprecated
:
24434 case OPT_SPECIAL_program_name
:
24435 case OPT_SPECIAL_input_file
:
24436 case OPT_grecord_gcc_switches
:
24437 case OPT__output_pch_
:
24438 case OPT_fdiagnostics_show_location_
:
24439 case OPT_fdiagnostics_show_option
:
24440 case OPT_fdiagnostics_show_caret
:
24441 case OPT_fdiagnostics_show_labels
:
24442 case OPT_fdiagnostics_show_line_numbers
:
24443 case OPT_fdiagnostics_color_
:
24444 case OPT_fdiagnostics_format_
:
24445 case OPT_fverbose_asm
:
24447 case OPT__sysroot_
:
24449 case OPT_nostdinc__
:
24450 case OPT_fpreprocessed
:
24451 case OPT_fltrans_output_list_
:
24452 case OPT_fresolution_
:
24453 case OPT_fdebug_prefix_map_
:
24454 case OPT_fmacro_prefix_map_
:
24455 case OPT_ffile_prefix_map_
:
24456 case OPT_fcompare_debug
:
24457 case OPT_fchecking
:
24458 case OPT_fchecking_
:
24459 /* Ignore these. */
24462 if (cl_options
[save_decoded_options
[j
].opt_index
].flags
24463 & CL_NO_DWARF_RECORD
)
24465 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
24467 switch (save_decoded_options
[j
].canonical_option
[0][1])
24474 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
24481 switches
.safe_push (save_decoded_options
[j
].orig_option_with_args_text
);
24482 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
24486 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
24488 sprintf (tail
, "%s %s", language_string
, version_string
);
24491 FOR_EACH_VEC_ELT (switches
, j
, p
)
24495 memcpy (tail
+ 1, p
, len
);
24503 /* Given a C and/or C++ language/version string return the "highest".
24504 C++ is assumed to be "higher" than C in this case. Used for merging
24505 LTO translation unit languages. */
24506 static const char *
24507 highest_c_language (const char *lang1
, const char *lang2
)
24509 if (strcmp ("GNU C++17", lang1
) == 0 || strcmp ("GNU C++17", lang2
) == 0)
24510 return "GNU C++17";
24511 if (strcmp ("GNU C++14", lang1
) == 0 || strcmp ("GNU C++14", lang2
) == 0)
24512 return "GNU C++14";
24513 if (strcmp ("GNU C++11", lang1
) == 0 || strcmp ("GNU C++11", lang2
) == 0)
24514 return "GNU C++11";
24515 if (strcmp ("GNU C++98", lang1
) == 0 || strcmp ("GNU C++98", lang2
) == 0)
24516 return "GNU C++98";
24518 if (strcmp ("GNU C2X", lang1
) == 0 || strcmp ("GNU C2X", lang2
) == 0)
24520 if (strcmp ("GNU C17", lang1
) == 0 || strcmp ("GNU C17", lang2
) == 0)
24522 if (strcmp ("GNU C11", lang1
) == 0 || strcmp ("GNU C11", lang2
) == 0)
24524 if (strcmp ("GNU C99", lang1
) == 0 || strcmp ("GNU C99", lang2
) == 0)
24526 if (strcmp ("GNU C89", lang1
) == 0 || strcmp ("GNU C89", lang2
) == 0)
24529 gcc_unreachable ();
24533 /* Generate the DIE for the compilation unit. */
24536 gen_compile_unit_die (const char *filename
)
24539 const char *language_string
= lang_hooks
.name
;
24542 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
24546 add_name_attribute (die
, filename
);
24547 /* Don't add cwd for <built-in>. */
24548 if (filename
[0] != '<')
24549 add_comp_dir_attribute (die
);
24552 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
24554 /* If our producer is LTO try to figure out a common language to use
24555 from the global list of translation units. */
24556 if (strcmp (language_string
, "GNU GIMPLE") == 0)
24560 const char *common_lang
= NULL
;
24562 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
24564 if (!TRANSLATION_UNIT_LANGUAGE (t
))
24567 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
24568 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
24570 else if (strncmp (common_lang
, "GNU C", 5) == 0
24571 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
24572 /* Mixing C and C++ is ok, use C++ in that case. */
24573 common_lang
= highest_c_language (common_lang
,
24574 TRANSLATION_UNIT_LANGUAGE (t
));
24577 /* Fall back to C. */
24578 common_lang
= NULL
;
24584 language_string
= common_lang
;
24587 language
= DW_LANG_C
;
24588 if (strncmp (language_string
, "GNU C", 5) == 0
24589 && ISDIGIT (language_string
[5]))
24591 language
= DW_LANG_C89
;
24592 if (dwarf_version
>= 3 || !dwarf_strict
)
24594 if (strcmp (language_string
, "GNU C89") != 0)
24595 language
= DW_LANG_C99
;
24597 if (dwarf_version
>= 5 /* || !dwarf_strict */)
24598 if (strcmp (language_string
, "GNU C11") == 0
24599 || strcmp (language_string
, "GNU C17") == 0
24600 || strcmp (language_string
, "GNU C2X"))
24601 language
= DW_LANG_C11
;
24604 else if (strncmp (language_string
, "GNU C++", 7) == 0)
24606 language
= DW_LANG_C_plus_plus
;
24607 if (dwarf_version
>= 5 /* || !dwarf_strict */)
24609 if (strcmp (language_string
, "GNU C++11") == 0)
24610 language
= DW_LANG_C_plus_plus_11
;
24611 else if (strcmp (language_string
, "GNU C++14") == 0)
24612 language
= DW_LANG_C_plus_plus_14
;
24613 else if (strcmp (language_string
, "GNU C++17") == 0)
24615 language
= DW_LANG_C_plus_plus_14
;
24618 else if (strcmp (language_string
, "GNU F77") == 0)
24619 language
= DW_LANG_Fortran77
;
24620 else if (dwarf_version
>= 3 || !dwarf_strict
)
24622 if (strcmp (language_string
, "GNU Ada") == 0)
24623 language
= DW_LANG_Ada95
;
24624 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
24626 language
= DW_LANG_Fortran95
;
24627 if (dwarf_version
>= 5 /* || !dwarf_strict */)
24629 if (strcmp (language_string
, "GNU Fortran2003") == 0)
24630 language
= DW_LANG_Fortran03
;
24631 else if (strcmp (language_string
, "GNU Fortran2008") == 0)
24632 language
= DW_LANG_Fortran08
;
24635 else if (strcmp (language_string
, "GNU Objective-C") == 0)
24636 language
= DW_LANG_ObjC
;
24637 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
24638 language
= DW_LANG_ObjC_plus_plus
;
24639 else if (strcmp (language_string
, "GNU D") == 0)
24640 language
= DW_LANG_D
;
24641 else if (dwarf_version
>= 5 || !dwarf_strict
)
24643 if (strcmp (language_string
, "GNU Go") == 0)
24644 language
= DW_LANG_Go
;
24647 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
24648 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
24649 language
= DW_LANG_Fortran90
;
24650 /* Likewise for Ada. */
24651 else if (strcmp (language_string
, "GNU Ada") == 0)
24652 language
= DW_LANG_Ada83
;
24654 add_AT_unsigned (die
, DW_AT_language
, language
);
24658 case DW_LANG_Fortran77
:
24659 case DW_LANG_Fortran90
:
24660 case DW_LANG_Fortran95
:
24661 case DW_LANG_Fortran03
:
24662 case DW_LANG_Fortran08
:
24663 /* Fortran has case insensitive identifiers and the front-end
24664 lowercases everything. */
24665 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
24668 /* The default DW_ID_case_sensitive doesn't need to be specified. */
24674 /* Generate the DIE for a base class. */
24677 gen_inheritance_die (tree binfo
, tree access
, tree type
,
24678 dw_die_ref context_die
)
24680 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
24681 struct vlr_context ctx
= { type
, NULL
};
24683 add_type_attribute (die
, BINFO_TYPE (binfo
), TYPE_UNQUALIFIED
, false,
24685 add_data_member_location_attribute (die
, binfo
, &ctx
);
24687 if (BINFO_VIRTUAL_P (binfo
))
24688 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
24690 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
24691 children, otherwise the default is DW_ACCESS_public. In DWARF2
24692 the default has always been DW_ACCESS_private. */
24693 if (access
== access_public_node
)
24695 if (dwarf_version
== 2
24696 || context_die
->die_tag
== DW_TAG_class_type
)
24697 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
24699 else if (access
== access_protected_node
)
24700 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
24701 else if (dwarf_version
> 2
24702 && context_die
->die_tag
!= DW_TAG_class_type
)
24703 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
24706 /* Return whether DECL is a FIELD_DECL that represents the variant part of a
24710 is_variant_part (tree decl
)
24712 return (TREE_CODE (decl
) == FIELD_DECL
24713 && TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
);
24716 /* Check that OPERAND is a reference to a field in STRUCT_TYPE. If it is,
24717 return the FIELD_DECL. Return NULL_TREE otherwise. */
24720 analyze_discr_in_predicate (tree operand
, tree struct_type
)
24722 while (CONVERT_EXPR_P (operand
))
24723 operand
= TREE_OPERAND (operand
, 0);
24725 /* Match field access to members of struct_type only. */
24726 if (TREE_CODE (operand
) == COMPONENT_REF
24727 && TREE_CODE (TREE_OPERAND (operand
, 0)) == PLACEHOLDER_EXPR
24728 && TREE_TYPE (TREE_OPERAND (operand
, 0)) == struct_type
24729 && TREE_CODE (TREE_OPERAND (operand
, 1)) == FIELD_DECL
)
24730 return TREE_OPERAND (operand
, 1);
24735 /* Check that SRC is a constant integer that can be represented as a native
24736 integer constant (either signed or unsigned). If so, store it into DEST and
24737 return true. Return false otherwise. */
24740 get_discr_value (tree src
, dw_discr_value
*dest
)
24742 tree discr_type
= TREE_TYPE (src
);
24744 if (lang_hooks
.types
.get_debug_type
)
24746 tree debug_type
= lang_hooks
.types
.get_debug_type (discr_type
);
24747 if (debug_type
!= NULL
)
24748 discr_type
= debug_type
;
24751 if (TREE_CODE (src
) != INTEGER_CST
|| !INTEGRAL_TYPE_P (discr_type
))
24754 /* Signedness can vary between the original type and the debug type. This
24755 can happen for character types in Ada for instance: the character type
24756 used for code generation can be signed, to be compatible with the C one,
24757 but from a debugger point of view, it must be unsigned. */
24758 bool is_orig_unsigned
= TYPE_UNSIGNED (TREE_TYPE (src
));
24759 bool is_debug_unsigned
= TYPE_UNSIGNED (discr_type
);
24761 if (is_orig_unsigned
!= is_debug_unsigned
)
24762 src
= fold_convert (discr_type
, src
);
24764 if (!(is_debug_unsigned
? tree_fits_uhwi_p (src
) : tree_fits_shwi_p (src
)))
24767 dest
->pos
= is_debug_unsigned
;
24768 if (is_debug_unsigned
)
24769 dest
->v
.uval
= tree_to_uhwi (src
);
24771 dest
->v
.sval
= tree_to_shwi (src
);
24776 /* Try to extract synthetic properties out of VARIANT_PART_DECL, which is a
24777 FIELD_DECL in STRUCT_TYPE that represents a variant part. If unsuccessful,
24778 store NULL_TREE in DISCR_DECL. Otherwise:
24780 - store the discriminant field in STRUCT_TYPE that controls the variant
24781 part to *DISCR_DECL
24783 - put in *DISCR_LISTS_P an array where for each variant, the item
24784 represents the corresponding matching list of discriminant values.
24786 - put in *DISCR_LISTS_LENGTH the number of variants, which is the size of
24789 Note that when the array is allocated (i.e. when the analysis is
24790 successful), it is up to the caller to free the array. */
24793 analyze_variants_discr (tree variant_part_decl
,
24796 dw_discr_list_ref
**discr_lists_p
,
24797 unsigned *discr_lists_length
)
24799 tree variant_part_type
= TREE_TYPE (variant_part_decl
);
24801 dw_discr_list_ref
*discr_lists
;
24804 /* Compute how many variants there are in this variant part. */
24805 *discr_lists_length
= 0;
24806 for (variant
= TYPE_FIELDS (variant_part_type
);
24807 variant
!= NULL_TREE
;
24808 variant
= DECL_CHAIN (variant
))
24809 ++*discr_lists_length
;
24811 *discr_decl
= NULL_TREE
;
24813 = (dw_discr_list_ref
*) xcalloc (*discr_lists_length
,
24814 sizeof (**discr_lists_p
));
24815 discr_lists
= *discr_lists_p
;
24817 /* And then analyze all variants to extract discriminant information for all
24818 of them. This analysis is conservative: as soon as we detect something we
24819 do not support, abort everything and pretend we found nothing. */
24820 for (variant
= TYPE_FIELDS (variant_part_type
), i
= 0;
24821 variant
!= NULL_TREE
;
24822 variant
= DECL_CHAIN (variant
), ++i
)
24824 tree match_expr
= DECL_QUALIFIER (variant
);
24826 /* Now, try to analyze the predicate and deduce a discriminant for
24828 if (match_expr
== boolean_true_node
)
24829 /* Typically happens for the default variant: it matches all cases that
24830 previous variants rejected. Don't output any matching value for
24834 /* The following loop tries to iterate over each discriminant
24835 possibility: single values or ranges. */
24836 while (match_expr
!= NULL_TREE
)
24838 tree next_round_match_expr
;
24839 tree candidate_discr
= NULL_TREE
;
24840 dw_discr_list_ref new_node
= NULL
;
24842 /* Possibilities are matched one after the other by nested
24843 TRUTH_ORIF_EXPR expressions. Process the current possibility and
24844 continue with the rest at next iteration. */
24845 if (TREE_CODE (match_expr
) == TRUTH_ORIF_EXPR
)
24847 next_round_match_expr
= TREE_OPERAND (match_expr
, 0);
24848 match_expr
= TREE_OPERAND (match_expr
, 1);
24851 next_round_match_expr
= NULL_TREE
;
24853 if (match_expr
== boolean_false_node
)
24854 /* This sub-expression matches nothing: just wait for the next
24858 else if (TREE_CODE (match_expr
) == EQ_EXPR
)
24860 /* We are matching: <discr_field> == <integer_cst>
24861 This sub-expression matches a single value. */
24862 tree integer_cst
= TREE_OPERAND (match_expr
, 1);
24865 = analyze_discr_in_predicate (TREE_OPERAND (match_expr
, 0),
24868 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
24869 if (!get_discr_value (integer_cst
,
24870 &new_node
->dw_discr_lower_bound
))
24872 new_node
->dw_discr_range
= false;
24875 else if (TREE_CODE (match_expr
) == TRUTH_ANDIF_EXPR
)
24877 /* We are matching:
24878 <discr_field> > <integer_cst>
24879 && <discr_field> < <integer_cst>.
24880 This sub-expression matches the range of values between the
24881 two matched integer constants. Note that comparisons can be
24882 inclusive or exclusive. */
24883 tree candidate_discr_1
, candidate_discr_2
;
24884 tree lower_cst
, upper_cst
;
24885 bool lower_cst_included
, upper_cst_included
;
24886 tree lower_op
= TREE_OPERAND (match_expr
, 0);
24887 tree upper_op
= TREE_OPERAND (match_expr
, 1);
24889 /* When the comparison is exclusive, the integer constant is not
24890 the discriminant range bound we are looking for: we will have
24891 to increment or decrement it. */
24892 if (TREE_CODE (lower_op
) == GE_EXPR
)
24893 lower_cst_included
= true;
24894 else if (TREE_CODE (lower_op
) == GT_EXPR
)
24895 lower_cst_included
= false;
24899 if (TREE_CODE (upper_op
) == LE_EXPR
)
24900 upper_cst_included
= true;
24901 else if (TREE_CODE (upper_op
) == LT_EXPR
)
24902 upper_cst_included
= false;
24906 /* Extract the discriminant from the first operand and check it
24907 is consistant with the same analysis in the second
24910 = analyze_discr_in_predicate (TREE_OPERAND (lower_op
, 0),
24913 = analyze_discr_in_predicate (TREE_OPERAND (upper_op
, 0),
24915 if (candidate_discr_1
== candidate_discr_2
)
24916 candidate_discr
= candidate_discr_1
;
24920 /* Extract bounds from both. */
24921 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
24922 lower_cst
= TREE_OPERAND (lower_op
, 1);
24923 upper_cst
= TREE_OPERAND (upper_op
, 1);
24925 if (!lower_cst_included
)
24927 = fold_build2 (PLUS_EXPR
, TREE_TYPE (lower_cst
), lower_cst
,
24928 build_int_cst (TREE_TYPE (lower_cst
), 1));
24929 if (!upper_cst_included
)
24931 = fold_build2 (MINUS_EXPR
, TREE_TYPE (upper_cst
), upper_cst
,
24932 build_int_cst (TREE_TYPE (upper_cst
), 1));
24934 if (!get_discr_value (lower_cst
,
24935 &new_node
->dw_discr_lower_bound
)
24936 || !get_discr_value (upper_cst
,
24937 &new_node
->dw_discr_upper_bound
))
24940 new_node
->dw_discr_range
= true;
24943 else if ((candidate_discr
24944 = analyze_discr_in_predicate (match_expr
, struct_type
))
24945 && TREE_TYPE (candidate_discr
) == boolean_type_node
)
24947 /* We are matching: <discr_field> for a boolean discriminant.
24948 This sub-expression matches boolean_true_node. */
24949 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
24950 if (!get_discr_value (boolean_true_node
,
24951 &new_node
->dw_discr_lower_bound
))
24953 new_node
->dw_discr_range
= false;
24957 /* Unsupported sub-expression: we cannot determine the set of
24958 matching discriminant values. Abort everything. */
24961 /* If the discriminant info is not consistant with what we saw so
24962 far, consider the analysis failed and abort everything. */
24963 if (candidate_discr
== NULL_TREE
24964 || (*discr_decl
!= NULL_TREE
&& candidate_discr
!= *discr_decl
))
24967 *discr_decl
= candidate_discr
;
24969 if (new_node
!= NULL
)
24971 new_node
->dw_discr_next
= discr_lists
[i
];
24972 discr_lists
[i
] = new_node
;
24974 match_expr
= next_round_match_expr
;
24978 /* If we reach this point, we could match everything we were interested
24983 /* Clean all data structure and return no result. */
24984 free (*discr_lists_p
);
24985 *discr_lists_p
= NULL
;
24986 *discr_decl
= NULL_TREE
;
24989 /* Generate a DIE to represent VARIANT_PART_DECL, a variant part that is part
24990 of STRUCT_TYPE, a record type. This new DIE is emitted as the next child
24993 Variant parts are supposed to be implemented as a FIELD_DECL whose type is a
24994 QUAL_UNION_TYPE: this is the VARIANT_PART_DECL parameter. The members for
24995 this type, which are record types, represent the available variants and each
24996 has a DECL_QUALIFIER attribute. The discriminant and the discriminant
24997 values are inferred from these attributes.
24999 In trees, the offsets for the fields inside these sub-records are relative
25000 to the variant part itself, whereas the corresponding DIEs should have
25001 offset attributes that are relative to the embedding record base address.
25002 This is why the caller must provide a VARIANT_PART_OFFSET expression: it
25003 must be an expression that computes the offset of the variant part to
25004 describe in DWARF. */
25007 gen_variant_part (tree variant_part_decl
, struct vlr_context
*vlr_ctx
,
25008 dw_die_ref context_die
)
25010 const tree variant_part_type
= TREE_TYPE (variant_part_decl
);
25011 tree variant_part_offset
= vlr_ctx
->variant_part_offset
;
25012 struct loc_descr_context ctx
= {
25013 vlr_ctx
->struct_type
, /* context_type */
25014 NULL_TREE
, /* base_decl */
25016 false, /* placeholder_arg */
25017 false /* placeholder_seen */
25020 /* The FIELD_DECL node in STRUCT_TYPE that acts as the discriminant, or
25021 NULL_TREE if there is no such field. */
25022 tree discr_decl
= NULL_TREE
;
25023 dw_discr_list_ref
*discr_lists
;
25024 unsigned discr_lists_length
= 0;
25027 dw_die_ref dwarf_proc_die
= NULL
;
25028 dw_die_ref variant_part_die
25029 = new_die (DW_TAG_variant_part
, context_die
, variant_part_type
);
25031 equate_decl_number_to_die (variant_part_decl
, variant_part_die
);
25033 analyze_variants_discr (variant_part_decl
, vlr_ctx
->struct_type
,
25034 &discr_decl
, &discr_lists
, &discr_lists_length
);
25036 if (discr_decl
!= NULL_TREE
)
25038 dw_die_ref discr_die
= lookup_decl_die (discr_decl
);
25041 add_AT_die_ref (variant_part_die
, DW_AT_discr
, discr_die
);
25043 /* We have no DIE for the discriminant, so just discard all
25044 discrimimant information in the output. */
25045 discr_decl
= NULL_TREE
;
25048 /* If the offset for this variant part is more complex than a constant,
25049 create a DWARF procedure for it so that we will not have to generate DWARF
25050 expressions for it for each member. */
25051 if (TREE_CODE (variant_part_offset
) != INTEGER_CST
25052 && (dwarf_version
>= 3 || !dwarf_strict
))
25054 const tree dwarf_proc_fndecl
25055 = build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
25056 build_function_type (TREE_TYPE (variant_part_offset
),
25058 const tree dwarf_proc_call
= build_call_expr (dwarf_proc_fndecl
, 0);
25059 const dw_loc_descr_ref dwarf_proc_body
25060 = loc_descriptor_from_tree (variant_part_offset
, 0, &ctx
);
25062 dwarf_proc_die
= new_dwarf_proc_die (dwarf_proc_body
,
25063 dwarf_proc_fndecl
, context_die
);
25064 if (dwarf_proc_die
!= NULL
)
25065 variant_part_offset
= dwarf_proc_call
;
25068 /* Output DIEs for all variants. */
25070 for (tree variant
= TYPE_FIELDS (variant_part_type
);
25071 variant
!= NULL_TREE
;
25072 variant
= DECL_CHAIN (variant
), ++i
)
25074 tree variant_type
= TREE_TYPE (variant
);
25075 dw_die_ref variant_die
;
25077 /* All variants (i.e. members of a variant part) are supposed to be
25078 encoded as structures. Sub-variant parts are QUAL_UNION_TYPE fields
25079 under these records. */
25080 gcc_assert (TREE_CODE (variant_type
) == RECORD_TYPE
);
25082 variant_die
= new_die (DW_TAG_variant
, variant_part_die
, variant_type
);
25083 equate_decl_number_to_die (variant
, variant_die
);
25085 /* Output discriminant values this variant matches, if any. */
25086 if (discr_decl
== NULL
|| discr_lists
[i
] == NULL
)
25087 /* In the case we have discriminant information at all, this is
25088 probably the default variant: as the standard says, don't
25089 output any discriminant value/list attribute. */
25091 else if (discr_lists
[i
]->dw_discr_next
== NULL
25092 && !discr_lists
[i
]->dw_discr_range
)
25093 /* If there is only one accepted value, don't bother outputting a
25095 add_discr_value (variant_die
, &discr_lists
[i
]->dw_discr_lower_bound
);
25097 add_discr_list (variant_die
, discr_lists
[i
]);
25099 for (tree member
= TYPE_FIELDS (variant_type
);
25100 member
!= NULL_TREE
;
25101 member
= DECL_CHAIN (member
))
25103 struct vlr_context vlr_sub_ctx
= {
25104 vlr_ctx
->struct_type
, /* struct_type */
25105 NULL
/* variant_part_offset */
25107 if (is_variant_part (member
))
25109 /* All offsets for fields inside variant parts are relative to
25110 the top-level embedding RECORD_TYPE's base address. On the
25111 other hand, offsets in GCC's types are relative to the
25112 nested-most variant part. So we have to sum offsets each time
25115 vlr_sub_ctx
.variant_part_offset
25116 = fold_build2 (PLUS_EXPR
, TREE_TYPE (variant_part_offset
),
25117 variant_part_offset
, byte_position (member
));
25118 gen_variant_part (member
, &vlr_sub_ctx
, variant_die
);
25122 vlr_sub_ctx
.variant_part_offset
= variant_part_offset
;
25123 gen_decl_die (member
, NULL
, &vlr_sub_ctx
, variant_die
);
25128 free (discr_lists
);
25131 /* Generate a DIE for a class member. */
25134 gen_member_die (tree type
, dw_die_ref context_die
)
25137 tree binfo
= TYPE_BINFO (type
);
25139 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
25141 /* If this is not an incomplete type, output descriptions of each of its
25142 members. Note that as we output the DIEs necessary to represent the
25143 members of this record or union type, we will also be trying to output
25144 DIEs to represent the *types* of those members. However the `type'
25145 function (above) will specifically avoid generating type DIEs for member
25146 types *within* the list of member DIEs for this (containing) type except
25147 for those types (of members) which are explicitly marked as also being
25148 members of this (containing) type themselves. The g++ front- end can
25149 force any given type to be treated as a member of some other (containing)
25150 type by setting the TYPE_CONTEXT of the given (member) type to point to
25151 the TREE node representing the appropriate (containing) type. */
25153 /* First output info about the base classes. */
25154 if (binfo
&& early_dwarf
)
25156 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
25160 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
25161 gen_inheritance_die (base
,
25162 (accesses
? (*accesses
)[i
] : access_public_node
),
25167 /* Now output info about the members. */
25168 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
25170 /* Ignore clones. */
25171 if (DECL_ABSTRACT_ORIGIN (member
))
25174 struct vlr_context vlr_ctx
= { type
, NULL_TREE
};
25175 bool static_inline_p
25177 && TREE_STATIC (member
)
25178 && (lang_hooks
.decls
.decl_dwarf_attribute (member
, DW_AT_inline
)
25181 /* If we thought we were generating minimal debug info for TYPE
25182 and then changed our minds, some of the member declarations
25183 may have already been defined. Don't define them again, but
25184 do put them in the right order. */
25186 if (dw_die_ref child
= lookup_decl_die (member
))
25188 /* Handle inline static data members, which only have in-class
25190 bool splice
= true;
25192 dw_die_ref ref
= NULL
;
25193 if (child
->die_tag
== DW_TAG_variable
25194 && child
->die_parent
== comp_unit_die ())
25196 ref
= get_AT_ref (child
, DW_AT_specification
);
25198 /* For C++17 inline static data members followed by redundant
25199 out of class redeclaration, we might get here with
25200 child being the DIE created for the out of class
25201 redeclaration and with its DW_AT_specification being
25202 the DIE created for in-class definition. We want to
25203 reparent the latter, and don't want to create another
25204 DIE with DW_AT_specification in that case, because
25205 we already have one. */
25208 && ref
->die_tag
== DW_TAG_variable
25209 && ref
->die_parent
== comp_unit_die ()
25210 && get_AT (ref
, DW_AT_specification
) == NULL
)
25214 static_inline_p
= false;
25219 reparent_child (child
, context_die
);
25220 if (dwarf_version
< 5)
25221 child
->die_tag
= DW_TAG_member
;
25227 splice_child_die (context_die
, child
);
25230 /* Do not generate standard DWARF for variant parts if we are generating
25231 the corresponding GNAT encodings: DIEs generated for both would
25232 conflict in our mappings. */
25233 else if (is_variant_part (member
)
25234 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
)
25236 vlr_ctx
.variant_part_offset
= byte_position (member
);
25237 gen_variant_part (member
, &vlr_ctx
, context_die
);
25241 vlr_ctx
.variant_part_offset
= NULL_TREE
;
25242 gen_decl_die (member
, NULL
, &vlr_ctx
, context_die
);
25245 /* For C++ inline static data members emit immediately a DW_TAG_variable
25246 DIE that will refer to that DW_TAG_member/DW_TAG_variable through
25247 DW_AT_specification. */
25248 if (static_inline_p
)
25250 int old_extern
= DECL_EXTERNAL (member
);
25251 DECL_EXTERNAL (member
) = 0;
25252 gen_decl_die (member
, NULL
, NULL
, comp_unit_die ());
25253 DECL_EXTERNAL (member
) = old_extern
;
25258 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
25259 is set, we pretend that the type was never defined, so we only get the
25260 member DIEs needed by later specification DIEs. */
25263 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
25264 enum debug_info_usage usage
)
25266 if (TREE_ASM_WRITTEN (type
))
25268 /* Fill in the bound of variable-length fields in late dwarf if
25269 still incomplete. */
25270 if (!early_dwarf
&& variably_modified_type_p (type
, NULL
))
25271 for (tree member
= TYPE_FIELDS (type
);
25273 member
= DECL_CHAIN (member
))
25274 fill_variable_array_bounds (TREE_TYPE (member
));
25278 dw_die_ref type_die
= lookup_type_die (type
);
25279 dw_die_ref scope_die
= 0;
25281 int complete
= (TYPE_SIZE (type
)
25282 && (! TYPE_STUB_DECL (type
)
25283 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
25284 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
25285 complete
= complete
&& should_emit_struct_debug (type
, usage
);
25287 if (type_die
&& ! complete
)
25290 if (TYPE_CONTEXT (type
) != NULL_TREE
25291 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
25292 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
25295 scope_die
= scope_die_for (type
, context_die
);
25297 /* Generate child dies for template paramaters. */
25298 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
25299 schedule_generic_params_dies_gen (type
);
25301 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
25302 /* First occurrence of type or toplevel definition of nested class. */
25304 dw_die_ref old_die
= type_die
;
25306 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
25307 ? record_type_tag (type
) : DW_TAG_union_type
,
25309 equate_type_number_to_die (type
, type_die
);
25311 add_AT_specification (type_die
, old_die
);
25313 add_name_attribute (type_die
, type_tag (type
));
25316 remove_AT (type_die
, DW_AT_declaration
);
25318 /* If this type has been completed, then give it a byte_size attribute and
25319 then give a list of members. */
25320 if (complete
&& !ns_decl
)
25322 /* Prevent infinite recursion in cases where the type of some member of
25323 this type is expressed in terms of this type itself. */
25324 TREE_ASM_WRITTEN (type
) = 1;
25325 add_byte_size_attribute (type_die
, type
);
25326 add_alignment_attribute (type_die
, type
);
25327 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
25329 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
25330 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
25333 /* If the first reference to this type was as the return type of an
25334 inline function, then it may not have a parent. Fix this now. */
25335 if (type_die
->die_parent
== NULL
)
25336 add_child_die (scope_die
, type_die
);
25338 gen_member_die (type
, type_die
);
25340 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
25341 if (TYPE_ARTIFICIAL (type
))
25342 add_AT_flag (type_die
, DW_AT_artificial
, 1);
25344 /* GNU extension: Record what type our vtable lives in. */
25345 if (TYPE_VFIELD (type
))
25347 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
25349 gen_type_die (vtype
, context_die
);
25350 add_AT_die_ref (type_die
, DW_AT_containing_type
,
25351 lookup_type_die (vtype
));
25356 add_AT_flag (type_die
, DW_AT_declaration
, 1);
25358 /* We don't need to do this for function-local types. */
25359 if (TYPE_STUB_DECL (type
)
25360 && ! decl_function_context (TYPE_STUB_DECL (type
)))
25361 vec_safe_push (incomplete_types
, type
);
25364 if (get_AT (type_die
, DW_AT_name
))
25365 add_pubtype (type
, type_die
);
25368 /* Generate a DIE for a subroutine _type_. */
25371 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
25373 tree return_type
= TREE_TYPE (type
);
25374 dw_die_ref subr_die
25375 = new_die (DW_TAG_subroutine_type
,
25376 scope_die_for (type
, context_die
), type
);
25378 equate_type_number_to_die (type
, subr_die
);
25379 add_prototyped_attribute (subr_die
, type
);
25380 add_type_attribute (subr_die
, return_type
, TYPE_UNQUALIFIED
, false,
25382 add_alignment_attribute (subr_die
, type
);
25383 gen_formal_types_die (type
, subr_die
);
25385 if (get_AT (subr_die
, DW_AT_name
))
25386 add_pubtype (type
, subr_die
);
25387 if ((dwarf_version
>= 5 || !dwarf_strict
)
25388 && lang_hooks
.types
.type_dwarf_attribute (type
, DW_AT_reference
) != -1)
25389 add_AT_flag (subr_die
, DW_AT_reference
, 1);
25390 if ((dwarf_version
>= 5 || !dwarf_strict
)
25391 && lang_hooks
.types
.type_dwarf_attribute (type
,
25392 DW_AT_rvalue_reference
) != -1)
25393 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
25396 /* Generate a DIE for a type definition. */
25399 gen_typedef_die (tree decl
, dw_die_ref context_die
)
25401 dw_die_ref type_die
;
25404 if (TREE_ASM_WRITTEN (decl
))
25406 if (DECL_ORIGINAL_TYPE (decl
))
25407 fill_variable_array_bounds (DECL_ORIGINAL_TYPE (decl
));
25411 /* As we avoid creating DIEs for local typedefs (see decl_ultimate_origin
25412 checks in process_scope_var and modified_type_die), this should be called
25413 only for original types. */
25414 gcc_assert (decl_ultimate_origin (decl
) == NULL
25415 || decl_ultimate_origin (decl
) == decl
);
25417 TREE_ASM_WRITTEN (decl
) = 1;
25418 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
25420 add_name_and_src_coords_attributes (type_die
, decl
);
25421 if (DECL_ORIGINAL_TYPE (decl
))
25423 type
= DECL_ORIGINAL_TYPE (decl
);
25424 if (type
== error_mark_node
)
25427 gcc_assert (type
!= TREE_TYPE (decl
));
25428 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
25432 type
= TREE_TYPE (decl
);
25433 if (type
== error_mark_node
)
25436 if (is_naming_typedef_decl (TYPE_NAME (type
)))
25438 /* Here, we are in the case of decl being a typedef naming
25439 an anonymous type, e.g:
25440 typedef struct {...} foo;
25441 In that case TREE_TYPE (decl) is not a typedef variant
25442 type and TYPE_NAME of the anonymous type is set to the
25443 TYPE_DECL of the typedef. This construct is emitted by
25446 TYPE is the anonymous struct named by the typedef
25447 DECL. As we need the DW_AT_type attribute of the
25448 DW_TAG_typedef to point to the DIE of TYPE, let's
25449 generate that DIE right away. add_type_attribute
25450 called below will then pick (via lookup_type_die) that
25451 anonymous struct DIE. */
25452 if (!TREE_ASM_WRITTEN (type
))
25453 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
25455 /* This is a GNU Extension. We are adding a
25456 DW_AT_linkage_name attribute to the DIE of the
25457 anonymous struct TYPE. The value of that attribute
25458 is the name of the typedef decl naming the anonymous
25459 struct. This greatly eases the work of consumers of
25460 this debug info. */
25461 add_linkage_name_raw (lookup_type_die (type
), decl
);
25465 add_type_attribute (type_die
, type
, decl_quals (decl
), false,
25468 if (is_naming_typedef_decl (decl
))
25469 /* We want that all subsequent calls to lookup_type_die with
25470 TYPE in argument yield the DW_TAG_typedef we have just
25472 equate_type_number_to_die (type
, type_die
);
25474 add_alignment_attribute (type_die
, TREE_TYPE (decl
));
25476 add_accessibility_attribute (type_die
, decl
);
25478 if (DECL_ABSTRACT_P (decl
))
25479 equate_decl_number_to_die (decl
, type_die
);
25481 if (get_AT (type_die
, DW_AT_name
))
25482 add_pubtype (decl
, type_die
);
25485 /* Generate a DIE for a struct, class, enum or union type. */
25488 gen_tagged_type_die (tree type
,
25489 dw_die_ref context_die
,
25490 enum debug_info_usage usage
)
25492 if (type
== NULL_TREE
25493 || !is_tagged_type (type
))
25496 if (TREE_ASM_WRITTEN (type
))
25498 /* If this is a nested type whose containing class hasn't been written
25499 out yet, writing it out will cover this one, too. This does not apply
25500 to instantiations of member class templates; they need to be added to
25501 the containing class as they are generated. FIXME: This hurts the
25502 idea of combining type decls from multiple TUs, since we can't predict
25503 what set of template instantiations we'll get. */
25504 else if (TYPE_CONTEXT (type
)
25505 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
25506 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
25508 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
25510 if (TREE_ASM_WRITTEN (type
))
25513 /* If that failed, attach ourselves to the stub. */
25514 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
25516 else if (TYPE_CONTEXT (type
) != NULL_TREE
25517 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
25519 /* If this type is local to a function that hasn't been written
25520 out yet, use a NULL context for now; it will be fixed up in
25521 decls_for_scope. */
25522 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
25523 /* A declaration DIE doesn't count; nested types need to go in the
25525 if (context_die
&& is_declaration_die (context_die
))
25526 context_die
= NULL
;
25529 context_die
= declare_in_namespace (type
, context_die
);
25531 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
25533 /* This might have been written out by the call to
25534 declare_in_namespace. */
25535 if (!TREE_ASM_WRITTEN (type
))
25536 gen_enumeration_type_die (type
, context_die
);
25539 gen_struct_or_union_type_die (type
, context_die
, usage
);
25541 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
25542 it up if it is ever completed. gen_*_type_die will set it for us
25543 when appropriate. */
25546 /* Generate a type description DIE. */
25549 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
25550 enum debug_info_usage usage
)
25552 struct array_descr_info info
;
25554 if (type
== NULL_TREE
|| type
== error_mark_node
)
25557 if (flag_checking
&& type
)
25558 verify_type (type
);
25560 if (TYPE_NAME (type
) != NULL_TREE
25561 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
25562 && is_redundant_typedef (TYPE_NAME (type
))
25563 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
25564 /* The DECL of this type is a typedef we don't want to emit debug
25565 info for but we want debug info for its underlying typedef.
25566 This can happen for e.g, the injected-class-name of a C++
25568 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
25570 /* If TYPE is a typedef type variant, let's generate debug info
25571 for the parent typedef which TYPE is a type of. */
25572 if (typedef_variant_p (type
))
25574 if (TREE_ASM_WRITTEN (type
))
25577 tree name
= TYPE_NAME (type
);
25578 tree origin
= decl_ultimate_origin (name
);
25579 if (origin
!= NULL
&& origin
!= name
)
25581 gen_decl_die (origin
, NULL
, NULL
, context_die
);
25585 /* Prevent broken recursion; we can't hand off to the same type. */
25586 gcc_assert (DECL_ORIGINAL_TYPE (name
) != type
);
25588 /* Give typedefs the right scope. */
25589 context_die
= scope_die_for (type
, context_die
);
25591 TREE_ASM_WRITTEN (type
) = 1;
25593 gen_decl_die (name
, NULL
, NULL
, context_die
);
25597 /* If type is an anonymous tagged type named by a typedef, let's
25598 generate debug info for the typedef. */
25599 if (is_naming_typedef_decl (TYPE_NAME (type
)))
25601 /* Give typedefs the right scope. */
25602 context_die
= scope_die_for (type
, context_die
);
25604 gen_decl_die (TYPE_NAME (type
), NULL
, NULL
, context_die
);
25608 if (lang_hooks
.types
.get_debug_type
)
25610 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
25612 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
25614 gen_type_die_with_usage (debug_type
, context_die
, usage
);
25619 /* We are going to output a DIE to represent the unqualified version
25620 of this type (i.e. without any const or volatile qualifiers) so
25621 get the main variant (i.e. the unqualified version) of this type
25622 now. (Vectors and arrays are special because the debugging info is in the
25623 cloned type itself. Similarly function/method types can contain extra
25624 ref-qualification). */
25625 if (TREE_CODE (type
) == FUNCTION_TYPE
25626 || TREE_CODE (type
) == METHOD_TYPE
)
25628 /* For function/method types, can't use type_main_variant here,
25629 because that can have different ref-qualifiers for C++,
25630 but try to canonicalize. */
25631 tree main
= TYPE_MAIN_VARIANT (type
);
25632 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
25633 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
25634 && check_base_type (t
, main
)
25635 && check_lang_type (t
, type
))
25641 else if (TREE_CODE (type
) != VECTOR_TYPE
25642 && TREE_CODE (type
) != ARRAY_TYPE
)
25643 type
= type_main_variant (type
);
25645 /* If this is an array type with hidden descriptor, handle it first. */
25646 if (!TREE_ASM_WRITTEN (type
)
25647 && lang_hooks
.types
.get_array_descr_info
)
25649 memset (&info
, 0, sizeof (info
));
25650 if (lang_hooks
.types
.get_array_descr_info (type
, &info
))
25652 /* Fortran sometimes emits array types with no dimension. */
25653 gcc_assert (info
.ndimensions
>= 0
25654 && (info
.ndimensions
25655 <= DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN
));
25656 gen_descr_array_type_die (type
, &info
, context_die
);
25657 TREE_ASM_WRITTEN (type
) = 1;
25662 if (TREE_ASM_WRITTEN (type
))
25664 /* Variable-length types may be incomplete even if
25665 TREE_ASM_WRITTEN. For such types, fall through to
25666 gen_array_type_die() and possibly fill in
25667 DW_AT_{upper,lower}_bound attributes. */
25668 if ((TREE_CODE (type
) != ARRAY_TYPE
25669 && TREE_CODE (type
) != RECORD_TYPE
25670 && TREE_CODE (type
) != UNION_TYPE
25671 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
25672 || !variably_modified_type_p (type
, NULL
))
25676 switch (TREE_CODE (type
))
25682 case REFERENCE_TYPE
:
25683 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
25684 ensures that the gen_type_die recursion will terminate even if the
25685 type is recursive. Recursive types are possible in Ada. */
25686 /* ??? We could perhaps do this for all types before the switch
25688 TREE_ASM_WRITTEN (type
) = 1;
25690 /* For these types, all that is required is that we output a DIE (or a
25691 set of DIEs) to represent the "basis" type. */
25692 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25693 DINFO_USAGE_IND_USE
);
25697 /* This code is used for C++ pointer-to-data-member types.
25698 Output a description of the relevant class type. */
25699 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
25700 DINFO_USAGE_IND_USE
);
25702 /* Output a description of the type of the object pointed to. */
25703 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25704 DINFO_USAGE_IND_USE
);
25706 /* Now output a DIE to represent this pointer-to-data-member type
25708 gen_ptr_to_mbr_type_die (type
, context_die
);
25711 case FUNCTION_TYPE
:
25712 /* Force out return type (in case it wasn't forced out already). */
25713 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25714 DINFO_USAGE_DIR_USE
);
25715 gen_subroutine_type_die (type
, context_die
);
25719 /* Force out return type (in case it wasn't forced out already). */
25720 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
25721 DINFO_USAGE_DIR_USE
);
25722 gen_subroutine_type_die (type
, context_die
);
25727 gen_array_type_die (type
, context_die
);
25730 case ENUMERAL_TYPE
:
25733 case QUAL_UNION_TYPE
:
25734 gen_tagged_type_die (type
, context_die
, usage
);
25740 case FIXED_POINT_TYPE
:
25743 /* No DIEs needed for fundamental types. */
25748 /* Just use DW_TAG_unspecified_type. */
25750 dw_die_ref type_die
= lookup_type_die (type
);
25751 if (type_die
== NULL
)
25753 tree name
= TYPE_IDENTIFIER (type
);
25754 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
25756 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
25757 equate_type_number_to_die (type
, type_die
);
25763 if (is_cxx_auto (type
))
25765 tree name
= TYPE_IDENTIFIER (type
);
25766 dw_die_ref
*die
= (name
== get_identifier ("auto")
25767 ? &auto_die
: &decltype_auto_die
);
25770 *die
= new_die (DW_TAG_unspecified_type
,
25771 comp_unit_die (), NULL_TREE
);
25772 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
25774 equate_type_number_to_die (type
, *die
);
25777 gcc_unreachable ();
25780 TREE_ASM_WRITTEN (type
) = 1;
25784 gen_type_die (tree type
, dw_die_ref context_die
)
25786 if (type
!= error_mark_node
)
25788 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
25791 dw_die_ref die
= lookup_type_die (type
);
25798 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
25799 things which are local to the given block. */
25802 gen_block_die (tree stmt
, dw_die_ref context_die
)
25804 int must_output_die
= 0;
25807 /* Ignore blocks that are NULL. */
25808 if (stmt
== NULL_TREE
)
25811 inlined_func
= inlined_function_outer_scope_p (stmt
);
25813 /* If the block is one fragment of a non-contiguous block, do not
25814 process the variables, since they will have been done by the
25815 origin block. Do process subblocks. */
25816 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
25820 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
25821 gen_block_die (sub
, context_die
);
25826 /* Determine if we need to output any Dwarf DIEs at all to represent this
25829 /* The outer scopes for inlinings *must* always be represented. We
25830 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
25831 must_output_die
= 1;
25832 else if (lookup_block_die (stmt
))
25833 /* If we already have a DIE then it was filled early. Meanwhile
25834 we might have pruned all BLOCK_VARS as optimized out but we
25835 still want to generate high/low PC attributes so output it. */
25836 must_output_die
= 1;
25837 else if (TREE_USED (stmt
)
25838 || TREE_ASM_WRITTEN (stmt
))
25840 /* Determine if this block directly contains any "significant"
25841 local declarations which we will need to output DIEs for. */
25842 if (debug_info_level
> DINFO_LEVEL_TERSE
)
25844 /* We are not in terse mode so any local declaration that
25845 is not ignored for debug purposes counts as being a
25846 "significant" one. */
25847 if (BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
25848 must_output_die
= 1;
25850 for (tree var
= BLOCK_VARS (stmt
); var
; var
= DECL_CHAIN (var
))
25851 if (!DECL_IGNORED_P (var
))
25853 must_output_die
= 1;
25857 else if (!dwarf2out_ignore_block (stmt
))
25858 must_output_die
= 1;
25861 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
25862 DIE for any block which contains no significant local declarations at
25863 all. Rather, in such cases we just call `decls_for_scope' so that any
25864 needed Dwarf info for any sub-blocks will get properly generated. Note
25865 that in terse mode, our definition of what constitutes a "significant"
25866 local declaration gets restricted to include only inlined function
25867 instances and local (nested) function definitions. */
25868 if (must_output_die
)
25871 gen_inlined_subroutine_die (stmt
, context_die
);
25873 gen_lexical_block_die (stmt
, context_die
);
25876 decls_for_scope (stmt
, context_die
);
25879 /* Process variable DECL (or variable with origin ORIGIN) within
25880 block STMT and add it to CONTEXT_DIE. */
25882 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
25885 tree decl_or_origin
= decl
? decl
: origin
;
25887 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
25888 die
= lookup_decl_die (decl_or_origin
);
25889 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
)
25891 if (TYPE_DECL_IS_STUB (decl_or_origin
))
25892 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
25894 die
= lookup_decl_die (decl_or_origin
);
25895 /* Avoid re-creating the DIE late if it was optimized as unused early. */
25896 if (! die
&& ! early_dwarf
)
25902 /* Avoid creating DIEs for local typedefs and concrete static variables that
25903 will only be pruned later. */
25904 if ((origin
|| decl_ultimate_origin (decl
))
25905 && (TREE_CODE (decl_or_origin
) == TYPE_DECL
25906 || (VAR_P (decl_or_origin
) && TREE_STATIC (decl_or_origin
))))
25908 origin
= decl_ultimate_origin (decl_or_origin
);
25909 if (decl
&& VAR_P (decl
) && die
!= NULL
)
25911 die
= lookup_decl_die (origin
);
25913 equate_decl_number_to_die (decl
, die
);
25918 if (die
!= NULL
&& die
->die_parent
== NULL
)
25919 add_child_die (context_die
, die
);
25920 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
25923 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
25924 stmt
, context_die
);
25928 if (decl
&& DECL_P (decl
))
25930 die
= lookup_decl_die (decl
);
25932 /* Early created DIEs do not have a parent as the decls refer
25933 to the function as DECL_CONTEXT rather than the BLOCK. */
25934 if (die
&& die
->die_parent
== NULL
)
25936 gcc_assert (in_lto_p
);
25937 add_child_die (context_die
, die
);
25941 gen_decl_die (decl
, origin
, NULL
, context_die
);
25945 /* Generate all of the decls declared within a given scope and (recursively)
25946 all of its sub-blocks. */
25949 decls_for_scope (tree stmt
, dw_die_ref context_die
, bool recurse
)
25955 /* Ignore NULL blocks. */
25956 if (stmt
== NULL_TREE
)
25959 /* Output the DIEs to represent all of the data objects and typedefs
25960 declared directly within this block but not within any nested
25961 sub-blocks. Also, nested function and tag DIEs have been
25962 generated with a parent of NULL; fix that up now. We don't
25963 have to do this if we're at -g1. */
25964 if (debug_info_level
> DINFO_LEVEL_TERSE
)
25966 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
25967 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
25968 /* BLOCK_NONLOCALIZED_VARs simply generate DIE stubs with abstract
25969 origin - avoid doing this twice as we have no good way to see
25970 if we've done it once already. */
25972 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
25974 decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
25975 if (decl
== current_function_decl
)
25976 /* Ignore declarations of the current function, while they
25977 are declarations, gen_subprogram_die would treat them
25978 as definitions again, because they are equal to
25979 current_function_decl and endlessly recurse. */;
25980 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
25981 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
25983 process_scope_var (stmt
, NULL_TREE
, decl
, context_die
);
25987 /* Even if we're at -g1, we need to process the subblocks in order to get
25988 inlined call information. */
25990 /* Output the DIEs to represent all sub-blocks (and the items declared
25991 therein) of this block. */
25993 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
25995 subblocks
= BLOCK_CHAIN (subblocks
))
25996 gen_block_die (subblocks
, context_die
);
25999 /* Is this a typedef we can avoid emitting? */
26002 is_redundant_typedef (const_tree decl
)
26004 if (TYPE_DECL_IS_STUB (decl
))
26007 if (DECL_ARTIFICIAL (decl
)
26008 && DECL_CONTEXT (decl
)
26009 && is_tagged_type (DECL_CONTEXT (decl
))
26010 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
26011 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
26012 /* Also ignore the artificial member typedef for the class name. */
26018 /* Return TRUE if TYPE is a typedef that names a type for linkage
26019 purposes. This kind of typedefs is produced by the C++ FE for
26022 typedef struct {...} foo;
26024 In that case, there is no typedef variant type produced for foo.
26025 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
26029 is_naming_typedef_decl (const_tree decl
)
26031 if (decl
== NULL_TREE
26032 || TREE_CODE (decl
) != TYPE_DECL
26033 || DECL_NAMELESS (decl
)
26034 || !is_tagged_type (TREE_TYPE (decl
))
26035 || DECL_IS_BUILTIN (decl
)
26036 || is_redundant_typedef (decl
)
26037 /* It looks like Ada produces TYPE_DECLs that are very similar
26038 to C++ naming typedefs but that have different
26039 semantics. Let's be specific to c++ for now. */
26043 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
26044 && TYPE_NAME (TREE_TYPE (decl
)) == decl
26045 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
26046 != TYPE_NAME (TREE_TYPE (decl
))));
26049 /* Looks up the DIE for a context. */
26051 static inline dw_die_ref
26052 lookup_context_die (tree context
)
26056 /* Find die that represents this context. */
26057 if (TYPE_P (context
))
26059 context
= TYPE_MAIN_VARIANT (context
);
26060 dw_die_ref ctx
= lookup_type_die (context
);
26063 return strip_naming_typedef (context
, ctx
);
26066 return lookup_decl_die (context
);
26068 return comp_unit_die ();
26071 /* Returns the DIE for a context. */
26073 static inline dw_die_ref
26074 get_context_die (tree context
)
26078 /* Find die that represents this context. */
26079 if (TYPE_P (context
))
26081 context
= TYPE_MAIN_VARIANT (context
);
26082 return strip_naming_typedef (context
, force_type_die (context
));
26085 return force_decl_die (context
);
26087 return comp_unit_die ();
26090 /* Returns the DIE for decl. A DIE will always be returned. */
26093 force_decl_die (tree decl
)
26095 dw_die_ref decl_die
;
26096 unsigned saved_external_flag
;
26097 tree save_fn
= NULL_TREE
;
26098 decl_die
= lookup_decl_die (decl
);
26101 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
26103 decl_die
= lookup_decl_die (decl
);
26107 switch (TREE_CODE (decl
))
26109 case FUNCTION_DECL
:
26110 /* Clear current_function_decl, so that gen_subprogram_die thinks
26111 that this is a declaration. At this point, we just want to force
26112 declaration die. */
26113 save_fn
= current_function_decl
;
26114 current_function_decl
= NULL_TREE
;
26115 gen_subprogram_die (decl
, context_die
);
26116 current_function_decl
= save_fn
;
26120 /* Set external flag to force declaration die. Restore it after
26121 gen_decl_die() call. */
26122 saved_external_flag
= DECL_EXTERNAL (decl
);
26123 DECL_EXTERNAL (decl
) = 1;
26124 gen_decl_die (decl
, NULL
, NULL
, context_die
);
26125 DECL_EXTERNAL (decl
) = saved_external_flag
;
26128 case NAMESPACE_DECL
:
26129 if (dwarf_version
>= 3 || !dwarf_strict
)
26130 dwarf2out_decl (decl
);
26132 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
26133 decl_die
= comp_unit_die ();
26136 case TRANSLATION_UNIT_DECL
:
26137 decl_die
= comp_unit_die ();
26141 gcc_unreachable ();
26144 /* We should be able to find the DIE now. */
26146 decl_die
= lookup_decl_die (decl
);
26147 gcc_assert (decl_die
);
26153 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
26154 always returned. */
26157 force_type_die (tree type
)
26159 dw_die_ref type_die
;
26161 type_die
= lookup_type_die (type
);
26164 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
26166 type_die
= modified_type_die (type
, TYPE_QUALS_NO_ADDR_SPACE (type
),
26167 false, context_die
);
26168 gcc_assert (type_die
);
26173 /* Force out any required namespaces to be able to output DECL,
26174 and return the new context_die for it, if it's changed. */
26177 setup_namespace_context (tree thing
, dw_die_ref context_die
)
26179 tree context
= (DECL_P (thing
)
26180 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
26181 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
26182 /* Force out the namespace. */
26183 context_die
= force_decl_die (context
);
26185 return context_die
;
26188 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
26189 type) within its namespace, if appropriate.
26191 For compatibility with older debuggers, namespace DIEs only contain
26192 declarations; all definitions are emitted at CU scope, with
26193 DW_AT_specification pointing to the declaration (like with class
26197 declare_in_namespace (tree thing
, dw_die_ref context_die
)
26199 dw_die_ref ns_context
;
26201 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26202 return context_die
;
26204 /* External declarations in the local scope only need to be emitted
26205 once, not once in the namespace and once in the scope.
26207 This avoids declaring the `extern' below in the
26208 namespace DIE as well as in the innermost scope:
26221 if (DECL_P (thing
) && DECL_EXTERNAL (thing
) && local_scope_p (context_die
))
26222 return context_die
;
26224 /* If this decl is from an inlined function, then don't try to emit it in its
26225 namespace, as we will get confused. It would have already been emitted
26226 when the abstract instance of the inline function was emitted anyways. */
26227 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
26228 return context_die
;
26230 ns_context
= setup_namespace_context (thing
, context_die
);
26232 if (ns_context
!= context_die
)
26234 if (is_fortran () || is_dlang ())
26236 if (DECL_P (thing
))
26237 gen_decl_die (thing
, NULL
, NULL
, ns_context
);
26239 gen_type_die (thing
, ns_context
);
26241 return context_die
;
26244 /* Generate a DIE for a namespace or namespace alias. */
26247 gen_namespace_die (tree decl
, dw_die_ref context_die
)
26249 dw_die_ref namespace_die
;
26251 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
26252 they are an alias of. */
26253 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
26255 /* Output a real namespace or module. */
26256 context_die
= setup_namespace_context (decl
, comp_unit_die ());
26257 namespace_die
= new_die (is_fortran () || is_dlang ()
26258 ? DW_TAG_module
: DW_TAG_namespace
,
26259 context_die
, decl
);
26260 /* For Fortran modules defined in different CU don't add src coords. */
26261 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
26263 const char *name
= dwarf2_name (decl
, 0);
26265 add_name_attribute (namespace_die
, name
);
26268 add_name_and_src_coords_attributes (namespace_die
, decl
);
26269 if (DECL_EXTERNAL (decl
))
26270 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
26271 equate_decl_number_to_die (decl
, namespace_die
);
26275 /* Output a namespace alias. */
26277 /* Force out the namespace we are an alias of, if necessary. */
26278 dw_die_ref origin_die
26279 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
26281 if (DECL_FILE_SCOPE_P (decl
)
26282 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
26283 context_die
= setup_namespace_context (decl
, comp_unit_die ());
26284 /* Now create the namespace alias DIE. */
26285 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
26286 add_name_and_src_coords_attributes (namespace_die
, decl
);
26287 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
26288 equate_decl_number_to_die (decl
, namespace_die
);
26290 if ((dwarf_version
>= 5 || !dwarf_strict
)
26291 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
26292 DW_AT_export_symbols
) == 1)
26293 add_AT_flag (namespace_die
, DW_AT_export_symbols
, 1);
26295 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
26296 if (want_pubnames ())
26297 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
26300 /* Generate Dwarf debug information for a decl described by DECL.
26301 The return value is currently only meaningful for PARM_DECLs,
26302 for all other decls it returns NULL.
26304 If DECL is a FIELD_DECL, CTX is required: see the comment for VLR_CONTEXT.
26305 It can be NULL otherwise. */
26308 gen_decl_die (tree decl
, tree origin
, struct vlr_context
*ctx
,
26309 dw_die_ref context_die
)
26311 tree decl_or_origin
= decl
? decl
: origin
;
26312 tree class_origin
= NULL
, ultimate_origin
;
26314 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
26317 switch (TREE_CODE (decl_or_origin
))
26323 if (!is_fortran () && !is_ada () && !is_dlang ())
26325 /* The individual enumerators of an enum type get output when we output
26326 the Dwarf representation of the relevant enum type itself. */
26330 /* Emit its type. */
26331 gen_type_die (TREE_TYPE (decl
), context_die
);
26333 /* And its containing namespace. */
26334 context_die
= declare_in_namespace (decl
, context_die
);
26336 gen_const_die (decl
, context_die
);
26339 case FUNCTION_DECL
:
26342 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
26343 on local redeclarations of global functions. That seems broken. */
26344 if (current_function_decl
!= decl
)
26345 /* This is only a declaration. */;
26348 /* We should have abstract copies already and should not generate
26349 stray type DIEs in late LTO dumping. */
26353 /* If we're emitting a clone, emit info for the abstract instance. */
26354 else if (origin
|| DECL_ORIGIN (decl
) != decl
)
26355 dwarf2out_abstract_function (origin
26356 ? DECL_ORIGIN (origin
)
26357 : DECL_ABSTRACT_ORIGIN (decl
));
26359 /* If we're emitting a possibly inlined function emit it as
26360 abstract instance. */
26361 else if (cgraph_function_possibly_inlined_p (decl
)
26362 && ! DECL_ABSTRACT_P (decl
)
26363 && ! class_or_namespace_scope_p (context_die
)
26364 /* dwarf2out_abstract_function won't emit a die if this is just
26365 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
26366 that case, because that works only if we have a die. */
26367 && DECL_INITIAL (decl
) != NULL_TREE
)
26368 dwarf2out_abstract_function (decl
);
26370 /* Otherwise we're emitting the primary DIE for this decl. */
26371 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
26373 /* Before we describe the FUNCTION_DECL itself, make sure that we
26374 have its containing type. */
26376 origin
= decl_class_context (decl
);
26377 if (origin
!= NULL_TREE
)
26378 gen_type_die (origin
, context_die
);
26380 /* And its return type. */
26381 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
26383 /* And its virtual context. */
26384 if (DECL_VINDEX (decl
) != NULL_TREE
)
26385 gen_type_die (DECL_CONTEXT (decl
), context_die
);
26387 /* Make sure we have a member DIE for decl. */
26388 if (origin
!= NULL_TREE
)
26389 gen_type_die_for_member (origin
, decl
, context_die
);
26391 /* And its containing namespace. */
26392 context_die
= declare_in_namespace (decl
, context_die
);
26395 /* Now output a DIE to represent the function itself. */
26397 gen_subprogram_die (decl
, context_die
);
26401 /* If we are in terse mode, don't generate any DIEs to represent any
26402 actual typedefs. */
26403 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26406 /* In the special case of a TYPE_DECL node representing the declaration
26407 of some type tag, if the given TYPE_DECL is marked as having been
26408 instantiated from some other (original) TYPE_DECL node (e.g. one which
26409 was generated within the original definition of an inline function) we
26410 used to generate a special (abbreviated) DW_TAG_structure_type,
26411 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
26412 should be actually referencing those DIEs, as variable DIEs with that
26413 type would be emitted already in the abstract origin, so it was always
26414 removed during unused type prunning. Don't add anything in this
26416 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
26419 if (is_redundant_typedef (decl
))
26420 gen_type_die (TREE_TYPE (decl
), context_die
);
26422 /* Output a DIE to represent the typedef itself. */
26423 gen_typedef_die (decl
, context_die
);
26427 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
26428 gen_label_die (decl
, context_die
);
26433 /* If we are in terse mode, don't generate any DIEs to represent any
26434 variable declarations or definitions. */
26435 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26438 /* Avoid generating stray type DIEs during late dwarf dumping.
26439 All types have been dumped early. */
26441 /* ??? But in LTRANS we cannot annotate early created variably
26442 modified type DIEs without copying them and adjusting all
26443 references to them. Dump them again as happens for inlining
26444 which copies both the decl and the types. */
26445 /* ??? And even non-LTO needs to re-visit type DIEs to fill
26446 in VLA bound information for example. */
26447 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
26448 current_function_decl
)))
26450 /* Output any DIEs that are needed to specify the type of this data
26452 if (decl_by_reference_p (decl_or_origin
))
26453 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
26455 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
26460 /* And its containing type. */
26461 class_origin
= decl_class_context (decl_or_origin
);
26462 if (class_origin
!= NULL_TREE
)
26463 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
26465 /* And its containing namespace. */
26466 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
26469 /* Now output the DIE to represent the data object itself. This gets
26470 complicated because of the possibility that the VAR_DECL really
26471 represents an inlined instance of a formal parameter for an inline
26473 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
26474 if (ultimate_origin
!= NULL_TREE
26475 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
26476 gen_formal_parameter_die (decl
, origin
,
26477 true /* Emit name attribute. */,
26480 gen_variable_die (decl
, origin
, context_die
);
26484 gcc_assert (ctx
!= NULL
&& ctx
->struct_type
!= NULL
);
26485 /* Ignore the nameless fields that are used to skip bits but handle C++
26486 anonymous unions and structs. */
26487 if (DECL_NAME (decl
) != NULL_TREE
26488 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
26489 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
26491 gen_type_die (member_declared_type (decl
), context_die
);
26492 gen_field_die (decl
, ctx
, context_die
);
26497 /* Avoid generating stray type DIEs during late dwarf dumping.
26498 All types have been dumped early. */
26500 /* ??? But in LTRANS we cannot annotate early created variably
26501 modified type DIEs without copying them and adjusting all
26502 references to them. Dump them again as happens for inlining
26503 which copies both the decl and the types. */
26504 /* ??? And even non-LTO needs to re-visit type DIEs to fill
26505 in VLA bound information for example. */
26506 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
26507 current_function_decl
)))
26509 if (DECL_BY_REFERENCE (decl_or_origin
))
26510 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
26512 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
26514 return gen_formal_parameter_die (decl
, origin
,
26515 true /* Emit name attribute. */,
26518 case NAMESPACE_DECL
:
26519 if (dwarf_version
>= 3 || !dwarf_strict
)
26520 gen_namespace_die (decl
, context_die
);
26523 case IMPORTED_DECL
:
26524 dwarf2out_imported_module_or_decl_1 (decl
, DECL_NAME (decl
),
26525 DECL_CONTEXT (decl
), context_die
);
26528 case NAMELIST_DECL
:
26529 gen_namelist_decl (DECL_NAME (decl
), context_die
,
26530 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
26534 /* Probably some frontend-internal decl. Assume we don't care. */
26535 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
26542 /* Output initial debug information for global DECL. Called at the
26543 end of the parsing process.
26545 This is the initial debug generation process. As such, the DIEs
26546 generated may be incomplete. A later debug generation pass
26547 (dwarf2out_late_global_decl) will augment the information generated
26548 in this pass (e.g., with complete location info). */
26551 dwarf2out_early_global_decl (tree decl
)
26555 /* gen_decl_die() will set DECL_ABSTRACT because
26556 cgraph_function_possibly_inlined_p() returns true. This is in
26557 turn will cause DW_AT_inline attributes to be set.
26559 This happens because at early dwarf generation, there is no
26560 cgraph information, causing cgraph_function_possibly_inlined_p()
26561 to return true. Trick cgraph_function_possibly_inlined_p()
26562 while we generate dwarf early. */
26563 bool save
= symtab
->global_info_ready
;
26564 symtab
->global_info_ready
= true;
26566 /* We don't handle TYPE_DECLs. If required, they'll be reached via
26567 other DECLs and they can point to template types or other things
26568 that dwarf2out can't handle when done via dwarf2out_decl. */
26569 if (TREE_CODE (decl
) != TYPE_DECL
26570 && TREE_CODE (decl
) != PARM_DECL
)
26572 if (TREE_CODE (decl
) == FUNCTION_DECL
)
26574 tree save_fndecl
= current_function_decl
;
26576 /* For nested functions, make sure we have DIEs for the parents first
26577 so that all nested DIEs are generated at the proper scope in the
26579 tree context
= decl_function_context (decl
);
26580 if (context
!= NULL
)
26582 dw_die_ref context_die
= lookup_decl_die (context
);
26583 current_function_decl
= context
;
26585 /* Avoid emitting DIEs multiple times, but still process CONTEXT
26586 enough so that it lands in its own context. This avoids type
26587 pruning issues later on. */
26588 if (context_die
== NULL
|| is_declaration_die (context_die
))
26589 dwarf2out_early_global_decl (context
);
26592 /* Emit an abstract origin of a function first. This happens
26593 with C++ constructor clones for example and makes
26594 dwarf2out_abstract_function happy which requires the early
26595 DIE of the abstract instance to be present. */
26596 tree origin
= DECL_ABSTRACT_ORIGIN (decl
);
26597 dw_die_ref origin_die
;
26599 /* Do not emit the DIE multiple times but make sure to
26600 process it fully here in case we just saw a declaration. */
26601 && ((origin_die
= lookup_decl_die (origin
)) == NULL
26602 || is_declaration_die (origin_die
)))
26604 current_function_decl
= origin
;
26605 dwarf2out_decl (origin
);
26608 /* Emit the DIE for decl but avoid doing that multiple times. */
26609 dw_die_ref old_die
;
26610 if ((old_die
= lookup_decl_die (decl
)) == NULL
26611 || is_declaration_die (old_die
))
26613 current_function_decl
= decl
;
26614 dwarf2out_decl (decl
);
26617 current_function_decl
= save_fndecl
;
26620 dwarf2out_decl (decl
);
26622 symtab
->global_info_ready
= save
;
26625 /* Return whether EXPR is an expression with the following pattern:
26626 INDIRECT_REF (NOP_EXPR (INTEGER_CST)). */
26629 is_trivial_indirect_ref (tree expr
)
26631 if (expr
== NULL_TREE
|| TREE_CODE (expr
) != INDIRECT_REF
)
26634 tree nop
= TREE_OPERAND (expr
, 0);
26635 if (nop
== NULL_TREE
|| TREE_CODE (nop
) != NOP_EXPR
)
26638 tree int_cst
= TREE_OPERAND (nop
, 0);
26639 return int_cst
!= NULL_TREE
&& TREE_CODE (int_cst
) == INTEGER_CST
;
26642 /* Output debug information for global decl DECL. Called from
26643 toplev.c after compilation proper has finished. */
26646 dwarf2out_late_global_decl (tree decl
)
26648 /* Fill-in any location information we were unable to determine
26649 on the first pass. */
26652 dw_die_ref die
= lookup_decl_die (decl
);
26654 /* We may have to generate early debug late for LTO in case debug
26655 was not enabled at compile-time or the target doesn't support
26656 the LTO early debug scheme. */
26657 if (! die
&& in_lto_p
)
26659 dwarf2out_decl (decl
);
26660 die
= lookup_decl_die (decl
);
26665 /* We get called via the symtab code invoking late_global_decl
26666 for symbols that are optimized out.
26668 Do not add locations for those, except if they have a
26669 DECL_VALUE_EXPR, in which case they are relevant for debuggers.
26670 Still don't add a location if the DECL_VALUE_EXPR is not a trivial
26671 INDIRECT_REF expression, as this could generate relocations to
26672 text symbols in LTO object files, which is invalid. */
26673 varpool_node
*node
= varpool_node::get (decl
);
26674 if ((! node
|| ! node
->definition
)
26675 && ! (DECL_HAS_VALUE_EXPR_P (decl
)
26676 && is_trivial_indirect_ref (DECL_VALUE_EXPR (decl
))))
26677 tree_add_const_value_attribute_for_decl (die
, decl
);
26679 add_location_or_const_value_attribute (die
, decl
, false);
26684 /* Output debug information for type decl DECL. Called from toplev.c
26685 and from language front ends (to record built-in types). */
26687 dwarf2out_type_decl (tree decl
, int local
)
26692 dwarf2out_decl (decl
);
26696 /* Output debug information for imported module or decl DECL.
26697 NAME is non-NULL name in the lexical block if the decl has been renamed.
26698 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
26699 that DECL belongs to.
26700 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
26702 dwarf2out_imported_module_or_decl_1 (tree decl
,
26704 tree lexical_block
,
26705 dw_die_ref lexical_block_die
)
26707 expanded_location xloc
;
26708 dw_die_ref imported_die
= NULL
;
26709 dw_die_ref at_import_die
;
26711 if (TREE_CODE (decl
) == IMPORTED_DECL
)
26713 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
26714 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
26718 xloc
= expand_location (input_location
);
26720 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
26722 at_import_die
= force_type_die (TREE_TYPE (decl
));
26723 /* For namespace N { typedef void T; } using N::T; base_type_die
26724 returns NULL, but DW_TAG_imported_declaration requires
26725 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
26726 if (!at_import_die
)
26728 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
26729 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
26730 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
26731 gcc_assert (at_import_die
);
26736 at_import_die
= lookup_decl_die (decl
);
26737 if (!at_import_die
)
26739 /* If we're trying to avoid duplicate debug info, we may not have
26740 emitted the member decl for this field. Emit it now. */
26741 if (TREE_CODE (decl
) == FIELD_DECL
)
26743 tree type
= DECL_CONTEXT (decl
);
26745 if (TYPE_CONTEXT (type
)
26746 && TYPE_P (TYPE_CONTEXT (type
))
26747 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
26748 DINFO_USAGE_DIR_USE
))
26750 gen_type_die_for_member (type
, decl
,
26751 get_context_die (TYPE_CONTEXT (type
)));
26753 if (TREE_CODE (decl
) == NAMELIST_DECL
)
26754 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
26755 get_context_die (DECL_CONTEXT (decl
)),
26758 at_import_die
= force_decl_die (decl
);
26762 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
26764 if (dwarf_version
>= 3 || !dwarf_strict
)
26765 imported_die
= new_die (DW_TAG_imported_module
,
26772 imported_die
= new_die (DW_TAG_imported_declaration
,
26776 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
26777 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
26778 if (debug_column_info
&& xloc
.column
)
26779 add_AT_unsigned (imported_die
, DW_AT_decl_column
, xloc
.column
);
26781 add_AT_string (imported_die
, DW_AT_name
,
26782 IDENTIFIER_POINTER (name
));
26783 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
26786 /* Output debug information for imported module or decl DECL.
26787 NAME is non-NULL name in context if the decl has been renamed.
26788 CHILD is true if decl is one of the renamed decls as part of
26789 importing whole module.
26790 IMPLICIT is set if this hook is called for an implicit import
26791 such as inline namespace. */
26794 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
26795 bool child
, bool implicit
)
26797 /* dw_die_ref at_import_die; */
26798 dw_die_ref scope_die
;
26800 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26805 /* For DWARF5, just DW_AT_export_symbols on the DW_TAG_namespace
26806 should be enough, for DWARF4 and older even if we emit as extension
26807 DW_AT_export_symbols add the implicit DW_TAG_imported_module anyway
26808 for the benefit of consumers unaware of DW_AT_export_symbols. */
26810 && dwarf_version
>= 5
26811 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
26812 DW_AT_export_symbols
) == 1)
26817 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
26818 We need decl DIE for reference and scope die. First, get DIE for the decl
26821 /* Get the scope die for decl context. Use comp_unit_die for global module
26822 or decl. If die is not found for non globals, force new die. */
26824 && TYPE_P (context
)
26825 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
26828 scope_die
= get_context_die (context
);
26832 /* DW_TAG_imported_module was introduced in the DWARFv3 specification, so
26833 there is nothing we can do, here. */
26834 if (dwarf_version
< 3 && dwarf_strict
)
26837 gcc_assert (scope_die
->die_child
);
26838 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
26839 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
26840 scope_die
= scope_die
->die_child
;
26843 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
26844 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
26847 /* Output debug information for namelists. */
26850 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
26852 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
26856 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26859 gcc_assert (scope_die
!= NULL
);
26860 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
26861 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
26863 /* If there are no item_decls, we have a nondefining namelist, e.g.
26864 with USE association; hence, set DW_AT_declaration. */
26865 if (item_decls
== NULL_TREE
)
26867 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
26871 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
26873 nml_item_ref_die
= lookup_decl_die (value
);
26874 if (!nml_item_ref_die
)
26875 nml_item_ref_die
= force_decl_die (value
);
26877 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
26878 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
26884 /* Write the debugging output for DECL and return the DIE. */
26887 dwarf2out_decl (tree decl
)
26889 dw_die_ref context_die
= comp_unit_die ();
26891 switch (TREE_CODE (decl
))
26896 case FUNCTION_DECL
:
26897 /* If we're a nested function, initially use a parent of NULL; if we're
26898 a plain function, this will be fixed up in decls_for_scope. If
26899 we're a method, it will be ignored, since we already have a DIE.
26900 Avoid doing this late though since clones of class methods may
26901 otherwise end up in limbo and create type DIEs late. */
26903 && decl_function_context (decl
)
26904 /* But if we're in terse mode, we don't care about scope. */
26905 && debug_info_level
> DINFO_LEVEL_TERSE
)
26906 context_die
= NULL
;
26910 /* For local statics lookup proper context die. */
26911 if (local_function_static (decl
))
26912 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
26914 /* If we are in terse mode, don't generate any DIEs to represent any
26915 variable declarations or definitions. */
26916 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26921 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26923 if (!is_fortran () && !is_ada () && !is_dlang ())
26925 if (TREE_STATIC (decl
) && decl_function_context (decl
))
26926 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
26929 case NAMESPACE_DECL
:
26930 case IMPORTED_DECL
:
26931 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26933 if (lookup_decl_die (decl
) != NULL
)
26938 /* Don't emit stubs for types unless they are needed by other DIEs. */
26939 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
26942 /* Don't bother trying to generate any DIEs to represent any of the
26943 normal built-in types for the language we are compiling. */
26944 if (DECL_IS_BUILTIN (decl
))
26947 /* If we are in terse mode, don't generate any DIEs for types. */
26948 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
26951 /* If we're a function-scope tag, initially use a parent of NULL;
26952 this will be fixed up in decls_for_scope. */
26953 if (decl_function_context (decl
))
26954 context_die
= NULL
;
26958 case NAMELIST_DECL
:
26965 gen_decl_die (decl
, NULL
, NULL
, context_die
);
26969 dw_die_ref die
= lookup_decl_die (decl
);
26975 /* Write the debugging output for DECL. */
26978 dwarf2out_function_decl (tree decl
)
26980 dwarf2out_decl (decl
);
26981 call_arg_locations
= NULL
;
26982 call_arg_loc_last
= NULL
;
26983 call_site_count
= -1;
26984 tail_call_site_count
= -1;
26985 decl_loc_table
->empty ();
26986 cached_dw_loc_list_table
->empty ();
26989 /* Output a marker (i.e. a label) for the beginning of the generated code for
26990 a lexical block. */
26993 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
26994 unsigned int blocknum
)
26996 switch_to_section (current_function_section ());
26997 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
27000 /* Output a marker (i.e. a label) for the end of the generated code for a
27004 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
27006 switch_to_section (current_function_section ());
27007 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
27010 /* Returns nonzero if it is appropriate not to emit any debugging
27011 information for BLOCK, because it doesn't contain any instructions.
27013 Don't allow this for blocks with nested functions or local classes
27014 as we would end up with orphans, and in the presence of scheduling
27015 we may end up calling them anyway. */
27018 dwarf2out_ignore_block (const_tree block
)
27023 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
27024 if (TREE_CODE (decl
) == FUNCTION_DECL
27025 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
27027 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
27029 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
27030 if (TREE_CODE (decl
) == FUNCTION_DECL
27031 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
27038 /* Hash table routines for file_hash. */
27041 dwarf_file_hasher::equal (dwarf_file_data
*p1
, const char *p2
)
27043 return filename_cmp (p1
->filename
, p2
) == 0;
27047 dwarf_file_hasher::hash (dwarf_file_data
*p
)
27049 return htab_hash_string (p
->filename
);
27052 /* Lookup FILE_NAME (in the list of filenames that we know about here in
27053 dwarf2out.c) and return its "index". The index of each (known) filename is
27054 just a unique number which is associated with only that one filename. We
27055 need such numbers for the sake of generating labels (in the .debug_sfnames
27056 section) and references to those files numbers (in the .debug_srcinfo
27057 and .debug_macinfo sections). If the filename given as an argument is not
27058 found in our current list, add it to the list and assign it the next
27059 available unique index number. */
27061 static struct dwarf_file_data
*
27062 lookup_filename (const char *file_name
)
27064 struct dwarf_file_data
* created
;
27069 dwarf_file_data
**slot
27070 = file_table
->find_slot_with_hash (file_name
, htab_hash_string (file_name
),
27075 created
= ggc_alloc
<dwarf_file_data
> ();
27076 created
->filename
= file_name
;
27077 created
->emitted_number
= 0;
27082 /* If the assembler will construct the file table, then translate the compiler
27083 internal file table number into the assembler file table number, and emit
27084 a .file directive if we haven't already emitted one yet. The file table
27085 numbers are different because we prune debug info for unused variables and
27086 types, which may include filenames. */
27089 maybe_emit_file (struct dwarf_file_data
* fd
)
27091 if (! fd
->emitted_number
)
27093 if (last_emitted_file
)
27094 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
27096 fd
->emitted_number
= 1;
27097 last_emitted_file
= fd
;
27099 if (output_asm_line_debug_info ())
27101 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
27102 output_quoted_string (asm_out_file
,
27103 remap_debug_filename (fd
->filename
));
27104 fputc ('\n', asm_out_file
);
27108 return fd
->emitted_number
;
27111 /* Schedule generation of a DW_AT_const_value attribute to DIE.
27112 That generation should happen after function debug info has been
27113 generated. The value of the attribute is the constant value of ARG. */
27116 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
27118 die_arg_entry entry
;
27123 gcc_assert (early_dwarf
);
27125 if (!tmpl_value_parm_die_table
)
27126 vec_alloc (tmpl_value_parm_die_table
, 32);
27130 vec_safe_push (tmpl_value_parm_die_table
, entry
);
27133 /* Return TRUE if T is an instance of generic type, FALSE
27137 generic_type_p (tree t
)
27139 if (t
== NULL_TREE
|| !TYPE_P (t
))
27141 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
27144 /* Schedule the generation of the generic parameter dies for the
27145 instance of generic type T. The proper generation itself is later
27146 done by gen_scheduled_generic_parms_dies. */
27149 schedule_generic_params_dies_gen (tree t
)
27151 if (!generic_type_p (t
))
27154 gcc_assert (early_dwarf
);
27156 if (!generic_type_instances
)
27157 vec_alloc (generic_type_instances
, 256);
27159 vec_safe_push (generic_type_instances
, t
);
27162 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
27163 by append_entry_to_tmpl_value_parm_die_table. This function must
27164 be called after function DIEs have been generated. */
27167 gen_remaining_tmpl_value_param_die_attribute (void)
27169 if (tmpl_value_parm_die_table
)
27174 /* We do this in two phases - first get the cases we can
27175 handle during early-finish, preserving those we cannot
27176 (containing symbolic constants where we don't yet know
27177 whether we are going to output the referenced symbols).
27178 For those we try again at late-finish. */
27180 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
27182 if (!e
->die
->removed
27183 && !tree_add_const_value_attribute (e
->die
, e
->arg
))
27185 dw_loc_descr_ref loc
= NULL
;
27187 && (dwarf_version
>= 5 || !dwarf_strict
))
27188 loc
= loc_descriptor_from_tree (e
->arg
, 2, NULL
);
27190 add_AT_loc (e
->die
, DW_AT_location
, loc
);
27192 (*tmpl_value_parm_die_table
)[j
++] = *e
;
27195 tmpl_value_parm_die_table
->truncate (j
);
27199 /* Generate generic parameters DIEs for instances of generic types
27200 that have been previously scheduled by
27201 schedule_generic_params_dies_gen. This function must be called
27202 after all the types of the CU have been laid out. */
27205 gen_scheduled_generic_parms_dies (void)
27210 if (!generic_type_instances
)
27213 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
27214 if (COMPLETE_TYPE_P (t
))
27215 gen_generic_params_dies (t
);
27217 generic_type_instances
= NULL
;
27221 /* Replace DW_AT_name for the decl with name. */
27224 dwarf2out_set_name (tree decl
, tree name
)
27227 dw_attr_node
*attr
;
27230 die
= TYPE_SYMTAB_DIE (decl
);
27234 dname
= dwarf2_name (name
, 0);
27238 attr
= get_AT (die
, DW_AT_name
);
27241 struct indirect_string_node
*node
;
27243 node
= find_AT_string (dname
);
27244 /* replace the string. */
27245 attr
->dw_attr_val
.v
.val_str
= node
;
27249 add_name_attribute (die
, dname
);
27252 /* True if before or during processing of the first function being emitted. */
27253 static bool in_first_function_p
= true;
27254 /* True if loc_note during dwarf2out_var_location call might still be
27255 before first real instruction at address equal to .Ltext0. */
27256 static bool maybe_at_text_label_p
= true;
27257 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
27258 static unsigned int first_loclabel_num_not_at_text_label
;
27260 /* Look ahead for a real insn, or for a begin stmt marker. */
27263 dwarf2out_next_real_insn (rtx_insn
*loc_note
)
27265 rtx_insn
*next_real
= NEXT_INSN (loc_note
);
27268 if (INSN_P (next_real
))
27271 next_real
= NEXT_INSN (next_real
);
27276 /* Called by the final INSN scan whenever we see a var location. We
27277 use it to drop labels in the right places, and throw the location in
27278 our lookup table. */
27281 dwarf2out_var_location (rtx_insn
*loc_note
)
27283 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
27284 struct var_loc_node
*newloc
;
27285 rtx_insn
*next_real
, *next_note
;
27286 rtx_insn
*call_insn
= NULL
;
27287 static const char *last_label
;
27288 static const char *last_postcall_label
;
27289 static bool last_in_cold_section_p
;
27290 static rtx_insn
*expected_next_loc_note
;
27293 var_loc_view view
= 0;
27295 if (!NOTE_P (loc_note
))
27297 if (CALL_P (loc_note
))
27299 maybe_reset_location_view (loc_note
, cur_line_info_table
);
27301 if (SIBLING_CALL_P (loc_note
))
27302 tail_call_site_count
++;
27303 if (find_reg_note (loc_note
, REG_CALL_ARG_LOCATION
, NULL_RTX
))
27305 call_insn
= loc_note
;
27309 next_real
= dwarf2out_next_real_insn (call_insn
);
27311 cached_next_real_insn
= NULL
;
27314 if (optimize
== 0 && !flag_var_tracking
)
27316 /* When the var-tracking pass is not running, there is no note
27317 for indirect calls whose target is compile-time known. In this
27318 case, process such calls specifically so that we generate call
27319 sites for them anyway. */
27320 rtx x
= PATTERN (loc_note
);
27321 if (GET_CODE (x
) == PARALLEL
)
27322 x
= XVECEXP (x
, 0, 0);
27323 if (GET_CODE (x
) == SET
)
27325 if (GET_CODE (x
) == CALL
)
27328 || GET_CODE (XEXP (x
, 0)) != SYMBOL_REF
27329 || !SYMBOL_REF_DECL (XEXP (x
, 0))
27330 || (TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0)))
27333 call_insn
= loc_note
;
27337 next_real
= dwarf2out_next_real_insn (call_insn
);
27339 cached_next_real_insn
= NULL
;
27344 else if (!debug_variable_location_views
)
27345 gcc_unreachable ();
27347 maybe_reset_location_view (loc_note
, cur_line_info_table
);
27352 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
27353 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
27356 /* Optimize processing a large consecutive sequence of location
27357 notes so we don't spend too much time in next_real_insn. If the
27358 next insn is another location note, remember the next_real_insn
27359 calculation for next time. */
27360 next_real
= cached_next_real_insn
;
27363 if (expected_next_loc_note
!= loc_note
)
27367 next_note
= NEXT_INSN (loc_note
);
27369 || next_note
->deleted ()
27370 || ! NOTE_P (next_note
)
27371 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
27372 && NOTE_KIND (next_note
) != NOTE_INSN_BEGIN_STMT
27373 && NOTE_KIND (next_note
) != NOTE_INSN_INLINE_ENTRY
))
27377 next_real
= dwarf2out_next_real_insn (loc_note
);
27381 expected_next_loc_note
= next_note
;
27382 cached_next_real_insn
= next_real
;
27385 cached_next_real_insn
= NULL
;
27387 /* If there are no instructions which would be affected by this note,
27388 don't do anything. */
27390 && next_real
== NULL_RTX
27391 && !NOTE_DURING_CALL_P (loc_note
))
27396 if (next_real
== NULL_RTX
)
27397 next_real
= get_last_insn ();
27399 /* If there were any real insns between note we processed last time
27400 and this note (or if it is the first note), clear
27401 last_{,postcall_}label so that they are not reused this time. */
27402 if (last_var_location_insn
== NULL_RTX
27403 || last_var_location_insn
!= next_real
27404 || last_in_cold_section_p
!= in_cold_section_p
)
27407 last_postcall_label
= NULL
;
27413 = NOTE_DURING_CALL_P (loc_note
) ? last_postcall_label
: last_label
;
27414 view
= cur_line_info_table
->view
;
27415 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
27416 newloc
= add_var_loc_to_decl (decl
, loc_note
, label
, view
);
27417 if (newloc
== NULL
)
27426 /* If there were no real insns between note we processed last time
27427 and this note, use the label we emitted last time. Otherwise
27428 create a new label and emit it. */
27429 if (last_label
== NULL
)
27431 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
27432 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
27434 last_label
= ggc_strdup (loclabel
);
27435 /* See if loclabel might be equal to .Ltext0. If yes,
27436 bump first_loclabel_num_not_at_text_label. */
27437 if (!have_multiple_function_sections
27438 && in_first_function_p
27439 && maybe_at_text_label_p
)
27441 static rtx_insn
*last_start
;
27443 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
27444 if (insn
== last_start
)
27446 else if (!NONDEBUG_INSN_P (insn
))
27450 rtx body
= PATTERN (insn
);
27451 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
27453 /* Inline asm could occupy zero bytes. */
27454 else if (GET_CODE (body
) == ASM_INPUT
27455 || asm_noperands (body
) >= 0)
27457 #ifdef HAVE_ATTR_length /* ??? We don't include insn-attr.h. */
27458 else if (HAVE_ATTR_length
&& get_attr_min_length (insn
) == 0)
27463 /* Assume insn has non-zero length. */
27464 maybe_at_text_label_p
= false;
27468 if (maybe_at_text_label_p
)
27470 last_start
= loc_note
;
27471 first_loclabel_num_not_at_text_label
= loclabel_num
;
27476 gcc_assert ((loc_note
== NULL_RTX
&& call_insn
!= NULL_RTX
)
27477 || (loc_note
!= NULL_RTX
&& call_insn
== NULL_RTX
));
27481 struct call_arg_loc_node
*ca_loc
27482 = ggc_cleared_alloc
<call_arg_loc_node
> ();
27483 rtx_insn
*prev
= call_insn
;
27485 ca_loc
->call_arg_loc_note
27486 = find_reg_note (call_insn
, REG_CALL_ARG_LOCATION
, NULL_RTX
);
27487 ca_loc
->next
= NULL
;
27488 ca_loc
->label
= last_label
;
27491 || (NONJUMP_INSN_P (prev
)
27492 && GET_CODE (PATTERN (prev
)) == SEQUENCE
27493 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
27494 if (!CALL_P (prev
))
27495 prev
= as_a
<rtx_sequence
*> (PATTERN (prev
))->insn (0);
27496 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
27498 /* Look for a SYMBOL_REF in the "prev" instruction. */
27499 rtx x
= get_call_rtx_from (PATTERN (prev
));
27502 /* Try to get the call symbol, if any. */
27503 if (MEM_P (XEXP (x
, 0)))
27505 /* First, look for a memory access to a symbol_ref. */
27506 if (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
27507 && SYMBOL_REF_DECL (XEXP (x
, 0))
27508 && TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0))) == FUNCTION_DECL
)
27509 ca_loc
->symbol_ref
= XEXP (x
, 0);
27510 /* Otherwise, look at a compile-time known user-level function
27514 && TREE_CODE (MEM_EXPR (x
)) == FUNCTION_DECL
)
27515 ca_loc
->symbol_ref
= XEXP (DECL_RTL (MEM_EXPR (x
)), 0);
27518 ca_loc
->block
= insn_scope (prev
);
27519 if (call_arg_locations
)
27520 call_arg_loc_last
->next
= ca_loc
;
27522 call_arg_locations
= ca_loc
;
27523 call_arg_loc_last
= ca_loc
;
27525 else if (loc_note
!= NULL_RTX
&& !NOTE_DURING_CALL_P (loc_note
))
27527 newloc
->label
= last_label
;
27528 newloc
->view
= view
;
27532 if (!last_postcall_label
)
27534 sprintf (loclabel
, "%s-1", last_label
);
27535 last_postcall_label
= ggc_strdup (loclabel
);
27537 newloc
->label
= last_postcall_label
;
27538 /* ??? This view is at last_label, not last_label-1, but we
27539 could only assume view at last_label-1 is zero if we could
27540 assume calls always have length greater than one. This is
27541 probably true in general, though there might be a rare
27542 exception to this rule, e.g. if a call insn is optimized out
27543 by target magic. Then, even the -1 in the label will be
27544 wrong, which might invalidate the range. Anyway, using view,
27545 though technically possibly incorrect, will work as far as
27546 ranges go: since L-1 is in the middle of the call insn,
27547 (L-1).0 and (L-1).V shouldn't make any difference, and having
27548 the loclist entry refer to the .loc entry might be useful, so
27549 leave it like this. */
27550 newloc
->view
= view
;
27553 if (var_loc_p
&& flag_debug_asm
)
27555 const char *name
, *sep
, *patstr
;
27556 if (decl
&& DECL_NAME (decl
))
27557 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
27560 if (NOTE_VAR_LOCATION_LOC (loc_note
))
27563 patstr
= str_pattern_slim (NOTE_VAR_LOCATION_LOC (loc_note
));
27570 fprintf (asm_out_file
, "\t%s DEBUG %s%s%s\n", ASM_COMMENT_START
,
27571 name
, sep
, patstr
);
27574 last_var_location_insn
= next_real
;
27575 last_in_cold_section_p
= in_cold_section_p
;
27578 /* Check whether BLOCK, a lexical block, is nested within OUTER, or is
27579 OUTER itself. If BOTHWAYS, check not only that BLOCK can reach
27580 OUTER through BLOCK_SUPERCONTEXT links, but also that there is a
27581 path from OUTER to BLOCK through BLOCK_SUBBLOCKs and
27582 BLOCK_FRAGMENT_ORIGIN links. */
27584 block_within_block_p (tree block
, tree outer
, bool bothways
)
27586 if (block
== outer
)
27589 /* Quickly check that OUTER is up BLOCK's supercontext chain. */
27590 for (tree context
= BLOCK_SUPERCONTEXT (block
);
27592 context
= BLOCK_SUPERCONTEXT (context
))
27593 if (!context
|| TREE_CODE (context
) != BLOCK
)
27599 /* Now check that each block is actually referenced by its
27601 for (tree context
= BLOCK_SUPERCONTEXT (block
); ;
27602 context
= BLOCK_SUPERCONTEXT (context
))
27604 if (BLOCK_FRAGMENT_ORIGIN (context
))
27606 gcc_assert (!BLOCK_SUBBLOCKS (context
));
27607 context
= BLOCK_FRAGMENT_ORIGIN (context
);
27609 for (tree sub
= BLOCK_SUBBLOCKS (context
);
27611 sub
= BLOCK_CHAIN (sub
))
27614 if (context
== outer
)
27621 /* Called during final while assembling the marker of the entry point
27622 for an inlined function. */
27625 dwarf2out_inline_entry (tree block
)
27627 gcc_assert (debug_inline_points
);
27629 /* If we can't represent it, don't bother. */
27630 if (!(dwarf_version
>= 3 || !dwarf_strict
))
27633 gcc_assert (DECL_P (block_ultimate_origin (block
)));
27635 /* Sanity check the block tree. This would catch a case in which
27636 BLOCK got removed from the tree reachable from the outermost
27637 lexical block, but got retained in markers. It would still link
27638 back to its parents, but some ancestor would be missing a link
27639 down the path to the sub BLOCK. If the block got removed, its
27640 BLOCK_NUMBER will not be a usable value. */
27642 gcc_assert (block_within_block_p (block
,
27643 DECL_INITIAL (current_function_decl
),
27646 gcc_assert (inlined_function_outer_scope_p (block
));
27647 gcc_assert (!lookup_block_die (block
));
27649 if (BLOCK_FRAGMENT_ORIGIN (block
))
27650 block
= BLOCK_FRAGMENT_ORIGIN (block
);
27651 /* Can the entry point ever not be at the beginning of an
27652 unfragmented lexical block? */
27653 else if (!(BLOCK_FRAGMENT_CHAIN (block
)
27654 || (cur_line_info_table
27655 && !ZERO_VIEW_P (cur_line_info_table
->view
))))
27658 if (!inline_entry_data_table
)
27659 inline_entry_data_table
27660 = hash_table
<inline_entry_data_hasher
>::create_ggc (10);
27663 inline_entry_data
**iedp
27664 = inline_entry_data_table
->find_slot_with_hash (block
,
27665 htab_hash_pointer (block
),
27668 /* ??? Ideally, we'd record all entry points for the same inlined
27669 function (some may have been duplicated by e.g. unrolling), but
27670 we have no way to represent that ATM. */
27673 inline_entry_data
*ied
= *iedp
= ggc_cleared_alloc
<inline_entry_data
> ();
27674 ied
->block
= block
;
27675 ied
->label_pfx
= BLOCK_INLINE_ENTRY_LABEL
;
27676 ied
->label_num
= BLOCK_NUMBER (block
);
27677 if (cur_line_info_table
)
27678 ied
->view
= cur_line_info_table
->view
;
27680 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_INLINE_ENTRY_LABEL
,
27681 BLOCK_NUMBER (block
));
27684 /* Called from finalize_size_functions for size functions so that their body
27685 can be encoded in the debug info to describe the layout of variable-length
27689 dwarf2out_size_function (tree decl
)
27691 function_to_dwarf_procedure (decl
);
27694 /* Note in one location list that text section has changed. */
27697 var_location_switch_text_section_1 (var_loc_list
**slot
, void *)
27699 var_loc_list
*list
= *slot
;
27701 list
->last_before_switch
27702 = list
->last
->next
? list
->last
->next
: list
->last
;
27706 /* Note in all location lists that text section has changed. */
27709 var_location_switch_text_section (void)
27711 if (decl_loc_table
== NULL
)
27714 decl_loc_table
->traverse
<void *, var_location_switch_text_section_1
> (NULL
);
27717 /* Create a new line number table. */
27719 static dw_line_info_table
*
27720 new_line_info_table (void)
27722 dw_line_info_table
*table
;
27724 table
= ggc_cleared_alloc
<dw_line_info_table
> ();
27725 table
->file_num
= 1;
27726 table
->line_num
= 1;
27727 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
27728 FORCE_RESET_NEXT_VIEW (table
->view
);
27729 table
->symviews_since_reset
= 0;
27734 /* Lookup the "current" table into which we emit line info, so
27735 that we don't have to do it for every source line. */
27738 set_cur_line_info_table (section
*sec
)
27740 dw_line_info_table
*table
;
27742 if (sec
== text_section
)
27743 table
= text_section_line_info
;
27744 else if (sec
== cold_text_section
)
27746 table
= cold_text_section_line_info
;
27749 cold_text_section_line_info
= table
= new_line_info_table ();
27750 table
->end_label
= cold_end_label
;
27755 const char *end_label
;
27757 if (crtl
->has_bb_partition
)
27759 if (in_cold_section_p
)
27760 end_label
= crtl
->subsections
.cold_section_end_label
;
27762 end_label
= crtl
->subsections
.hot_section_end_label
;
27766 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27767 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
27768 current_function_funcdef_no
);
27769 end_label
= ggc_strdup (label
);
27772 table
= new_line_info_table ();
27773 table
->end_label
= end_label
;
27775 vec_safe_push (separate_line_info
, table
);
27778 if (output_asm_line_debug_info ())
27779 table
->is_stmt
= (cur_line_info_table
27780 ? cur_line_info_table
->is_stmt
27781 : DWARF_LINE_DEFAULT_IS_STMT_START
);
27782 cur_line_info_table
= table
;
27786 /* We need to reset the locations at the beginning of each
27787 function. We can't do this in the end_function hook, because the
27788 declarations that use the locations won't have been output when
27789 that hook is called. Also compute have_multiple_function_sections here. */
27792 dwarf2out_begin_function (tree fun
)
27794 section
*sec
= function_section (fun
);
27796 if (sec
!= text_section
)
27797 have_multiple_function_sections
= true;
27799 if (crtl
->has_bb_partition
&& !cold_text_section
)
27801 gcc_assert (current_function_decl
== fun
);
27802 cold_text_section
= unlikely_text_section ();
27803 switch_to_section (cold_text_section
);
27804 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
27805 switch_to_section (sec
);
27808 dwarf2out_note_section_used ();
27809 call_site_count
= 0;
27810 tail_call_site_count
= 0;
27812 set_cur_line_info_table (sec
);
27813 FORCE_RESET_NEXT_VIEW (cur_line_info_table
->view
);
27816 /* Helper function of dwarf2out_end_function, called only after emitting
27817 the very first function into assembly. Check if some .debug_loc range
27818 might end with a .LVL* label that could be equal to .Ltext0.
27819 In that case we must force using absolute addresses in .debug_loc ranges,
27820 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
27821 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
27823 Set have_multiple_function_sections to true in that case and
27824 terminate htab traversal. */
27827 find_empty_loc_ranges_at_text_label (var_loc_list
**slot
, int)
27829 var_loc_list
*entry
= *slot
;
27830 struct var_loc_node
*node
;
27832 node
= entry
->first
;
27833 if (node
&& node
->next
&& node
->next
->label
)
27836 const char *label
= node
->next
->label
;
27837 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
27839 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
27841 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
27842 if (strcmp (label
, loclabel
) == 0)
27844 have_multiple_function_sections
= true;
27852 /* Hook called after emitting a function into assembly.
27853 This does something only for the very first function emitted. */
27856 dwarf2out_end_function (unsigned int)
27858 if (in_first_function_p
27859 && !have_multiple_function_sections
27860 && first_loclabel_num_not_at_text_label
27862 decl_loc_table
->traverse
<int, find_empty_loc_ranges_at_text_label
> (0);
27863 in_first_function_p
= false;
27864 maybe_at_text_label_p
= false;
27867 /* Temporary holder for dwarf2out_register_main_translation_unit. Used to let
27868 front-ends register a translation unit even before dwarf2out_init is
27870 static tree main_translation_unit
= NULL_TREE
;
27872 /* Hook called by front-ends after they built their main translation unit.
27873 Associate comp_unit_die to UNIT. */
27876 dwarf2out_register_main_translation_unit (tree unit
)
27878 gcc_assert (TREE_CODE (unit
) == TRANSLATION_UNIT_DECL
27879 && main_translation_unit
== NULL_TREE
);
27880 main_translation_unit
= unit
;
27881 /* If dwarf2out_init has not been called yet, it will perform the association
27882 itself looking at main_translation_unit. */
27883 if (decl_die_table
!= NULL
)
27884 equate_decl_number_to_die (unit
, comp_unit_die ());
27887 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
27890 push_dw_line_info_entry (dw_line_info_table
*table
,
27891 enum dw_line_info_opcode opcode
, unsigned int val
)
27893 dw_line_info_entry e
;
27896 vec_safe_push (table
->entries
, e
);
27899 /* Output a label to mark the beginning of a source code line entry
27900 and record information relating to this source line, in
27901 'line_info_table' for later output of the .debug_line section. */
27902 /* ??? The discriminator parameter ought to be unsigned. */
27905 dwarf2out_source_line (unsigned int line
, unsigned int column
,
27906 const char *filename
,
27907 int discriminator
, bool is_stmt
)
27909 unsigned int file_num
;
27910 dw_line_info_table
*table
;
27911 static var_loc_view lvugid
;
27913 if (debug_info_level
< DINFO_LEVEL_TERSE
)
27916 table
= cur_line_info_table
;
27920 if (debug_variable_location_views
27921 && output_asm_line_debug_info ()
27922 && table
&& !RESETTING_VIEW_P (table
->view
))
27924 /* If we're using the assembler to compute view numbers, we
27925 can't issue a .loc directive for line zero, so we can't
27926 get a view number at this point. We might attempt to
27927 compute it from the previous view, or equate it to a
27928 subsequent view (though it might not be there!), but
27929 since we're omitting the line number entry, we might as
27930 well omit the view number as well. That means pretending
27931 it's a view number zero, which might very well turn out
27932 to be correct. ??? Extend the assembler so that the
27933 compiler could emit e.g. ".locview .LVU#", to output a
27934 view without changing line number information. We'd then
27935 have to count it in symviews_since_reset; when it's omitted,
27936 it doesn't count. */
27938 zero_view_p
= BITMAP_GGC_ALLOC ();
27939 bitmap_set_bit (zero_view_p
, table
->view
);
27940 if (flag_debug_asm
)
27942 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27943 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", table
->view
);
27944 fprintf (asm_out_file
, "\t%s line 0, omitted view ",
27945 ASM_COMMENT_START
);
27946 assemble_name (asm_out_file
, label
);
27947 putc ('\n', asm_out_file
);
27949 table
->view
= ++lvugid
;
27954 /* The discriminator column was added in dwarf4. Simplify the below
27955 by simply removing it if we're not supposed to output it. */
27956 if (dwarf_version
< 4 && dwarf_strict
)
27959 if (!debug_column_info
)
27962 file_num
= maybe_emit_file (lookup_filename (filename
));
27964 /* ??? TODO: Elide duplicate line number entries. Traditionally,
27965 the debugger has used the second (possibly duplicate) line number
27966 at the beginning of the function to mark the end of the prologue.
27967 We could eliminate any other duplicates within the function. For
27968 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
27969 that second line number entry. */
27970 /* Recall that this end-of-prologue indication is *not* the same thing
27971 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
27972 to which the hook corresponds, follows the last insn that was
27973 emitted by gen_prologue. What we need is to precede the first insn
27974 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
27975 insn that corresponds to something the user wrote. These may be
27976 very different locations once scheduling is enabled. */
27978 if (0 && file_num
== table
->file_num
27979 && line
== table
->line_num
27980 && column
== table
->column_num
27981 && discriminator
== table
->discrim_num
27982 && is_stmt
== table
->is_stmt
)
27985 switch_to_section (current_function_section ());
27987 /* If requested, emit something human-readable. */
27988 if (flag_debug_asm
)
27990 if (debug_column_info
)
27991 fprintf (asm_out_file
, "\t%s %s:%d:%d\n", ASM_COMMENT_START
,
27992 filename
, line
, column
);
27994 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
27998 if (output_asm_line_debug_info ())
28000 /* Emit the .loc directive understood by GNU as. */
28001 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
28002 file_num, line, is_stmt, discriminator */
28003 fputs ("\t.loc ", asm_out_file
);
28004 fprint_ul (asm_out_file
, file_num
);
28005 putc (' ', asm_out_file
);
28006 fprint_ul (asm_out_file
, line
);
28007 putc (' ', asm_out_file
);
28008 fprint_ul (asm_out_file
, column
);
28010 if (is_stmt
!= table
->is_stmt
)
28012 #if HAVE_GAS_LOC_STMT
28013 fputs (" is_stmt ", asm_out_file
);
28014 putc (is_stmt
? '1' : '0', asm_out_file
);
28017 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
28019 gcc_assert (discriminator
> 0);
28020 fputs (" discriminator ", asm_out_file
);
28021 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
28023 if (debug_variable_location_views
)
28025 if (!RESETTING_VIEW_P (table
->view
))
28027 table
->symviews_since_reset
++;
28028 if (table
->symviews_since_reset
> symview_upper_bound
)
28029 symview_upper_bound
= table
->symviews_since_reset
;
28030 /* When we're using the assembler to compute view
28031 numbers, we output symbolic labels after "view" in
28032 .loc directives, and the assembler will set them for
28033 us, so that we can refer to the view numbers in
28034 location lists. The only exceptions are when we know
28035 a view will be zero: "-0" is a forced reset, used
28036 e.g. in the beginning of functions, whereas "0" tells
28037 the assembler to check that there was a PC change
28038 since the previous view, in a way that implicitly
28039 resets the next view. */
28040 fputs (" view ", asm_out_file
);
28041 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28042 ASM_GENERATE_INTERNAL_LABEL (label
, "LVU", table
->view
);
28043 assemble_name (asm_out_file
, label
);
28044 table
->view
= ++lvugid
;
28048 table
->symviews_since_reset
= 0;
28049 if (FORCE_RESETTING_VIEW_P (table
->view
))
28050 fputs (" view -0", asm_out_file
);
28052 fputs (" view 0", asm_out_file
);
28053 /* Mark the present view as a zero view. Earlier debug
28054 binds may have already added its id to loclists to be
28055 emitted later, so we can't reuse the id for something
28056 else. However, it's good to know whether a view is
28057 known to be zero, because then we may be able to
28058 optimize out locviews that are all zeros, so take
28059 note of it in zero_view_p. */
28061 zero_view_p
= BITMAP_GGC_ALLOC ();
28062 bitmap_set_bit (zero_view_p
, lvugid
);
28063 table
->view
= ++lvugid
;
28066 putc ('\n', asm_out_file
);
28070 unsigned int label_num
= ++line_info_label_num
;
28072 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
28074 if (debug_variable_location_views
&& !RESETTING_VIEW_P (table
->view
))
28075 push_dw_line_info_entry (table
, LI_adv_address
, label_num
);
28077 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
28078 if (debug_variable_location_views
)
28080 bool resetting
= FORCE_RESETTING_VIEW_P (table
->view
);
28084 if (flag_debug_asm
)
28085 fprintf (asm_out_file
, "\t%s view %s%d\n",
28087 resetting
? "-" : "",
28092 if (file_num
!= table
->file_num
)
28093 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
28094 if (discriminator
!= table
->discrim_num
)
28095 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
28096 if (is_stmt
!= table
->is_stmt
)
28097 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
28098 push_dw_line_info_entry (table
, LI_set_line
, line
);
28099 if (debug_column_info
)
28100 push_dw_line_info_entry (table
, LI_set_column
, column
);
28103 table
->file_num
= file_num
;
28104 table
->line_num
= line
;
28105 table
->column_num
= column
;
28106 table
->discrim_num
= discriminator
;
28107 table
->is_stmt
= is_stmt
;
28108 table
->in_use
= true;
28111 /* Record the beginning of a new source file. */
28114 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
28116 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28119 e
.code
= DW_MACINFO_start_file
;
28121 e
.info
= ggc_strdup (filename
);
28122 vec_safe_push (macinfo_table
, e
);
28126 /* Record the end of a source file. */
28129 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
28131 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28134 e
.code
= DW_MACINFO_end_file
;
28137 vec_safe_push (macinfo_table
, e
);
28141 /* Called from debug_define in toplev.c. The `buffer' parameter contains
28142 the tail part of the directive line, i.e. the part which is past the
28143 initial whitespace, #, whitespace, directive-name, whitespace part. */
28146 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
28147 const char *buffer ATTRIBUTE_UNUSED
)
28149 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28152 /* Insert a dummy first entry to be able to optimize the whole
28153 predefined macro block using DW_MACRO_import. */
28154 if (macinfo_table
->is_empty () && lineno
<= 1)
28159 vec_safe_push (macinfo_table
, e
);
28161 e
.code
= DW_MACINFO_define
;
28163 e
.info
= ggc_strdup (buffer
);
28164 vec_safe_push (macinfo_table
, e
);
28168 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
28169 the tail part of the directive line, i.e. the part which is past the
28170 initial whitespace, #, whitespace, directive-name, whitespace part. */
28173 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
28174 const char *buffer ATTRIBUTE_UNUSED
)
28176 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28179 /* Insert a dummy first entry to be able to optimize the whole
28180 predefined macro block using DW_MACRO_import. */
28181 if (macinfo_table
->is_empty () && lineno
<= 1)
28186 vec_safe_push (macinfo_table
, e
);
28188 e
.code
= DW_MACINFO_undef
;
28190 e
.info
= ggc_strdup (buffer
);
28191 vec_safe_push (macinfo_table
, e
);
28195 /* Helpers to manipulate hash table of CUs. */
28197 struct macinfo_entry_hasher
: nofree_ptr_hash
<macinfo_entry
>
28199 static inline hashval_t
hash (const macinfo_entry
*);
28200 static inline bool equal (const macinfo_entry
*, const macinfo_entry
*);
28204 macinfo_entry_hasher::hash (const macinfo_entry
*entry
)
28206 return htab_hash_string (entry
->info
);
28210 macinfo_entry_hasher::equal (const macinfo_entry
*entry1
,
28211 const macinfo_entry
*entry2
)
28213 return !strcmp (entry1
->info
, entry2
->info
);
28216 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
28218 /* Output a single .debug_macinfo entry. */
28221 output_macinfo_op (macinfo_entry
*ref
)
28225 struct indirect_string_node
*node
;
28226 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28227 struct dwarf_file_data
*fd
;
28231 case DW_MACINFO_start_file
:
28232 fd
= lookup_filename (ref
->info
);
28233 file_num
= maybe_emit_file (fd
);
28234 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
28235 dw2_asm_output_data_uleb128 (ref
->lineno
,
28236 "Included from line number %lu",
28237 (unsigned long) ref
->lineno
);
28238 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
28240 case DW_MACINFO_end_file
:
28241 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
28243 case DW_MACINFO_define
:
28244 case DW_MACINFO_undef
:
28245 len
= strlen (ref
->info
) + 1;
28247 && len
> DWARF_OFFSET_SIZE
28248 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
28249 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
28251 ref
->code
= ref
->code
== DW_MACINFO_define
28252 ? DW_MACRO_define_strp
: DW_MACRO_undef_strp
;
28253 output_macinfo_op (ref
);
28256 dw2_asm_output_data (1, ref
->code
,
28257 ref
->code
== DW_MACINFO_define
28258 ? "Define macro" : "Undefine macro");
28259 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
28260 (unsigned long) ref
->lineno
);
28261 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
28263 case DW_MACRO_define_strp
:
28264 case DW_MACRO_undef_strp
:
28265 /* NB: dwarf2out_finish performs:
28266 1. save_macinfo_strings
28267 2. hash table traverse of index_string
28268 3. output_macinfo -> output_macinfo_op
28269 4. output_indirect_strings
28270 -> hash table traverse of output_index_string
28272 When output_macinfo_op is called, all index strings have been
28273 added to hash table by save_macinfo_strings and we can't pass
28274 INSERT to find_slot_with_hash which may expand hash table, even
28275 if no insertion is needed, and change hash table traverse order
28276 between index_string and output_index_string. */
28277 node
= find_AT_string (ref
->info
, NO_INSERT
);
28279 && (node
->form
== DW_FORM_strp
28280 || node
->form
== dwarf_FORM (DW_FORM_strx
)));
28281 dw2_asm_output_data (1, ref
->code
,
28282 ref
->code
== DW_MACRO_define_strp
28283 ? "Define macro strp"
28284 : "Undefine macro strp");
28285 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
28286 (unsigned long) ref
->lineno
);
28287 if (node
->form
== DW_FORM_strp
)
28288 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
28289 debug_str_section
, "The macro: \"%s\"",
28292 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
28295 case DW_MACRO_import
:
28296 dw2_asm_output_data (1, ref
->code
, "Import");
28297 ASM_GENERATE_INTERNAL_LABEL (label
,
28298 DEBUG_MACRO_SECTION_LABEL
,
28299 ref
->lineno
+ macinfo_label_base
);
28300 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
28303 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
28304 ASM_COMMENT_START
, (unsigned long) ref
->code
);
28309 /* Attempt to make a sequence of define/undef macinfo ops shareable with
28310 other compilation unit .debug_macinfo sections. IDX is the first
28311 index of a define/undef, return the number of ops that should be
28312 emitted in a comdat .debug_macinfo section and emit
28313 a DW_MACRO_import entry referencing it.
28314 If the define/undef entry should be emitted normally, return 0. */
28317 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
28318 macinfo_hash_type
**macinfo_htab
)
28320 macinfo_entry
*first
, *second
, *cur
, *inc
;
28321 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
28322 unsigned char checksum
[16];
28323 struct md5_ctx ctx
;
28324 char *grp_name
, *tail
;
28326 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
28327 macinfo_entry
**slot
;
28329 first
= &(*macinfo_table
)[idx
];
28330 second
= &(*macinfo_table
)[idx
+ 1];
28332 /* Optimize only if there are at least two consecutive define/undef ops,
28333 and either all of them are before first DW_MACINFO_start_file
28334 with lineno {0,1} (i.e. predefined macro block), or all of them are
28335 in some included header file. */
28336 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
28338 if (vec_safe_is_empty (files
))
28340 if (first
->lineno
> 1 || second
->lineno
> 1)
28343 else if (first
->lineno
== 0)
28346 /* Find the last define/undef entry that can be grouped together
28347 with first and at the same time compute md5 checksum of their
28348 codes, linenumbers and strings. */
28349 md5_init_ctx (&ctx
);
28350 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
28351 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
28353 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
28357 unsigned char code
= cur
->code
;
28358 md5_process_bytes (&code
, 1, &ctx
);
28359 checksum_uleb128 (cur
->lineno
, &ctx
);
28360 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
28362 md5_finish_ctx (&ctx
, checksum
);
28365 /* From the containing include filename (if any) pick up just
28366 usable characters from its basename. */
28367 if (vec_safe_is_empty (files
))
28370 base
= lbasename (files
->last ().info
);
28371 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
28372 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
28373 encoded_filename_len
++;
28374 /* Count . at the end. */
28375 if (encoded_filename_len
)
28376 encoded_filename_len
++;
28378 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
28379 linebuf_len
= strlen (linebuf
);
28381 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
28382 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
28384 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
28385 tail
= grp_name
+ 4;
28386 if (encoded_filename_len
)
28388 for (i
= 0; base
[i
]; i
++)
28389 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
28393 memcpy (tail
, linebuf
, linebuf_len
);
28394 tail
+= linebuf_len
;
28396 for (i
= 0; i
< 16; i
++)
28397 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
28399 /* Construct a macinfo_entry for DW_MACRO_import
28400 in the empty vector entry before the first define/undef. */
28401 inc
= &(*macinfo_table
)[idx
- 1];
28402 inc
->code
= DW_MACRO_import
;
28404 inc
->info
= ggc_strdup (grp_name
);
28405 if (!*macinfo_htab
)
28406 *macinfo_htab
= new macinfo_hash_type (10);
28407 /* Avoid emitting duplicates. */
28408 slot
= (*macinfo_htab
)->find_slot (inc
, INSERT
);
28413 /* If such an entry has been used before, just emit
28414 a DW_MACRO_import op. */
28416 output_macinfo_op (inc
);
28417 /* And clear all macinfo_entry in the range to avoid emitting them
28418 in the second pass. */
28419 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
28428 inc
->lineno
= (*macinfo_htab
)->elements ();
28429 output_macinfo_op (inc
);
28434 /* Save any strings needed by the macinfo table in the debug str
28435 table. All strings must be collected into the table by the time
28436 index_string is called. */
28439 save_macinfo_strings (void)
28443 macinfo_entry
*ref
;
28445 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
28449 /* Match the logic in output_macinfo_op to decide on
28450 indirect strings. */
28451 case DW_MACINFO_define
:
28452 case DW_MACINFO_undef
:
28453 len
= strlen (ref
->info
) + 1;
28455 && len
> DWARF_OFFSET_SIZE
28456 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
28457 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
28458 set_indirect_string (find_AT_string (ref
->info
));
28460 case DW_MACINFO_start_file
:
28461 /* -gsplit-dwarf -g3 will also output filename as indirect
28463 if (!dwarf_split_debug_info
)
28465 /* Fall through. */
28466 case DW_MACRO_define_strp
:
28467 case DW_MACRO_undef_strp
:
28468 set_indirect_string (find_AT_string (ref
->info
));
28476 /* Output macinfo section(s). */
28479 output_macinfo (const char *debug_line_label
, bool early_lto_debug
)
28482 unsigned long length
= vec_safe_length (macinfo_table
);
28483 macinfo_entry
*ref
;
28484 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
28485 macinfo_hash_type
*macinfo_htab
= NULL
;
28486 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
28491 /* output_macinfo* uses these interchangeably. */
28492 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_define
28493 && (int) DW_MACINFO_undef
== (int) DW_MACRO_undef
28494 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_start_file
28495 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_end_file
);
28497 /* AIX Assembler inserts the length, so adjust the reference to match the
28498 offset expected by debuggers. */
28499 strcpy (dl_section_ref
, debug_line_label
);
28500 if (XCOFF_DEBUGGING_INFO
)
28501 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
28503 /* For .debug_macro emit the section header. */
28504 if (!dwarf_strict
|| dwarf_version
>= 5)
28506 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
28507 "DWARF macro version number");
28508 if (DWARF_OFFSET_SIZE
== 8)
28509 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
28511 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
28512 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_line_label
,
28513 debug_line_section
, NULL
);
28516 /* In the first loop, it emits the primary .debug_macinfo section
28517 and after each emitted op the macinfo_entry is cleared.
28518 If a longer range of define/undef ops can be optimized using
28519 DW_MACRO_import, the DW_MACRO_import op is emitted and kept in
28520 the vector before the first define/undef in the range and the
28521 whole range of define/undef ops is not emitted and kept. */
28522 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
28526 case DW_MACINFO_start_file
:
28527 vec_safe_push (files
, *ref
);
28529 case DW_MACINFO_end_file
:
28530 if (!vec_safe_is_empty (files
))
28533 case DW_MACINFO_define
:
28534 case DW_MACINFO_undef
:
28535 if ((!dwarf_strict
|| dwarf_version
>= 5)
28536 && HAVE_COMDAT_GROUP
28537 && vec_safe_length (files
) != 1
28540 && (*macinfo_table
)[i
- 1].code
== 0)
28542 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
28551 /* A dummy entry may be inserted at the beginning to be able
28552 to optimize the whole block of predefined macros. */
28558 output_macinfo_op (ref
);
28566 /* Save the number of transparent includes so we can adjust the
28567 label number for the fat LTO object DWARF. */
28568 unsigned macinfo_label_base_adj
= macinfo_htab
->elements ();
28570 delete macinfo_htab
;
28571 macinfo_htab
= NULL
;
28573 /* If any DW_MACRO_import were used, on those DW_MACRO_import entries
28574 terminate the current chain and switch to a new comdat .debug_macinfo
28575 section and emit the define/undef entries within it. */
28576 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
28581 case DW_MACRO_import
:
28583 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
28584 tree comdat_key
= get_identifier (ref
->info
);
28585 /* Terminate the previous .debug_macinfo section. */
28586 dw2_asm_output_data (1, 0, "End compilation unit");
28587 targetm
.asm_out
.named_section (debug_macinfo_section_name
,
28591 ? SECTION_EXCLUDE
: 0),
28593 ASM_GENERATE_INTERNAL_LABEL (label
,
28594 DEBUG_MACRO_SECTION_LABEL
,
28595 ref
->lineno
+ macinfo_label_base
);
28596 ASM_OUTPUT_LABEL (asm_out_file
, label
);
28599 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
28600 "DWARF macro version number");
28601 if (DWARF_OFFSET_SIZE
== 8)
28602 dw2_asm_output_data (1, 1, "Flags: 64-bit");
28604 dw2_asm_output_data (1, 0, "Flags: 32-bit");
28607 case DW_MACINFO_define
:
28608 case DW_MACINFO_undef
:
28609 output_macinfo_op (ref
);
28614 gcc_unreachable ();
28617 macinfo_label_base
+= macinfo_label_base_adj
;
28620 /* Initialize the various sections and labels for dwarf output and prefix
28621 them with PREFIX if non-NULL. Returns the generation (zero based
28622 number of times function was called). */
28625 init_sections_and_labels (bool early_lto_debug
)
28627 /* As we may get called multiple times have a generation count for
28629 static unsigned generation
= 0;
28631 if (early_lto_debug
)
28633 if (!dwarf_split_debug_info
)
28635 debug_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
28636 SECTION_DEBUG
| SECTION_EXCLUDE
,
28638 debug_abbrev_section
= get_section (DEBUG_LTO_ABBREV_SECTION
,
28639 SECTION_DEBUG
| SECTION_EXCLUDE
,
28641 debug_macinfo_section_name
28642 = ((dwarf_strict
&& dwarf_version
< 5)
28643 ? DEBUG_LTO_MACINFO_SECTION
: DEBUG_LTO_MACRO_SECTION
);
28644 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28646 | SECTION_EXCLUDE
, NULL
);
28650 /* ??? Which of the following do we need early? */
28651 debug_info_section
= get_section (DEBUG_LTO_DWO_INFO_SECTION
,
28652 SECTION_DEBUG
| SECTION_EXCLUDE
,
28654 debug_abbrev_section
= get_section (DEBUG_LTO_DWO_ABBREV_SECTION
,
28655 SECTION_DEBUG
| SECTION_EXCLUDE
,
28657 debug_skeleton_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
28659 | SECTION_EXCLUDE
, NULL
);
28660 debug_skeleton_abbrev_section
28661 = get_section (DEBUG_LTO_ABBREV_SECTION
,
28662 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28663 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
28664 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
28667 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
28668 stay in the main .o, but the skeleton_line goes into the split
28670 debug_skeleton_line_section
28671 = get_section (DEBUG_LTO_LINE_SECTION
,
28672 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28673 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
28674 DEBUG_SKELETON_LINE_SECTION_LABEL
,
28676 debug_str_offsets_section
28677 = get_section (DEBUG_LTO_DWO_STR_OFFSETS_SECTION
,
28678 SECTION_DEBUG
| SECTION_EXCLUDE
,
28680 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
28681 DEBUG_SKELETON_INFO_SECTION_LABEL
,
28683 debug_str_dwo_section
= get_section (DEBUG_LTO_STR_DWO_SECTION
,
28684 DEBUG_STR_DWO_SECTION_FLAGS
,
28686 debug_macinfo_section_name
28687 = ((dwarf_strict
&& dwarf_version
< 5)
28688 ? DEBUG_LTO_DWO_MACINFO_SECTION
: DEBUG_LTO_DWO_MACRO_SECTION
);
28689 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28690 SECTION_DEBUG
| SECTION_EXCLUDE
,
28693 /* For macro info and the file table we have to refer to a
28694 debug_line section. */
28695 debug_line_section
= get_section (DEBUG_LTO_LINE_SECTION
,
28696 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28697 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
28698 DEBUG_LINE_SECTION_LABEL
, generation
);
28700 debug_str_section
= get_section (DEBUG_LTO_STR_SECTION
,
28701 DEBUG_STR_SECTION_FLAGS
28702 | SECTION_EXCLUDE
, NULL
);
28703 if (!dwarf_split_debug_info
)
28704 debug_line_str_section
28705 = get_section (DEBUG_LTO_LINE_STR_SECTION
,
28706 DEBUG_STR_SECTION_FLAGS
| SECTION_EXCLUDE
, NULL
);
28710 if (!dwarf_split_debug_info
)
28712 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
28713 SECTION_DEBUG
, NULL
);
28714 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
28715 SECTION_DEBUG
, NULL
);
28716 debug_loc_section
= get_section (dwarf_version
>= 5
28717 ? DEBUG_LOCLISTS_SECTION
28718 : DEBUG_LOC_SECTION
,
28719 SECTION_DEBUG
, NULL
);
28720 debug_macinfo_section_name
28721 = ((dwarf_strict
&& dwarf_version
< 5)
28722 ? DEBUG_MACINFO_SECTION
: DEBUG_MACRO_SECTION
);
28723 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28724 SECTION_DEBUG
, NULL
);
28728 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
28729 SECTION_DEBUG
| SECTION_EXCLUDE
,
28731 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
28732 SECTION_DEBUG
| SECTION_EXCLUDE
,
28734 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
28735 SECTION_DEBUG
, NULL
);
28736 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
28737 SECTION_DEBUG
, NULL
);
28738 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
28739 SECTION_DEBUG
, NULL
);
28740 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
28741 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
28744 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
28745 stay in the main .o, but the skeleton_line goes into the
28747 debug_skeleton_line_section
28748 = get_section (DEBUG_DWO_LINE_SECTION
,
28749 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28750 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
28751 DEBUG_SKELETON_LINE_SECTION_LABEL
,
28753 debug_str_offsets_section
28754 = get_section (DEBUG_DWO_STR_OFFSETS_SECTION
,
28755 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
28756 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
28757 DEBUG_SKELETON_INFO_SECTION_LABEL
,
28759 debug_loc_section
= get_section (dwarf_version
>= 5
28760 ? DEBUG_DWO_LOCLISTS_SECTION
28761 : DEBUG_DWO_LOC_SECTION
,
28762 SECTION_DEBUG
| SECTION_EXCLUDE
,
28764 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
28765 DEBUG_STR_DWO_SECTION_FLAGS
,
28767 debug_macinfo_section_name
28768 = ((dwarf_strict
&& dwarf_version
< 5)
28769 ? DEBUG_DWO_MACINFO_SECTION
: DEBUG_DWO_MACRO_SECTION
);
28770 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
28771 SECTION_DEBUG
| SECTION_EXCLUDE
,
28774 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
28775 SECTION_DEBUG
, NULL
);
28776 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
28777 SECTION_DEBUG
, NULL
);
28778 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
28779 SECTION_DEBUG
, NULL
);
28780 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
28781 SECTION_DEBUG
, NULL
);
28782 debug_str_section
= get_section (DEBUG_STR_SECTION
,
28783 DEBUG_STR_SECTION_FLAGS
, NULL
);
28784 if (!dwarf_split_debug_info
&& !output_asm_line_debug_info ())
28785 debug_line_str_section
= get_section (DEBUG_LINE_STR_SECTION
,
28786 DEBUG_STR_SECTION_FLAGS
, NULL
);
28788 debug_ranges_section
= get_section (dwarf_version
>= 5
28789 ? DEBUG_RNGLISTS_SECTION
28790 : DEBUG_RANGES_SECTION
,
28791 SECTION_DEBUG
, NULL
);
28792 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
28793 SECTION_DEBUG
, NULL
);
28796 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
28797 DEBUG_ABBREV_SECTION_LABEL
, generation
);
28798 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
28799 DEBUG_INFO_SECTION_LABEL
, generation
);
28800 info_section_emitted
= false;
28801 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
28802 DEBUG_LINE_SECTION_LABEL
, generation
);
28803 /* There are up to 4 unique ranges labels per generation.
28804 See also output_rnglists. */
28805 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
28806 DEBUG_RANGES_SECTION_LABEL
, generation
* 4);
28807 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
28808 ASM_GENERATE_INTERNAL_LABEL (ranges_base_label
,
28809 DEBUG_RANGES_SECTION_LABEL
,
28810 1 + generation
* 4);
28811 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
28812 DEBUG_ADDR_SECTION_LABEL
, generation
);
28813 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
28814 (dwarf_strict
&& dwarf_version
< 5)
28815 ? DEBUG_MACINFO_SECTION_LABEL
28816 : DEBUG_MACRO_SECTION_LABEL
, generation
);
28817 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
,
28821 return generation
- 1;
28824 /* Set up for Dwarf output at the start of compilation. */
28827 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
28829 /* Allocate the file_table. */
28830 file_table
= hash_table
<dwarf_file_hasher
>::create_ggc (50);
28832 #ifndef DWARF2_LINENO_DEBUGGING_INFO
28833 /* Allocate the decl_die_table. */
28834 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (10);
28836 /* Allocate the decl_loc_table. */
28837 decl_loc_table
= hash_table
<decl_loc_hasher
>::create_ggc (10);
28839 /* Allocate the cached_dw_loc_list_table. */
28840 cached_dw_loc_list_table
= hash_table
<dw_loc_list_hasher
>::create_ggc (10);
28842 /* Allocate the initial hunk of the abbrev_die_table. */
28843 vec_alloc (abbrev_die_table
, 256);
28844 /* Zero-th entry is allocated, but unused. */
28845 abbrev_die_table
->quick_push (NULL
);
28847 /* Allocate the dwarf_proc_stack_usage_map. */
28848 dwarf_proc_stack_usage_map
= new hash_map
<dw_die_ref
, int>;
28850 /* Allocate the pubtypes and pubnames vectors. */
28851 vec_alloc (pubname_table
, 32);
28852 vec_alloc (pubtype_table
, 32);
28854 vec_alloc (incomplete_types
, 64);
28856 vec_alloc (used_rtx_array
, 32);
28858 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
28859 vec_alloc (macinfo_table
, 64);
28862 /* If front-ends already registered a main translation unit but we were not
28863 ready to perform the association, do this now. */
28864 if (main_translation_unit
!= NULL_TREE
)
28865 equate_decl_number_to_die (main_translation_unit
, comp_unit_die ());
28868 /* Called before compile () starts outputtting functions, variables
28869 and toplevel asms into assembly. */
28872 dwarf2out_assembly_start (void)
28874 if (text_section_line_info
)
28877 #ifndef DWARF2_LINENO_DEBUGGING_INFO
28878 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
28879 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
28880 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
28881 COLD_TEXT_SECTION_LABEL
, 0);
28882 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
28884 switch_to_section (text_section
);
28885 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
28888 /* Make sure the line number table for .text always exists. */
28889 text_section_line_info
= new_line_info_table ();
28890 text_section_line_info
->end_label
= text_end_label
;
28892 #ifdef DWARF2_LINENO_DEBUGGING_INFO
28893 cur_line_info_table
= text_section_line_info
;
28896 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
28897 && dwarf2out_do_cfi_asm ()
28898 && !dwarf2out_do_eh_frame ())
28899 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
28902 /* A helper function for dwarf2out_finish called through
28903 htab_traverse. Assign a string its index. All strings must be
28904 collected into the table by the time index_string is called,
28905 because the indexing code relies on htab_traverse to traverse nodes
28906 in the same order for each run. */
28909 index_string (indirect_string_node
**h
, unsigned int *index
)
28911 indirect_string_node
*node
= *h
;
28913 find_string_form (node
);
28914 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28916 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
28917 node
->index
= *index
;
28923 /* A helper function for output_indirect_strings called through
28924 htab_traverse. Output the offset to a string and update the
28928 output_index_string_offset (indirect_string_node
**h
, unsigned int *offset
)
28930 indirect_string_node
*node
= *h
;
28932 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28934 /* Assert that this node has been assigned an index. */
28935 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
28936 && node
->index
!= NOT_INDEXED
);
28937 dw2_asm_output_data (DWARF_OFFSET_SIZE
, *offset
,
28938 "indexed string 0x%x: %s", node
->index
, node
->str
);
28939 *offset
+= strlen (node
->str
) + 1;
28944 /* A helper function for dwarf2out_finish called through
28945 htab_traverse. Output the indexed string. */
28948 output_index_string (indirect_string_node
**h
, unsigned int *cur_idx
)
28950 struct indirect_string_node
*node
= *h
;
28952 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28954 /* Assert that the strings are output in the same order as their
28955 indexes were assigned. */
28956 gcc_assert (*cur_idx
== node
->index
);
28957 assemble_string (node
->str
, strlen (node
->str
) + 1);
28963 /* A helper function for output_indirect_strings. Counts the number
28964 of index strings offsets. Must match the logic of the functions
28965 output_index_string[_offsets] above. */
28967 count_index_strings (indirect_string_node
**h
, unsigned int *last_idx
)
28969 struct indirect_string_node
*node
= *h
;
28971 if (node
->form
== dwarf_FORM (DW_FORM_strx
) && node
->refcount
> 0)
28976 /* A helper function for dwarf2out_finish called through
28977 htab_traverse. Emit one queued .debug_str string. */
28980 output_indirect_string (indirect_string_node
**h
, enum dwarf_form form
)
28982 struct indirect_string_node
*node
= *h
;
28984 node
->form
= find_string_form (node
);
28985 if (node
->form
== form
&& node
->refcount
> 0)
28987 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
28988 assemble_string (node
->str
, strlen (node
->str
) + 1);
28994 /* Output the indexed string table. */
28997 output_indirect_strings (void)
28999 switch_to_section (debug_str_section
);
29000 if (!dwarf_split_debug_info
)
29001 debug_str_hash
->traverse
<enum dwarf_form
,
29002 output_indirect_string
> (DW_FORM_strp
);
29005 unsigned int offset
= 0;
29006 unsigned int cur_idx
= 0;
29008 if (skeleton_debug_str_hash
)
29009 skeleton_debug_str_hash
->traverse
<enum dwarf_form
,
29010 output_indirect_string
> (DW_FORM_strp
);
29012 switch_to_section (debug_str_offsets_section
);
29013 /* For DWARF5 the .debug_str_offsets[.dwo] section needs a unit
29014 header. Note that we don't need to generate a label to the
29015 actual index table following the header here, because this is
29016 for the split dwarf case only. In an .dwo file there is only
29017 one string offsets table (and one debug info section). But
29018 if we would start using string offset tables for the main (or
29019 skeleton) unit, then we have to add a DW_AT_str_offsets_base
29020 pointing to the actual index after the header. Split dwarf
29021 units will never have a string offsets base attribute. When
29022 a split unit is moved into a .dwp file the string offsets can
29023 be found through the .debug_cu_index section table. */
29024 if (dwarf_version
>= 5)
29026 unsigned int last_idx
= 0;
29027 unsigned long str_offsets_length
;
29029 debug_str_hash
->traverse_noresize
29030 <unsigned int *, count_index_strings
> (&last_idx
);
29031 str_offsets_length
= last_idx
* DWARF_OFFSET_SIZE
+ 4;
29032 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
29033 dw2_asm_output_data (4, 0xffffffff,
29034 "Escape value for 64-bit DWARF extension");
29035 dw2_asm_output_data (DWARF_OFFSET_SIZE
, str_offsets_length
,
29036 "Length of string offsets unit");
29037 dw2_asm_output_data (2, 5, "DWARF string offsets version");
29038 dw2_asm_output_data (2, 0, "Header zero padding");
29040 debug_str_hash
->traverse_noresize
29041 <unsigned int *, output_index_string_offset
> (&offset
);
29042 switch_to_section (debug_str_dwo_section
);
29043 debug_str_hash
->traverse_noresize
<unsigned int *, output_index_string
>
29048 /* Callback for htab_traverse to assign an index to an entry in the
29049 table, and to write that entry to the .debug_addr section. */
29052 output_addr_table_entry (addr_table_entry
**slot
, unsigned int *cur_index
)
29054 addr_table_entry
*entry
= *slot
;
29056 if (entry
->refcount
== 0)
29058 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
29059 || entry
->index
== NOT_INDEXED
);
29063 gcc_assert (entry
->index
== *cur_index
);
29066 switch (entry
->kind
)
29069 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
29070 "0x%x", entry
->index
);
29072 case ate_kind_rtx_dtprel
:
29073 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
29074 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
29077 fputc ('\n', asm_out_file
);
29079 case ate_kind_label
:
29080 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
29081 "0x%x", entry
->index
);
29084 gcc_unreachable ();
29089 /* A helper function for dwarf2out_finish. Counts the number
29090 of indexed addresses. Must match the logic of the functions
29091 output_addr_table_entry above. */
29093 count_index_addrs (addr_table_entry
**slot
, unsigned int *last_idx
)
29095 addr_table_entry
*entry
= *slot
;
29097 if (entry
->refcount
> 0)
29102 /* Produce the .debug_addr section. */
29105 output_addr_table (void)
29107 unsigned int index
= 0;
29108 if (addr_index_table
== NULL
|| addr_index_table
->size () == 0)
29111 switch_to_section (debug_addr_section
);
29113 ->traverse_noresize
<unsigned int *, output_addr_table_entry
> (&index
);
29116 #if ENABLE_ASSERT_CHECKING
29117 /* Verify that all marks are clear. */
29120 verify_marks_clear (dw_die_ref die
)
29124 gcc_assert (! die
->die_mark
);
29125 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
29127 #endif /* ENABLE_ASSERT_CHECKING */
29129 /* Clear the marks for a die and its children.
29130 Be cool if the mark isn't set. */
29133 prune_unmark_dies (dw_die_ref die
)
29139 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
29142 /* Given LOC that is referenced by a DIE we're marking as used, find all
29143 referenced DWARF procedures it references and mark them as used. */
29146 prune_unused_types_walk_loc_descr (dw_loc_descr_ref loc
)
29148 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
29149 switch (loc
->dw_loc_opc
)
29151 case DW_OP_implicit_pointer
:
29152 case DW_OP_convert
:
29153 case DW_OP_reinterpret
:
29154 case DW_OP_GNU_implicit_pointer
:
29155 case DW_OP_GNU_convert
:
29156 case DW_OP_GNU_reinterpret
:
29157 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
)
29158 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
29160 case DW_OP_GNU_variable_value
:
29161 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
29164 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
29167 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
29168 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
29169 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29174 case DW_OP_call_ref
:
29175 case DW_OP_const_type
:
29176 case DW_OP_GNU_const_type
:
29177 case DW_OP_GNU_parameter_ref
:
29178 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
);
29179 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
29181 case DW_OP_regval_type
:
29182 case DW_OP_deref_type
:
29183 case DW_OP_GNU_regval_type
:
29184 case DW_OP_GNU_deref_type
:
29185 gcc_assert (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_die_ref
);
29186 prune_unused_types_mark (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
, 1);
29188 case DW_OP_entry_value
:
29189 case DW_OP_GNU_entry_value
:
29190 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
);
29191 prune_unused_types_walk_loc_descr (loc
->dw_loc_oprnd1
.v
.val_loc
);
29198 /* Given DIE that we're marking as used, find any other dies
29199 it references as attributes and mark them as used. */
29202 prune_unused_types_walk_attribs (dw_die_ref die
)
29207 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29209 switch (AT_class (a
))
29211 /* Make sure DWARF procedures referenced by location descriptions will
29213 case dw_val_class_loc
:
29214 prune_unused_types_walk_loc_descr (AT_loc (a
));
29216 case dw_val_class_loc_list
:
29217 for (dw_loc_list_ref list
= AT_loc_list (a
);
29219 list
= list
->dw_loc_next
)
29220 prune_unused_types_walk_loc_descr (list
->expr
);
29223 case dw_val_class_view_list
:
29224 /* This points to a loc_list in another attribute, so it's
29225 already covered. */
29228 case dw_val_class_die_ref
:
29229 /* A reference to another DIE.
29230 Make sure that it will get emitted.
29231 If it was broken out into a comdat group, don't follow it. */
29232 if (! AT_ref (a
)->comdat_type_p
29233 || a
->dw_attr
== DW_AT_specification
)
29234 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
29237 case dw_val_class_str
:
29238 /* Set the string's refcount to 0 so that prune_unused_types_mark
29239 accounts properly for it. */
29240 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
29249 /* Mark the generic parameters and arguments children DIEs of DIE. */
29252 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
29256 if (die
== NULL
|| die
->die_child
== NULL
)
29258 c
= die
->die_child
;
29261 if (is_template_parameter (c
))
29262 prune_unused_types_mark (c
, 1);
29264 } while (c
&& c
!= die
->die_child
);
29267 /* Mark DIE as being used. If DOKIDS is true, then walk down
29268 to DIE's children. */
29271 prune_unused_types_mark (dw_die_ref die
, int dokids
)
29275 if (die
->die_mark
== 0)
29277 /* We haven't done this node yet. Mark it as used. */
29279 /* If this is the DIE of a generic type instantiation,
29280 mark the children DIEs that describe its generic parms and
29282 prune_unused_types_mark_generic_parms_dies (die
);
29284 /* We also have to mark its parents as used.
29285 (But we don't want to mark our parent's kids due to this,
29286 unless it is a class.) */
29287 if (die
->die_parent
)
29288 prune_unused_types_mark (die
->die_parent
,
29289 class_scope_p (die
->die_parent
));
29291 /* Mark any referenced nodes. */
29292 prune_unused_types_walk_attribs (die
);
29294 /* If this node is a specification,
29295 also mark the definition, if it exists. */
29296 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
29297 prune_unused_types_mark (die
->die_definition
, 1);
29300 if (dokids
&& die
->die_mark
!= 2)
29302 /* We need to walk the children, but haven't done so yet.
29303 Remember that we've walked the kids. */
29306 /* If this is an array type, we need to make sure our
29307 kids get marked, even if they're types. If we're
29308 breaking out types into comdat sections, do this
29309 for all type definitions. */
29310 if (die
->die_tag
== DW_TAG_array_type
29311 || (use_debug_types
29312 && is_type_die (die
) && ! is_declaration_die (die
)))
29313 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
29315 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
29319 /* For local classes, look if any static member functions were emitted
29320 and if so, mark them. */
29323 prune_unused_types_walk_local_classes (dw_die_ref die
)
29327 if (die
->die_mark
== 2)
29330 switch (die
->die_tag
)
29332 case DW_TAG_structure_type
:
29333 case DW_TAG_union_type
:
29334 case DW_TAG_class_type
:
29335 case DW_TAG_interface_type
:
29338 case DW_TAG_subprogram
:
29339 if (!get_AT_flag (die
, DW_AT_declaration
)
29340 || die
->die_definition
!= NULL
)
29341 prune_unused_types_mark (die
, 1);
29348 /* Mark children. */
29349 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
29352 /* Walk the tree DIE and mark types that we actually use. */
29355 prune_unused_types_walk (dw_die_ref die
)
29359 /* Don't do anything if this node is already marked and
29360 children have been marked as well. */
29361 if (die
->die_mark
== 2)
29364 switch (die
->die_tag
)
29366 case DW_TAG_structure_type
:
29367 case DW_TAG_union_type
:
29368 case DW_TAG_class_type
:
29369 case DW_TAG_interface_type
:
29370 if (die
->die_perennial_p
)
29373 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
29374 if (c
->die_tag
== DW_TAG_subprogram
)
29377 /* Finding used static member functions inside of classes
29378 is needed just for local classes, because for other classes
29379 static member function DIEs with DW_AT_specification
29380 are emitted outside of the DW_TAG_*_type. If we ever change
29381 it, we'd need to call this even for non-local classes. */
29383 prune_unused_types_walk_local_classes (die
);
29385 /* It's a type node --- don't mark it. */
29388 case DW_TAG_const_type
:
29389 case DW_TAG_packed_type
:
29390 case DW_TAG_pointer_type
:
29391 case DW_TAG_reference_type
:
29392 case DW_TAG_rvalue_reference_type
:
29393 case DW_TAG_volatile_type
:
29394 case DW_TAG_typedef
:
29395 case DW_TAG_array_type
:
29396 case DW_TAG_friend
:
29397 case DW_TAG_enumeration_type
:
29398 case DW_TAG_subroutine_type
:
29399 case DW_TAG_string_type
:
29400 case DW_TAG_set_type
:
29401 case DW_TAG_subrange_type
:
29402 case DW_TAG_ptr_to_member_type
:
29403 case DW_TAG_file_type
:
29404 /* Type nodes are useful only when other DIEs reference them --- don't
29408 case DW_TAG_dwarf_procedure
:
29409 /* Likewise for DWARF procedures. */
29411 if (die
->die_perennial_p
)
29416 case DW_TAG_variable
:
29417 if (flag_debug_only_used_symbols
)
29419 if (die
->die_perennial_p
)
29422 /* premark_used_variables marks external variables --- don't mark
29423 them here. But function-local externals are always considered
29425 if (get_AT (die
, DW_AT_external
))
29427 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
29428 if (c
->die_tag
== DW_TAG_subprogram
)
29437 /* Mark everything else. */
29441 if (die
->die_mark
== 0)
29445 /* Now, mark any dies referenced from here. */
29446 prune_unused_types_walk_attribs (die
);
29451 /* Mark children. */
29452 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
29455 /* Increment the string counts on strings referred to from DIE's
29459 prune_unused_types_update_strings (dw_die_ref die
)
29464 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29465 if (AT_class (a
) == dw_val_class_str
)
29467 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
29469 /* Avoid unnecessarily putting strings that are used less than
29470 twice in the hash table. */
29472 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
29474 indirect_string_node
**slot
29475 = debug_str_hash
->find_slot_with_hash (s
->str
,
29476 htab_hash_string (s
->str
),
29478 gcc_assert (*slot
== NULL
);
29484 /* Mark DIE and its children as removed. */
29487 mark_removed (dw_die_ref die
)
29490 die
->removed
= true;
29491 FOR_EACH_CHILD (die
, c
, mark_removed (c
));
29494 /* Remove from the tree DIE any dies that aren't marked. */
29497 prune_unused_types_prune (dw_die_ref die
)
29501 gcc_assert (die
->die_mark
);
29502 prune_unused_types_update_strings (die
);
29504 if (! die
->die_child
)
29507 c
= die
->die_child
;
29509 dw_die_ref prev
= c
, next
;
29510 for (c
= c
->die_sib
; ! c
->die_mark
; c
= next
)
29511 if (c
== die
->die_child
)
29513 /* No marked children between 'prev' and the end of the list. */
29515 /* No marked children at all. */
29516 die
->die_child
= NULL
;
29519 prev
->die_sib
= c
->die_sib
;
29520 die
->die_child
= prev
;
29533 if (c
!= prev
->die_sib
)
29535 prune_unused_types_prune (c
);
29536 } while (c
!= die
->die_child
);
29539 /* Remove dies representing declarations that we never use. */
29542 prune_unused_types (void)
29545 limbo_die_node
*node
;
29546 comdat_type_node
*ctnode
;
29547 pubname_entry
*pub
;
29548 dw_die_ref base_type
;
29550 #if ENABLE_ASSERT_CHECKING
29551 /* All the marks should already be clear. */
29552 verify_marks_clear (comp_unit_die ());
29553 for (node
= limbo_die_list
; node
; node
= node
->next
)
29554 verify_marks_clear (node
->die
);
29555 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29556 verify_marks_clear (ctnode
->root_die
);
29557 #endif /* ENABLE_ASSERT_CHECKING */
29559 /* Mark types that are used in global variables. */
29560 premark_types_used_by_global_vars ();
29562 /* Mark variables used in the symtab. */
29563 if (flag_debug_only_used_symbols
)
29564 premark_used_variables ();
29566 /* Set the mark on nodes that are actually used. */
29567 prune_unused_types_walk (comp_unit_die ());
29568 for (node
= limbo_die_list
; node
; node
= node
->next
)
29569 prune_unused_types_walk (node
->die
);
29570 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29572 prune_unused_types_walk (ctnode
->root_die
);
29573 prune_unused_types_mark (ctnode
->type_die
, 1);
29576 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
29577 are unusual in that they are pubnames that are the children of pubtypes.
29578 They should only be marked via their parent DW_TAG_enumeration_type die,
29579 not as roots in themselves. */
29580 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
29581 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
29582 prune_unused_types_mark (pub
->die
, 1);
29583 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
29584 prune_unused_types_mark (base_type
, 1);
29586 /* For -fvar-tracking-assignments, also set the mark on nodes that could be
29587 referenced by DW_TAG_call_site DW_AT_call_origin (i.e. direct call
29589 cgraph_node
*cnode
;
29590 FOR_EACH_FUNCTION (cnode
)
29591 if (cnode
->referred_to_p (false))
29593 dw_die_ref die
= lookup_decl_die (cnode
->decl
);
29594 if (die
== NULL
|| die
->die_mark
)
29596 for (cgraph_edge
*e
= cnode
->callers
; e
; e
= e
->next_caller
)
29597 if (e
->caller
!= cnode
29598 && opt_for_fn (e
->caller
->decl
, flag_var_tracking_assignments
))
29600 prune_unused_types_mark (die
, 1);
29605 if (debug_str_hash
)
29606 debug_str_hash
->empty ();
29607 if (skeleton_debug_str_hash
)
29608 skeleton_debug_str_hash
->empty ();
29609 prune_unused_types_prune (comp_unit_die ());
29610 for (limbo_die_node
**pnode
= &limbo_die_list
; *pnode
; )
29613 if (!node
->die
->die_mark
)
29614 *pnode
= node
->next
;
29617 prune_unused_types_prune (node
->die
);
29618 pnode
= &node
->next
;
29621 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29622 prune_unused_types_prune (ctnode
->root_die
);
29624 /* Leave the marks clear. */
29625 prune_unmark_dies (comp_unit_die ());
29626 for (node
= limbo_die_list
; node
; node
= node
->next
)
29627 prune_unmark_dies (node
->die
);
29628 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
29629 prune_unmark_dies (ctnode
->root_die
);
29632 /* Helpers to manipulate hash table of comdat type units. */
29634 struct comdat_type_hasher
: nofree_ptr_hash
<comdat_type_node
>
29636 static inline hashval_t
hash (const comdat_type_node
*);
29637 static inline bool equal (const comdat_type_node
*, const comdat_type_node
*);
29641 comdat_type_hasher::hash (const comdat_type_node
*type_node
)
29644 memcpy (&h
, type_node
->signature
, sizeof (h
));
29649 comdat_type_hasher::equal (const comdat_type_node
*type_node_1
,
29650 const comdat_type_node
*type_node_2
)
29652 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
29653 DWARF_TYPE_SIGNATURE_SIZE
));
29656 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
29657 to the location it would have been added, should we know its
29658 DECL_ASSEMBLER_NAME when we added other attributes. This will
29659 probably improve compactness of debug info, removing equivalent
29660 abbrevs, and hide any differences caused by deferring the
29661 computation of the assembler name, triggered by e.g. PCH. */
29664 move_linkage_attr (dw_die_ref die
)
29666 unsigned ix
= vec_safe_length (die
->die_attr
);
29667 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
29669 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
29670 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
29674 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
29676 if (prev
->dw_attr
== DW_AT_decl_line
29677 || prev
->dw_attr
== DW_AT_decl_column
29678 || prev
->dw_attr
== DW_AT_name
)
29682 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
29684 die
->die_attr
->pop ();
29685 die
->die_attr
->quick_insert (ix
, linkage
);
29689 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
29690 referenced from typed stack ops and count how often they are used. */
29693 mark_base_types (dw_loc_descr_ref loc
)
29695 dw_die_ref base_type
= NULL
;
29697 for (; loc
; loc
= loc
->dw_loc_next
)
29699 switch (loc
->dw_loc_opc
)
29701 case DW_OP_regval_type
:
29702 case DW_OP_deref_type
:
29703 case DW_OP_GNU_regval_type
:
29704 case DW_OP_GNU_deref_type
:
29705 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
29707 case DW_OP_convert
:
29708 case DW_OP_reinterpret
:
29709 case DW_OP_GNU_convert
:
29710 case DW_OP_GNU_reinterpret
:
29711 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
29714 case DW_OP_const_type
:
29715 case DW_OP_GNU_const_type
:
29716 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29718 case DW_OP_entry_value
:
29719 case DW_OP_GNU_entry_value
:
29720 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
29725 gcc_assert (base_type
->die_parent
== comp_unit_die ());
29726 if (base_type
->die_mark
)
29727 base_type
->die_mark
++;
29730 base_types
.safe_push (base_type
);
29731 base_type
->die_mark
= 1;
29736 /* Comparison function for sorting marked base types. */
29739 base_type_cmp (const void *x
, const void *y
)
29741 dw_die_ref dx
= *(const dw_die_ref
*) x
;
29742 dw_die_ref dy
= *(const dw_die_ref
*) y
;
29743 unsigned int byte_size1
, byte_size2
;
29744 unsigned int encoding1
, encoding2
;
29745 unsigned int align1
, align2
;
29746 if (dx
->die_mark
> dy
->die_mark
)
29748 if (dx
->die_mark
< dy
->die_mark
)
29750 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
29751 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
29752 if (byte_size1
< byte_size2
)
29754 if (byte_size1
> byte_size2
)
29756 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
29757 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
29758 if (encoding1
< encoding2
)
29760 if (encoding1
> encoding2
)
29762 align1
= get_AT_unsigned (dx
, DW_AT_alignment
);
29763 align2
= get_AT_unsigned (dy
, DW_AT_alignment
);
29764 if (align1
< align2
)
29766 if (align1
> align2
)
29771 /* Move base types marked by mark_base_types as early as possible
29772 in the CU, sorted by decreasing usage count both to make the
29773 uleb128 references as small as possible and to make sure they
29774 will have die_offset already computed by calc_die_sizes when
29775 sizes of typed stack loc ops is computed. */
29778 move_marked_base_types (void)
29781 dw_die_ref base_type
, die
, c
;
29783 if (base_types
.is_empty ())
29786 /* Sort by decreasing usage count, they will be added again in that
29788 base_types
.qsort (base_type_cmp
);
29789 die
= comp_unit_die ();
29790 c
= die
->die_child
;
29793 dw_die_ref prev
= c
;
29795 while (c
->die_mark
)
29797 remove_child_with_prev (c
, prev
);
29798 /* As base types got marked, there must be at least
29799 one node other than DW_TAG_base_type. */
29800 gcc_assert (die
->die_child
!= NULL
);
29804 while (c
!= die
->die_child
);
29805 gcc_assert (die
->die_child
);
29806 c
= die
->die_child
;
29807 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
29809 base_type
->die_mark
= 0;
29810 base_type
->die_sib
= c
->die_sib
;
29811 c
->die_sib
= base_type
;
29816 /* Helper function for resolve_addr, attempt to resolve
29817 one CONST_STRING, return true if successful. Similarly verify that
29818 SYMBOL_REFs refer to variables emitted in the current CU. */
29821 resolve_one_addr (rtx
*addr
)
29825 if (GET_CODE (rtl
) == CONST_STRING
)
29827 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
29828 tree t
= build_string (len
, XSTR (rtl
, 0));
29829 tree tlen
= size_int (len
- 1);
29831 = build_array_type (char_type_node
, build_index_type (tlen
));
29832 rtl
= lookup_constant_def (t
);
29833 if (!rtl
|| !MEM_P (rtl
))
29835 rtl
= XEXP (rtl
, 0);
29836 if (GET_CODE (rtl
) == SYMBOL_REF
29837 && SYMBOL_REF_DECL (rtl
)
29838 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
29840 vec_safe_push (used_rtx_array
, rtl
);
29845 if (GET_CODE (rtl
) == SYMBOL_REF
29846 && SYMBOL_REF_DECL (rtl
))
29848 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
29850 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
29853 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
29857 if (GET_CODE (rtl
) == CONST
)
29859 subrtx_ptr_iterator::array_type array
;
29860 FOR_EACH_SUBRTX_PTR (iter
, array
, &XEXP (rtl
, 0), ALL
)
29861 if (!resolve_one_addr (*iter
))
29868 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
29869 if possible, and create DW_TAG_dwarf_procedure that can be referenced
29870 from DW_OP_implicit_pointer if the string hasn't been seen yet. */
29873 string_cst_pool_decl (tree t
)
29875 rtx rtl
= output_constant_def (t
, 1);
29876 unsigned char *array
;
29877 dw_loc_descr_ref l
;
29882 if (!rtl
|| !MEM_P (rtl
))
29884 rtl
= XEXP (rtl
, 0);
29885 if (GET_CODE (rtl
) != SYMBOL_REF
29886 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
29889 decl
= SYMBOL_REF_DECL (rtl
);
29890 if (!lookup_decl_die (decl
))
29892 len
= TREE_STRING_LENGTH (t
);
29893 vec_safe_push (used_rtx_array
, rtl
);
29894 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
29895 array
= ggc_vec_alloc
<unsigned char> (len
);
29896 memcpy (array
, TREE_STRING_POINTER (t
), len
);
29897 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
29898 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
29899 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
29900 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
29901 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
29902 add_AT_loc (ref
, DW_AT_location
, l
);
29903 equate_decl_number_to_die (decl
, ref
);
29908 /* Helper function of resolve_addr_in_expr. LOC is
29909 a DW_OP_addr followed by DW_OP_stack_value, either at the start
29910 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
29911 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
29912 with DW_OP_implicit_pointer if possible
29913 and return true, if unsuccessful, return false. */
29916 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
29918 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
29919 HOST_WIDE_INT offset
= 0;
29920 dw_die_ref ref
= NULL
;
29923 if (GET_CODE (rtl
) == CONST
29924 && GET_CODE (XEXP (rtl
, 0)) == PLUS
29925 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
29927 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
29928 rtl
= XEXP (XEXP (rtl
, 0), 0);
29930 if (GET_CODE (rtl
) == CONST_STRING
)
29932 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
29933 tree t
= build_string (len
, XSTR (rtl
, 0));
29934 tree tlen
= size_int (len
- 1);
29937 = build_array_type (char_type_node
, build_index_type (tlen
));
29938 rtl
= string_cst_pool_decl (t
);
29942 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
29944 decl
= SYMBOL_REF_DECL (rtl
);
29945 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
29947 ref
= lookup_decl_die (decl
);
29948 if (ref
&& (get_AT (ref
, DW_AT_location
)
29949 || get_AT (ref
, DW_AT_const_value
)))
29951 loc
->dw_loc_opc
= dwarf_OP (DW_OP_implicit_pointer
);
29952 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
29953 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
29954 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
29955 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29956 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
29957 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
29965 /* Helper function for resolve_addr, handle one location
29966 expression, return false if at least one CONST_STRING or SYMBOL_REF in
29967 the location list couldn't be resolved. */
29970 resolve_addr_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
29972 dw_loc_descr_ref keep
= NULL
;
29973 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
29974 switch (loc
->dw_loc_opc
)
29977 if (!resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
29980 || prev
->dw_loc_opc
== DW_OP_piece
29981 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
29982 && loc
->dw_loc_next
29983 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
29984 && (!dwarf_strict
|| dwarf_version
>= 5)
29985 && optimize_one_addr_into_implicit_ptr (loc
))
29990 case DW_OP_GNU_addr_index
:
29992 case DW_OP_GNU_const_index
:
29994 if ((loc
->dw_loc_opc
== DW_OP_GNU_addr_index
29995 || loc
->dw_loc_opc
== DW_OP_addrx
)
29996 || ((loc
->dw_loc_opc
== DW_OP_GNU_const_index
29997 || loc
->dw_loc_opc
== DW_OP_constx
)
30000 rtx rtl
= loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
;
30001 if (!resolve_one_addr (&rtl
))
30003 remove_addr_table_entry (loc
->dw_loc_oprnd1
.val_entry
);
30004 loc
->dw_loc_oprnd1
.val_entry
30005 = add_addr_table_entry (rtl
, ate_kind_rtx
);
30008 case DW_OP_const4u
:
30009 case DW_OP_const8u
:
30011 && !resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
30014 case DW_OP_plus_uconst
:
30015 if (size_of_loc_descr (loc
)
30016 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
30018 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
30020 dw_loc_descr_ref repl
30021 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
30022 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
30023 add_loc_descr (&repl
, loc
->dw_loc_next
);
30027 case DW_OP_implicit_value
:
30028 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
30029 && !resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
))
30032 case DW_OP_implicit_pointer
:
30033 case DW_OP_GNU_implicit_pointer
:
30034 case DW_OP_GNU_parameter_ref
:
30035 case DW_OP_GNU_variable_value
:
30036 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
30039 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
30042 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30043 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30044 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30046 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
)
30049 && loc
->dw_loc_next
== NULL
30050 && AT_class (a
) == dw_val_class_loc
)
30051 switch (a
->dw_attr
)
30053 /* Following attributes allow both exprloc and reference,
30054 so if the whole expression is DW_OP_GNU_variable_value
30055 alone we could transform it into reference. */
30056 case DW_AT_byte_size
:
30057 case DW_AT_bit_size
:
30058 case DW_AT_lower_bound
:
30059 case DW_AT_upper_bound
:
30060 case DW_AT_bit_stride
:
30062 case DW_AT_allocated
:
30063 case DW_AT_associated
:
30064 case DW_AT_byte_stride
:
30065 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
30066 a
->dw_attr_val
.val_entry
= NULL
;
30067 a
->dw_attr_val
.v
.val_die_ref
.die
30068 = loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30069 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
30078 case DW_OP_const_type
:
30079 case DW_OP_regval_type
:
30080 case DW_OP_deref_type
:
30081 case DW_OP_convert
:
30082 case DW_OP_reinterpret
:
30083 case DW_OP_GNU_const_type
:
30084 case DW_OP_GNU_regval_type
:
30085 case DW_OP_GNU_deref_type
:
30086 case DW_OP_GNU_convert
:
30087 case DW_OP_GNU_reinterpret
:
30088 while (loc
->dw_loc_next
30089 && (loc
->dw_loc_next
->dw_loc_opc
== DW_OP_convert
30090 || loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
))
30092 dw_die_ref base1
, base2
;
30093 unsigned enc1
, enc2
, size1
, size2
;
30094 if (loc
->dw_loc_opc
== DW_OP_regval_type
30095 || loc
->dw_loc_opc
== DW_OP_deref_type
30096 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
30097 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
30098 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
30099 else if (loc
->dw_loc_oprnd1
.val_class
30100 == dw_val_class_unsigned_const
)
30103 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30104 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
30105 == dw_val_class_unsigned_const
)
30107 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30108 gcc_assert (base1
->die_tag
== DW_TAG_base_type
30109 && base2
->die_tag
== DW_TAG_base_type
);
30110 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
30111 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
30112 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
30113 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
30115 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
30116 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
30120 /* Optimize away next DW_OP_convert after
30121 adjusting LOC's base type die reference. */
30122 if (loc
->dw_loc_opc
== DW_OP_regval_type
30123 || loc
->dw_loc_opc
== DW_OP_deref_type
30124 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
30125 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
30126 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
30128 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
30129 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
30132 /* Don't change integer DW_OP_convert after e.g. floating
30133 point typed stack entry. */
30134 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
30135 keep
= loc
->dw_loc_next
;
30145 /* Helper function of resolve_addr. DIE had DW_AT_location of
30146 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
30147 and DW_OP_addr couldn't be resolved. resolve_addr has already
30148 removed the DW_AT_location attribute. This function attempts to
30149 add a new DW_AT_location attribute with DW_OP_implicit_pointer
30150 to it or DW_AT_const_value attribute, if possible. */
30153 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
30156 || lookup_decl_die (decl
) != die
30157 || DECL_EXTERNAL (decl
)
30158 || !TREE_STATIC (decl
)
30159 || DECL_INITIAL (decl
) == NULL_TREE
30160 || DECL_P (DECL_INITIAL (decl
))
30161 || get_AT (die
, DW_AT_const_value
))
30164 tree init
= DECL_INITIAL (decl
);
30165 HOST_WIDE_INT offset
= 0;
30166 /* For variables that have been optimized away and thus
30167 don't have a memory location, see if we can emit
30168 DW_AT_const_value instead. */
30169 if (tree_add_const_value_attribute (die
, init
))
30171 if (dwarf_strict
&& dwarf_version
< 5)
30173 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
30174 and ADDR_EXPR refers to a decl that has DW_AT_location or
30175 DW_AT_const_value (but isn't addressable, otherwise
30176 resolving the original DW_OP_addr wouldn't fail), see if
30177 we can add DW_OP_implicit_pointer. */
30179 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
30180 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
30182 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
30183 init
= TREE_OPERAND (init
, 0);
30186 if (TREE_CODE (init
) != ADDR_EXPR
)
30188 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
30189 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
30190 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
30191 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
30192 && TREE_OPERAND (init
, 0) != decl
))
30195 dw_loc_descr_ref l
;
30197 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
30199 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
30202 decl
= SYMBOL_REF_DECL (rtl
);
30205 decl
= TREE_OPERAND (init
, 0);
30206 ref
= lookup_decl_die (decl
);
30208 || (!get_AT (ref
, DW_AT_location
)
30209 && !get_AT (ref
, DW_AT_const_value
)))
30211 l
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
30212 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30213 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30214 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30215 add_AT_loc (die
, DW_AT_location
, l
);
30219 /* Return NULL if l is a DWARF expression, or first op that is not
30220 valid DWARF expression. */
30222 static dw_loc_descr_ref
30223 non_dwarf_expression (dw_loc_descr_ref l
)
30227 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
30229 switch (l
->dw_loc_opc
)
30232 case DW_OP_implicit_value
:
30233 case DW_OP_stack_value
:
30234 case DW_OP_implicit_pointer
:
30235 case DW_OP_GNU_implicit_pointer
:
30236 case DW_OP_GNU_parameter_ref
:
30238 case DW_OP_bit_piece
:
30243 l
= l
->dw_loc_next
;
30248 /* Return adjusted copy of EXPR:
30249 If it is empty DWARF expression, return it.
30250 If it is valid non-empty DWARF expression,
30251 return copy of EXPR with DW_OP_deref appended to it.
30252 If it is DWARF expression followed by DW_OP_reg{N,x}, return
30253 copy of the DWARF expression with DW_OP_breg{N,x} <0> appended.
30254 If it is DWARF expression followed by DW_OP_stack_value, return
30255 copy of the DWARF expression without anything appended.
30256 Otherwise, return NULL. */
30258 static dw_loc_descr_ref
30259 copy_deref_exprloc (dw_loc_descr_ref expr
)
30261 dw_loc_descr_ref tail
= NULL
;
30266 dw_loc_descr_ref l
= non_dwarf_expression (expr
);
30267 if (l
&& l
->dw_loc_next
)
30272 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
30273 tail
= new_loc_descr ((enum dwarf_location_atom
)
30274 (DW_OP_breg0
+ (l
->dw_loc_opc
- DW_OP_reg0
)),
30277 switch (l
->dw_loc_opc
)
30280 tail
= new_loc_descr (DW_OP_bregx
,
30281 l
->dw_loc_oprnd1
.v
.val_unsigned
, 0);
30283 case DW_OP_stack_value
:
30290 tail
= new_loc_descr (DW_OP_deref
, 0, 0);
30292 dw_loc_descr_ref ret
= NULL
, *p
= &ret
;
30295 *p
= new_loc_descr (expr
->dw_loc_opc
, 0, 0);
30296 (*p
)->dw_loc_oprnd1
= expr
->dw_loc_oprnd1
;
30297 (*p
)->dw_loc_oprnd2
= expr
->dw_loc_oprnd2
;
30298 p
= &(*p
)->dw_loc_next
;
30299 expr
= expr
->dw_loc_next
;
30305 /* For DW_AT_string_length attribute with DW_OP_GNU_variable_value
30306 reference to a variable or argument, adjust it if needed and return:
30307 -1 if the DW_AT_string_length attribute and DW_AT_{string_length_,}byte_size
30308 attribute if present should be removed
30309 0 keep the attribute perhaps with minor modifications, no need to rescan
30310 1 if the attribute has been successfully adjusted. */
30313 optimize_string_length (dw_attr_node
*a
)
30315 dw_loc_descr_ref l
= AT_loc (a
), lv
;
30317 if (l
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
30319 tree decl
= l
->dw_loc_oprnd1
.v
.val_decl_ref
;
30320 die
= lookup_decl_die (decl
);
30323 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30324 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= die
;
30325 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30331 die
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
30333 /* DWARF5 allows reference class, so we can then reference the DIE.
30334 Only do this for DW_OP_GNU_variable_value DW_OP_stack_value. */
30335 if (l
->dw_loc_next
!= NULL
&& dwarf_version
>= 5)
30337 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
30338 a
->dw_attr_val
.val_entry
= NULL
;
30339 a
->dw_attr_val
.v
.val_die_ref
.die
= die
;
30340 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
30344 dw_attr_node
*av
= get_AT (die
, DW_AT_location
);
30346 bool non_dwarf_expr
= false;
30349 return dwarf_strict
? -1 : 0;
30350 switch (AT_class (av
))
30352 case dw_val_class_loc_list
:
30353 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
30354 if (d
->expr
&& non_dwarf_expression (d
->expr
))
30355 non_dwarf_expr
= true;
30357 case dw_val_class_view_list
:
30358 gcc_unreachable ();
30359 case dw_val_class_loc
:
30362 return dwarf_strict
? -1 : 0;
30363 if (non_dwarf_expression (lv
))
30364 non_dwarf_expr
= true;
30367 return dwarf_strict
? -1 : 0;
30370 /* If it is safe to transform DW_OP_GNU_variable_value DW_OP_stack_value
30371 into DW_OP_call4 or DW_OP_GNU_variable_value into
30372 DW_OP_call4 DW_OP_deref, do so. */
30373 if (!non_dwarf_expr
30374 && (l
->dw_loc_next
!= NULL
|| AT_class (av
) == dw_val_class_loc
))
30376 l
->dw_loc_opc
= DW_OP_call4
;
30377 if (l
->dw_loc_next
)
30378 l
->dw_loc_next
= NULL
;
30380 l
->dw_loc_next
= new_loc_descr (DW_OP_deref
, 0, 0);
30384 /* For DW_OP_GNU_variable_value DW_OP_stack_value, we can just
30385 copy over the DW_AT_location attribute from die to a. */
30386 if (l
->dw_loc_next
!= NULL
)
30388 a
->dw_attr_val
= av
->dw_attr_val
;
30392 dw_loc_list_ref list
, *p
;
30393 switch (AT_class (av
))
30395 case dw_val_class_loc_list
:
30398 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
30400 lv
= copy_deref_exprloc (d
->expr
);
30403 *p
= new_loc_list (lv
, d
->begin
, d
->vbegin
, d
->end
, d
->vend
, d
->section
);
30404 p
= &(*p
)->dw_loc_next
;
30406 else if (!dwarf_strict
&& d
->expr
)
30410 return dwarf_strict
? -1 : 0;
30411 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
30413 *AT_loc_list_ptr (a
) = list
;
30415 case dw_val_class_loc
:
30416 lv
= copy_deref_exprloc (AT_loc (av
));
30418 return dwarf_strict
? -1 : 0;
30419 a
->dw_attr_val
.v
.val_loc
= lv
;
30422 gcc_unreachable ();
30426 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
30427 an address in .rodata section if the string literal is emitted there,
30428 or remove the containing location list or replace DW_AT_const_value
30429 with DW_AT_location and empty location expression, if it isn't found
30430 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
30431 to something that has been emitted in the current CU. */
30434 resolve_addr (dw_die_ref die
)
30438 dw_loc_list_ref
*curr
, *start
, loc
;
30440 bool remove_AT_byte_size
= false;
30442 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30443 switch (AT_class (a
))
30445 case dw_val_class_loc_list
:
30446 start
= curr
= AT_loc_list_ptr (a
);
30449 /* The same list can be referenced more than once. See if we have
30450 already recorded the result from a previous pass. */
30452 *curr
= loc
->dw_loc_next
;
30453 else if (!loc
->resolved_addr
)
30455 /* As things stand, we do not expect or allow one die to
30456 reference a suffix of another die's location list chain.
30457 References must be identical or completely separate.
30458 There is therefore no need to cache the result of this
30459 pass on any list other than the first; doing so
30460 would lead to unnecessary writes. */
30463 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
30464 if (!resolve_addr_in_expr (a
, (*curr
)->expr
))
30466 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
30467 dw_loc_descr_ref l
= (*curr
)->expr
;
30469 if (next
&& (*curr
)->ll_symbol
)
30471 gcc_assert (!next
->ll_symbol
);
30472 next
->ll_symbol
= (*curr
)->ll_symbol
;
30473 next
->vl_symbol
= (*curr
)->vl_symbol
;
30475 if (dwarf_split_debug_info
)
30476 remove_loc_list_addr_table_entries (l
);
30481 mark_base_types ((*curr
)->expr
);
30482 curr
= &(*curr
)->dw_loc_next
;
30486 loc
->resolved_addr
= 1;
30490 loc
->dw_loc_next
= *start
;
30495 remove_AT (die
, a
->dw_attr
);
30499 case dw_val_class_view_list
:
30501 gcc_checking_assert (a
->dw_attr
== DW_AT_GNU_locviews
);
30502 gcc_checking_assert (dwarf2out_locviews_in_attribute ());
30503 dw_val_node
*llnode
30504 = view_list_to_loc_list_val_node (&a
->dw_attr_val
);
30505 /* If we no longer have a loclist, or it no longer needs
30506 views, drop this attribute. */
30507 if (!llnode
|| !llnode
->v
.val_loc_list
->vl_symbol
)
30509 remove_AT (die
, a
->dw_attr
);
30514 case dw_val_class_loc
:
30516 dw_loc_descr_ref l
= AT_loc (a
);
30517 /* DW_OP_GNU_variable_value DW_OP_stack_value or
30518 DW_OP_GNU_variable_value in DW_AT_string_length can be converted
30519 into DW_OP_call4 or DW_OP_call4 DW_OP_deref, which is standard
30520 DWARF4 unlike DW_OP_GNU_variable_value. Or for DWARF5
30521 DW_OP_GNU_variable_value DW_OP_stack_value can be replaced
30522 with DW_FORM_ref referencing the same DIE as
30523 DW_OP_GNU_variable_value used to reference. */
30524 if (a
->dw_attr
== DW_AT_string_length
30526 && l
->dw_loc_opc
== DW_OP_GNU_variable_value
30527 && (l
->dw_loc_next
== NULL
30528 || (l
->dw_loc_next
->dw_loc_next
== NULL
30529 && l
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
)))
30531 switch (optimize_string_length (a
))
30534 remove_AT (die
, a
->dw_attr
);
30536 /* If we drop DW_AT_string_length, we need to drop also
30537 DW_AT_{string_length_,}byte_size. */
30538 remove_AT_byte_size
= true;
30543 /* Even if we keep the optimized DW_AT_string_length,
30544 it might have changed AT_class, so process it again. */
30549 /* For -gdwarf-2 don't attempt to optimize
30550 DW_AT_data_member_location containing
30551 DW_OP_plus_uconst - older consumers might
30552 rely on it being that op instead of a more complex,
30553 but shorter, location description. */
30554 if ((dwarf_version
> 2
30555 || a
->dw_attr
!= DW_AT_data_member_location
30557 || l
->dw_loc_opc
!= DW_OP_plus_uconst
30558 || l
->dw_loc_next
!= NULL
)
30559 && !resolve_addr_in_expr (a
, l
))
30561 if (dwarf_split_debug_info
)
30562 remove_loc_list_addr_table_entries (l
);
30564 && l
->dw_loc_next
== NULL
30565 && l
->dw_loc_opc
== DW_OP_addr
30566 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
30567 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
30568 && a
->dw_attr
== DW_AT_location
)
30570 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
30571 remove_AT (die
, a
->dw_attr
);
30573 optimize_location_into_implicit_ptr (die
, decl
);
30576 if (a
->dw_attr
== DW_AT_string_length
)
30577 /* If we drop DW_AT_string_length, we need to drop also
30578 DW_AT_{string_length_,}byte_size. */
30579 remove_AT_byte_size
= true;
30580 remove_AT (die
, a
->dw_attr
);
30584 mark_base_types (l
);
30587 case dw_val_class_addr
:
30588 if (a
->dw_attr
== DW_AT_const_value
30589 && !resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
))
30591 if (AT_index (a
) != NOT_INDEXED
)
30592 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
30593 remove_AT (die
, a
->dw_attr
);
30596 if ((die
->die_tag
== DW_TAG_call_site
30597 && a
->dw_attr
== DW_AT_call_origin
)
30598 || (die
->die_tag
== DW_TAG_GNU_call_site
30599 && a
->dw_attr
== DW_AT_abstract_origin
))
30601 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
30602 dw_die_ref tdie
= lookup_decl_die (tdecl
);
30605 && DECL_EXTERNAL (tdecl
)
30606 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
30607 && (cdie
= lookup_context_die (DECL_CONTEXT (tdecl
))))
30609 dw_die_ref pdie
= cdie
;
30610 /* Make sure we don't add these DIEs into type units.
30611 We could emit skeleton DIEs for context (namespaces,
30612 outer structs/classes) and a skeleton DIE for the
30613 innermost context with DW_AT_signature pointing to the
30614 type unit. See PR78835. */
30615 while (pdie
&& pdie
->die_tag
!= DW_TAG_type_unit
)
30616 pdie
= pdie
->die_parent
;
30619 /* Creating a full DIE for tdecl is overly expensive and
30620 at this point even wrong when in the LTO phase
30621 as it can end up generating new type DIEs we didn't
30622 output and thus optimize_external_refs will crash. */
30623 tdie
= new_die (DW_TAG_subprogram
, cdie
, NULL_TREE
);
30624 add_AT_flag (tdie
, DW_AT_external
, 1);
30625 add_AT_flag (tdie
, DW_AT_declaration
, 1);
30626 add_linkage_attr (tdie
, tdecl
);
30627 add_name_and_src_coords_attributes (tdie
, tdecl
, true);
30628 equate_decl_number_to_die (tdecl
, tdie
);
30633 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
30634 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
30635 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
30639 if (AT_index (a
) != NOT_INDEXED
)
30640 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
30641 remove_AT (die
, a
->dw_attr
);
30650 if (remove_AT_byte_size
)
30651 remove_AT (die
, dwarf_version
>= 5
30652 ? DW_AT_string_length_byte_size
30653 : DW_AT_byte_size
);
30655 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
30658 /* Helper routines for optimize_location_lists.
30659 This pass tries to share identical local lists in .debug_loc
30662 /* Iteratively hash operands of LOC opcode into HSTATE. */
30665 hash_loc_operands (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
30667 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
30668 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
30670 switch (loc
->dw_loc_opc
)
30672 case DW_OP_const4u
:
30673 case DW_OP_const8u
:
30677 case DW_OP_const1u
:
30678 case DW_OP_const1s
:
30679 case DW_OP_const2u
:
30680 case DW_OP_const2s
:
30681 case DW_OP_const4s
:
30682 case DW_OP_const8s
:
30686 case DW_OP_plus_uconst
:
30722 case DW_OP_deref_size
:
30723 case DW_OP_xderef_size
:
30724 hstate
.add_object (val1
->v
.val_int
);
30731 gcc_assert (val1
->val_class
== dw_val_class_loc
);
30732 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
30733 hstate
.add_object (offset
);
30736 case DW_OP_implicit_value
:
30737 hstate
.add_object (val1
->v
.val_unsigned
);
30738 switch (val2
->val_class
)
30740 case dw_val_class_const
:
30741 hstate
.add_object (val2
->v
.val_int
);
30743 case dw_val_class_vec
:
30745 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
30746 unsigned int len
= val2
->v
.val_vec
.length
;
30748 hstate
.add_int (elt_size
);
30749 hstate
.add_int (len
);
30750 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
30753 case dw_val_class_const_double
:
30754 hstate
.add_object (val2
->v
.val_double
.low
);
30755 hstate
.add_object (val2
->v
.val_double
.high
);
30757 case dw_val_class_wide_int
:
30758 hstate
.add (val2
->v
.val_wide
->get_val (),
30759 get_full_len (*val2
->v
.val_wide
)
30760 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
30762 case dw_val_class_addr
:
30763 inchash::add_rtx (val2
->v
.val_addr
, hstate
);
30766 gcc_unreachable ();
30770 case DW_OP_bit_piece
:
30771 hstate
.add_object (val1
->v
.val_int
);
30772 hstate
.add_object (val2
->v
.val_int
);
30778 unsigned char dtprel
= 0xd1;
30779 hstate
.add_object (dtprel
);
30781 inchash::add_rtx (val1
->v
.val_addr
, hstate
);
30783 case DW_OP_GNU_addr_index
:
30785 case DW_OP_GNU_const_index
:
30790 unsigned char dtprel
= 0xd1;
30791 hstate
.add_object (dtprel
);
30793 inchash::add_rtx (val1
->val_entry
->addr
.rtl
, hstate
);
30796 case DW_OP_implicit_pointer
:
30797 case DW_OP_GNU_implicit_pointer
:
30798 hstate
.add_int (val2
->v
.val_int
);
30800 case DW_OP_entry_value
:
30801 case DW_OP_GNU_entry_value
:
30802 hstate
.add_object (val1
->v
.val_loc
);
30804 case DW_OP_regval_type
:
30805 case DW_OP_deref_type
:
30806 case DW_OP_GNU_regval_type
:
30807 case DW_OP_GNU_deref_type
:
30809 unsigned int byte_size
30810 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
30811 unsigned int encoding
30812 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
30813 hstate
.add_object (val1
->v
.val_int
);
30814 hstate
.add_object (byte_size
);
30815 hstate
.add_object (encoding
);
30818 case DW_OP_convert
:
30819 case DW_OP_reinterpret
:
30820 case DW_OP_GNU_convert
:
30821 case DW_OP_GNU_reinterpret
:
30822 if (val1
->val_class
== dw_val_class_unsigned_const
)
30824 hstate
.add_object (val1
->v
.val_unsigned
);
30828 case DW_OP_const_type
:
30829 case DW_OP_GNU_const_type
:
30831 unsigned int byte_size
30832 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
30833 unsigned int encoding
30834 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
30835 hstate
.add_object (byte_size
);
30836 hstate
.add_object (encoding
);
30837 if (loc
->dw_loc_opc
!= DW_OP_const_type
30838 && loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
30840 hstate
.add_object (val2
->val_class
);
30841 switch (val2
->val_class
)
30843 case dw_val_class_const
:
30844 hstate
.add_object (val2
->v
.val_int
);
30846 case dw_val_class_vec
:
30848 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
30849 unsigned int len
= val2
->v
.val_vec
.length
;
30851 hstate
.add_object (elt_size
);
30852 hstate
.add_object (len
);
30853 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
30856 case dw_val_class_const_double
:
30857 hstate
.add_object (val2
->v
.val_double
.low
);
30858 hstate
.add_object (val2
->v
.val_double
.high
);
30860 case dw_val_class_wide_int
:
30861 hstate
.add (val2
->v
.val_wide
->get_val (),
30862 get_full_len (*val2
->v
.val_wide
)
30863 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
30866 gcc_unreachable ();
30872 /* Other codes have no operands. */
30877 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
30880 hash_locs (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
30882 dw_loc_descr_ref l
;
30883 bool sizes_computed
= false;
30884 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
30885 size_of_locs (loc
);
30887 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
30889 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
30890 hstate
.add_object (opc
);
30891 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
30893 size_of_locs (loc
);
30894 sizes_computed
= true;
30896 hash_loc_operands (l
, hstate
);
30900 /* Compute hash of the whole location list LIST_HEAD. */
30903 hash_loc_list (dw_loc_list_ref list_head
)
30905 dw_loc_list_ref curr
= list_head
;
30906 inchash::hash hstate
;
30908 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
30910 hstate
.add (curr
->begin
, strlen (curr
->begin
) + 1);
30911 hstate
.add (curr
->end
, strlen (curr
->end
) + 1);
30912 hstate
.add_object (curr
->vbegin
);
30913 hstate
.add_object (curr
->vend
);
30915 hstate
.add (curr
->section
, strlen (curr
->section
) + 1);
30916 hash_locs (curr
->expr
, hstate
);
30918 list_head
->hash
= hstate
.end ();
30921 /* Return true if X and Y opcodes have the same operands. */
30924 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
30926 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
30927 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
30928 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
30929 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
30931 switch (x
->dw_loc_opc
)
30933 case DW_OP_const4u
:
30934 case DW_OP_const8u
:
30938 case DW_OP_const1u
:
30939 case DW_OP_const1s
:
30940 case DW_OP_const2u
:
30941 case DW_OP_const2s
:
30942 case DW_OP_const4s
:
30943 case DW_OP_const8s
:
30947 case DW_OP_plus_uconst
:
30983 case DW_OP_deref_size
:
30984 case DW_OP_xderef_size
:
30985 return valx1
->v
.val_int
== valy1
->v
.val_int
;
30988 /* If splitting debug info, the use of DW_OP_GNU_addr_index
30989 can cause irrelevant differences in dw_loc_addr. */
30990 gcc_assert (valx1
->val_class
== dw_val_class_loc
30991 && valy1
->val_class
== dw_val_class_loc
30992 && (dwarf_split_debug_info
30993 || x
->dw_loc_addr
== y
->dw_loc_addr
));
30994 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
30995 case DW_OP_implicit_value
:
30996 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
30997 || valx2
->val_class
!= valy2
->val_class
)
30999 switch (valx2
->val_class
)
31001 case dw_val_class_const
:
31002 return valx2
->v
.val_int
== valy2
->v
.val_int
;
31003 case dw_val_class_vec
:
31004 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
31005 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
31006 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
31007 valx2
->v
.val_vec
.elt_size
31008 * valx2
->v
.val_vec
.length
) == 0;
31009 case dw_val_class_const_double
:
31010 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
31011 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
31012 case dw_val_class_wide_int
:
31013 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
31014 case dw_val_class_addr
:
31015 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
31017 gcc_unreachable ();
31020 case DW_OP_bit_piece
:
31021 return valx1
->v
.val_int
== valy1
->v
.val_int
31022 && valx2
->v
.val_int
== valy2
->v
.val_int
;
31025 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
31026 case DW_OP_GNU_addr_index
:
31028 case DW_OP_GNU_const_index
:
31031 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
31032 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
31033 return rtx_equal_p (ax1
, ay1
);
31035 case DW_OP_implicit_pointer
:
31036 case DW_OP_GNU_implicit_pointer
:
31037 return valx1
->val_class
== dw_val_class_die_ref
31038 && valx1
->val_class
== valy1
->val_class
31039 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
31040 && valx2
->v
.val_int
== valy2
->v
.val_int
;
31041 case DW_OP_entry_value
:
31042 case DW_OP_GNU_entry_value
:
31043 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
31044 case DW_OP_const_type
:
31045 case DW_OP_GNU_const_type
:
31046 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
31047 || valx2
->val_class
!= valy2
->val_class
)
31049 switch (valx2
->val_class
)
31051 case dw_val_class_const
:
31052 return valx2
->v
.val_int
== valy2
->v
.val_int
;
31053 case dw_val_class_vec
:
31054 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
31055 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
31056 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
31057 valx2
->v
.val_vec
.elt_size
31058 * valx2
->v
.val_vec
.length
) == 0;
31059 case dw_val_class_const_double
:
31060 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
31061 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
31062 case dw_val_class_wide_int
:
31063 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
31065 gcc_unreachable ();
31067 case DW_OP_regval_type
:
31068 case DW_OP_deref_type
:
31069 case DW_OP_GNU_regval_type
:
31070 case DW_OP_GNU_deref_type
:
31071 return valx1
->v
.val_int
== valy1
->v
.val_int
31072 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
31073 case DW_OP_convert
:
31074 case DW_OP_reinterpret
:
31075 case DW_OP_GNU_convert
:
31076 case DW_OP_GNU_reinterpret
:
31077 if (valx1
->val_class
!= valy1
->val_class
)
31079 if (valx1
->val_class
== dw_val_class_unsigned_const
)
31080 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
31081 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
31082 case DW_OP_GNU_parameter_ref
:
31083 return valx1
->val_class
== dw_val_class_die_ref
31084 && valx1
->val_class
== valy1
->val_class
31085 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
31087 /* Other codes have no operands. */
31092 /* Return true if DWARF location expressions X and Y are the same. */
31095 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
31097 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
31098 if (x
->dw_loc_opc
!= y
->dw_loc_opc
31099 || x
->dtprel
!= y
->dtprel
31100 || !compare_loc_operands (x
, y
))
31102 return x
== NULL
&& y
== NULL
;
31105 /* Hashtable helpers. */
31107 struct loc_list_hasher
: nofree_ptr_hash
<dw_loc_list_struct
>
31109 static inline hashval_t
hash (const dw_loc_list_struct
*);
31110 static inline bool equal (const dw_loc_list_struct
*,
31111 const dw_loc_list_struct
*);
31114 /* Return precomputed hash of location list X. */
31117 loc_list_hasher::hash (const dw_loc_list_struct
*x
)
31122 /* Return true if location lists A and B are the same. */
31125 loc_list_hasher::equal (const dw_loc_list_struct
*a
,
31126 const dw_loc_list_struct
*b
)
31130 if (a
->hash
!= b
->hash
)
31132 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
31133 if (strcmp (a
->begin
, b
->begin
) != 0
31134 || strcmp (a
->end
, b
->end
) != 0
31135 || (a
->section
== NULL
) != (b
->section
== NULL
)
31136 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
31137 || a
->vbegin
!= b
->vbegin
|| a
->vend
!= b
->vend
31138 || !compare_locs (a
->expr
, b
->expr
))
31140 return a
== NULL
&& b
== NULL
;
31143 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
31146 /* Recursively optimize location lists referenced from DIE
31147 children and share them whenever possible. */
31150 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type
*htab
)
31155 dw_loc_list_struct
**slot
;
31156 bool drop_locviews
= false;
31157 bool has_locviews
= false;
31159 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31160 if (AT_class (a
) == dw_val_class_loc_list
)
31162 dw_loc_list_ref list
= AT_loc_list (a
);
31163 /* TODO: perform some optimizations here, before hashing
31164 it and storing into the hash table. */
31165 hash_loc_list (list
);
31166 slot
= htab
->find_slot_with_hash (list
, list
->hash
, INSERT
);
31170 if (loc_list_has_views (list
))
31171 gcc_assert (list
->vl_symbol
);
31172 else if (list
->vl_symbol
)
31174 drop_locviews
= true;
31175 list
->vl_symbol
= NULL
;
31180 if (list
->vl_symbol
&& !(*slot
)->vl_symbol
)
31181 drop_locviews
= true;
31182 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
31185 else if (AT_class (a
) == dw_val_class_view_list
)
31187 gcc_checking_assert (a
->dw_attr
== DW_AT_GNU_locviews
);
31188 has_locviews
= true;
31192 if (drop_locviews
&& has_locviews
)
31193 remove_AT (die
, DW_AT_GNU_locviews
);
31195 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
31199 /* Recursively assign each location list a unique index into the debug_addr
31203 index_location_lists (dw_die_ref die
)
31209 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31210 if (AT_class (a
) == dw_val_class_loc_list
)
31212 dw_loc_list_ref list
= AT_loc_list (a
);
31213 dw_loc_list_ref curr
;
31214 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
31216 /* Don't index an entry that has already been indexed
31217 or won't be output. Make sure skip_loc_list_entry doesn't
31218 call size_of_locs, because that might cause circular dependency,
31219 index_location_lists requiring address table indexes to be
31220 computed, but adding new indexes through add_addr_table_entry
31221 and address table index computation requiring no new additions
31222 to the hash table. In the rare case of DWARF[234] >= 64KB
31223 location expression, we'll just waste unused address table entry
31225 if (curr
->begin_entry
!= NULL
31226 || skip_loc_list_entry (curr
))
31230 = add_addr_table_entry (xstrdup (curr
->begin
), ate_kind_label
);
31234 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
31237 /* Optimize location lists referenced from DIE
31238 children and share them whenever possible. */
31241 optimize_location_lists (dw_die_ref die
)
31243 loc_list_hash_type
htab (500);
31244 optimize_location_lists_1 (die
, &htab
);
31247 /* Traverse the limbo die list, and add parent/child links. The only
31248 dies without parents that should be here are concrete instances of
31249 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
31250 For concrete instances, we can get the parent die from the abstract
31254 flush_limbo_die_list (void)
31256 limbo_die_node
*node
;
31258 /* get_context_die calls force_decl_die, which can put new DIEs on the
31259 limbo list in LTO mode when nested functions are put in a different
31260 partition than that of their parent function. */
31261 while ((node
= limbo_die_list
))
31263 dw_die_ref die
= node
->die
;
31264 limbo_die_list
= node
->next
;
31266 if (die
->die_parent
== NULL
)
31268 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
31270 if (origin
&& origin
->die_parent
)
31271 add_child_die (origin
->die_parent
, die
);
31272 else if (is_cu_die (die
))
31274 else if (seen_error ())
31275 /* It's OK to be confused by errors in the input. */
31276 add_child_die (comp_unit_die (), die
);
31279 /* In certain situations, the lexical block containing a
31280 nested function can be optimized away, which results
31281 in the nested function die being orphaned. Likewise
31282 with the return type of that nested function. Force
31283 this to be a child of the containing function.
31285 It may happen that even the containing function got fully
31286 inlined and optimized out. In that case we are lost and
31287 assign the empty child. This should not be big issue as
31288 the function is likely unreachable too. */
31289 gcc_assert (node
->created_for
);
31291 if (DECL_P (node
->created_for
))
31292 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
31293 else if (TYPE_P (node
->created_for
))
31294 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
31296 origin
= comp_unit_die ();
31298 add_child_die (origin
, die
);
31304 /* Reset DIEs so we can output them again. */
31307 reset_dies (dw_die_ref die
)
31311 /* Remove stuff we re-generate. */
31313 die
->die_offset
= 0;
31314 die
->die_abbrev
= 0;
31315 remove_AT (die
, DW_AT_sibling
);
31317 FOR_EACH_CHILD (die
, c
, reset_dies (c
));
31320 /* Output stuff that dwarf requires at the end of every file,
31321 and generate the DWARF-2 debugging info. */
31324 dwarf2out_finish (const char *filename
)
31326 comdat_type_node
*ctnode
;
31327 dw_die_ref main_comp_unit_die
;
31328 unsigned char checksum
[16];
31329 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
31331 /* Flush out any latecomers to the limbo party. */
31332 flush_limbo_die_list ();
31334 if (inline_entry_data_table
)
31335 gcc_assert (inline_entry_data_table
->is_empty ());
31339 verify_die (comp_unit_die ());
31340 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
31341 verify_die (node
->die
);
31344 /* We shouldn't have any symbols with delayed asm names for
31345 DIEs generated after early finish. */
31346 gcc_assert (deferred_asm_name
== NULL
);
31348 gen_remaining_tmpl_value_param_die_attribute ();
31350 if (flag_generate_lto
|| flag_generate_offload
)
31352 gcc_assert (flag_fat_lto_objects
|| flag_generate_offload
);
31354 /* Prune stuff so that dwarf2out_finish runs successfully
31355 for the fat part of the object. */
31356 reset_dies (comp_unit_die ());
31357 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
31358 reset_dies (node
->die
);
31360 hash_table
<comdat_type_hasher
> comdat_type_table (100);
31361 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31363 comdat_type_node
**slot
31364 = comdat_type_table
.find_slot (ctnode
, INSERT
);
31366 /* Don't reset types twice. */
31367 if (*slot
!= HTAB_EMPTY_ENTRY
)
31370 /* Remove the pointer to the line table. */
31371 remove_AT (ctnode
->root_die
, DW_AT_stmt_list
);
31373 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31374 reset_dies (ctnode
->root_die
);
31379 /* Reset die CU symbol so we don't output it twice. */
31380 comp_unit_die ()->die_id
.die_symbol
= NULL
;
31382 /* Remove DW_AT_macro and DW_AT_stmt_list from the early output. */
31383 remove_AT (comp_unit_die (), DW_AT_stmt_list
);
31385 remove_AT (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
);
31387 /* Remove indirect string decisions. */
31388 debug_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
31389 if (debug_line_str_hash
)
31391 debug_line_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
31392 debug_line_str_hash
= NULL
;
31396 #if ENABLE_ASSERT_CHECKING
31398 dw_die_ref die
= comp_unit_die (), c
;
31399 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
31402 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31403 resolve_addr (ctnode
->root_die
);
31404 resolve_addr (comp_unit_die ());
31405 move_marked_base_types ();
31409 fprintf (dump_file
, "DWARF for %s\n", filename
);
31410 print_die (comp_unit_die (), dump_file
);
31413 /* Initialize sections and labels used for actual assembler output. */
31414 unsigned generation
= init_sections_and_labels (false);
31416 /* Traverse the DIE's and add sibling attributes to those DIE's that
31418 add_sibling_attributes (comp_unit_die ());
31419 limbo_die_node
*node
;
31420 for (node
= cu_die_list
; node
; node
= node
->next
)
31421 add_sibling_attributes (node
->die
);
31422 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31423 add_sibling_attributes (ctnode
->root_die
);
31425 /* When splitting DWARF info, we put some attributes in the
31426 skeleton compile_unit DIE that remains in the .o, while
31427 most attributes go in the DWO compile_unit_die. */
31428 if (dwarf_split_debug_info
)
31430 limbo_die_node
*cu
;
31431 main_comp_unit_die
= gen_compile_unit_die (NULL
);
31432 if (dwarf_version
>= 5)
31433 main_comp_unit_die
->die_tag
= DW_TAG_skeleton_unit
;
31434 cu
= limbo_die_list
;
31435 gcc_assert (cu
->die
== main_comp_unit_die
);
31436 limbo_die_list
= limbo_die_list
->next
;
31437 cu
->next
= cu_die_list
;
31441 main_comp_unit_die
= comp_unit_die ();
31443 /* Output a terminator label for the .text section. */
31444 switch_to_section (text_section
);
31445 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
31446 if (cold_text_section
)
31448 switch_to_section (cold_text_section
);
31449 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
31452 /* We can only use the low/high_pc attributes if all of the code was
31454 if (!have_multiple_function_sections
31455 || (dwarf_version
< 3 && dwarf_strict
))
31457 /* Don't add if the CU has no associated code. */
31458 if (text_section_used
)
31459 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
31460 text_end_label
, true);
31466 bool range_list_added
= false;
31468 if (text_section_used
)
31469 add_ranges_by_labels (main_comp_unit_die
, text_section_label
,
31470 text_end_label
, &range_list_added
, true);
31471 if (cold_text_section_used
)
31472 add_ranges_by_labels (main_comp_unit_die
, cold_text_section_label
,
31473 cold_end_label
, &range_list_added
, true);
31475 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
31477 if (DECL_IGNORED_P (fde
->decl
))
31479 if (!fde
->in_std_section
)
31480 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
31481 fde
->dw_fde_end
, &range_list_added
,
31483 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
31484 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
31485 fde
->dw_fde_second_end
, &range_list_added
,
31489 if (range_list_added
)
31491 /* We need to give .debug_loc and .debug_ranges an appropriate
31492 "base address". Use zero so that these addresses become
31493 absolute. Historically, we've emitted the unexpected
31494 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
31495 Emit both to give time for other tools to adapt. */
31496 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
31497 if (! dwarf_strict
&& dwarf_version
< 4)
31498 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
31504 /* AIX Assembler inserts the length, so adjust the reference to match the
31505 offset expected by debuggers. */
31506 strcpy (dl_section_ref
, debug_line_section_label
);
31507 if (XCOFF_DEBUGGING_INFO
)
31508 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
31510 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31511 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
31515 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
31516 macinfo_section_label
);
31518 if (dwarf_split_debug_info
)
31520 if (have_location_lists
)
31522 /* Since we generate the loclists in the split DWARF .dwo
31523 file itself, we don't need to generate a loclists_base
31524 attribute for the split compile unit DIE. That attribute
31525 (and using relocatable sec_offset FORMs) isn't allowed
31526 for a split compile unit. Only if the .debug_loclists
31527 section was in the main file, would we need to generate a
31528 loclists_base attribute here (for the full or skeleton
31531 /* optimize_location_lists calculates the size of the lists,
31532 so index them first, and assign indices to the entries.
31533 Although optimize_location_lists will remove entries from
31534 the table, it only does so for duplicates, and therefore
31535 only reduces ref_counts to 1. */
31536 index_location_lists (comp_unit_die ());
31539 if (addr_index_table
!= NULL
)
31541 unsigned int index
= 0;
31543 ->traverse_noresize
<unsigned int *, index_addr_table_entry
>
31549 if (have_location_lists
)
31551 optimize_location_lists (comp_unit_die ());
31552 /* And finally assign indexes to the entries for -gsplit-dwarf. */
31553 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
31554 assign_location_list_indexes (comp_unit_die ());
31557 save_macinfo_strings ();
31559 if (dwarf_split_debug_info
)
31561 unsigned int index
= 0;
31563 /* Add attributes common to skeleton compile_units and
31564 type_units. Because these attributes include strings, it
31565 must be done before freezing the string table. Top-level
31566 skeleton die attrs are added when the skeleton type unit is
31567 created, so ensure it is created by this point. */
31568 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
31569 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
31572 /* Output all of the compilation units. We put the main one last so that
31573 the offsets are available to output_pubnames. */
31574 for (node
= cu_die_list
; node
; node
= node
->next
)
31575 output_comp_unit (node
->die
, 0, NULL
);
31577 hash_table
<comdat_type_hasher
> comdat_type_table (100);
31578 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
31580 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
31582 /* Don't output duplicate types. */
31583 if (*slot
!= HTAB_EMPTY_ENTRY
)
31586 /* Add a pointer to the line table for the main compilation unit
31587 so that the debugger can make sense of DW_AT_decl_file
31589 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
31590 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
31591 (!dwarf_split_debug_info
31593 : debug_skeleton_line_section_label
));
31595 output_comdat_type_unit (ctnode
, false);
31599 if (dwarf_split_debug_info
)
31602 struct md5_ctx ctx
;
31604 if (dwarf_version
>= 5 && !vec_safe_is_empty (ranges_table
))
31607 /* Compute a checksum of the comp_unit to use as the dwo_id. */
31608 md5_init_ctx (&ctx
);
31610 die_checksum (comp_unit_die (), &ctx
, &mark
);
31611 unmark_all_dies (comp_unit_die ());
31612 md5_finish_ctx (&ctx
, checksum
);
31614 if (dwarf_version
< 5)
31616 /* Use the first 8 bytes of the checksum as the dwo_id,
31617 and add it to both comp-unit DIEs. */
31618 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
31619 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
31622 /* Add the base offset of the ranges table to the skeleton
31624 if (!vec_safe_is_empty (ranges_table
))
31626 if (dwarf_version
>= 5)
31627 add_AT_lineptr (main_comp_unit_die
, DW_AT_rnglists_base
,
31628 ranges_base_label
);
31630 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
31631 ranges_section_label
);
31634 switch_to_section (debug_addr_section
);
31635 /* GNU DebugFission https://gcc.gnu.org/wiki/DebugFission
31636 which GCC uses to implement -gsplit-dwarf as DWARF GNU extension
31637 before DWARF5, didn't have a header for .debug_addr units.
31638 DWARF5 specifies a small header when address tables are used. */
31639 if (dwarf_version
>= 5)
31641 unsigned int last_idx
= 0;
31642 unsigned long addrs_length
;
31644 addr_index_table
->traverse_noresize
31645 <unsigned int *, count_index_addrs
> (&last_idx
);
31646 addrs_length
= last_idx
* DWARF2_ADDR_SIZE
+ 4;
31648 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
31649 dw2_asm_output_data (4, 0xffffffff,
31650 "Escape value for 64-bit DWARF extension");
31651 dw2_asm_output_data (DWARF_OFFSET_SIZE
, addrs_length
,
31652 "Length of Address Unit");
31653 dw2_asm_output_data (2, 5, "DWARF addr version");
31654 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
31655 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
31657 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
31658 output_addr_table ();
31661 /* Output the main compilation unit if non-empty or if .debug_macinfo
31662 or .debug_macro will be emitted. */
31663 output_comp_unit (comp_unit_die (), have_macinfo
,
31664 dwarf_split_debug_info
? checksum
: NULL
);
31666 if (dwarf_split_debug_info
&& info_section_emitted
)
31667 output_skeleton_debug_sections (main_comp_unit_die
, checksum
);
31669 /* Output the abbreviation table. */
31670 if (vec_safe_length (abbrev_die_table
) != 1)
31672 switch_to_section (debug_abbrev_section
);
31673 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
31674 output_abbrev_section ();
31677 /* Output location list section if necessary. */
31678 if (have_location_lists
)
31680 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
31681 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
31682 /* Output the location lists info. */
31683 switch_to_section (debug_loc_section
);
31684 if (dwarf_version
>= 5)
31686 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_LOC_SECTION_LABEL
, 2);
31687 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_LOC_SECTION_LABEL
, 3);
31688 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
31689 dw2_asm_output_data (4, 0xffffffff,
31690 "Initial length escape value indicating "
31691 "64-bit DWARF extension");
31692 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
31693 "Length of Location Lists");
31694 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
31695 output_dwarf_version ();
31696 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
31697 dw2_asm_output_data (1, 0, "Segment Size");
31698 dw2_asm_output_data (4, dwarf_split_debug_info
? loc_list_idx
: 0,
31699 "Offset Entry Count");
31701 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
31702 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
31704 unsigned int save_loc_list_idx
= loc_list_idx
;
31706 output_loclists_offsets (comp_unit_die ());
31707 gcc_assert (save_loc_list_idx
== loc_list_idx
);
31709 output_location_lists (comp_unit_die ());
31710 if (dwarf_version
>= 5)
31711 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
31714 output_pubtables ();
31716 /* Output the address range information if a CU (.debug_info section)
31717 was emitted. We output an empty table even if we had no functions
31718 to put in it. This because the consumer has no way to tell the
31719 difference between an empty table that we omitted and failure to
31720 generate a table that would have contained data. */
31721 if (info_section_emitted
)
31723 switch_to_section (debug_aranges_section
);
31727 /* Output ranges section if necessary. */
31728 if (!vec_safe_is_empty (ranges_table
))
31730 if (dwarf_version
>= 5)
31731 output_rnglists (generation
);
31736 /* Have to end the macro section. */
31739 switch_to_section (debug_macinfo_section
);
31740 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
31741 output_macinfo (!dwarf_split_debug_info
? debug_line_section_label
31742 : debug_skeleton_line_section_label
, false);
31743 dw2_asm_output_data (1, 0, "End compilation unit");
31746 /* Output the source line correspondence table. We must do this
31747 even if there is no line information. Otherwise, on an empty
31748 translation unit, we will generate a present, but empty,
31749 .debug_info section. IRIX 6.5 `nm' will then complain when
31750 examining the file. This is done late so that any filenames
31751 used by the debug_info section are marked as 'used'. */
31752 switch_to_section (debug_line_section
);
31753 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
31754 if (! output_asm_line_debug_info ())
31755 output_line_info (false);
31757 if (dwarf_split_debug_info
&& info_section_emitted
)
31759 switch_to_section (debug_skeleton_line_section
);
31760 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
31761 output_line_info (true);
31764 /* If we emitted any indirect strings, output the string table too. */
31765 if (debug_str_hash
|| skeleton_debug_str_hash
)
31766 output_indirect_strings ();
31767 if (debug_line_str_hash
)
31769 switch_to_section (debug_line_str_section
);
31770 const enum dwarf_form form
= DW_FORM_line_strp
;
31771 debug_line_str_hash
->traverse
<enum dwarf_form
,
31772 output_indirect_string
> (form
);
31775 /* ??? Move lvugid out of dwarf2out_source_line and reset it too? */
31776 symview_upper_bound
= 0;
31778 bitmap_clear (zero_view_p
);
31781 /* Returns a hash value for X (which really is a variable_value_struct). */
31784 variable_value_hasher::hash (variable_value_struct
*x
)
31786 return (hashval_t
) x
->decl_id
;
31789 /* Return nonzero if decl_id of variable_value_struct X is the same as
31793 variable_value_hasher::equal (variable_value_struct
*x
, tree y
)
31795 return x
->decl_id
== DECL_UID (y
);
31798 /* Helper function for resolve_variable_value, handle
31799 DW_OP_GNU_variable_value in one location expression.
31800 Return true if exprloc has been changed into loclist. */
31803 resolve_variable_value_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
31805 dw_loc_descr_ref next
;
31806 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= next
)
31808 next
= loc
->dw_loc_next
;
31809 if (loc
->dw_loc_opc
!= DW_OP_GNU_variable_value
31810 || loc
->dw_loc_oprnd1
.val_class
!= dw_val_class_decl_ref
)
31813 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
31814 if (DECL_CONTEXT (decl
) != current_function_decl
)
31817 dw_die_ref ref
= lookup_decl_die (decl
);
31820 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31821 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31822 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31825 dw_loc_list_ref l
= loc_list_from_tree (decl
, 0, NULL
);
31828 if (l
->dw_loc_next
)
31830 if (AT_class (a
) != dw_val_class_loc
)
31832 switch (a
->dw_attr
)
31834 /* Following attributes allow both exprloc and loclist
31835 classes, so we can change them into a loclist. */
31836 case DW_AT_location
:
31837 case DW_AT_string_length
:
31838 case DW_AT_return_addr
:
31839 case DW_AT_data_member_location
:
31840 case DW_AT_frame_base
:
31841 case DW_AT_segment
:
31842 case DW_AT_static_link
:
31843 case DW_AT_use_location
:
31844 case DW_AT_vtable_elem_location
:
31847 prev
->dw_loc_next
= NULL
;
31848 prepend_loc_descr_to_each (l
, AT_loc (a
));
31851 add_loc_descr_to_each (l
, next
);
31852 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
31853 a
->dw_attr_val
.val_entry
= NULL
;
31854 a
->dw_attr_val
.v
.val_loc_list
= l
;
31855 have_location_lists
= true;
31857 /* Following attributes allow both exprloc and reference,
31858 so if the whole expression is DW_OP_GNU_variable_value alone
31859 we could transform it into reference. */
31860 case DW_AT_byte_size
:
31861 case DW_AT_bit_size
:
31862 case DW_AT_lower_bound
:
31863 case DW_AT_upper_bound
:
31864 case DW_AT_bit_stride
:
31866 case DW_AT_allocated
:
31867 case DW_AT_associated
:
31868 case DW_AT_byte_stride
:
31869 if (prev
== NULL
&& next
== NULL
)
31877 /* Create DW_TAG_variable that we can refer to. */
31878 gen_decl_die (decl
, NULL_TREE
, NULL
,
31879 lookup_decl_die (current_function_decl
));
31880 ref
= lookup_decl_die (decl
);
31883 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31884 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31885 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31891 prev
->dw_loc_next
= l
->expr
;
31892 add_loc_descr (&prev
->dw_loc_next
, next
);
31893 free_loc_descr (loc
, NULL
);
31894 next
= prev
->dw_loc_next
;
31898 memcpy (loc
, l
->expr
, sizeof (dw_loc_descr_node
));
31899 add_loc_descr (&loc
, next
);
31907 /* Attempt to resolve DW_OP_GNU_variable_value using loc_list_from_tree. */
31910 resolve_variable_value (dw_die_ref die
)
31913 dw_loc_list_ref loc
;
31916 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
31917 switch (AT_class (a
))
31919 case dw_val_class_loc
:
31920 if (!resolve_variable_value_in_expr (a
, AT_loc (a
)))
31923 case dw_val_class_loc_list
:
31924 loc
= AT_loc_list (a
);
31926 for (; loc
; loc
= loc
->dw_loc_next
)
31927 resolve_variable_value_in_expr (a
, loc
->expr
);
31934 /* Attempt to optimize DW_OP_GNU_variable_value refering to
31935 temporaries in the current function. */
31938 resolve_variable_values (void)
31940 if (!variable_value_hash
|| !current_function_decl
)
31943 struct variable_value_struct
*node
31944 = variable_value_hash
->find_with_hash (current_function_decl
,
31945 DECL_UID (current_function_decl
));
31952 FOR_EACH_VEC_SAFE_ELT (node
->dies
, i
, die
)
31953 resolve_variable_value (die
);
31956 /* Helper function for note_variable_value, handle one location
31960 note_variable_value_in_expr (dw_die_ref die
, dw_loc_descr_ref loc
)
31962 for (; loc
; loc
= loc
->dw_loc_next
)
31963 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
31964 && loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
31966 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
31967 dw_die_ref ref
= lookup_decl_die (decl
);
31968 if (! ref
&& (flag_generate_lto
|| flag_generate_offload
))
31970 /* ??? This is somewhat a hack because we do not create DIEs
31971 for variables not in BLOCK trees early but when generating
31972 early LTO output we need the dw_val_class_decl_ref to be
31973 fully resolved. For fat LTO objects we'd also like to
31974 undo this after LTO dwarf output. */
31975 gcc_assert (DECL_CONTEXT (decl
));
31976 dw_die_ref ctx
= lookup_decl_die (DECL_CONTEXT (decl
));
31977 gcc_assert (ctx
!= NULL
);
31978 gen_decl_die (decl
, NULL_TREE
, NULL
, ctx
);
31979 ref
= lookup_decl_die (decl
);
31980 gcc_assert (ref
!= NULL
);
31984 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
31985 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
31986 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
31990 && DECL_CONTEXT (decl
)
31991 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
31992 && lookup_decl_die (DECL_CONTEXT (decl
)))
31994 if (!variable_value_hash
)
31995 variable_value_hash
31996 = hash_table
<variable_value_hasher
>::create_ggc (10);
31998 tree fndecl
= DECL_CONTEXT (decl
);
31999 struct variable_value_struct
*node
;
32000 struct variable_value_struct
**slot
32001 = variable_value_hash
->find_slot_with_hash (fndecl
,
32006 node
= ggc_cleared_alloc
<variable_value_struct
> ();
32007 node
->decl_id
= DECL_UID (fndecl
);
32013 vec_safe_push (node
->dies
, die
);
32018 /* Walk the tree DIE and note DIEs with DW_OP_GNU_variable_value still
32019 with dw_val_class_decl_ref operand. */
32022 note_variable_value (dw_die_ref die
)
32026 dw_loc_list_ref loc
;
32029 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
32030 switch (AT_class (a
))
32032 case dw_val_class_loc_list
:
32033 loc
= AT_loc_list (a
);
32035 if (!loc
->noted_variable_value
)
32037 loc
->noted_variable_value
= 1;
32038 for (; loc
; loc
= loc
->dw_loc_next
)
32039 note_variable_value_in_expr (die
, loc
->expr
);
32042 case dw_val_class_loc
:
32043 note_variable_value_in_expr (die
, AT_loc (a
));
32049 /* Mark children. */
32050 FOR_EACH_CHILD (die
, c
, note_variable_value (c
));
32053 /* Perform any cleanups needed after the early debug generation pass
32057 dwarf2out_early_finish (const char *filename
)
32060 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
32062 /* PCH might result in DW_AT_producer string being restored from the
32063 header compilation, so always fill it with empty string initially
32064 and overwrite only here. */
32065 dw_attr_node
*producer
= get_AT (comp_unit_die (), DW_AT_producer
);
32066 producer_string
= gen_producer_string ();
32067 producer
->dw_attr_val
.v
.val_str
->refcount
--;
32068 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
32070 /* Add the name for the main input file now. We delayed this from
32071 dwarf2out_init to avoid complications with PCH. */
32072 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
32073 add_comp_dir_attribute (comp_unit_die ());
32075 /* When emitting DWARF5 .debug_line_str, move DW_AT_name and
32076 DW_AT_comp_dir into .debug_line_str section. */
32077 if (!output_asm_line_debug_info ()
32078 && dwarf_version
>= 5
32079 && DWARF5_USE_DEBUG_LINE_STR
)
32081 for (int i
= 0; i
< 2; i
++)
32083 dw_attr_node
*a
= get_AT (comp_unit_die (),
32084 i
? DW_AT_comp_dir
: DW_AT_name
);
32086 || AT_class (a
) != dw_val_class_str
32087 || strlen (AT_string (a
)) + 1 <= DWARF_OFFSET_SIZE
)
32090 if (! debug_line_str_hash
)
32091 debug_line_str_hash
32092 = hash_table
<indirect_string_hasher
>::create_ggc (10);
32094 struct indirect_string_node
*node
32095 = find_AT_string_in_table (AT_string (a
), debug_line_str_hash
);
32096 set_indirect_string (node
);
32097 node
->form
= DW_FORM_line_strp
;
32098 a
->dw_attr_val
.v
.val_str
->refcount
--;
32099 a
->dw_attr_val
.v
.val_str
= node
;
32103 /* With LTO early dwarf was really finished at compile-time, so make
32104 sure to adjust the phase after annotating the LTRANS CU DIE. */
32107 /* Force DW_TAG_imported_unit to be created now, otherwise
32108 we might end up without it or ordered after DW_TAG_inlined_subroutine
32109 referencing DIEs from it. */
32110 if (! flag_wpa
&& flag_incremental_link
!= INCREMENTAL_LINK_LTO
)
32114 if (external_die_map
)
32115 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, tu
)
32116 if (sym_off_pair
*desc
= external_die_map
->get (tu
))
32118 dw_die_ref import
= new_die (DW_TAG_imported_unit
,
32119 comp_unit_die (), NULL_TREE
);
32120 add_AT_external_die_ref (import
, DW_AT_import
,
32121 desc
->sym
, desc
->off
);
32125 early_dwarf_finished
= true;
32128 fprintf (dump_file
, "LTO EARLY DWARF for %s\n", filename
);
32129 print_die (comp_unit_die (), dump_file
);
32134 /* Walk through the list of incomplete types again, trying once more to
32135 emit full debugging info for them. */
32136 retry_incomplete_types ();
32138 /* The point here is to flush out the limbo list so that it is empty
32139 and we don't need to stream it for LTO. */
32140 flush_limbo_die_list ();
32142 gen_scheduled_generic_parms_dies ();
32143 gen_remaining_tmpl_value_param_die_attribute ();
32145 /* Add DW_AT_linkage_name for all deferred DIEs. */
32146 for (limbo_die_node
*node
= deferred_asm_name
; node
; node
= node
->next
)
32148 tree decl
= node
->created_for
;
32149 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
32150 /* A missing DECL_ASSEMBLER_NAME can be a constant DIE that
32151 ended up in deferred_asm_name before we knew it was
32152 constant and never written to disk. */
32153 && DECL_ASSEMBLER_NAME (decl
))
32155 add_linkage_attr (node
->die
, decl
);
32156 move_linkage_attr (node
->die
);
32159 deferred_asm_name
= NULL
;
32161 if (flag_eliminate_unused_debug_types
)
32162 prune_unused_types ();
32164 /* Generate separate COMDAT sections for type DIEs. */
32165 if (use_debug_types
)
32167 break_out_comdat_types (comp_unit_die ());
32169 /* Each new type_unit DIE was added to the limbo die list when created.
32170 Since these have all been added to comdat_type_list, clear the
32172 limbo_die_list
= NULL
;
32174 /* For each new comdat type unit, copy declarations for incomplete
32175 types to make the new unit self-contained (i.e., no direct
32176 references to the main compile unit). */
32177 for (comdat_type_node
*ctnode
= comdat_type_list
;
32178 ctnode
!= NULL
; ctnode
= ctnode
->next
)
32179 copy_decls_for_unworthy_types (ctnode
->root_die
);
32180 copy_decls_for_unworthy_types (comp_unit_die ());
32182 /* In the process of copying declarations from one unit to another,
32183 we may have left some declarations behind that are no longer
32184 referenced. Prune them. */
32185 prune_unused_types ();
32188 /* Traverse the DIE's and note DIEs with DW_OP_GNU_variable_value still
32189 with dw_val_class_decl_ref operand. */
32190 note_variable_value (comp_unit_die ());
32191 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
32192 note_variable_value (node
->die
);
32193 for (comdat_type_node
*ctnode
= comdat_type_list
; ctnode
!= NULL
;
32194 ctnode
= ctnode
->next
)
32195 note_variable_value (ctnode
->root_die
);
32196 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
32197 note_variable_value (node
->die
);
32199 /* The AT_pubnames attribute needs to go in all skeleton dies, including
32200 both the main_cu and all skeleton TUs. Making this call unconditional
32201 would end up either adding a second copy of the AT_pubnames attribute, or
32202 requiring a special case in add_top_level_skeleton_die_attrs. */
32203 if (!dwarf_split_debug_info
)
32204 add_AT_pubnames (comp_unit_die ());
32206 /* The early debug phase is now finished. */
32207 early_dwarf_finished
= true;
32210 fprintf (dump_file
, "EARLY DWARF for %s\n", filename
);
32211 print_die (comp_unit_die (), dump_file
);
32214 /* Do not generate DWARF assembler now when not producing LTO bytecode. */
32215 if ((!flag_generate_lto
&& !flag_generate_offload
)
32216 /* FIXME: Disable debug info generation for (PE-)COFF targets since the
32217 copy_lto_debug_sections operation of the simple object support in
32218 libiberty is not implemented for them yet. */
32219 || TARGET_PECOFF
|| TARGET_COFF
)
32222 /* Now as we are going to output for LTO initialize sections and labels
32223 to the LTO variants. We don't need a random-seed postfix as other
32224 LTO sections as linking the LTO debug sections into one in a partial
32226 init_sections_and_labels (true);
32228 /* The output below is modeled after dwarf2out_finish with all
32229 location related output removed and some LTO specific changes.
32230 Some refactoring might make both smaller and easier to match up. */
32232 /* Traverse the DIE's and add add sibling attributes to those DIE's
32233 that have children. */
32234 add_sibling_attributes (comp_unit_die ());
32235 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
32236 add_sibling_attributes (node
->die
);
32237 for (comdat_type_node
*ctnode
= comdat_type_list
;
32238 ctnode
!= NULL
; ctnode
= ctnode
->next
)
32239 add_sibling_attributes (ctnode
->root_die
);
32241 /* AIX Assembler inserts the length, so adjust the reference to match the
32242 offset expected by debuggers. */
32243 strcpy (dl_section_ref
, debug_line_section_label
);
32244 if (XCOFF_DEBUGGING_INFO
)
32245 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
32247 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32248 add_AT_lineptr (comp_unit_die (), DW_AT_stmt_list
, dl_section_ref
);
32251 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
32252 macinfo_section_label
);
32254 save_macinfo_strings ();
32256 if (dwarf_split_debug_info
)
32258 unsigned int index
= 0;
32259 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
32262 /* Output all of the compilation units. We put the main one last so that
32263 the offsets are available to output_pubnames. */
32264 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
32265 output_comp_unit (node
->die
, 0, NULL
);
32267 hash_table
<comdat_type_hasher
> comdat_type_table (100);
32268 for (comdat_type_node
*ctnode
= comdat_type_list
;
32269 ctnode
!= NULL
; ctnode
= ctnode
->next
)
32271 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
32273 /* Don't output duplicate types. */
32274 if (*slot
!= HTAB_EMPTY_ENTRY
)
32277 /* Add a pointer to the line table for the main compilation unit
32278 so that the debugger can make sense of DW_AT_decl_file
32280 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
32281 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
32282 (!dwarf_split_debug_info
32283 ? debug_line_section_label
32284 : debug_skeleton_line_section_label
));
32286 output_comdat_type_unit (ctnode
, true);
32290 /* Stick a unique symbol to the main debuginfo section. */
32291 compute_comp_unit_symbol (comp_unit_die ());
32293 /* Output the main compilation unit. We always need it if only for
32295 output_comp_unit (comp_unit_die (), true, NULL
);
32297 /* Output the abbreviation table. */
32298 if (vec_safe_length (abbrev_die_table
) != 1)
32300 switch_to_section (debug_abbrev_section
);
32301 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
32302 output_abbrev_section ();
32305 /* Have to end the macro section. */
32308 /* We have to save macinfo state if we need to output it again
32309 for the FAT part of the object. */
32310 vec
<macinfo_entry
, va_gc
> *saved_macinfo_table
= macinfo_table
;
32311 if (flag_fat_lto_objects
)
32312 macinfo_table
= macinfo_table
->copy ();
32314 switch_to_section (debug_macinfo_section
);
32315 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
32316 output_macinfo (debug_line_section_label
, true);
32317 dw2_asm_output_data (1, 0, "End compilation unit");
32319 if (flag_fat_lto_objects
)
32321 vec_free (macinfo_table
);
32322 macinfo_table
= saved_macinfo_table
;
32326 /* Emit a skeleton debug_line section. */
32327 switch_to_section (debug_line_section
);
32328 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
32329 output_line_info (true);
32331 /* If we emitted any indirect strings, output the string table too. */
32332 if (debug_str_hash
|| skeleton_debug_str_hash
)
32333 output_indirect_strings ();
32334 if (debug_line_str_hash
)
32336 switch_to_section (debug_line_str_section
);
32337 const enum dwarf_form form
= DW_FORM_line_strp
;
32338 debug_line_str_hash
->traverse
<enum dwarf_form
,
32339 output_indirect_string
> (form
);
32342 /* Switch back to the text section. */
32343 switch_to_section (text_section
);
32346 /* Reset all state within dwarf2out.c so that we can rerun the compiler
32347 within the same process. For use by toplev::finalize. */
32350 dwarf2out_c_finalize (void)
32352 last_var_location_insn
= NULL
;
32353 cached_next_real_insn
= NULL
;
32354 used_rtx_array
= NULL
;
32355 incomplete_types
= NULL
;
32356 debug_info_section
= NULL
;
32357 debug_skeleton_info_section
= NULL
;
32358 debug_abbrev_section
= NULL
;
32359 debug_skeleton_abbrev_section
= NULL
;
32360 debug_aranges_section
= NULL
;
32361 debug_addr_section
= NULL
;
32362 debug_macinfo_section
= NULL
;
32363 debug_line_section
= NULL
;
32364 debug_skeleton_line_section
= NULL
;
32365 debug_loc_section
= NULL
;
32366 debug_pubnames_section
= NULL
;
32367 debug_pubtypes_section
= NULL
;
32368 debug_str_section
= NULL
;
32369 debug_line_str_section
= NULL
;
32370 debug_str_dwo_section
= NULL
;
32371 debug_str_offsets_section
= NULL
;
32372 debug_ranges_section
= NULL
;
32373 debug_frame_section
= NULL
;
32375 debug_str_hash
= NULL
;
32376 debug_line_str_hash
= NULL
;
32377 skeleton_debug_str_hash
= NULL
;
32378 dw2_string_counter
= 0;
32379 have_multiple_function_sections
= false;
32380 text_section_used
= false;
32381 cold_text_section_used
= false;
32382 cold_text_section
= NULL
;
32383 current_unit_personality
= NULL
;
32385 early_dwarf
= false;
32386 early_dwarf_finished
= false;
32388 next_die_offset
= 0;
32389 single_comp_unit_die
= NULL
;
32390 comdat_type_list
= NULL
;
32391 limbo_die_list
= NULL
;
32393 decl_die_table
= NULL
;
32394 common_block_die_table
= NULL
;
32395 decl_loc_table
= NULL
;
32396 call_arg_locations
= NULL
;
32397 call_arg_loc_last
= NULL
;
32398 call_site_count
= -1;
32399 tail_call_site_count
= -1;
32400 cached_dw_loc_list_table
= NULL
;
32401 abbrev_die_table
= NULL
;
32402 delete dwarf_proc_stack_usage_map
;
32403 dwarf_proc_stack_usage_map
= NULL
;
32404 line_info_label_num
= 0;
32405 cur_line_info_table
= NULL
;
32406 text_section_line_info
= NULL
;
32407 cold_text_section_line_info
= NULL
;
32408 separate_line_info
= NULL
;
32409 info_section_emitted
= false;
32410 pubname_table
= NULL
;
32411 pubtype_table
= NULL
;
32412 macinfo_table
= NULL
;
32413 ranges_table
= NULL
;
32414 ranges_by_label
= NULL
;
32416 have_location_lists
= false;
32419 last_emitted_file
= NULL
;
32421 tmpl_value_parm_die_table
= NULL
;
32422 generic_type_instances
= NULL
;
32423 frame_pointer_fb_offset
= 0;
32424 frame_pointer_fb_offset_valid
= false;
32425 base_types
.release ();
32426 XDELETEVEC (producer_string
);
32427 producer_string
= NULL
;
32430 #include "gt-dwarf2out.h"