1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992-2017 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"
99 static void dwarf2out_source_line (unsigned int, unsigned int, const char *,
101 static rtx_insn
*last_var_location_insn
;
102 static rtx_insn
*cached_next_real_insn
;
103 static void dwarf2out_decl (tree
);
105 #ifndef XCOFF_DEBUGGING_INFO
106 #define XCOFF_DEBUGGING_INFO 0
109 #ifndef HAVE_XCOFF_DWARF_EXTRAS
110 #define HAVE_XCOFF_DWARF_EXTRAS 0
113 #ifdef VMS_DEBUGGING_INFO
114 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
116 /* Define this macro to be a nonzero value if the directory specifications
117 which are output in the debug info should end with a separator. */
118 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
119 /* Define this macro to evaluate to a nonzero value if GCC should refrain
120 from generating indirect strings in DWARF2 debug information, for instance
121 if your target is stuck with an old version of GDB that is unable to
122 process them properly or uses VMS Debug. */
123 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
125 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
126 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
129 /* ??? Poison these here until it can be done generically. They've been
130 totally replaced in this file; make sure it stays that way. */
131 #undef DWARF2_UNWIND_INFO
132 #undef DWARF2_FRAME_INFO
133 #if (GCC_VERSION >= 3000)
134 #pragma GCC poison DWARF2_UNWIND_INFO DWARF2_FRAME_INFO
137 /* The size of the target's pointer type. */
139 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
142 /* Array of RTXes referenced by the debugging information, which therefore
143 must be kept around forever. */
144 static GTY(()) vec
<rtx
, va_gc
> *used_rtx_array
;
146 /* A pointer to the base of a list of incomplete types which might be
147 completed at some later time. incomplete_types_list needs to be a
148 vec<tree, va_gc> *because we want to tell the garbage collector about
150 static GTY(()) vec
<tree
, va_gc
> *incomplete_types
;
152 /* A pointer to the base of a table of references to declaration
153 scopes. This table is a display which tracks the nesting
154 of declaration scopes at the current scope and containing
155 scopes. This table is used to find the proper place to
156 define type declaration DIE's. */
157 static GTY(()) vec
<tree
, va_gc
> *decl_scope_table
;
159 /* Pointers to various DWARF2 sections. */
160 static GTY(()) section
*debug_info_section
;
161 static GTY(()) section
*debug_skeleton_info_section
;
162 static GTY(()) section
*debug_abbrev_section
;
163 static GTY(()) section
*debug_skeleton_abbrev_section
;
164 static GTY(()) section
*debug_aranges_section
;
165 static GTY(()) section
*debug_addr_section
;
166 static GTY(()) section
*debug_macinfo_section
;
167 static const char *debug_macinfo_section_name
;
168 static unsigned macinfo_label_base
= 1;
169 static GTY(()) section
*debug_line_section
;
170 static GTY(()) section
*debug_skeleton_line_section
;
171 static GTY(()) section
*debug_loc_section
;
172 static GTY(()) section
*debug_pubnames_section
;
173 static GTY(()) section
*debug_pubtypes_section
;
174 static GTY(()) section
*debug_str_section
;
175 static GTY(()) section
*debug_line_str_section
;
176 static GTY(()) section
*debug_str_dwo_section
;
177 static GTY(()) section
*debug_str_offsets_section
;
178 static GTY(()) section
*debug_ranges_section
;
179 static GTY(()) section
*debug_frame_section
;
181 /* Maximum size (in bytes) of an artificially generated label. */
182 #define MAX_ARTIFICIAL_LABEL_BYTES 40
184 /* According to the (draft) DWARF 3 specification, the initial length
185 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
186 bytes are 0xffffffff, followed by the length stored in the next 8
189 However, the SGI/MIPS ABI uses an initial length which is equal to
190 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
192 #ifndef DWARF_INITIAL_LENGTH_SIZE
193 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
196 #ifndef DWARF_INITIAL_LENGTH_SIZE_STR
197 #define DWARF_INITIAL_LENGTH_SIZE_STR (DWARF_OFFSET_SIZE == 4 ? "-4" : "-12")
200 /* Round SIZE up to the nearest BOUNDARY. */
201 #define DWARF_ROUND(SIZE,BOUNDARY) \
202 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
204 /* CIE identifier. */
205 #if HOST_BITS_PER_WIDE_INT >= 64
206 #define DWARF_CIE_ID \
207 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
209 #define DWARF_CIE_ID DW_CIE_ID
213 /* A vector for a table that contains frame description
214 information for each routine. */
215 #define NOT_INDEXED (-1U)
216 #define NO_INDEX_ASSIGNED (-2U)
218 static GTY(()) vec
<dw_fde_ref
, va_gc
> *fde_vec
;
220 struct GTY((for_user
)) indirect_string_node
{
222 unsigned int refcount
;
223 enum dwarf_form form
;
228 struct indirect_string_hasher
: ggc_ptr_hash
<indirect_string_node
>
230 typedef const char *compare_type
;
232 static hashval_t
hash (indirect_string_node
*);
233 static bool equal (indirect_string_node
*, const char *);
236 static GTY (()) hash_table
<indirect_string_hasher
> *debug_str_hash
;
238 static GTY (()) hash_table
<indirect_string_hasher
> *debug_line_str_hash
;
240 /* With split_debug_info, both the comp_dir and dwo_name go in the
241 main object file, rather than the dwo, similar to the force_direct
242 parameter elsewhere but with additional complications:
244 1) The string is needed in both the main object file and the dwo.
245 That is, the comp_dir and dwo_name will appear in both places.
247 2) Strings can use four forms: DW_FORM_string, DW_FORM_strp,
248 DW_FORM_line_strp or DW_FORM_GNU_str_index.
250 3) GCC chooses the form to use late, depending on the size and
253 Rather than forcing the all debug string handling functions and
254 callers to deal with these complications, simply use a separate,
255 special-cased string table for any attribute that should go in the
256 main object file. This limits the complexity to just the places
259 static GTY (()) hash_table
<indirect_string_hasher
> *skeleton_debug_str_hash
;
261 static GTY(()) int dw2_string_counter
;
263 /* True if the compilation unit places functions in more than one section. */
264 static GTY(()) bool have_multiple_function_sections
= false;
266 /* Whether the default text and cold text sections have been used at all. */
267 static GTY(()) bool text_section_used
= false;
268 static GTY(()) bool cold_text_section_used
= false;
270 /* The default cold text section. */
271 static GTY(()) section
*cold_text_section
;
273 /* The DIE for C++14 'auto' in a function return type. */
274 static GTY(()) dw_die_ref auto_die
;
276 /* The DIE for C++14 'decltype(auto)' in a function return type. */
277 static GTY(()) dw_die_ref decltype_auto_die
;
279 /* Forward declarations for functions defined in this file. */
281 static void output_call_frame_info (int);
282 static void dwarf2out_note_section_used (void);
284 /* Personality decl of current unit. Used only when assembler does not support
286 static GTY(()) rtx current_unit_personality
;
288 /* Whether an eh_frame section is required. */
289 static GTY(()) bool do_eh_frame
= false;
291 /* .debug_rnglists next index. */
292 static unsigned int rnglist_idx
;
294 /* Data and reference forms for relocatable data. */
295 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
296 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
298 #ifndef DEBUG_FRAME_SECTION
299 #define DEBUG_FRAME_SECTION ".debug_frame"
302 #ifndef FUNC_BEGIN_LABEL
303 #define FUNC_BEGIN_LABEL "LFB"
306 #ifndef FUNC_END_LABEL
307 #define FUNC_END_LABEL "LFE"
310 #ifndef PROLOGUE_END_LABEL
311 #define PROLOGUE_END_LABEL "LPE"
314 #ifndef EPILOGUE_BEGIN_LABEL
315 #define EPILOGUE_BEGIN_LABEL "LEB"
318 #ifndef FRAME_BEGIN_LABEL
319 #define FRAME_BEGIN_LABEL "Lframe"
321 #define CIE_AFTER_SIZE_LABEL "LSCIE"
322 #define CIE_END_LABEL "LECIE"
323 #define FDE_LABEL "LSFDE"
324 #define FDE_AFTER_SIZE_LABEL "LASFDE"
325 #define FDE_END_LABEL "LEFDE"
326 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
327 #define LINE_NUMBER_END_LABEL "LELT"
328 #define LN_PROLOG_AS_LABEL "LASLTP"
329 #define LN_PROLOG_END_LABEL "LELTP"
330 #define DIE_LABEL_PREFIX "DW"
332 /* Match the base name of a file to the base name of a compilation unit. */
335 matches_main_base (const char *path
)
337 /* Cache the last query. */
338 static const char *last_path
= NULL
;
339 static int last_match
= 0;
340 if (path
!= last_path
)
343 int length
= base_of_path (path
, &base
);
345 last_match
= (length
== main_input_baselength
346 && memcmp (base
, main_input_basename
, length
) == 0);
351 #ifdef DEBUG_DEBUG_STRUCT
354 dump_struct_debug (tree type
, enum debug_info_usage usage
,
355 enum debug_struct_file criterion
, int generic
,
356 int matches
, int result
)
358 /* Find the type name. */
359 tree type_decl
= TYPE_STUB_DECL (type
);
361 const char *name
= 0;
362 if (TREE_CODE (t
) == TYPE_DECL
)
365 name
= IDENTIFIER_POINTER (t
);
367 fprintf (stderr
, " struct %d %s %s %s %s %d %p %s\n",
369 DECL_IN_SYSTEM_HEADER (type_decl
) ? "sys" : "usr",
370 matches
? "bas" : "hdr",
371 generic
? "gen" : "ord",
372 usage
== DINFO_USAGE_DFN
? ";" :
373 usage
== DINFO_USAGE_DIR_USE
? "." : "*",
375 (void*) type_decl
, name
);
378 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
379 dump_struct_debug (type, usage, criterion, generic, matches, result)
383 #define DUMP_GSTRUCT(type, usage, criterion, generic, matches, result) \
388 /* Get the number of HOST_WIDE_INTs needed to represent the precision
389 of the number. Some constants have a large uniform precision, so
390 we get the precision needed for the actual value of the number. */
393 get_full_len (const wide_int
&op
)
395 int prec
= wi::min_precision (op
, UNSIGNED
);
396 return ((prec
+ HOST_BITS_PER_WIDE_INT
- 1)
397 / HOST_BITS_PER_WIDE_INT
);
401 should_emit_struct_debug (tree type
, enum debug_info_usage usage
)
403 enum debug_struct_file criterion
;
405 bool generic
= lang_hooks
.types
.generic_p (type
);
408 criterion
= debug_struct_generic
[usage
];
410 criterion
= debug_struct_ordinary
[usage
];
412 if (criterion
== DINFO_STRUCT_FILE_NONE
)
413 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
414 if (criterion
== DINFO_STRUCT_FILE_ANY
)
415 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
417 type_decl
= TYPE_STUB_DECL (TYPE_MAIN_VARIANT (type
));
419 if (type_decl
!= NULL
)
421 if (criterion
== DINFO_STRUCT_FILE_SYS
&& DECL_IN_SYSTEM_HEADER (type_decl
))
422 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, true);
424 if (matches_main_base (DECL_SOURCE_FILE (type_decl
)))
425 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, true, true);
428 return DUMP_GSTRUCT (type
, usage
, criterion
, generic
, false, false);
431 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
432 switch to the data section instead, and write out a synthetic start label
433 for collect2 the first time around. */
436 switch_to_eh_frame_section (bool back ATTRIBUTE_UNUSED
)
438 if (eh_frame_section
== 0)
442 if (EH_TABLES_CAN_BE_READ_ONLY
)
448 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
450 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
452 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
455 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
456 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
457 && (per_encoding
& 0x70) != DW_EH_PE_absptr
458 && (per_encoding
& 0x70) != DW_EH_PE_aligned
459 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
460 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
461 ? 0 : SECTION_WRITE
);
464 flags
= SECTION_WRITE
;
466 #ifdef EH_FRAME_SECTION_NAME
467 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
469 eh_frame_section
= ((flags
== SECTION_WRITE
)
470 ? data_section
: readonly_data_section
);
471 #endif /* EH_FRAME_SECTION_NAME */
474 switch_to_section (eh_frame_section
);
476 #ifdef EH_FRAME_THROUGH_COLLECT2
477 /* We have no special eh_frame section. Emit special labels to guide
481 tree label
= get_file_function_name ("F");
482 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
483 targetm
.asm_out
.globalize_label (asm_out_file
,
484 IDENTIFIER_POINTER (label
));
485 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
490 /* Switch [BACK] to the eh or debug frame table section, depending on
494 switch_to_frame_table_section (int for_eh
, bool back
)
497 switch_to_eh_frame_section (back
);
500 if (!debug_frame_section
)
501 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
502 SECTION_DEBUG
, NULL
);
503 switch_to_section (debug_frame_section
);
507 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
509 enum dw_cfi_oprnd_type
510 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
515 case DW_CFA_GNU_window_save
:
516 case DW_CFA_remember_state
:
517 case DW_CFA_restore_state
:
518 return dw_cfi_oprnd_unused
;
521 case DW_CFA_advance_loc1
:
522 case DW_CFA_advance_loc2
:
523 case DW_CFA_advance_loc4
:
524 case DW_CFA_MIPS_advance_loc8
:
525 return dw_cfi_oprnd_addr
;
528 case DW_CFA_offset_extended
:
530 case DW_CFA_offset_extended_sf
:
531 case DW_CFA_def_cfa_sf
:
533 case DW_CFA_restore_extended
:
534 case DW_CFA_undefined
:
535 case DW_CFA_same_value
:
536 case DW_CFA_def_cfa_register
:
537 case DW_CFA_register
:
538 case DW_CFA_expression
:
539 case DW_CFA_val_expression
:
540 return dw_cfi_oprnd_reg_num
;
542 case DW_CFA_def_cfa_offset
:
543 case DW_CFA_GNU_args_size
:
544 case DW_CFA_def_cfa_offset_sf
:
545 return dw_cfi_oprnd_offset
;
547 case DW_CFA_def_cfa_expression
:
548 return dw_cfi_oprnd_loc
;
555 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
557 enum dw_cfi_oprnd_type
558 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
563 case DW_CFA_def_cfa_sf
:
565 case DW_CFA_offset_extended_sf
:
566 case DW_CFA_offset_extended
:
567 return dw_cfi_oprnd_offset
;
569 case DW_CFA_register
:
570 return dw_cfi_oprnd_reg_num
;
572 case DW_CFA_expression
:
573 case DW_CFA_val_expression
:
574 return dw_cfi_oprnd_loc
;
576 case DW_CFA_def_cfa_expression
:
577 return dw_cfi_oprnd_cfa_loc
;
580 return dw_cfi_oprnd_unused
;
584 /* Output one FDE. */
587 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
588 char *section_start_label
, int fde_encoding
, char *augmentation
,
589 bool any_lsda_needed
, int lsda_encoding
)
591 const char *begin
, *end
;
592 static unsigned int j
;
593 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
595 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
597 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
599 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
600 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
601 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
603 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
604 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
605 " indicating 64-bit DWARF extension");
606 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
609 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
612 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
614 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
615 debug_frame_section
, "FDE CIE offset");
617 begin
= second
? fde
->dw_fde_second_begin
: fde
->dw_fde_begin
;
618 end
= second
? fde
->dw_fde_second_end
: fde
->dw_fde_end
;
622 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
623 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
624 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
625 "FDE initial location");
626 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
627 end
, begin
, "FDE address range");
631 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
632 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
639 int size
= size_of_encoded_value (lsda_encoding
);
641 if (lsda_encoding
== DW_EH_PE_aligned
)
643 int offset
= ( 4 /* Length */
645 + 2 * size_of_encoded_value (fde_encoding
)
646 + 1 /* Augmentation size */ );
647 int pad
= -offset
& (PTR_SIZE
- 1);
650 gcc_assert (size_of_uleb128 (size
) == 1);
653 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
655 if (fde
->uses_eh_lsda
)
657 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
658 fde
->funcdef_number
);
659 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
660 gen_rtx_SYMBOL_REF (Pmode
, l1
),
662 "Language Specific Data Area");
666 if (lsda_encoding
== DW_EH_PE_aligned
)
667 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
668 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
669 "Language Specific Data Area (none)");
673 dw2_asm_output_data_uleb128 (0, "Augmentation size");
676 /* Loop through the Call Frame Instructions associated with this FDE. */
677 fde
->dw_fde_current_label
= begin
;
679 size_t from
, until
, i
;
682 until
= vec_safe_length (fde
->dw_fde_cfi
);
684 if (fde
->dw_fde_second_begin
== NULL
)
687 until
= fde
->dw_fde_switch_cfi_index
;
689 from
= fde
->dw_fde_switch_cfi_index
;
691 for (i
= from
; i
< until
; i
++)
692 output_cfi ((*fde
->dw_fde_cfi
)[i
], fde
, for_eh
);
695 /* If we are to emit a ref/link from function bodies to their frame tables,
696 do it now. This is typically performed to make sure that tables
697 associated with functions are dragged with them and not discarded in
698 garbage collecting links. We need to do this on a per function basis to
699 cope with -ffunction-sections. */
701 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
702 /* Switch to the function section, emit the ref to the tables, and
703 switch *back* into the table section. */
704 switch_to_section (function_section (fde
->decl
));
705 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
706 switch_to_frame_table_section (for_eh
, true);
709 /* Pad the FDE out to an address sized boundary. */
710 ASM_OUTPUT_ALIGN (asm_out_file
,
711 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
712 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
717 /* Return true if frame description entry FDE is needed for EH. */
720 fde_needed_for_eh_p (dw_fde_ref fde
)
722 if (flag_asynchronous_unwind_tables
)
725 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
728 if (fde
->uses_eh_lsda
)
731 /* If exceptions are enabled, we have collected nothrow info. */
732 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
738 /* Output the call frame information used to record information
739 that relates to calculating the frame pointer, and records the
740 location of saved registers. */
743 output_call_frame_info (int for_eh
)
748 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
749 char section_start_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
750 bool any_lsda_needed
= false;
751 char augmentation
[6];
752 int augmentation_size
;
753 int fde_encoding
= DW_EH_PE_absptr
;
754 int per_encoding
= DW_EH_PE_absptr
;
755 int lsda_encoding
= DW_EH_PE_absptr
;
757 rtx personality
= NULL
;
760 /* Don't emit a CIE if there won't be any FDEs. */
764 /* Nothing to do if the assembler's doing it all. */
765 if (dwarf2out_do_cfi_asm ())
768 /* If we don't have any functions we'll want to unwind out of, don't emit
769 any EH unwind information. If we make FDEs linkonce, we may have to
770 emit an empty label for an FDE that wouldn't otherwise be emitted. We
771 want to avoid having an FDE kept around when the function it refers to
772 is discarded. Example where this matters: a primary function template
773 in C++ requires EH information, an explicit specialization doesn't. */
776 bool any_eh_needed
= false;
778 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
780 if (fde
->uses_eh_lsda
)
781 any_eh_needed
= any_lsda_needed
= true;
782 else if (fde_needed_for_eh_p (fde
))
783 any_eh_needed
= true;
784 else if (TARGET_USES_WEAK_UNWIND_INFO
)
785 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, 1, 1);
792 /* We're going to be generating comments, so turn on app. */
796 /* Switch to the proper frame section, first time. */
797 switch_to_frame_table_section (for_eh
, false);
799 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
800 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
802 /* Output the CIE. */
803 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
804 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
805 if (!XCOFF_DEBUGGING_INFO
|| for_eh
)
807 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
808 dw2_asm_output_data (4, 0xffffffff,
809 "Initial length escape value indicating 64-bit DWARF extension");
810 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
811 "Length of Common Information Entry");
813 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
815 /* Now that the CIE pointer is PC-relative for EH,
816 use 0 to identify the CIE. */
817 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
818 (for_eh
? 0 : DWARF_CIE_ID
),
819 "CIE Identifier Tag");
821 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
822 use CIE version 1, unless that would produce incorrect results
823 due to overflowing the return register column. */
824 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
826 if (return_reg
>= 256 || dwarf_version
> 2)
828 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
831 augmentation_size
= 0;
833 personality
= current_unit_personality
;
839 z Indicates that a uleb128 is present to size the
840 augmentation section.
841 L Indicates the encoding (and thus presence) of
842 an LSDA pointer in the FDE augmentation.
843 R Indicates a non-default pointer encoding for
845 P Indicates the presence of an encoding + language
846 personality routine in the CIE augmentation. */
848 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
849 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
850 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
852 p
= augmentation
+ 1;
856 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
857 assemble_external_libcall (personality
);
862 augmentation_size
+= 1;
864 if (fde_encoding
!= DW_EH_PE_absptr
)
867 augmentation_size
+= 1;
869 if (p
> augmentation
+ 1)
871 augmentation
[0] = 'z';
875 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
876 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
878 int offset
= ( 4 /* Length */
880 + 1 /* CIE version */
881 + strlen (augmentation
) + 1 /* Augmentation */
882 + size_of_uleb128 (1) /* Code alignment */
883 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
885 + 1 /* Augmentation size */
886 + 1 /* Personality encoding */ );
887 int pad
= -offset
& (PTR_SIZE
- 1);
889 augmentation_size
+= pad
;
891 /* Augmentations should be small, so there's scarce need to
892 iterate for a solution. Die if we exceed one uleb128 byte. */
893 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
897 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
898 if (dw_cie_version
>= 4)
900 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
901 dw2_asm_output_data (1, 0, "CIE Segment Size");
903 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
904 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
905 "CIE Data Alignment Factor");
907 if (dw_cie_version
== 1)
908 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
910 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
914 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
917 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
918 eh_data_format_name (per_encoding
));
919 dw2_asm_output_encoded_addr_rtx (per_encoding
,
925 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
926 eh_data_format_name (lsda_encoding
));
928 if (fde_encoding
!= DW_EH_PE_absptr
)
929 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
930 eh_data_format_name (fde_encoding
));
933 FOR_EACH_VEC_ELT (*cie_cfi_vec
, i
, cfi
)
934 output_cfi (cfi
, NULL
, for_eh
);
936 /* Pad the CIE out to an address sized boundary. */
937 ASM_OUTPUT_ALIGN (asm_out_file
,
938 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
939 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
941 /* Loop through all of the FDE's. */
942 FOR_EACH_VEC_ELT (*fde_vec
, i
, fde
)
946 /* Don't emit EH unwind info for leaf functions that don't need it. */
947 if (for_eh
&& !fde_needed_for_eh_p (fde
))
950 for (k
= 0; k
< (fde
->dw_fde_second_begin
? 2 : 1); k
++)
951 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
952 augmentation
, any_lsda_needed
, lsda_encoding
);
955 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
956 dw2_asm_output_data (4, 0, "End of Table");
958 /* Turn off app to make assembly quicker. */
963 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
966 dwarf2out_do_cfi_startproc (bool second
)
971 fprintf (asm_out_file
, "\t.cfi_startproc\n");
973 /* .cfi_personality and .cfi_lsda are only relevant to DWARF2
975 if (targetm_common
.except_unwind_info (&global_options
) != UI_DWARF2
)
978 rtx personality
= get_personality_function (current_function_decl
);
982 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
985 /* ??? The GAS support isn't entirely consistent. We have to
986 handle indirect support ourselves, but PC-relative is done
987 in the assembler. Further, the assembler can't handle any
988 of the weirder relocation types. */
989 if (enc
& DW_EH_PE_indirect
)
990 ref
= dw2_force_const_mem (ref
, true);
992 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
993 output_addr_const (asm_out_file
, ref
);
994 fputc ('\n', asm_out_file
);
997 if (crtl
->uses_eh_lsda
)
999 char lab
[MAX_ARTIFICIAL_LABEL_BYTES
];
1001 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1002 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
1003 current_function_funcdef_no
);
1004 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
1005 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
1007 if (enc
& DW_EH_PE_indirect
)
1008 ref
= dw2_force_const_mem (ref
, true);
1010 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
1011 output_addr_const (asm_out_file
, ref
);
1012 fputc ('\n', asm_out_file
);
1016 /* Allocate CURRENT_FDE. Immediately initialize all we can, noting that
1017 this allocation may be done before pass_final. */
1020 dwarf2out_alloc_current_fde (void)
1024 fde
= ggc_cleared_alloc
<dw_fde_node
> ();
1025 fde
->decl
= current_function_decl
;
1026 fde
->funcdef_number
= current_function_funcdef_no
;
1027 fde
->fde_index
= vec_safe_length (fde_vec
);
1028 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
1029 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
1030 fde
->nothrow
= crtl
->nothrow
;
1031 fde
->drap_reg
= INVALID_REGNUM
;
1032 fde
->vdrap_reg
= INVALID_REGNUM
;
1034 /* Record the FDE associated with this function. */
1036 vec_safe_push (fde_vec
, fde
);
1041 /* Output a marker (i.e. a label) for the beginning of a function, before
1045 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1046 unsigned int column ATTRIBUTE_UNUSED
,
1047 const char *file ATTRIBUTE_UNUSED
)
1049 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1055 current_function_func_begin_label
= NULL
;
1057 do_frame
= dwarf2out_do_frame ();
1059 /* ??? current_function_func_begin_label is also used by except.c for
1060 call-site information. We must emit this label if it might be used. */
1062 && (!flag_exceptions
1063 || targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
))
1066 fnsec
= function_section (current_function_decl
);
1067 switch_to_section (fnsec
);
1068 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1069 current_function_funcdef_no
);
1070 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
1071 current_function_funcdef_no
);
1072 dup_label
= xstrdup (label
);
1073 current_function_func_begin_label
= dup_label
;
1075 /* We can elide FDE allocation if we're not emitting frame unwind info. */
1079 /* Unlike the debug version, the EH version of frame unwind info is a per-
1080 function setting so we need to record whether we need it for the unit. */
1081 do_eh_frame
|= dwarf2out_do_eh_frame ();
1083 /* Cater to the various TARGET_ASM_OUTPUT_MI_THUNK implementations that
1084 emit insns as rtx but bypass the bulk of rest_of_compilation, which
1085 would include pass_dwarf2_frame. If we've not created the FDE yet,
1089 fde
= dwarf2out_alloc_current_fde ();
1091 /* Initialize the bits of CURRENT_FDE that were not available earlier. */
1092 fde
->dw_fde_begin
= dup_label
;
1093 fde
->dw_fde_current_label
= dup_label
;
1094 fde
->in_std_section
= (fnsec
== text_section
1095 || (cold_text_section
&& fnsec
== cold_text_section
));
1097 /* We only want to output line number information for the genuine dwarf2
1098 prologue case, not the eh frame case. */
1099 #ifdef DWARF2_DEBUGGING_INFO
1101 dwarf2out_source_line (line
, column
, file
, 0, true);
1104 if (dwarf2out_do_cfi_asm ())
1105 dwarf2out_do_cfi_startproc (false);
1108 rtx personality
= get_personality_function (current_function_decl
);
1109 if (!current_unit_personality
)
1110 current_unit_personality
= personality
;
1112 /* We cannot keep a current personality per function as without CFI
1113 asm, at the point where we emit the CFI data, there is no current
1114 function anymore. */
1115 if (personality
&& current_unit_personality
!= personality
)
1116 sorry ("multiple EH personalities are supported only with assemblers "
1117 "supporting .cfi_personality directive");
1121 /* Output a marker (i.e. a label) for the end of the generated code
1122 for a function prologue. This gets called *after* the prologue code has
1126 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
1127 const char *file ATTRIBUTE_UNUSED
)
1129 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1131 /* Output a label to mark the endpoint of the code generated for this
1133 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
1134 current_function_funcdef_no
);
1135 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
1136 current_function_funcdef_no
);
1137 cfun
->fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
1140 /* Output a marker (i.e. a label) for the beginning of the generated code
1141 for a function epilogue. This gets called *before* the prologue code has
1145 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1146 const char *file ATTRIBUTE_UNUSED
)
1148 dw_fde_ref fde
= cfun
->fde
;
1149 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1151 if (fde
->dw_fde_vms_begin_epilogue
)
1154 /* Output a label to mark the endpoint of the code generated for this
1156 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
1157 current_function_funcdef_no
);
1158 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
1159 current_function_funcdef_no
);
1160 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
1163 /* Output a marker (i.e. a label) for the absolute end of the generated code
1164 for a function definition. This gets called *after* the epilogue code has
1168 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
1169 const char *file ATTRIBUTE_UNUSED
)
1172 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1174 last_var_location_insn
= NULL
;
1175 cached_next_real_insn
= NULL
;
1177 if (dwarf2out_do_cfi_asm ())
1178 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1180 /* Output a label to mark the endpoint of the code generated for this
1182 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
1183 current_function_funcdef_no
);
1184 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1186 gcc_assert (fde
!= NULL
);
1187 if (fde
->dw_fde_second_begin
== NULL
)
1188 fde
->dw_fde_end
= xstrdup (label
);
1192 dwarf2out_frame_finish (void)
1194 /* Output call frame information. */
1195 if (targetm
.debug_unwind_info () == UI_DWARF2
)
1196 output_call_frame_info (0);
1198 /* Output another copy for the unwinder. */
1200 output_call_frame_info (1);
1203 /* Note that the current function section is being used for code. */
1206 dwarf2out_note_section_used (void)
1208 section
*sec
= current_function_section ();
1209 if (sec
== text_section
)
1210 text_section_used
= true;
1211 else if (sec
== cold_text_section
)
1212 cold_text_section_used
= true;
1215 static void var_location_switch_text_section (void);
1216 static void set_cur_line_info_table (section
*);
1219 dwarf2out_switch_text_section (void)
1222 dw_fde_ref fde
= cfun
->fde
;
1224 gcc_assert (cfun
&& fde
&& fde
->dw_fde_second_begin
== NULL
);
1226 if (!in_cold_section_p
)
1228 fde
->dw_fde_end
= crtl
->subsections
.cold_section_end_label
;
1229 fde
->dw_fde_second_begin
= crtl
->subsections
.hot_section_label
;
1230 fde
->dw_fde_second_end
= crtl
->subsections
.hot_section_end_label
;
1234 fde
->dw_fde_end
= crtl
->subsections
.hot_section_end_label
;
1235 fde
->dw_fde_second_begin
= crtl
->subsections
.cold_section_label
;
1236 fde
->dw_fde_second_end
= crtl
->subsections
.cold_section_end_label
;
1238 have_multiple_function_sections
= true;
1240 /* There is no need to mark used sections when not debugging. */
1241 if (cold_text_section
!= NULL
)
1242 dwarf2out_note_section_used ();
1244 if (dwarf2out_do_cfi_asm ())
1245 fprintf (asm_out_file
, "\t.cfi_endproc\n");
1247 /* Now do the real section switch. */
1248 sect
= current_function_section ();
1249 switch_to_section (sect
);
1251 fde
->second_in_std_section
1252 = (sect
== text_section
1253 || (cold_text_section
&& sect
== cold_text_section
));
1255 if (dwarf2out_do_cfi_asm ())
1256 dwarf2out_do_cfi_startproc (true);
1258 var_location_switch_text_section ();
1260 if (cold_text_section
!= NULL
)
1261 set_cur_line_info_table (sect
);
1264 /* And now, the subset of the debugging information support code necessary
1265 for emitting location expressions. */
1267 /* Data about a single source file. */
1268 struct GTY((for_user
)) dwarf_file_data
{
1269 const char * filename
;
1273 /* Describe an entry into the .debug_addr section. */
1277 ate_kind_rtx_dtprel
,
1281 struct GTY((for_user
)) addr_table_entry
{
1283 unsigned int refcount
;
1285 union addr_table_entry_struct_union
1287 rtx
GTY ((tag ("0"))) rtl
;
1288 char * GTY ((tag ("1"))) label
;
1290 GTY ((desc ("%1.kind"))) addr
;
1293 /* Location lists are ranges + location descriptions for that range,
1294 so you can track variables that are in different places over
1295 their entire life. */
1296 typedef struct GTY(()) dw_loc_list_struct
{
1297 dw_loc_list_ref dw_loc_next
;
1298 const char *begin
; /* Label and addr_entry for start of range */
1299 addr_table_entry
*begin_entry
;
1300 const char *end
; /* Label for end of range */
1301 char *ll_symbol
; /* Label for beginning of location list.
1302 Only on head of list */
1303 const char *section
; /* Section this loclist is relative to */
1304 dw_loc_descr_ref expr
;
1306 /* True if all addresses in this and subsequent lists are known to be
1309 /* True if this list has been replaced by dw_loc_next. */
1311 /* True if it has been emitted into .debug_loc* / .debug_loclists*
1313 unsigned char emitted
: 1;
1314 /* True if hash field is index rather than hash value. */
1315 unsigned char num_assigned
: 1;
1316 /* True if .debug_loclists.dwo offset has been emitted for it already. */
1317 unsigned char offset_emitted
: 1;
1318 /* True if note_variable_value_in_expr has been called on it. */
1319 unsigned char noted_variable_value
: 1;
1320 /* True if the range should be emitted even if begin and end
1325 static dw_loc_descr_ref
int_loc_descriptor (poly_int64
);
1326 static dw_loc_descr_ref
uint_loc_descriptor (unsigned HOST_WIDE_INT
);
1328 /* Convert a DWARF stack opcode into its string name. */
1331 dwarf_stack_op_name (unsigned int op
)
1333 const char *name
= get_DW_OP_name (op
);
1338 return "OP_<unknown>";
1341 /* Return a pointer to a newly allocated location description. Location
1342 descriptions are simple expression terms that can be strung
1343 together to form more complicated location (address) descriptions. */
1345 static inline dw_loc_descr_ref
1346 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
1347 unsigned HOST_WIDE_INT oprnd2
)
1349 dw_loc_descr_ref descr
= ggc_cleared_alloc
<dw_loc_descr_node
> ();
1351 descr
->dw_loc_opc
= op
;
1352 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
1353 descr
->dw_loc_oprnd1
.val_entry
= NULL
;
1354 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
1355 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
1356 descr
->dw_loc_oprnd2
.val_entry
= NULL
;
1357 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
1362 /* Add a location description term to a location description expression. */
1365 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
1367 dw_loc_descr_ref
*d
;
1369 /* Find the end of the chain. */
1370 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
1376 /* Compare two location operands for exact equality. */
1379 dw_val_equal_p (dw_val_node
*a
, dw_val_node
*b
)
1381 if (a
->val_class
!= b
->val_class
)
1383 switch (a
->val_class
)
1385 case dw_val_class_none
:
1387 case dw_val_class_addr
:
1388 return rtx_equal_p (a
->v
.val_addr
, b
->v
.val_addr
);
1390 case dw_val_class_offset
:
1391 case dw_val_class_unsigned_const
:
1392 case dw_val_class_const
:
1393 case dw_val_class_unsigned_const_implicit
:
1394 case dw_val_class_const_implicit
:
1395 case dw_val_class_range_list
:
1396 /* These are all HOST_WIDE_INT, signed or unsigned. */
1397 return a
->v
.val_unsigned
== b
->v
.val_unsigned
;
1399 case dw_val_class_loc
:
1400 return a
->v
.val_loc
== b
->v
.val_loc
;
1401 case dw_val_class_loc_list
:
1402 return a
->v
.val_loc_list
== b
->v
.val_loc_list
;
1403 case dw_val_class_die_ref
:
1404 return a
->v
.val_die_ref
.die
== b
->v
.val_die_ref
.die
;
1405 case dw_val_class_fde_ref
:
1406 return a
->v
.val_fde_index
== b
->v
.val_fde_index
;
1407 case dw_val_class_lbl_id
:
1408 case dw_val_class_lineptr
:
1409 case dw_val_class_macptr
:
1410 case dw_val_class_loclistsptr
:
1411 case dw_val_class_high_pc
:
1412 return strcmp (a
->v
.val_lbl_id
, b
->v
.val_lbl_id
) == 0;
1413 case dw_val_class_str
:
1414 return a
->v
.val_str
== b
->v
.val_str
;
1415 case dw_val_class_flag
:
1416 return a
->v
.val_flag
== b
->v
.val_flag
;
1417 case dw_val_class_file
:
1418 case dw_val_class_file_implicit
:
1419 return a
->v
.val_file
== b
->v
.val_file
;
1420 case dw_val_class_decl_ref
:
1421 return a
->v
.val_decl_ref
== b
->v
.val_decl_ref
;
1423 case dw_val_class_const_double
:
1424 return (a
->v
.val_double
.high
== b
->v
.val_double
.high
1425 && a
->v
.val_double
.low
== b
->v
.val_double
.low
);
1427 case dw_val_class_wide_int
:
1428 return *a
->v
.val_wide
== *b
->v
.val_wide
;
1430 case dw_val_class_vec
:
1432 size_t a_len
= a
->v
.val_vec
.elt_size
* a
->v
.val_vec
.length
;
1433 size_t b_len
= b
->v
.val_vec
.elt_size
* b
->v
.val_vec
.length
;
1435 return (a_len
== b_len
1436 && !memcmp (a
->v
.val_vec
.array
, b
->v
.val_vec
.array
, a_len
));
1439 case dw_val_class_data8
:
1440 return memcmp (a
->v
.val_data8
, b
->v
.val_data8
, 8) == 0;
1442 case dw_val_class_vms_delta
:
1443 return (!strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
)
1444 && !strcmp (a
->v
.val_vms_delta
.lbl1
, b
->v
.val_vms_delta
.lbl1
));
1446 case dw_val_class_discr_value
:
1447 return (a
->v
.val_discr_value
.pos
== b
->v
.val_discr_value
.pos
1448 && a
->v
.val_discr_value
.v
.uval
== b
->v
.val_discr_value
.v
.uval
);
1449 case dw_val_class_discr_list
:
1450 /* It makes no sense comparing two discriminant value lists. */
1456 /* Compare two location atoms for exact equality. */
1459 loc_descr_equal_p_1 (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1461 if (a
->dw_loc_opc
!= b
->dw_loc_opc
)
1464 /* ??? This is only ever set for DW_OP_constNu, for N equal to the
1465 address size, but since we always allocate cleared storage it
1466 should be zero for other types of locations. */
1467 if (a
->dtprel
!= b
->dtprel
)
1470 return (dw_val_equal_p (&a
->dw_loc_oprnd1
, &b
->dw_loc_oprnd1
)
1471 && dw_val_equal_p (&a
->dw_loc_oprnd2
, &b
->dw_loc_oprnd2
));
1474 /* Compare two complete location expressions for exact equality. */
1477 loc_descr_equal_p (dw_loc_descr_ref a
, dw_loc_descr_ref b
)
1483 if (a
== NULL
|| b
== NULL
)
1485 if (!loc_descr_equal_p_1 (a
, b
))
1494 /* Add a constant POLY_OFFSET to a location expression. */
1497 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, poly_int64 poly_offset
)
1499 dw_loc_descr_ref loc
;
1502 gcc_assert (*list_head
!= NULL
);
1504 if (known_eq (poly_offset
, 0))
1507 /* Find the end of the chain. */
1508 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
1511 HOST_WIDE_INT offset
;
1512 if (!poly_offset
.is_constant (&offset
))
1514 loc
->dw_loc_next
= int_loc_descriptor (poly_offset
);
1515 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_plus
, 0, 0));
1520 if (loc
->dw_loc_opc
== DW_OP_fbreg
1521 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
1522 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
1523 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
1524 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
1526 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
1527 offset. Don't optimize if an signed integer overflow would happen. */
1529 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
1530 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
1533 else if (offset
> 0)
1534 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
1539 = uint_loc_descriptor (-(unsigned HOST_WIDE_INT
) offset
);
1540 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
1544 /* Return a pointer to a newly allocated location description for
1547 static inline dw_loc_descr_ref
1548 new_reg_loc_descr (unsigned int reg
, poly_int64 offset
)
1550 HOST_WIDE_INT const_offset
;
1551 if (offset
.is_constant (&const_offset
))
1554 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
1557 return new_loc_descr (DW_OP_bregx
, reg
, const_offset
);
1561 dw_loc_descr_ref ret
= new_reg_loc_descr (reg
, 0);
1562 loc_descr_plus_const (&ret
, offset
);
1567 /* Add a constant OFFSET to a location list. */
1570 loc_list_plus_const (dw_loc_list_ref list_head
, poly_int64 offset
)
1573 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
1574 loc_descr_plus_const (&d
->expr
, offset
);
1577 #define DWARF_REF_SIZE \
1578 (dwarf_version == 2 ? DWARF2_ADDR_SIZE : DWARF_OFFSET_SIZE)
1580 /* The number of bits that can be encoded by largest DW_FORM_dataN.
1581 In DWARF4 and earlier it is DW_FORM_data8 with 64 bits, in DWARF5
1582 DW_FORM_data16 with 128 bits. */
1583 #define DWARF_LARGEST_DATA_FORM_BITS \
1584 (dwarf_version >= 5 ? 128 : 64)
1586 /* Utility inline function for construction of ops that were GNU extension
1588 static inline enum dwarf_location_atom
1589 dwarf_OP (enum dwarf_location_atom op
)
1593 case DW_OP_implicit_pointer
:
1594 if (dwarf_version
< 5)
1595 return DW_OP_GNU_implicit_pointer
;
1598 case DW_OP_entry_value
:
1599 if (dwarf_version
< 5)
1600 return DW_OP_GNU_entry_value
;
1603 case DW_OP_const_type
:
1604 if (dwarf_version
< 5)
1605 return DW_OP_GNU_const_type
;
1608 case DW_OP_regval_type
:
1609 if (dwarf_version
< 5)
1610 return DW_OP_GNU_regval_type
;
1613 case DW_OP_deref_type
:
1614 if (dwarf_version
< 5)
1615 return DW_OP_GNU_deref_type
;
1619 if (dwarf_version
< 5)
1620 return DW_OP_GNU_convert
;
1623 case DW_OP_reinterpret
:
1624 if (dwarf_version
< 5)
1625 return DW_OP_GNU_reinterpret
;
1634 /* Similarly for attributes. */
1635 static inline enum dwarf_attribute
1636 dwarf_AT (enum dwarf_attribute at
)
1640 case DW_AT_call_return_pc
:
1641 if (dwarf_version
< 5)
1642 return DW_AT_low_pc
;
1645 case DW_AT_call_tail_call
:
1646 if (dwarf_version
< 5)
1647 return DW_AT_GNU_tail_call
;
1650 case DW_AT_call_origin
:
1651 if (dwarf_version
< 5)
1652 return DW_AT_abstract_origin
;
1655 case DW_AT_call_target
:
1656 if (dwarf_version
< 5)
1657 return DW_AT_GNU_call_site_target
;
1660 case DW_AT_call_target_clobbered
:
1661 if (dwarf_version
< 5)
1662 return DW_AT_GNU_call_site_target_clobbered
;
1665 case DW_AT_call_parameter
:
1666 if (dwarf_version
< 5)
1667 return DW_AT_abstract_origin
;
1670 case DW_AT_call_value
:
1671 if (dwarf_version
< 5)
1672 return DW_AT_GNU_call_site_value
;
1675 case DW_AT_call_data_value
:
1676 if (dwarf_version
< 5)
1677 return DW_AT_GNU_call_site_data_value
;
1680 case DW_AT_call_all_calls
:
1681 if (dwarf_version
< 5)
1682 return DW_AT_GNU_all_call_sites
;
1685 case DW_AT_call_all_tail_calls
:
1686 if (dwarf_version
< 5)
1687 return DW_AT_GNU_all_tail_call_sites
;
1690 case DW_AT_dwo_name
:
1691 if (dwarf_version
< 5)
1692 return DW_AT_GNU_dwo_name
;
1701 /* And similarly for tags. */
1702 static inline enum dwarf_tag
1703 dwarf_TAG (enum dwarf_tag tag
)
1707 case DW_TAG_call_site
:
1708 if (dwarf_version
< 5)
1709 return DW_TAG_GNU_call_site
;
1712 case DW_TAG_call_site_parameter
:
1713 if (dwarf_version
< 5)
1714 return DW_TAG_GNU_call_site_parameter
;
1723 static unsigned long int get_base_type_offset (dw_die_ref
);
1725 /* Return the size of a location descriptor. */
1727 static unsigned long
1728 size_of_loc_descr (dw_loc_descr_ref loc
)
1730 unsigned long size
= 1;
1732 switch (loc
->dw_loc_opc
)
1735 size
+= DWARF2_ADDR_SIZE
;
1737 case DW_OP_GNU_addr_index
:
1738 case DW_OP_GNU_const_index
:
1739 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
1740 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
);
1759 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1762 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1767 case DW_OP_plus_uconst
:
1768 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1806 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1809 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1812 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
1815 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1816 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1819 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1821 case DW_OP_bit_piece
:
1822 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1823 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
1825 case DW_OP_deref_size
:
1826 case DW_OP_xderef_size
:
1835 case DW_OP_call_ref
:
1836 case DW_OP_GNU_variable_value
:
1837 size
+= DWARF_REF_SIZE
;
1839 case DW_OP_implicit_value
:
1840 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1841 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
1843 case DW_OP_implicit_pointer
:
1844 case DW_OP_GNU_implicit_pointer
:
1845 size
+= DWARF_REF_SIZE
+ size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
1847 case DW_OP_entry_value
:
1848 case DW_OP_GNU_entry_value
:
1850 unsigned long op_size
= size_of_locs (loc
->dw_loc_oprnd1
.v
.val_loc
);
1851 size
+= size_of_uleb128 (op_size
) + op_size
;
1854 case DW_OP_const_type
:
1855 case DW_OP_GNU_const_type
:
1858 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1859 size
+= size_of_uleb128 (o
) + 1;
1860 switch (loc
->dw_loc_oprnd2
.val_class
)
1862 case dw_val_class_vec
:
1863 size
+= loc
->dw_loc_oprnd2
.v
.val_vec
.length
1864 * loc
->dw_loc_oprnd2
.v
.val_vec
.elt_size
;
1866 case dw_val_class_const
:
1867 size
+= HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
;
1869 case dw_val_class_const_double
:
1870 size
+= HOST_BITS_PER_DOUBLE_INT
/ BITS_PER_UNIT
;
1872 case dw_val_class_wide_int
:
1873 size
+= (get_full_len (*loc
->dw_loc_oprnd2
.v
.val_wide
)
1874 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
1881 case DW_OP_regval_type
:
1882 case DW_OP_GNU_regval_type
:
1885 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1886 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
1887 + size_of_uleb128 (o
);
1890 case DW_OP_deref_type
:
1891 case DW_OP_GNU_deref_type
:
1894 = get_base_type_offset (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
);
1895 size
+= 1 + size_of_uleb128 (o
);
1899 case DW_OP_reinterpret
:
1900 case DW_OP_GNU_convert
:
1901 case DW_OP_GNU_reinterpret
:
1902 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
1903 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
1907 = get_base_type_offset (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
);
1908 size
+= size_of_uleb128 (o
);
1911 case DW_OP_GNU_parameter_ref
:
1921 /* Return the size of a series of location descriptors. */
1924 size_of_locs (dw_loc_descr_ref loc
)
1929 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
1930 field, to avoid writing to a PCH file. */
1931 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1933 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
1935 size
+= size_of_loc_descr (l
);
1940 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
1942 l
->dw_loc_addr
= size
;
1943 size
+= size_of_loc_descr (l
);
1949 /* Return the size of the value in a DW_AT_discr_value attribute. */
1952 size_of_discr_value (dw_discr_value
*discr_value
)
1954 if (discr_value
->pos
)
1955 return size_of_uleb128 (discr_value
->v
.uval
);
1957 return size_of_sleb128 (discr_value
->v
.sval
);
1960 /* Return the size of the value in a DW_AT_discr_list attribute. */
1963 size_of_discr_list (dw_discr_list_ref discr_list
)
1967 for (dw_discr_list_ref list
= discr_list
;
1969 list
= list
->dw_discr_next
)
1971 /* One byte for the discriminant value descriptor, and then one or two
1972 LEB128 numbers, depending on whether it's a single case label or a
1975 size
+= size_of_discr_value (&list
->dw_discr_lower_bound
);
1976 if (list
->dw_discr_range
!= 0)
1977 size
+= size_of_discr_value (&list
->dw_discr_upper_bound
);
1982 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
1983 static void get_ref_die_offset_label (char *, dw_die_ref
);
1984 static unsigned long int get_ref_die_offset (dw_die_ref
);
1986 /* Output location description stack opcode's operands (if any).
1987 The for_eh_or_skip parameter controls whether register numbers are
1988 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
1989 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
1990 info). This should be suppressed for the cases that have not been converted
1991 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
1994 output_loc_operands (dw_loc_descr_ref loc
, int for_eh_or_skip
)
1996 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
1997 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
1999 switch (loc
->dw_loc_opc
)
2001 #ifdef DWARF2_DEBUGGING_INFO
2004 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
2009 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2010 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 4,
2012 fputc ('\n', asm_out_file
);
2017 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
2022 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
2023 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
, 8,
2025 fputc ('\n', asm_out_file
);
2030 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2031 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
2038 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2039 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2041 dw2_asm_output_data (2, offset
, NULL
);
2044 case DW_OP_implicit_value
:
2045 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2046 switch (val2
->val_class
)
2048 case dw_val_class_const
:
2049 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
2051 case dw_val_class_vec
:
2053 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2054 unsigned int len
= val2
->v
.val_vec
.length
;
2058 if (elt_size
> sizeof (HOST_WIDE_INT
))
2063 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2066 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2067 "fp or vector constant word %u", i
);
2070 case dw_val_class_const_double
:
2072 unsigned HOST_WIDE_INT first
, second
;
2074 if (WORDS_BIG_ENDIAN
)
2076 first
= val2
->v
.val_double
.high
;
2077 second
= val2
->v
.val_double
.low
;
2081 first
= val2
->v
.val_double
.low
;
2082 second
= val2
->v
.val_double
.high
;
2084 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2086 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2090 case dw_val_class_wide_int
:
2093 int len
= get_full_len (*val2
->v
.val_wide
);
2094 if (WORDS_BIG_ENDIAN
)
2095 for (i
= len
- 1; i
>= 0; --i
)
2096 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2097 val2
->v
.val_wide
->elt (i
), NULL
);
2099 for (i
= 0; i
< len
; ++i
)
2100 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
2101 val2
->v
.val_wide
->elt (i
), NULL
);
2104 case dw_val_class_addr
:
2105 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
2106 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
2121 case DW_OP_implicit_value
:
2122 /* We currently don't make any attempt to make sure these are
2123 aligned properly like we do for the main unwind info, so
2124 don't support emitting things larger than a byte if we're
2125 only doing unwinding. */
2130 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2133 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2136 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2139 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2141 case DW_OP_plus_uconst
:
2142 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2176 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2180 unsigned r
= val1
->v
.val_unsigned
;
2181 if (for_eh_or_skip
>= 0)
2182 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2183 gcc_assert (size_of_uleb128 (r
)
2184 == size_of_uleb128 (val1
->v
.val_unsigned
));
2185 dw2_asm_output_data_uleb128 (r
, NULL
);
2189 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2193 unsigned r
= val1
->v
.val_unsigned
;
2194 if (for_eh_or_skip
>= 0)
2195 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2196 gcc_assert (size_of_uleb128 (r
)
2197 == size_of_uleb128 (val1
->v
.val_unsigned
));
2198 dw2_asm_output_data_uleb128 (r
, NULL
);
2199 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2203 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2205 case DW_OP_bit_piece
:
2206 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2207 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
2209 case DW_OP_deref_size
:
2210 case DW_OP_xderef_size
:
2211 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2217 if (targetm
.asm_out
.output_dwarf_dtprel
)
2219 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
2222 fputc ('\n', asm_out_file
);
2229 #ifdef DWARF2_DEBUGGING_INFO
2230 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
2237 case DW_OP_GNU_addr_index
:
2238 case DW_OP_GNU_const_index
:
2239 gcc_assert (loc
->dw_loc_oprnd1
.val_entry
->index
!= NO_INDEX_ASSIGNED
);
2240 dw2_asm_output_data_uleb128 (loc
->dw_loc_oprnd1
.val_entry
->index
,
2241 "(index into .debug_addr)");
2247 unsigned long die_offset
2248 = get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2249 /* Make sure the offset has been computed and that we can encode it as
2251 gcc_assert (die_offset
> 0
2252 && die_offset
<= (loc
->dw_loc_opc
== DW_OP_call2
2255 dw2_asm_output_data ((loc
->dw_loc_opc
== DW_OP_call2
) ? 2 : 4,
2260 case DW_OP_call_ref
:
2261 case DW_OP_GNU_variable_value
:
2263 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2264 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2265 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2266 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2267 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2271 case DW_OP_implicit_pointer
:
2272 case DW_OP_GNU_implicit_pointer
:
2274 char label
[MAX_ARTIFICIAL_LABEL_BYTES
2275 + HOST_BITS_PER_WIDE_INT
/ 2 + 2];
2276 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2277 get_ref_die_offset_label (label
, val1
->v
.val_die_ref
.die
);
2278 dw2_asm_output_offset (DWARF_REF_SIZE
, label
, debug_info_section
, NULL
);
2279 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
2283 case DW_OP_entry_value
:
2284 case DW_OP_GNU_entry_value
:
2285 dw2_asm_output_data_uleb128 (size_of_locs (val1
->v
.val_loc
), NULL
);
2286 output_loc_sequence (val1
->v
.val_loc
, for_eh_or_skip
);
2289 case DW_OP_const_type
:
2290 case DW_OP_GNU_const_type
:
2292 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
), l
;
2294 dw2_asm_output_data_uleb128 (o
, NULL
);
2295 switch (val2
->val_class
)
2297 case dw_val_class_const
:
2298 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2299 dw2_asm_output_data (1, l
, NULL
);
2300 dw2_asm_output_data (l
, val2
->v
.val_int
, NULL
);
2302 case dw_val_class_vec
:
2304 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
2305 unsigned int len
= val2
->v
.val_vec
.length
;
2310 dw2_asm_output_data (1, l
, NULL
);
2311 if (elt_size
> sizeof (HOST_WIDE_INT
))
2316 for (i
= 0, p
= (unsigned char *) val2
->v
.val_vec
.array
;
2319 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
2320 "fp or vector constant word %u", i
);
2323 case dw_val_class_const_double
:
2325 unsigned HOST_WIDE_INT first
, second
;
2326 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2328 dw2_asm_output_data (1, 2 * l
, NULL
);
2329 if (WORDS_BIG_ENDIAN
)
2331 first
= val2
->v
.val_double
.high
;
2332 second
= val2
->v
.val_double
.low
;
2336 first
= val2
->v
.val_double
.low
;
2337 second
= val2
->v
.val_double
.high
;
2339 dw2_asm_output_data (l
, first
, NULL
);
2340 dw2_asm_output_data (l
, second
, NULL
);
2343 case dw_val_class_wide_int
:
2346 int len
= get_full_len (*val2
->v
.val_wide
);
2347 l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
2349 dw2_asm_output_data (1, len
* l
, NULL
);
2350 if (WORDS_BIG_ENDIAN
)
2351 for (i
= len
- 1; i
>= 0; --i
)
2352 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2354 for (i
= 0; i
< len
; ++i
)
2355 dw2_asm_output_data (l
, val2
->v
.val_wide
->elt (i
), NULL
);
2363 case DW_OP_regval_type
:
2364 case DW_OP_GNU_regval_type
:
2366 unsigned r
= val1
->v
.val_unsigned
;
2367 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2369 if (for_eh_or_skip
>= 0)
2371 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2372 gcc_assert (size_of_uleb128 (r
)
2373 == size_of_uleb128 (val1
->v
.val_unsigned
));
2375 dw2_asm_output_data_uleb128 (r
, NULL
);
2376 dw2_asm_output_data_uleb128 (o
, NULL
);
2379 case DW_OP_deref_type
:
2380 case DW_OP_GNU_deref_type
:
2382 unsigned long o
= get_base_type_offset (val2
->v
.val_die_ref
.die
);
2384 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2385 dw2_asm_output_data_uleb128 (o
, NULL
);
2389 case DW_OP_reinterpret
:
2390 case DW_OP_GNU_convert
:
2391 case DW_OP_GNU_reinterpret
:
2392 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
2393 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2396 unsigned long o
= get_base_type_offset (val1
->v
.val_die_ref
.die
);
2398 dw2_asm_output_data_uleb128 (o
, NULL
);
2402 case DW_OP_GNU_parameter_ref
:
2405 gcc_assert (val1
->val_class
== dw_val_class_die_ref
);
2406 o
= get_ref_die_offset (val1
->v
.val_die_ref
.die
);
2407 dw2_asm_output_data (4, o
, NULL
);
2412 /* Other codes have no operands. */
2417 /* Output a sequence of location operations.
2418 The for_eh_or_skip parameter controls whether register numbers are
2419 converted using DWARF2_FRAME_REG_OUT, which is needed in the case that
2420 hard reg numbers have been processed via DWARF_FRAME_REGNUM (i.e. for unwind
2421 info). This should be suppressed for the cases that have not been converted
2422 (i.e. symbolic debug info), by setting the parameter < 0. See PR47324. */
2425 output_loc_sequence (dw_loc_descr_ref loc
, int for_eh_or_skip
)
2427 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2429 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2430 /* Output the opcode. */
2431 if (for_eh_or_skip
>= 0
2432 && opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2434 unsigned r
= (opc
- DW_OP_breg0
);
2435 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2436 gcc_assert (r
<= 31);
2437 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2439 else if (for_eh_or_skip
>= 0
2440 && opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2442 unsigned r
= (opc
- DW_OP_reg0
);
2443 r
= DWARF2_FRAME_REG_OUT (r
, for_eh_or_skip
);
2444 gcc_assert (r
<= 31);
2445 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2448 dw2_asm_output_data (1, opc
,
2449 "%s", dwarf_stack_op_name (opc
));
2451 /* Output the operand(s) (if any). */
2452 output_loc_operands (loc
, for_eh_or_skip
);
2456 /* Output location description stack opcode's operands (if any).
2457 The output is single bytes on a line, suitable for .cfi_escape. */
2460 output_loc_operands_raw (dw_loc_descr_ref loc
)
2462 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2463 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2465 switch (loc
->dw_loc_opc
)
2468 case DW_OP_GNU_addr_index
:
2469 case DW_OP_GNU_const_index
:
2470 case DW_OP_implicit_value
:
2471 /* We cannot output addresses in .cfi_escape, only bytes. */
2477 case DW_OP_deref_size
:
2478 case DW_OP_xderef_size
:
2479 fputc (',', asm_out_file
);
2480 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
2485 fputc (',', asm_out_file
);
2486 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
2491 fputc (',', asm_out_file
);
2492 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
2497 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
2498 fputc (',', asm_out_file
);
2499 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
2507 gcc_assert (val1
->val_class
== dw_val_class_loc
);
2508 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2510 fputc (',', asm_out_file
);
2511 dw2_asm_output_data_raw (2, offset
);
2517 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2518 gcc_assert (size_of_uleb128 (r
)
2519 == size_of_uleb128 (val1
->v
.val_unsigned
));
2520 fputc (',', asm_out_file
);
2521 dw2_asm_output_data_uleb128_raw (r
);
2526 case DW_OP_plus_uconst
:
2528 fputc (',', asm_out_file
);
2529 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2532 case DW_OP_bit_piece
:
2533 fputc (',', asm_out_file
);
2534 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
2535 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
2572 fputc (',', asm_out_file
);
2573 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
2578 unsigned r
= DWARF2_FRAME_REG_OUT (val1
->v
.val_unsigned
, 1);
2579 gcc_assert (size_of_uleb128 (r
)
2580 == size_of_uleb128 (val1
->v
.val_unsigned
));
2581 fputc (',', asm_out_file
);
2582 dw2_asm_output_data_uleb128_raw (r
);
2583 fputc (',', asm_out_file
);
2584 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
2588 case DW_OP_implicit_pointer
:
2589 case DW_OP_entry_value
:
2590 case DW_OP_const_type
:
2591 case DW_OP_regval_type
:
2592 case DW_OP_deref_type
:
2594 case DW_OP_reinterpret
:
2595 case DW_OP_GNU_implicit_pointer
:
2596 case DW_OP_GNU_entry_value
:
2597 case DW_OP_GNU_const_type
:
2598 case DW_OP_GNU_regval_type
:
2599 case DW_OP_GNU_deref_type
:
2600 case DW_OP_GNU_convert
:
2601 case DW_OP_GNU_reinterpret
:
2602 case DW_OP_GNU_parameter_ref
:
2607 /* Other codes have no operands. */
2613 output_loc_sequence_raw (dw_loc_descr_ref loc
)
2617 enum dwarf_location_atom opc
= loc
->dw_loc_opc
;
2618 /* Output the opcode. */
2619 if (opc
>= DW_OP_breg0
&& opc
<= DW_OP_breg31
)
2621 unsigned r
= (opc
- DW_OP_breg0
);
2622 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2623 gcc_assert (r
<= 31);
2624 opc
= (enum dwarf_location_atom
) (DW_OP_breg0
+ r
);
2626 else if (opc
>= DW_OP_reg0
&& opc
<= DW_OP_reg31
)
2628 unsigned r
= (opc
- DW_OP_reg0
);
2629 r
= DWARF2_FRAME_REG_OUT (r
, 1);
2630 gcc_assert (r
<= 31);
2631 opc
= (enum dwarf_location_atom
) (DW_OP_reg0
+ r
);
2633 /* Output the opcode. */
2634 fprintf (asm_out_file
, "%#x", opc
);
2635 output_loc_operands_raw (loc
);
2637 if (!loc
->dw_loc_next
)
2639 loc
= loc
->dw_loc_next
;
2641 fputc (',', asm_out_file
);
2645 /* This function builds a dwarf location descriptor sequence from a
2646 dw_cfa_location, adding the given OFFSET to the result of the
2649 struct dw_loc_descr_node
*
2650 build_cfa_loc (dw_cfa_location
*cfa
, poly_int64 offset
)
2652 struct dw_loc_descr_node
*head
, *tmp
;
2654 offset
+= cfa
->offset
;
2658 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
2659 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
2660 head
->dw_loc_oprnd1
.val_entry
= NULL
;
2661 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
2662 add_loc_descr (&head
, tmp
);
2663 loc_descr_plus_const (&head
, offset
);
2666 head
= new_reg_loc_descr (cfa
->reg
, offset
);
2671 /* This function builds a dwarf location descriptor sequence for
2672 the address at OFFSET from the CFA when stack is aligned to
2675 struct dw_loc_descr_node
*
2676 build_cfa_aligned_loc (dw_cfa_location
*cfa
,
2677 poly_int64 offset
, HOST_WIDE_INT alignment
)
2679 struct dw_loc_descr_node
*head
;
2680 unsigned int dwarf_fp
2681 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
2683 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
2684 if (cfa
->reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
->indirect
== 0)
2686 head
= new_reg_loc_descr (dwarf_fp
, 0);
2687 add_loc_descr (&head
, int_loc_descriptor (alignment
));
2688 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
2689 loc_descr_plus_const (&head
, offset
);
2692 head
= new_reg_loc_descr (dwarf_fp
, offset
);
2696 /* And now, the support for symbolic debugging information. */
2698 /* .debug_str support. */
2700 static void dwarf2out_init (const char *);
2701 static void dwarf2out_finish (const char *);
2702 static void dwarf2out_early_finish (const char *);
2703 static void dwarf2out_assembly_start (void);
2704 static void dwarf2out_define (unsigned int, const char *);
2705 static void dwarf2out_undef (unsigned int, const char *);
2706 static void dwarf2out_start_source_file (unsigned, const char *);
2707 static void dwarf2out_end_source_file (unsigned);
2708 static void dwarf2out_function_decl (tree
);
2709 static void dwarf2out_begin_block (unsigned, unsigned);
2710 static void dwarf2out_end_block (unsigned, unsigned);
2711 static bool dwarf2out_ignore_block (const_tree
);
2712 static void dwarf2out_early_global_decl (tree
);
2713 static void dwarf2out_late_global_decl (tree
);
2714 static void dwarf2out_type_decl (tree
, int);
2715 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool, bool);
2716 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
2718 static void dwarf2out_abstract_function (tree
);
2719 static void dwarf2out_var_location (rtx_insn
*);
2720 static void dwarf2out_size_function (tree
);
2721 static void dwarf2out_begin_function (tree
);
2722 static void dwarf2out_end_function (unsigned int);
2723 static void dwarf2out_register_main_translation_unit (tree unit
);
2724 static void dwarf2out_set_name (tree
, tree
);
2725 static void dwarf2out_register_external_die (tree decl
, const char *sym
,
2726 unsigned HOST_WIDE_INT off
);
2727 static bool dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
2728 unsigned HOST_WIDE_INT
*off
);
2730 /* The debug hooks structure. */
2732 const struct gcc_debug_hooks dwarf2_debug_hooks
=
2736 dwarf2out_early_finish
,
2737 dwarf2out_assembly_start
,
2740 dwarf2out_start_source_file
,
2741 dwarf2out_end_source_file
,
2742 dwarf2out_begin_block
,
2743 dwarf2out_end_block
,
2744 dwarf2out_ignore_block
,
2745 dwarf2out_source_line
,
2746 dwarf2out_begin_prologue
,
2747 #if VMS_DEBUGGING_INFO
2748 dwarf2out_vms_end_prologue
,
2749 dwarf2out_vms_begin_epilogue
,
2751 debug_nothing_int_charstar
,
2752 debug_nothing_int_charstar
,
2754 dwarf2out_end_epilogue
,
2755 dwarf2out_begin_function
,
2756 dwarf2out_end_function
, /* end_function */
2757 dwarf2out_register_main_translation_unit
,
2758 dwarf2out_function_decl
, /* function_decl */
2759 dwarf2out_early_global_decl
,
2760 dwarf2out_late_global_decl
,
2761 dwarf2out_type_decl
, /* type_decl */
2762 dwarf2out_imported_module_or_decl
,
2763 dwarf2out_die_ref_for_decl
,
2764 dwarf2out_register_external_die
,
2765 debug_nothing_tree
, /* deferred_inline_function */
2766 /* The DWARF 2 backend tries to reduce debugging bloat by not
2767 emitting the abstract description of inline functions until
2768 something tries to reference them. */
2769 dwarf2out_abstract_function
, /* outlining_inline_function */
2770 debug_nothing_rtx_code_label
, /* label */
2771 debug_nothing_int
, /* handle_pch */
2772 dwarf2out_var_location
,
2773 debug_nothing_tree
, /* inline_entry */
2774 dwarf2out_size_function
, /* size_function */
2775 dwarf2out_switch_text_section
,
2777 1, /* start_end_main_source_file */
2778 TYPE_SYMTAB_IS_DIE
/* tree_type_symtab_field */
2781 const struct gcc_debug_hooks dwarf2_lineno_debug_hooks
=
2784 debug_nothing_charstar
,
2785 debug_nothing_charstar
,
2786 dwarf2out_assembly_start
,
2787 debug_nothing_int_charstar
,
2788 debug_nothing_int_charstar
,
2789 debug_nothing_int_charstar
,
2791 debug_nothing_int_int
, /* begin_block */
2792 debug_nothing_int_int
, /* end_block */
2793 debug_true_const_tree
, /* ignore_block */
2794 dwarf2out_source_line
, /* source_line */
2795 debug_nothing_int_int_charstar
, /* begin_prologue */
2796 debug_nothing_int_charstar
, /* end_prologue */
2797 debug_nothing_int_charstar
, /* begin_epilogue */
2798 debug_nothing_int_charstar
, /* end_epilogue */
2799 debug_nothing_tree
, /* begin_function */
2800 debug_nothing_int
, /* end_function */
2801 debug_nothing_tree
, /* register_main_translation_unit */
2802 debug_nothing_tree
, /* function_decl */
2803 debug_nothing_tree
, /* early_global_decl */
2804 debug_nothing_tree
, /* late_global_decl */
2805 debug_nothing_tree_int
, /* type_decl */
2806 debug_nothing_tree_tree_tree_bool_bool
,/* imported_module_or_decl */
2807 debug_false_tree_charstarstar_uhwistar
,/* die_ref_for_decl */
2808 debug_nothing_tree_charstar_uhwi
, /* register_external_die */
2809 debug_nothing_tree
, /* deferred_inline_function */
2810 debug_nothing_tree
, /* outlining_inline_function */
2811 debug_nothing_rtx_code_label
, /* label */
2812 debug_nothing_int
, /* handle_pch */
2813 debug_nothing_rtx_insn
, /* var_location */
2814 debug_nothing_tree
, /* inline_entry */
2815 debug_nothing_tree
, /* size_function */
2816 debug_nothing_void
, /* switch_text_section */
2817 debug_nothing_tree_tree
, /* set_name */
2818 0, /* start_end_main_source_file */
2819 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
2822 /* NOTE: In the comments in this file, many references are made to
2823 "Debugging Information Entries". This term is abbreviated as `DIE'
2824 throughout the remainder of this file. */
2826 /* An internal representation of the DWARF output is built, and then
2827 walked to generate the DWARF debugging info. The walk of the internal
2828 representation is done after the entire program has been compiled.
2829 The types below are used to describe the internal representation. */
2831 /* Whether to put type DIEs into their own section .debug_types instead
2832 of making them part of the .debug_info section. Only supported for
2833 Dwarf V4 or higher and the user didn't disable them through
2834 -fno-debug-types-section. It is more efficient to put them in a
2835 separate comdat sections since the linker will then be able to
2836 remove duplicates. But not all tools support .debug_types sections
2837 yet. For Dwarf V5 or higher .debug_types doesn't exist any more,
2838 it is DW_UT_type unit type in .debug_info section. */
2840 #define use_debug_types (dwarf_version >= 4 && flag_debug_types_section)
2842 /* Various DIE's use offsets relative to the beginning of the
2843 .debug_info section to refer to each other. */
2845 typedef long int dw_offset
;
2847 struct comdat_type_node
;
2849 /* The entries in the line_info table more-or-less mirror the opcodes
2850 that are used in the real dwarf line table. Arrays of these entries
2851 are collected per section when DWARF2_ASM_LINE_DEBUG_INFO is not
2854 enum dw_line_info_opcode
{
2855 /* Emit DW_LNE_set_address; the operand is the label index. */
2858 /* Emit a row to the matrix with the given line. This may be done
2859 via any combination of DW_LNS_copy, DW_LNS_advance_line, and
2863 /* Emit a DW_LNS_set_file. */
2866 /* Emit a DW_LNS_set_column. */
2869 /* Emit a DW_LNS_negate_stmt; the operand is ignored. */
2872 /* Emit a DW_LNS_set_prologue_end/epilogue_begin; the operand is ignored. */
2873 LI_set_prologue_end
,
2874 LI_set_epilogue_begin
,
2876 /* Emit a DW_LNE_set_discriminator. */
2877 LI_set_discriminator
2880 typedef struct GTY(()) dw_line_info_struct
{
2881 enum dw_line_info_opcode opcode
;
2883 } dw_line_info_entry
;
2886 struct GTY(()) dw_line_info_table
{
2887 /* The label that marks the end of this section. */
2888 const char *end_label
;
2890 /* The values for the last row of the matrix, as collected in the table.
2891 These are used to minimize the changes to the next row. */
2892 unsigned int file_num
;
2893 unsigned int line_num
;
2894 unsigned int column_num
;
2899 vec
<dw_line_info_entry
, va_gc
> *entries
;
2903 /* Each DIE attribute has a field specifying the attribute kind,
2904 a link to the next attribute in the chain, and an attribute value.
2905 Attributes are typically linked below the DIE they modify. */
2907 typedef struct GTY(()) dw_attr_struct
{
2908 enum dwarf_attribute dw_attr
;
2909 dw_val_node dw_attr_val
;
2914 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
2915 The children of each node form a circular list linked by
2916 die_sib. die_child points to the node *before* the "first" child node. */
2918 typedef struct GTY((chain_circular ("%h.die_sib"), for_user
)) die_struct
{
2919 union die_symbol_or_type_node
2921 const char * GTY ((tag ("0"))) die_symbol
;
2922 comdat_type_node
*GTY ((tag ("1"))) die_type_node
;
2924 GTY ((desc ("%0.comdat_type_p"))) die_id
;
2925 vec
<dw_attr_node
, va_gc
> *die_attr
;
2926 dw_die_ref die_parent
;
2927 dw_die_ref die_child
;
2929 dw_die_ref die_definition
; /* ref from a specification to its definition */
2930 dw_offset die_offset
;
2931 unsigned long die_abbrev
;
2933 unsigned int decl_id
;
2934 enum dwarf_tag die_tag
;
2935 /* Die is used and must not be pruned as unused. */
2936 BOOL_BITFIELD die_perennial_p
: 1;
2937 BOOL_BITFIELD comdat_type_p
: 1; /* DIE has a type signature */
2938 /* For an external ref to die_symbol if die_offset contains an extra
2939 offset to that symbol. */
2940 BOOL_BITFIELD with_offset
: 1;
2941 /* Whether this DIE was removed from the DIE tree, for example via
2942 prune_unused_types. We don't consider those present from the
2943 DIE lookup routines. */
2944 BOOL_BITFIELD removed
: 1;
2945 /* Lots of spare bits. */
2949 /* Set to TRUE while dwarf2out_early_global_decl is running. */
2950 static bool early_dwarf
;
2951 static bool early_dwarf_finished
;
2952 struct set_early_dwarf
{
2954 set_early_dwarf () : saved(early_dwarf
)
2956 gcc_assert (! early_dwarf_finished
);
2959 ~set_early_dwarf () { early_dwarf
= saved
; }
2962 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
2963 #define FOR_EACH_CHILD(die, c, expr) do { \
2964 c = die->die_child; \
2968 } while (c != die->die_child); \
2971 /* The pubname structure */
2973 typedef struct GTY(()) pubname_struct
{
2980 struct GTY(()) dw_ranges
{
2982 /* If this is positive, it's a block number, otherwise it's a
2983 bitwise-negated index into dw_ranges_by_label. */
2985 /* Index for the range list for DW_FORM_rnglistx. */
2986 unsigned int idx
: 31;
2987 /* True if this range might be possibly in a different section
2988 from previous entry. */
2989 unsigned int maybe_new_sec
: 1;
2992 /* A structure to hold a macinfo entry. */
2994 typedef struct GTY(()) macinfo_struct
{
2996 unsigned HOST_WIDE_INT lineno
;
3002 struct GTY(()) dw_ranges_by_label
{
3007 /* The comdat type node structure. */
3008 struct GTY(()) comdat_type_node
3010 dw_die_ref root_die
;
3011 dw_die_ref type_die
;
3012 dw_die_ref skeleton_die
;
3013 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
3014 comdat_type_node
*next
;
3017 /* A list of DIEs for which we can't determine ancestry (parent_die
3018 field) just yet. Later in dwarf2out_finish we will fill in the
3020 typedef struct GTY(()) limbo_die_struct
{
3022 /* The tree for which this DIE was created. We use this to
3023 determine ancestry later. */
3025 struct limbo_die_struct
*next
;
3029 typedef struct skeleton_chain_struct
3033 struct skeleton_chain_struct
*parent
;
3035 skeleton_chain_node
;
3037 /* Define a macro which returns nonzero for a TYPE_DECL which was
3038 implicitly generated for a type.
3040 Note that, unlike the C front-end (which generates a NULL named
3041 TYPE_DECL node for each complete tagged type, each array type,
3042 and each function type node created) the C++ front-end generates
3043 a _named_ TYPE_DECL node for each tagged type node created.
3044 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3045 generate a DW_TAG_typedef DIE for them. Likewise with the Ada
3046 front-end, but for each type, tagged or not. */
3048 #define TYPE_DECL_IS_STUB(decl) \
3049 (DECL_NAME (decl) == NULL_TREE \
3050 || (DECL_ARTIFICIAL (decl) \
3051 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3052 /* This is necessary for stub decls that \
3053 appear in nested inline functions. */ \
3054 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3055 && (decl_ultimate_origin (decl) \
3056 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3058 /* Information concerning the compilation unit's programming
3059 language, and compiler version. */
3061 /* Fixed size portion of the DWARF compilation unit header. */
3062 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3063 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE \
3064 + (dwarf_version >= 5 ? 4 : 3))
3066 /* Fixed size portion of the DWARF comdat type unit header. */
3067 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
3068 (DWARF_COMPILE_UNIT_HEADER_SIZE \
3069 + DWARF_TYPE_SIGNATURE_SIZE + DWARF_OFFSET_SIZE)
3071 /* Fixed size portion of the DWARF skeleton compilation unit header. */
3072 #define DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE \
3073 (DWARF_COMPILE_UNIT_HEADER_SIZE + (dwarf_version >= 5 ? 8 : 0))
3075 /* Fixed size portion of public names info. */
3076 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3078 /* Fixed size portion of the address range info. */
3079 #define DWARF_ARANGES_HEADER_SIZE \
3080 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3081 DWARF2_ADDR_SIZE * 2) \
3082 - DWARF_INITIAL_LENGTH_SIZE)
3084 /* Size of padding portion in the address range info. It must be
3085 aligned to twice the pointer size. */
3086 #define DWARF_ARANGES_PAD_SIZE \
3087 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3088 DWARF2_ADDR_SIZE * 2) \
3089 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3091 /* Use assembler line directives if available. */
3092 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3093 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3094 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3096 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3100 /* Minimum line offset in a special line info. opcode.
3101 This value was chosen to give a reasonable range of values. */
3102 #define DWARF_LINE_BASE -10
3104 /* First special line opcode - leave room for the standard opcodes. */
3105 #define DWARF_LINE_OPCODE_BASE ((int)DW_LNS_set_isa + 1)
3107 /* Range of line offsets in a special line info. opcode. */
3108 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3110 /* Flag that indicates the initial value of the is_stmt_start flag.
3111 In the present implementation, we do not mark any lines as
3112 the beginning of a source statement, because that information
3113 is not made available by the GCC front-end. */
3114 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3116 /* Maximum number of operations per instruction bundle. */
3117 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
3118 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
3121 /* This location is used by calc_die_sizes() to keep track
3122 the offset of each DIE within the .debug_info section. */
3123 static unsigned long next_die_offset
;
3125 /* Record the root of the DIE's built for the current compilation unit. */
3126 static GTY(()) dw_die_ref single_comp_unit_die
;
3128 /* A list of type DIEs that have been separated into comdat sections. */
3129 static GTY(()) comdat_type_node
*comdat_type_list
;
3131 /* A list of CU DIEs that have been separated. */
3132 static GTY(()) limbo_die_node
*cu_die_list
;
3134 /* A list of DIEs with a NULL parent waiting to be relocated. */
3135 static GTY(()) limbo_die_node
*limbo_die_list
;
3137 /* A list of DIEs for which we may have to generate
3138 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
3139 static GTY(()) limbo_die_node
*deferred_asm_name
;
3141 struct dwarf_file_hasher
: ggc_ptr_hash
<dwarf_file_data
>
3143 typedef const char *compare_type
;
3145 static hashval_t
hash (dwarf_file_data
*);
3146 static bool equal (dwarf_file_data
*, const char *);
3149 /* Filenames referenced by this compilation unit. */
3150 static GTY(()) hash_table
<dwarf_file_hasher
> *file_table
;
3152 struct decl_die_hasher
: ggc_ptr_hash
<die_node
>
3154 typedef tree compare_type
;
3156 static hashval_t
hash (die_node
*);
3157 static bool equal (die_node
*, tree
);
3159 /* A hash table of references to DIE's that describe declarations.
3160 The key is a DECL_UID() which is a unique number identifying each decl. */
3161 static GTY (()) hash_table
<decl_die_hasher
> *decl_die_table
;
3163 struct GTY ((for_user
)) variable_value_struct
{
3164 unsigned int decl_id
;
3165 vec
<dw_die_ref
, va_gc
> *dies
;
3168 struct variable_value_hasher
: ggc_ptr_hash
<variable_value_struct
>
3170 typedef tree compare_type
;
3172 static hashval_t
hash (variable_value_struct
*);
3173 static bool equal (variable_value_struct
*, tree
);
3175 /* A hash table of DIEs that contain DW_OP_GNU_variable_value with
3176 dw_val_class_decl_ref class, indexed by FUNCTION_DECLs which is
3177 DECL_CONTEXT of the referenced VAR_DECLs. */
3178 static GTY (()) hash_table
<variable_value_hasher
> *variable_value_hash
;
3180 struct block_die_hasher
: ggc_ptr_hash
<die_struct
>
3182 static hashval_t
hash (die_struct
*);
3183 static bool equal (die_struct
*, die_struct
*);
3186 /* A hash table of references to DIE's that describe COMMON blocks.
3187 The key is DECL_UID() ^ die_parent. */
3188 static GTY (()) hash_table
<block_die_hasher
> *common_block_die_table
;
3190 typedef struct GTY(()) die_arg_entry_struct
{
3196 /* Node of the variable location list. */
3197 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
3198 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
3199 EXPR_LIST chain. For small bitsizes, bitsize is encoded
3200 in mode of the EXPR_LIST node and first EXPR_LIST operand
3201 is either NOTE_INSN_VAR_LOCATION for a piece with a known
3202 location or NULL for padding. For larger bitsizes,
3203 mode is 0 and first operand is a CONCAT with bitsize
3204 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
3205 NULL as second operand. */
3207 const char * GTY (()) label
;
3208 struct var_loc_node
* GTY (()) next
;
3211 /* Variable location list. */
3212 struct GTY ((for_user
)) var_loc_list_def
{
3213 struct var_loc_node
* GTY (()) first
;
3215 /* Pointer to the last but one or last element of the
3216 chained list. If the list is empty, both first and
3217 last are NULL, if the list contains just one node
3218 or the last node certainly is not redundant, it points
3219 to the last node, otherwise points to the last but one.
3220 Do not mark it for GC because it is marked through the chain. */
3221 struct var_loc_node
* GTY ((skip ("%h"))) last
;
3223 /* Pointer to the last element before section switch,
3224 if NULL, either sections weren't switched or first
3225 is after section switch. */
3226 struct var_loc_node
* GTY ((skip ("%h"))) last_before_switch
;
3228 /* DECL_UID of the variable decl. */
3229 unsigned int decl_id
;
3231 typedef struct var_loc_list_def var_loc_list
;
3233 /* Call argument location list. */
3234 struct GTY ((chain_next ("%h.next"))) call_arg_loc_node
{
3235 rtx
GTY (()) call_arg_loc_note
;
3236 const char * GTY (()) label
;
3237 tree
GTY (()) block
;
3239 rtx
GTY (()) symbol_ref
;
3240 struct call_arg_loc_node
* GTY (()) next
;
3244 struct decl_loc_hasher
: ggc_ptr_hash
<var_loc_list
>
3246 typedef const_tree compare_type
;
3248 static hashval_t
hash (var_loc_list
*);
3249 static bool equal (var_loc_list
*, const_tree
);
3252 /* Table of decl location linked lists. */
3253 static GTY (()) hash_table
<decl_loc_hasher
> *decl_loc_table
;
3255 /* Head and tail of call_arg_loc chain. */
3256 static GTY (()) struct call_arg_loc_node
*call_arg_locations
;
3257 static struct call_arg_loc_node
*call_arg_loc_last
;
3259 /* Number of call sites in the current function. */
3260 static int call_site_count
= -1;
3261 /* Number of tail call sites in the current function. */
3262 static int tail_call_site_count
= -1;
3264 /* A cached location list. */
3265 struct GTY ((for_user
)) cached_dw_loc_list_def
{
3266 /* The DECL_UID of the decl that this entry describes. */
3267 unsigned int decl_id
;
3269 /* The cached location list. */
3270 dw_loc_list_ref loc_list
;
3272 typedef struct cached_dw_loc_list_def cached_dw_loc_list
;
3274 struct dw_loc_list_hasher
: ggc_ptr_hash
<cached_dw_loc_list
>
3277 typedef const_tree compare_type
;
3279 static hashval_t
hash (cached_dw_loc_list
*);
3280 static bool equal (cached_dw_loc_list
*, const_tree
);
3283 /* Table of cached location lists. */
3284 static GTY (()) hash_table
<dw_loc_list_hasher
> *cached_dw_loc_list_table
;
3286 /* A vector of references to DIE's that are uniquely identified by their tag,
3287 presence/absence of children DIE's, and list of attribute/value pairs. */
3288 static GTY(()) vec
<dw_die_ref
, va_gc
> *abbrev_die_table
;
3290 /* A hash map to remember the stack usage for DWARF procedures. The value
3291 stored is the stack size difference between before the DWARF procedure
3292 invokation and after it returned. In other words, for a DWARF procedure
3293 that consumes N stack slots and that pushes M ones, this stores M - N. */
3294 static hash_map
<dw_die_ref
, int> *dwarf_proc_stack_usage_map
;
3296 /* A global counter for generating labels for line number data. */
3297 static unsigned int line_info_label_num
;
3299 /* The current table to which we should emit line number information
3300 for the current function. This will be set up at the beginning of
3301 assembly for the function. */
3302 static GTY(()) dw_line_info_table
*cur_line_info_table
;
3304 /* The two default tables of line number info. */
3305 static GTY(()) dw_line_info_table
*text_section_line_info
;
3306 static GTY(()) dw_line_info_table
*cold_text_section_line_info
;
3308 /* The set of all non-default tables of line number info. */
3309 static GTY(()) vec
<dw_line_info_table
*, va_gc
> *separate_line_info
;
3311 /* A flag to tell pubnames/types export if there is an info section to
3313 static bool info_section_emitted
;
3315 /* A pointer to the base of a table that contains a list of publicly
3316 accessible names. */
3317 static GTY (()) vec
<pubname_entry
, va_gc
> *pubname_table
;
3319 /* A pointer to the base of a table that contains a list of publicly
3320 accessible types. */
3321 static GTY (()) vec
<pubname_entry
, va_gc
> *pubtype_table
;
3323 /* A pointer to the base of a table that contains a list of macro
3324 defines/undefines (and file start/end markers). */
3325 static GTY (()) vec
<macinfo_entry
, va_gc
> *macinfo_table
;
3327 /* True if .debug_macinfo or .debug_macros section is going to be
3329 #define have_macinfo \
3330 ((!XCOFF_DEBUGGING_INFO || HAVE_XCOFF_DWARF_EXTRAS) \
3331 && debug_info_level >= DINFO_LEVEL_VERBOSE \
3332 && !macinfo_table->is_empty ())
3334 /* Vector of dies for which we should generate .debug_ranges info. */
3335 static GTY (()) vec
<dw_ranges
, va_gc
> *ranges_table
;
3337 /* Vector of pairs of labels referenced in ranges_table. */
3338 static GTY (()) vec
<dw_ranges_by_label
, va_gc
> *ranges_by_label
;
3340 /* Whether we have location lists that need outputting */
3341 static GTY(()) bool have_location_lists
;
3343 /* Unique label counter. */
3344 static GTY(()) unsigned int loclabel_num
;
3346 /* Unique label counter for point-of-call tables. */
3347 static GTY(()) unsigned int poc_label_num
;
3349 /* The last file entry emitted by maybe_emit_file(). */
3350 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
3352 /* Number of internal labels generated by gen_internal_sym(). */
3353 static GTY(()) int label_num
;
3355 static GTY(()) vec
<die_arg_entry
, va_gc
> *tmpl_value_parm_die_table
;
3357 /* Instances of generic types for which we need to generate debug
3358 info that describe their generic parameters and arguments. That
3359 generation needs to happen once all types are properly laid out so
3360 we do it at the end of compilation. */
3361 static GTY(()) vec
<tree
, va_gc
> *generic_type_instances
;
3363 /* Offset from the "steady-state frame pointer" to the frame base,
3364 within the current function. */
3365 static poly_int64 frame_pointer_fb_offset
;
3366 static bool frame_pointer_fb_offset_valid
;
3368 static vec
<dw_die_ref
> base_types
;
3370 /* Flags to represent a set of attribute classes for attributes that represent
3371 a scalar value (bounds, pointers, ...). */
3374 dw_scalar_form_constant
= 0x01,
3375 dw_scalar_form_exprloc
= 0x02,
3376 dw_scalar_form_reference
= 0x04
3379 /* Forward declarations for functions defined in this file. */
3381 static int is_pseudo_reg (const_rtx
);
3382 static tree
type_main_variant (tree
);
3383 static int is_tagged_type (const_tree
);
3384 static const char *dwarf_tag_name (unsigned);
3385 static const char *dwarf_attr_name (unsigned);
3386 static const char *dwarf_form_name (unsigned);
3387 static tree
decl_ultimate_origin (const_tree
);
3388 static tree
decl_class_context (tree
);
3389 static void add_dwarf_attr (dw_die_ref
, dw_attr_node
*);
3390 static inline enum dw_val_class
AT_class (dw_attr_node
*);
3391 static inline unsigned int AT_index (dw_attr_node
*);
3392 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3393 static inline unsigned AT_flag (dw_attr_node
*);
3394 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3395 static inline HOST_WIDE_INT
AT_int (dw_attr_node
*);
3396 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3397 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_node
*);
3398 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
3399 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
3400 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3401 unsigned int, unsigned char *);
3402 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
3403 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3404 static inline const char *AT_string (dw_attr_node
*);
3405 static enum dwarf_form
AT_string_form (dw_attr_node
*);
3406 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3407 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3408 static inline dw_die_ref
AT_ref (dw_attr_node
*);
3409 static inline int AT_ref_external (dw_attr_node
*);
3410 static inline void set_AT_ref_external (dw_attr_node
*, int);
3411 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
3412 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3413 static inline dw_loc_descr_ref
AT_loc (dw_attr_node
*);
3414 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3416 static inline dw_loc_list_ref
AT_loc_list (dw_attr_node
*);
3417 static addr_table_entry
*add_addr_table_entry (void *, enum ate_kind
);
3418 static void remove_addr_table_entry (addr_table_entry
*);
3419 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
, bool);
3420 static inline rtx
AT_addr (dw_attr_node
*);
3421 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3422 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3423 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
3424 static void add_AT_loclistsptr (dw_die_ref
, enum dwarf_attribute
,
3426 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
3427 unsigned HOST_WIDE_INT
);
3428 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3429 unsigned long, bool);
3430 static inline const char *AT_lbl (dw_attr_node
*);
3431 static dw_attr_node
*get_AT (dw_die_ref
, enum dwarf_attribute
);
3432 static const char *get_AT_low_pc (dw_die_ref
);
3433 static const char *get_AT_hi_pc (dw_die_ref
);
3434 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
3435 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
3436 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
3437 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
3438 static bool is_cxx (void);
3439 static bool is_cxx (const_tree
);
3440 static bool is_fortran (void);
3441 static bool is_ada (void);
3442 static bool remove_AT (dw_die_ref
, enum dwarf_attribute
);
3443 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3444 static void add_child_die (dw_die_ref
, dw_die_ref
);
3445 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3446 static dw_die_ref
lookup_type_die (tree
);
3447 static dw_die_ref
strip_naming_typedef (tree
, dw_die_ref
);
3448 static dw_die_ref
lookup_type_die_strip_naming_typedef (tree
);
3449 static void equate_type_number_to_die (tree
, dw_die_ref
);
3450 static dw_die_ref
lookup_decl_die (tree
);
3451 static var_loc_list
*lookup_decl_loc (const_tree
);
3452 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3453 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *);
3454 static void print_spaces (FILE *);
3455 static void print_die (dw_die_ref
, FILE *);
3456 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3457 static void attr_checksum (dw_attr_node
*, struct md5_ctx
*, int *);
3458 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3459 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
3460 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
3461 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
3462 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_node
*,
3463 struct md5_ctx
*, int *);
3464 struct checksum_attributes
;
3465 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
3466 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
3467 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
3468 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
3469 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3470 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
3471 static int same_attr_p (dw_attr_node
*, dw_attr_node
*, int *);
3472 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3473 static int is_type_die (dw_die_ref
);
3474 static int is_comdat_die (dw_die_ref
);
3475 static inline bool is_template_instantiation (dw_die_ref
);
3476 static int is_declaration_die (dw_die_ref
);
3477 static int should_move_die_to_comdat (dw_die_ref
);
3478 static dw_die_ref
clone_as_declaration (dw_die_ref
);
3479 static dw_die_ref
clone_die (dw_die_ref
);
3480 static dw_die_ref
clone_tree (dw_die_ref
);
3481 static dw_die_ref
copy_declaration_context (dw_die_ref
, dw_die_ref
);
3482 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
3483 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
3484 static dw_die_ref
generate_skeleton (dw_die_ref
);
3485 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
3488 static void break_out_comdat_types (dw_die_ref
);
3489 static void copy_decls_for_unworthy_types (dw_die_ref
);
3491 static void add_sibling_attributes (dw_die_ref
);
3492 static void output_location_lists (dw_die_ref
);
3493 static int constant_size (unsigned HOST_WIDE_INT
);
3494 static unsigned long size_of_die (dw_die_ref
);
3495 static void calc_die_sizes (dw_die_ref
);
3496 static void calc_base_type_die_sizes (void);
3497 static void mark_dies (dw_die_ref
);
3498 static void unmark_dies (dw_die_ref
);
3499 static void unmark_all_dies (dw_die_ref
);
3500 static unsigned long size_of_pubnames (vec
<pubname_entry
, va_gc
> *);
3501 static unsigned long size_of_aranges (void);
3502 static enum dwarf_form
value_format (dw_attr_node
*);
3503 static void output_value_format (dw_attr_node
*);
3504 static void output_abbrev_section (void);
3505 static void output_die_abbrevs (unsigned long, dw_die_ref
);
3506 static void output_die (dw_die_ref
);
3507 static void output_compilation_unit_header (enum dwarf_unit_type
);
3508 static void output_comp_unit (dw_die_ref
, int, const unsigned char *);
3509 static void output_comdat_type_unit (comdat_type_node
*);
3510 static const char *dwarf2_name (tree
, int);
3511 static void add_pubname (tree
, dw_die_ref
);
3512 static void add_enumerator_pubname (const char *, dw_die_ref
);
3513 static void add_pubname_string (const char *, dw_die_ref
);
3514 static void add_pubtype (tree
, dw_die_ref
);
3515 static void output_pubnames (vec
<pubname_entry
, va_gc
> *);
3516 static void output_aranges (void);
3517 static unsigned int add_ranges (const_tree
, bool = false);
3518 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
3520 static void output_ranges (void);
3521 static dw_line_info_table
*new_line_info_table (void);
3522 static void output_line_info (bool);
3523 static void output_file_names (void);
3524 static dw_die_ref
base_type_die (tree
, bool);
3525 static int is_base_type (tree
);
3526 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, tree
, dw_die_ref
);
3527 static int decl_quals (const_tree
);
3528 static dw_die_ref
modified_type_die (tree
, int, bool, dw_die_ref
);
3529 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
3530 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
3531 static int type_is_enum (const_tree
);
3532 static unsigned int dbx_reg_number (const_rtx
);
3533 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
3534 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
3535 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
3536 enum var_init_status
);
3537 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
3538 enum var_init_status
);
3539 static dw_loc_descr_ref
based_loc_descr (rtx
, poly_int64
,
3540 enum var_init_status
);
3541 static int is_based_loc (const_rtx
);
3542 static bool resolve_one_addr (rtx
*);
3543 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
3544 enum var_init_status
);
3545 static dw_loc_descr_ref
loc_descriptor (rtx
, machine_mode mode
,
3546 enum var_init_status
);
3547 struct loc_descr_context
;
3548 static void add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
);
3549 static void add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
);
3550 static dw_loc_list_ref
loc_list_from_tree (tree
, int,
3551 struct loc_descr_context
*);
3552 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int,
3553 struct loc_descr_context
*);
3554 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
3555 static tree
field_type (const_tree
);
3556 static unsigned int simple_type_align_in_bits (const_tree
);
3557 static unsigned int simple_decl_align_in_bits (const_tree
);
3558 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
3560 static dw_loc_descr_ref
field_byte_offset (const_tree
, struct vlr_context
*,
3562 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3564 static void add_data_member_location_attribute (dw_die_ref
, tree
,
3565 struct vlr_context
*);
3566 static bool add_const_value_attribute (dw_die_ref
, rtx
);
3567 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3568 static void insert_wide_int (const wide_int
&, unsigned char *, int);
3569 static void insert_float (const_rtx
, unsigned char *);
3570 static rtx
rtl_for_decl_location (tree
);
3571 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
, bool);
3572 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
3573 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
3574 static void add_name_attribute (dw_die_ref
, const char *);
3575 static void add_gnat_descriptive_type_attribute (dw_die_ref
, tree
, dw_die_ref
);
3576 static void add_comp_dir_attribute (dw_die_ref
);
3577 static void add_scalar_info (dw_die_ref
, enum dwarf_attribute
, tree
, int,
3578 struct loc_descr_context
*);
3579 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
,
3580 struct loc_descr_context
*);
3581 static void add_subscript_info (dw_die_ref
, tree
, bool);
3582 static void add_byte_size_attribute (dw_die_ref
, tree
);
3583 static void add_alignment_attribute (dw_die_ref
, tree
);
3584 static inline void add_bit_offset_attribute (dw_die_ref
, tree
,
3585 struct vlr_context
*);
3586 static void add_bit_size_attribute (dw_die_ref
, tree
);
3587 static void add_prototyped_attribute (dw_die_ref
, tree
);
3588 static dw_die_ref
add_abstract_origin_attribute (dw_die_ref
, tree
);
3589 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3590 static void add_src_coords_attributes (dw_die_ref
, tree
);
3591 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
, bool = false);
3592 static void add_discr_value (dw_die_ref
, dw_discr_value
*);
3593 static void add_discr_list (dw_die_ref
, dw_discr_list_ref
);
3594 static inline dw_discr_list_ref
AT_discr_list (dw_attr_node
*);
3595 static void push_decl_scope (tree
);
3596 static void pop_decl_scope (void);
3597 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3598 static inline int local_scope_p (dw_die_ref
);
3599 static inline int class_scope_p (dw_die_ref
);
3600 static inline int class_or_namespace_scope_p (dw_die_ref
);
3601 static void add_type_attribute (dw_die_ref
, tree
, int, bool, dw_die_ref
);
3602 static void add_calling_convention_attribute (dw_die_ref
, tree
);
3603 static const char *type_tag (const_tree
);
3604 static tree
member_declared_type (const_tree
);
3606 static const char *decl_start_label (tree
);
3608 static void gen_array_type_die (tree
, dw_die_ref
);
3609 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
3611 static void gen_entry_point_die (tree
, dw_die_ref
);
3613 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3614 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
3615 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
3616 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3617 static void gen_formal_types_die (tree
, dw_die_ref
);
3618 static void gen_subprogram_die (tree
, dw_die_ref
);
3619 static void gen_variable_die (tree
, tree
, dw_die_ref
);
3620 static void gen_const_die (tree
, dw_die_ref
);
3621 static void gen_label_die (tree
, dw_die_ref
);
3622 static void gen_lexical_block_die (tree
, dw_die_ref
);
3623 static void gen_inlined_subroutine_die (tree
, dw_die_ref
);
3624 static void gen_field_die (tree
, struct vlr_context
*, dw_die_ref
);
3625 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3626 static dw_die_ref
gen_compile_unit_die (const char *);
3627 static void gen_inheritance_die (tree
, tree
, tree
, dw_die_ref
);
3628 static void gen_member_die (tree
, dw_die_ref
);
3629 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
3630 enum debug_info_usage
);
3631 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3632 static void gen_typedef_die (tree
, dw_die_ref
);
3633 static void gen_type_die (tree
, dw_die_ref
);
3634 static void gen_block_die (tree
, dw_die_ref
);
3635 static void decls_for_scope (tree
, dw_die_ref
);
3636 static bool is_naming_typedef_decl (const_tree
);
3637 static inline dw_die_ref
get_context_die (tree
);
3638 static void gen_namespace_die (tree
, dw_die_ref
);
3639 static dw_die_ref
gen_namelist_decl (tree
, dw_die_ref
, tree
);
3640 static dw_die_ref
gen_decl_die (tree
, tree
, struct vlr_context
*, dw_die_ref
);
3641 static dw_die_ref
force_decl_die (tree
);
3642 static dw_die_ref
force_type_die (tree
);
3643 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3644 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
3645 static struct dwarf_file_data
* lookup_filename (const char *);
3646 static void retry_incomplete_types (void);
3647 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3648 static void gen_generic_params_dies (tree
);
3649 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
3650 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
3651 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3652 static int file_info_cmp (const void *, const void *);
3653 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *,
3654 const char *, const char *);
3655 static void output_loc_list (dw_loc_list_ref
);
3656 static char *gen_internal_sym (const char *);
3657 static bool want_pubnames (void);
3659 static void prune_unmark_dies (dw_die_ref
);
3660 static void prune_unused_types_mark_generic_parms_dies (dw_die_ref
);
3661 static void prune_unused_types_mark (dw_die_ref
, int);
3662 static void prune_unused_types_walk (dw_die_ref
);
3663 static void prune_unused_types_walk_attribs (dw_die_ref
);
3664 static void prune_unused_types_prune (dw_die_ref
);
3665 static void prune_unused_types (void);
3666 static int maybe_emit_file (struct dwarf_file_data
*fd
);
3667 static inline const char *AT_vms_delta1 (dw_attr_node
*);
3668 static inline const char *AT_vms_delta2 (dw_attr_node
*);
3669 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
3670 const char *, const char *);
3671 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
3672 static void gen_remaining_tmpl_value_param_die_attribute (void);
3673 static bool generic_type_p (tree
);
3674 static void schedule_generic_params_dies_gen (tree t
);
3675 static void gen_scheduled_generic_parms_dies (void);
3676 static void resolve_variable_values (void);
3678 static const char *comp_dir_string (void);
3680 static void hash_loc_operands (dw_loc_descr_ref
, inchash::hash
&);
3682 /* enum for tracking thread-local variables whose address is really an offset
3683 relative to the TLS pointer, which will need link-time relocation, but will
3684 not need relocation by the DWARF consumer. */
3692 /* Return the operator to use for an address of a variable. For dtprel_true, we
3693 use DW_OP_const*. For regular variables, which need both link-time
3694 relocation and consumer-level relocation (e.g., to account for shared objects
3695 loaded at a random address), we use DW_OP_addr*. */
3697 static inline enum dwarf_location_atom
3698 dw_addr_op (enum dtprel_bool dtprel
)
3700 if (dtprel
== dtprel_true
)
3701 return (dwarf_split_debug_info
? DW_OP_GNU_const_index
3702 : (DWARF2_ADDR_SIZE
== 4 ? DW_OP_const4u
: DW_OP_const8u
));
3704 return dwarf_split_debug_info
? DW_OP_GNU_addr_index
: DW_OP_addr
;
3707 /* Return a pointer to a newly allocated address location description. If
3708 dwarf_split_debug_info is true, then record the address with the appropriate
3710 static inline dw_loc_descr_ref
3711 new_addr_loc_descr (rtx addr
, enum dtprel_bool dtprel
)
3713 dw_loc_descr_ref ref
= new_loc_descr (dw_addr_op (dtprel
), 0, 0);
3715 ref
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
3716 ref
->dw_loc_oprnd1
.v
.val_addr
= addr
;
3717 ref
->dtprel
= dtprel
;
3718 if (dwarf_split_debug_info
)
3719 ref
->dw_loc_oprnd1
.val_entry
3720 = add_addr_table_entry (addr
,
3721 dtprel
? ate_kind_rtx_dtprel
: ate_kind_rtx
);
3723 ref
->dw_loc_oprnd1
.val_entry
= NULL
;
3728 /* Section names used to hold DWARF debugging information. */
3730 #ifndef DEBUG_INFO_SECTION
3731 #define DEBUG_INFO_SECTION ".debug_info"
3733 #ifndef DEBUG_DWO_INFO_SECTION
3734 #define DEBUG_DWO_INFO_SECTION ".debug_info.dwo"
3736 #ifndef DEBUG_LTO_INFO_SECTION
3737 #define DEBUG_LTO_INFO_SECTION ".gnu.debuglto_.debug_info"
3739 #ifndef DEBUG_LTO_DWO_INFO_SECTION
3740 #define DEBUG_LTO_DWO_INFO_SECTION ".gnu.debuglto_.debug_info.dwo"
3742 #ifndef DEBUG_ABBREV_SECTION
3743 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3745 #ifndef DEBUG_LTO_ABBREV_SECTION
3746 #define DEBUG_LTO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev"
3748 #ifndef DEBUG_DWO_ABBREV_SECTION
3749 #define DEBUG_DWO_ABBREV_SECTION ".debug_abbrev.dwo"
3751 #ifndef DEBUG_LTO_DWO_ABBREV_SECTION
3752 #define DEBUG_LTO_DWO_ABBREV_SECTION ".gnu.debuglto_.debug_abbrev.dwo"
3754 #ifndef DEBUG_ARANGES_SECTION
3755 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3757 #ifndef DEBUG_ADDR_SECTION
3758 #define DEBUG_ADDR_SECTION ".debug_addr"
3760 #ifndef DEBUG_MACINFO_SECTION
3761 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
3763 #ifndef DEBUG_LTO_MACINFO_SECTION
3764 #define DEBUG_LTO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo"
3766 #ifndef DEBUG_DWO_MACINFO_SECTION
3767 #define DEBUG_DWO_MACINFO_SECTION ".debug_macinfo.dwo"
3769 #ifndef DEBUG_LTO_DWO_MACINFO_SECTION
3770 #define DEBUG_LTO_DWO_MACINFO_SECTION ".gnu.debuglto_.debug_macinfo.dwo"
3772 #ifndef DEBUG_MACRO_SECTION
3773 #define DEBUG_MACRO_SECTION ".debug_macro"
3775 #ifndef DEBUG_LTO_MACRO_SECTION
3776 #define DEBUG_LTO_MACRO_SECTION ".gnu.debuglto_.debug_macro"
3778 #ifndef DEBUG_DWO_MACRO_SECTION
3779 #define DEBUG_DWO_MACRO_SECTION ".debug_macro.dwo"
3781 #ifndef DEBUG_LTO_DWO_MACRO_SECTION
3782 #define DEBUG_LTO_DWO_MACRO_SECTION ".gnu.debuglto_.debug_macro.dwo"
3784 #ifndef DEBUG_LINE_SECTION
3785 #define DEBUG_LINE_SECTION ".debug_line"
3787 #ifndef DEBUG_LTO_LINE_SECTION
3788 #define DEBUG_LTO_LINE_SECTION ".gnu.debuglto_.debug_line"
3790 #ifndef DEBUG_DWO_LINE_SECTION
3791 #define DEBUG_DWO_LINE_SECTION ".debug_line.dwo"
3793 #ifndef DEBUG_LTO_DWO_LINE_SECTION
3794 #define DEBUG_LTO_DWO_LINE_SECTION ".gnu.debuglto_.debug_line.dwo"
3796 #ifndef DEBUG_LOC_SECTION
3797 #define DEBUG_LOC_SECTION ".debug_loc"
3799 #ifndef DEBUG_DWO_LOC_SECTION
3800 #define DEBUG_DWO_LOC_SECTION ".debug_loc.dwo"
3802 #ifndef DEBUG_LOCLISTS_SECTION
3803 #define DEBUG_LOCLISTS_SECTION ".debug_loclists"
3805 #ifndef DEBUG_DWO_LOCLISTS_SECTION
3806 #define DEBUG_DWO_LOCLISTS_SECTION ".debug_loclists.dwo"
3808 #ifndef DEBUG_PUBNAMES_SECTION
3809 #define DEBUG_PUBNAMES_SECTION \
3810 ((debug_generate_pub_sections == 2) \
3811 ? ".debug_gnu_pubnames" : ".debug_pubnames")
3813 #ifndef DEBUG_PUBTYPES_SECTION
3814 #define DEBUG_PUBTYPES_SECTION \
3815 ((debug_generate_pub_sections == 2) \
3816 ? ".debug_gnu_pubtypes" : ".debug_pubtypes")
3818 #ifndef DEBUG_STR_OFFSETS_SECTION
3819 #define DEBUG_STR_OFFSETS_SECTION ".debug_str_offsets"
3821 #ifndef DEBUG_DWO_STR_OFFSETS_SECTION
3822 #define DEBUG_DWO_STR_OFFSETS_SECTION ".debug_str_offsets.dwo"
3824 #ifndef DEBUG_LTO_DWO_STR_OFFSETS_SECTION
3825 #define DEBUG_LTO_DWO_STR_OFFSETS_SECTION ".gnu.debuglto_.debug_str_offsets.dwo"
3827 #ifndef DEBUG_STR_SECTION
3828 #define DEBUG_STR_SECTION ".debug_str"
3830 #ifndef DEBUG_LTO_STR_SECTION
3831 #define DEBUG_LTO_STR_SECTION ".gnu.debuglto_.debug_str"
3833 #ifndef DEBUG_STR_DWO_SECTION
3834 #define DEBUG_STR_DWO_SECTION ".debug_str.dwo"
3836 #ifndef DEBUG_LTO_STR_DWO_SECTION
3837 #define DEBUG_LTO_STR_DWO_SECTION ".gnu.debuglto_.debug_str.dwo"
3839 #ifndef DEBUG_RANGES_SECTION
3840 #define DEBUG_RANGES_SECTION ".debug_ranges"
3842 #ifndef DEBUG_RNGLISTS_SECTION
3843 #define DEBUG_RNGLISTS_SECTION ".debug_rnglists"
3845 #ifndef DEBUG_LINE_STR_SECTION
3846 #define DEBUG_LINE_STR_SECTION ".debug_line_str"
3848 #ifndef DEBUG_LTO_LINE_STR_SECTION
3849 #define DEBUG_LTO_LINE_STR_SECTION ".gnu.debuglto_.debug_line_str"
3852 /* Standard ELF section names for compiled code and data. */
3853 #ifndef TEXT_SECTION_NAME
3854 #define TEXT_SECTION_NAME ".text"
3857 /* Section flags for .debug_str section. */
3858 #define DEBUG_STR_SECTION_FLAGS \
3859 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
3860 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3863 /* Section flags for .debug_str.dwo section. */
3864 #define DEBUG_STR_DWO_SECTION_FLAGS (SECTION_DEBUG | SECTION_EXCLUDE)
3866 /* Attribute used to refer to the macro section. */
3867 #define DEBUG_MACRO_ATTRIBUTE (dwarf_version >= 5 ? DW_AT_macros \
3868 : dwarf_strict ? DW_AT_macro_info : DW_AT_GNU_macros)
3870 /* Labels we insert at beginning sections we can reference instead of
3871 the section names themselves. */
3873 #ifndef TEXT_SECTION_LABEL
3874 #define TEXT_SECTION_LABEL "Ltext"
3876 #ifndef COLD_TEXT_SECTION_LABEL
3877 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
3879 #ifndef DEBUG_LINE_SECTION_LABEL
3880 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3882 #ifndef DEBUG_SKELETON_LINE_SECTION_LABEL
3883 #define DEBUG_SKELETON_LINE_SECTION_LABEL "Lskeleton_debug_line"
3885 #ifndef DEBUG_INFO_SECTION_LABEL
3886 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3888 #ifndef DEBUG_SKELETON_INFO_SECTION_LABEL
3889 #define DEBUG_SKELETON_INFO_SECTION_LABEL "Lskeleton_debug_info"
3891 #ifndef DEBUG_ABBREV_SECTION_LABEL
3892 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3894 #ifndef DEBUG_SKELETON_ABBREV_SECTION_LABEL
3895 #define DEBUG_SKELETON_ABBREV_SECTION_LABEL "Lskeleton_debug_abbrev"
3897 #ifndef DEBUG_ADDR_SECTION_LABEL
3898 #define DEBUG_ADDR_SECTION_LABEL "Ldebug_addr"
3900 #ifndef DEBUG_LOC_SECTION_LABEL
3901 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3903 #ifndef DEBUG_RANGES_SECTION_LABEL
3904 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3906 #ifndef DEBUG_MACINFO_SECTION_LABEL
3907 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3909 #ifndef DEBUG_MACRO_SECTION_LABEL
3910 #define DEBUG_MACRO_SECTION_LABEL "Ldebug_macro"
3912 #define SKELETON_COMP_DIE_ABBREV 1
3913 #define SKELETON_TYPE_DIE_ABBREV 2
3915 /* Definitions of defaults for formats and names of various special
3916 (artificial) labels which may be generated within this file (when the -g
3917 options is used and DWARF2_DEBUGGING_INFO is in effect.
3918 If necessary, these may be overridden from within the tm.h file, but
3919 typically, overriding these defaults is unnecessary. */
3921 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3922 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3923 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3924 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3925 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3926 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3927 static char debug_skeleton_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3928 static char debug_skeleton_abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3929 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3930 static char debug_addr_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3931 static char debug_skeleton_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3932 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3933 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3934 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
3935 static char ranges_base_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
3937 #ifndef TEXT_END_LABEL
3938 #define TEXT_END_LABEL "Letext"
3940 #ifndef COLD_END_LABEL
3941 #define COLD_END_LABEL "Letext_cold"
3943 #ifndef BLOCK_BEGIN_LABEL
3944 #define BLOCK_BEGIN_LABEL "LBB"
3946 #ifndef BLOCK_END_LABEL
3947 #define BLOCK_END_LABEL "LBE"
3949 #ifndef LINE_CODE_LABEL
3950 #define LINE_CODE_LABEL "LM"
3954 /* Return the root of the DIE's built for the current compilation unit. */
3956 comp_unit_die (void)
3958 if (!single_comp_unit_die
)
3959 single_comp_unit_die
= gen_compile_unit_die (NULL
);
3960 return single_comp_unit_die
;
3963 /* We allow a language front-end to designate a function that is to be
3964 called to "demangle" any name before it is put into a DIE. */
3966 static const char *(*demangle_name_func
) (const char *);
3969 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
3971 demangle_name_func
= func
;
3974 /* Test if rtl node points to a pseudo register. */
3977 is_pseudo_reg (const_rtx rtl
)
3979 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
3980 || (GET_CODE (rtl
) == SUBREG
3981 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
3984 /* Return a reference to a type, with its const and volatile qualifiers
3988 type_main_variant (tree type
)
3990 type
= TYPE_MAIN_VARIANT (type
);
3992 /* ??? There really should be only one main variant among any group of
3993 variants of a given type (and all of the MAIN_VARIANT values for all
3994 members of the group should point to that one type) but sometimes the C
3995 front-end messes this up for array types, so we work around that bug
3997 if (TREE_CODE (type
) == ARRAY_TYPE
)
3998 while (type
!= TYPE_MAIN_VARIANT (type
))
3999 type
= TYPE_MAIN_VARIANT (type
);
4004 /* Return nonzero if the given type node represents a tagged type. */
4007 is_tagged_type (const_tree type
)
4009 enum tree_code code
= TREE_CODE (type
);
4011 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
4012 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
4015 /* Set label to debug_info_section_label + die_offset of a DIE reference. */
4018 get_ref_die_offset_label (char *label
, dw_die_ref ref
)
4020 sprintf (label
, "%s+%ld", debug_info_section_label
, ref
->die_offset
);
4023 /* Return die_offset of a DIE reference to a base type. */
4025 static unsigned long int
4026 get_base_type_offset (dw_die_ref ref
)
4028 if (ref
->die_offset
)
4029 return ref
->die_offset
;
4030 if (comp_unit_die ()->die_abbrev
)
4032 calc_base_type_die_sizes ();
4033 gcc_assert (ref
->die_offset
);
4035 return ref
->die_offset
;
4038 /* Return die_offset of a DIE reference other than base type. */
4040 static unsigned long int
4041 get_ref_die_offset (dw_die_ref ref
)
4043 gcc_assert (ref
->die_offset
);
4044 return ref
->die_offset
;
4047 /* Convert a DIE tag into its string name. */
4050 dwarf_tag_name (unsigned int tag
)
4052 const char *name
= get_DW_TAG_name (tag
);
4057 return "DW_TAG_<unknown>";
4060 /* Convert a DWARF attribute code into its string name. */
4063 dwarf_attr_name (unsigned int attr
)
4069 #if VMS_DEBUGGING_INFO
4070 case DW_AT_HP_prologue
:
4071 return "DW_AT_HP_prologue";
4073 case DW_AT_MIPS_loop_unroll_factor
:
4074 return "DW_AT_MIPS_loop_unroll_factor";
4077 #if VMS_DEBUGGING_INFO
4078 case DW_AT_HP_epilogue
:
4079 return "DW_AT_HP_epilogue";
4081 case DW_AT_MIPS_stride
:
4082 return "DW_AT_MIPS_stride";
4086 name
= get_DW_AT_name (attr
);
4091 return "DW_AT_<unknown>";
4094 /* Convert a DWARF value form code into its string name. */
4097 dwarf_form_name (unsigned int form
)
4099 const char *name
= get_DW_FORM_name (form
);
4104 return "DW_FORM_<unknown>";
4107 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4108 instance of an inlined instance of a decl which is local to an inline
4109 function, so we have to trace all of the way back through the origin chain
4110 to find out what sort of node actually served as the original seed for the
4114 decl_ultimate_origin (const_tree decl
)
4116 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
4119 /* DECL_ABSTRACT_ORIGIN can point to itself; ignore that if
4120 we're trying to output the abstract instance of this function. */
4121 if (DECL_ABSTRACT_P (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
4124 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4125 most distant ancestor, this should never happen. */
4126 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
4128 return DECL_ABSTRACT_ORIGIN (decl
);
4131 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4132 of a virtual function may refer to a base class, so we check the 'this'
4136 decl_class_context (tree decl
)
4138 tree context
= NULL_TREE
;
4140 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
4141 context
= DECL_CONTEXT (decl
);
4143 context
= TYPE_MAIN_VARIANT
4144 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
4146 if (context
&& !TYPE_P (context
))
4147 context
= NULL_TREE
;
4152 /* Add an attribute/value pair to a DIE. */
4155 add_dwarf_attr (dw_die_ref die
, dw_attr_node
*attr
)
4157 /* Maybe this should be an assert? */
4163 /* Check we do not add duplicate attrs. Can't use get_AT here
4164 because that recurses to the specification/abstract origin DIE. */
4167 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
4168 gcc_assert (a
->dw_attr
!= attr
->dw_attr
);
4171 vec_safe_reserve (die
->die_attr
, 1);
4172 vec_safe_push (die
->die_attr
, *attr
);
4175 static inline enum dw_val_class
4176 AT_class (dw_attr_node
*a
)
4178 return a
->dw_attr_val
.val_class
;
4181 /* Return the index for any attribute that will be referenced with a
4182 DW_FORM_GNU_addr_index or DW_FORM_GNU_str_index. String indices
4183 are stored in dw_attr_val.v.val_str for reference counting
4186 static inline unsigned int
4187 AT_index (dw_attr_node
*a
)
4189 if (AT_class (a
) == dw_val_class_str
)
4190 return a
->dw_attr_val
.v
.val_str
->index
;
4191 else if (a
->dw_attr_val
.val_entry
!= NULL
)
4192 return a
->dw_attr_val
.val_entry
->index
;
4196 /* Add a flag value attribute to a DIE. */
4199 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
4203 attr
.dw_attr
= attr_kind
;
4204 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
4205 attr
.dw_attr_val
.val_entry
= NULL
;
4206 attr
.dw_attr_val
.v
.val_flag
= flag
;
4207 add_dwarf_attr (die
, &attr
);
4210 static inline unsigned
4211 AT_flag (dw_attr_node
*a
)
4213 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
4214 return a
->dw_attr_val
.v
.val_flag
;
4217 /* Add a signed integer attribute value to a DIE. */
4220 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
4224 attr
.dw_attr
= attr_kind
;
4225 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
4226 attr
.dw_attr_val
.val_entry
= NULL
;
4227 attr
.dw_attr_val
.v
.val_int
= int_val
;
4228 add_dwarf_attr (die
, &attr
);
4231 static inline HOST_WIDE_INT
4232 AT_int (dw_attr_node
*a
)
4234 gcc_assert (a
&& (AT_class (a
) == dw_val_class_const
4235 || AT_class (a
) == dw_val_class_const_implicit
));
4236 return a
->dw_attr_val
.v
.val_int
;
4239 /* Add an unsigned integer attribute value to a DIE. */
4242 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4243 unsigned HOST_WIDE_INT unsigned_val
)
4247 attr
.dw_attr
= attr_kind
;
4248 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
4249 attr
.dw_attr_val
.val_entry
= NULL
;
4250 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
4251 add_dwarf_attr (die
, &attr
);
4254 static inline unsigned HOST_WIDE_INT
4255 AT_unsigned (dw_attr_node
*a
)
4257 gcc_assert (a
&& (AT_class (a
) == dw_val_class_unsigned_const
4258 || AT_class (a
) == dw_val_class_unsigned_const_implicit
));
4259 return a
->dw_attr_val
.v
.val_unsigned
;
4262 /* Add an unsigned wide integer attribute value to a DIE. */
4265 add_AT_wide (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4270 attr
.dw_attr
= attr_kind
;
4271 attr
.dw_attr_val
.val_class
= dw_val_class_wide_int
;
4272 attr
.dw_attr_val
.val_entry
= NULL
;
4273 attr
.dw_attr_val
.v
.val_wide
= ggc_alloc
<wide_int
> ();
4274 *attr
.dw_attr_val
.v
.val_wide
= w
;
4275 add_dwarf_attr (die
, &attr
);
4278 /* Add an unsigned double integer attribute value to a DIE. */
4281 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4282 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
4286 attr
.dw_attr
= attr_kind
;
4287 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
4288 attr
.dw_attr_val
.val_entry
= NULL
;
4289 attr
.dw_attr_val
.v
.val_double
.high
= high
;
4290 attr
.dw_attr_val
.v
.val_double
.low
= low
;
4291 add_dwarf_attr (die
, &attr
);
4294 /* Add a floating point attribute value to a DIE and return it. */
4297 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4298 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
4302 attr
.dw_attr
= attr_kind
;
4303 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
4304 attr
.dw_attr_val
.val_entry
= NULL
;
4305 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
4306 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
4307 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
4308 add_dwarf_attr (die
, &attr
);
4311 /* Add an 8-byte data attribute value to a DIE. */
4314 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4315 unsigned char data8
[8])
4319 attr
.dw_attr
= attr_kind
;
4320 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
4321 attr
.dw_attr_val
.val_entry
= NULL
;
4322 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
4323 add_dwarf_attr (die
, &attr
);
4326 /* Add DW_AT_low_pc and DW_AT_high_pc to a DIE. When using
4327 dwarf_split_debug_info, address attributes in dies destined for the
4328 final executable have force_direct set to avoid using indexed
4332 add_AT_low_high_pc (dw_die_ref die
, const char *lbl_low
, const char *lbl_high
,
4338 lbl_id
= xstrdup (lbl_low
);
4339 attr
.dw_attr
= DW_AT_low_pc
;
4340 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4341 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4342 if (dwarf_split_debug_info
&& !force_direct
)
4343 attr
.dw_attr_val
.val_entry
4344 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4346 attr
.dw_attr_val
.val_entry
= NULL
;
4347 add_dwarf_attr (die
, &attr
);
4349 attr
.dw_attr
= DW_AT_high_pc
;
4350 if (dwarf_version
< 4)
4351 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4353 attr
.dw_attr_val
.val_class
= dw_val_class_high_pc
;
4354 lbl_id
= xstrdup (lbl_high
);
4355 attr
.dw_attr_val
.v
.val_lbl_id
= lbl_id
;
4356 if (attr
.dw_attr_val
.val_class
== dw_val_class_lbl_id
4357 && dwarf_split_debug_info
&& !force_direct
)
4358 attr
.dw_attr_val
.val_entry
4359 = add_addr_table_entry (lbl_id
, ate_kind_label
);
4361 attr
.dw_attr_val
.val_entry
= NULL
;
4362 add_dwarf_attr (die
, &attr
);
4365 /* Hash and equality functions for debug_str_hash. */
4368 indirect_string_hasher::hash (indirect_string_node
*x
)
4370 return htab_hash_string (x
->str
);
4374 indirect_string_hasher::equal (indirect_string_node
*x1
, const char *x2
)
4376 return strcmp (x1
->str
, x2
) == 0;
4379 /* Add STR to the given string hash table. */
4381 static struct indirect_string_node
*
4382 find_AT_string_in_table (const char *str
,
4383 hash_table
<indirect_string_hasher
> *table
)
4385 struct indirect_string_node
*node
;
4387 indirect_string_node
**slot
4388 = table
->find_slot_with_hash (str
, htab_hash_string (str
), INSERT
);
4391 node
= ggc_cleared_alloc
<indirect_string_node
> ();
4392 node
->str
= ggc_strdup (str
);
4402 /* Add STR to the indirect string hash table. */
4404 static struct indirect_string_node
*
4405 find_AT_string (const char *str
)
4407 if (! debug_str_hash
)
4408 debug_str_hash
= hash_table
<indirect_string_hasher
>::create_ggc (10);
4410 return find_AT_string_in_table (str
, debug_str_hash
);
4413 /* Add a string attribute value to a DIE. */
4416 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
4419 struct indirect_string_node
*node
;
4421 node
= find_AT_string (str
);
4423 attr
.dw_attr
= attr_kind
;
4424 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
4425 attr
.dw_attr_val
.val_entry
= NULL
;
4426 attr
.dw_attr_val
.v
.val_str
= node
;
4427 add_dwarf_attr (die
, &attr
);
4430 static inline const char *
4431 AT_string (dw_attr_node
*a
)
4433 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4434 return a
->dw_attr_val
.v
.val_str
->str
;
4437 /* Call this function directly to bypass AT_string_form's logic to put
4438 the string inline in the die. */
4441 set_indirect_string (struct indirect_string_node
*node
)
4443 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4444 /* Already indirect is a no op. */
4445 if (node
->form
== DW_FORM_strp
4446 || node
->form
== DW_FORM_line_strp
4447 || node
->form
== DW_FORM_GNU_str_index
)
4449 gcc_assert (node
->label
);
4452 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4453 ++dw2_string_counter
;
4454 node
->label
= xstrdup (label
);
4456 if (!dwarf_split_debug_info
)
4458 node
->form
= DW_FORM_strp
;
4459 node
->index
= NOT_INDEXED
;
4463 node
->form
= DW_FORM_GNU_str_index
;
4464 node
->index
= NO_INDEX_ASSIGNED
;
4468 /* A helper function for dwarf2out_finish, called to reset indirect
4469 string decisions done for early LTO dwarf output before fat object
4473 reset_indirect_string (indirect_string_node
**h
, void *)
4475 struct indirect_string_node
*node
= *h
;
4476 if (node
->form
== DW_FORM_strp
|| node
->form
== DW_FORM_GNU_str_index
)
4480 node
->form
= (dwarf_form
) 0;
4486 /* Find out whether a string should be output inline in DIE
4487 or out-of-line in .debug_str section. */
4489 static enum dwarf_form
4490 find_string_form (struct indirect_string_node
*node
)
4497 len
= strlen (node
->str
) + 1;
4499 /* If the string is shorter or equal to the size of the reference, it is
4500 always better to put it inline. */
4501 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
4502 return node
->form
= DW_FORM_string
;
4504 /* If we cannot expect the linker to merge strings in .debug_str
4505 section, only put it into .debug_str if it is worth even in this
4507 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
4508 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
4509 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
))
4510 return node
->form
= DW_FORM_string
;
4512 set_indirect_string (node
);
4517 /* Find out whether the string referenced from the attribute should be
4518 output inline in DIE or out-of-line in .debug_str section. */
4520 static enum dwarf_form
4521 AT_string_form (dw_attr_node
*a
)
4523 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4524 return find_string_form (a
->dw_attr_val
.v
.val_str
);
4527 /* Add a DIE reference attribute value to a DIE. */
4530 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4533 gcc_checking_assert (targ_die
!= NULL
);
4535 /* With LTO we can end up trying to reference something we didn't create
4536 a DIE for. Avoid crashing later on a NULL referenced DIE. */
4537 if (targ_die
== NULL
)
4540 attr
.dw_attr
= attr_kind
;
4541 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
4542 attr
.dw_attr_val
.val_entry
= NULL
;
4543 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4544 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
4545 add_dwarf_attr (die
, &attr
);
4548 /* Change DIE reference REF to point to NEW_DIE instead. */
4551 change_AT_die_ref (dw_attr_node
*ref
, dw_die_ref new_die
)
4553 gcc_assert (ref
->dw_attr_val
.val_class
== dw_val_class_die_ref
);
4554 ref
->dw_attr_val
.v
.val_die_ref
.die
= new_die
;
4555 ref
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4558 /* Add an AT_specification attribute to a DIE, and also make the back
4559 pointer from the specification to the definition. */
4562 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4564 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4565 gcc_assert (!targ_die
->die_definition
);
4566 targ_die
->die_definition
= die
;
4569 static inline dw_die_ref
4570 AT_ref (dw_attr_node
*a
)
4572 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4573 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4577 AT_ref_external (dw_attr_node
*a
)
4579 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4580 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4586 set_AT_ref_external (dw_attr_node
*a
, int i
)
4588 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4589 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4592 /* Add an FDE reference attribute value to a DIE. */
4595 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
4599 attr
.dw_attr
= attr_kind
;
4600 attr
.dw_attr_val
.val_class
= dw_val_class_fde_ref
;
4601 attr
.dw_attr_val
.val_entry
= NULL
;
4602 attr
.dw_attr_val
.v
.val_fde_index
= targ_fde
;
4603 add_dwarf_attr (die
, &attr
);
4606 /* Add a location description attribute value to a DIE. */
4609 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4613 attr
.dw_attr
= attr_kind
;
4614 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
4615 attr
.dw_attr_val
.val_entry
= NULL
;
4616 attr
.dw_attr_val
.v
.val_loc
= loc
;
4617 add_dwarf_attr (die
, &attr
);
4620 static inline dw_loc_descr_ref
4621 AT_loc (dw_attr_node
*a
)
4623 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4624 return a
->dw_attr_val
.v
.val_loc
;
4628 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4632 if (XCOFF_DEBUGGING_INFO
&& !HAVE_XCOFF_DWARF_EXTRAS
)
4635 attr
.dw_attr
= attr_kind
;
4636 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
4637 attr
.dw_attr_val
.val_entry
= NULL
;
4638 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
4639 add_dwarf_attr (die
, &attr
);
4640 have_location_lists
= true;
4643 static inline dw_loc_list_ref
4644 AT_loc_list (dw_attr_node
*a
)
4646 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4647 return a
->dw_attr_val
.v
.val_loc_list
;
4650 static inline dw_loc_list_ref
*
4651 AT_loc_list_ptr (dw_attr_node
*a
)
4653 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4654 return &a
->dw_attr_val
.v
.val_loc_list
;
4657 struct addr_hasher
: ggc_ptr_hash
<addr_table_entry
>
4659 static hashval_t
hash (addr_table_entry
*);
4660 static bool equal (addr_table_entry
*, addr_table_entry
*);
4663 /* Table of entries into the .debug_addr section. */
4665 static GTY (()) hash_table
<addr_hasher
> *addr_index_table
;
4667 /* Hash an address_table_entry. */
4670 addr_hasher::hash (addr_table_entry
*a
)
4672 inchash::hash hstate
;
4678 case ate_kind_rtx_dtprel
:
4681 case ate_kind_label
:
4682 return htab_hash_string (a
->addr
.label
);
4686 inchash::add_rtx (a
->addr
.rtl
, hstate
);
4687 return hstate
.end ();
4690 /* Determine equality for two address_table_entries. */
4693 addr_hasher::equal (addr_table_entry
*a1
, addr_table_entry
*a2
)
4695 if (a1
->kind
!= a2
->kind
)
4700 case ate_kind_rtx_dtprel
:
4701 return rtx_equal_p (a1
->addr
.rtl
, a2
->addr
.rtl
);
4702 case ate_kind_label
:
4703 return strcmp (a1
->addr
.label
, a2
->addr
.label
) == 0;
4709 /* Initialize an addr_table_entry. */
4712 init_addr_table_entry (addr_table_entry
*e
, enum ate_kind kind
, void *addr
)
4718 case ate_kind_rtx_dtprel
:
4719 e
->addr
.rtl
= (rtx
) addr
;
4721 case ate_kind_label
:
4722 e
->addr
.label
= (char *) addr
;
4726 e
->index
= NO_INDEX_ASSIGNED
;
4729 /* Add attr to the address table entry to the table. Defer setting an
4730 index until output time. */
4732 static addr_table_entry
*
4733 add_addr_table_entry (void *addr
, enum ate_kind kind
)
4735 addr_table_entry
*node
;
4736 addr_table_entry finder
;
4738 gcc_assert (dwarf_split_debug_info
);
4739 if (! addr_index_table
)
4740 addr_index_table
= hash_table
<addr_hasher
>::create_ggc (10);
4741 init_addr_table_entry (&finder
, kind
, addr
);
4742 addr_table_entry
**slot
= addr_index_table
->find_slot (&finder
, INSERT
);
4744 if (*slot
== HTAB_EMPTY_ENTRY
)
4746 node
= ggc_cleared_alloc
<addr_table_entry
> ();
4747 init_addr_table_entry (node
, kind
, addr
);
4757 /* Remove an entry from the addr table by decrementing its refcount.
4758 Strictly, decrementing the refcount would be enough, but the
4759 assertion that the entry is actually in the table has found
4763 remove_addr_table_entry (addr_table_entry
*entry
)
4765 gcc_assert (dwarf_split_debug_info
&& addr_index_table
);
4766 /* After an index is assigned, the table is frozen. */
4767 gcc_assert (entry
->refcount
> 0 && entry
->index
== NO_INDEX_ASSIGNED
);
4771 /* Given a location list, remove all addresses it refers to from the
4775 remove_loc_list_addr_table_entries (dw_loc_descr_ref descr
)
4777 for (; descr
; descr
= descr
->dw_loc_next
)
4778 if (descr
->dw_loc_oprnd1
.val_entry
!= NULL
)
4780 gcc_assert (descr
->dw_loc_oprnd1
.val_entry
->index
== NO_INDEX_ASSIGNED
);
4781 remove_addr_table_entry (descr
->dw_loc_oprnd1
.val_entry
);
4785 /* A helper function for dwarf2out_finish called through
4786 htab_traverse. Assign an addr_table_entry its index. All entries
4787 must be collected into the table when this function is called,
4788 because the indexing code relies on htab_traverse to traverse nodes
4789 in the same order for each run. */
4792 index_addr_table_entry (addr_table_entry
**h
, unsigned int *index
)
4794 addr_table_entry
*node
= *h
;
4796 /* Don't index unreferenced nodes. */
4797 if (node
->refcount
== 0)
4800 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
4801 node
->index
= *index
;
4807 /* Add an address constant attribute value to a DIE. When using
4808 dwarf_split_debug_info, address attributes in dies destined for the
4809 final executable should be direct references--setting the parameter
4810 force_direct ensures this behavior. */
4813 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
,
4818 attr
.dw_attr
= attr_kind
;
4819 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
4820 attr
.dw_attr_val
.v
.val_addr
= addr
;
4821 if (dwarf_split_debug_info
&& !force_direct
)
4822 attr
.dw_attr_val
.val_entry
= add_addr_table_entry (addr
, ate_kind_rtx
);
4824 attr
.dw_attr_val
.val_entry
= NULL
;
4825 add_dwarf_attr (die
, &attr
);
4828 /* Get the RTX from to an address DIE attribute. */
4831 AT_addr (dw_attr_node
*a
)
4833 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
4834 return a
->dw_attr_val
.v
.val_addr
;
4837 /* Add a file attribute value to a DIE. */
4840 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4841 struct dwarf_file_data
*fd
)
4845 attr
.dw_attr
= attr_kind
;
4846 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
4847 attr
.dw_attr_val
.val_entry
= NULL
;
4848 attr
.dw_attr_val
.v
.val_file
= fd
;
4849 add_dwarf_attr (die
, &attr
);
4852 /* Get the dwarf_file_data from a file DIE attribute. */
4854 static inline struct dwarf_file_data
*
4855 AT_file (dw_attr_node
*a
)
4857 gcc_assert (a
&& (AT_class (a
) == dw_val_class_file
4858 || AT_class (a
) == dw_val_class_file_implicit
));
4859 return a
->dw_attr_val
.v
.val_file
;
4862 /* Add a vms delta attribute value to a DIE. */
4865 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4866 const char *lbl1
, const char *lbl2
)
4870 attr
.dw_attr
= attr_kind
;
4871 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
4872 attr
.dw_attr_val
.val_entry
= NULL
;
4873 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
4874 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
4875 add_dwarf_attr (die
, &attr
);
4878 /* Add a label identifier attribute value to a DIE. */
4881 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4886 attr
.dw_attr
= attr_kind
;
4887 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4888 attr
.dw_attr_val
.val_entry
= NULL
;
4889 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
4890 if (dwarf_split_debug_info
)
4891 attr
.dw_attr_val
.val_entry
4892 = add_addr_table_entry (attr
.dw_attr_val
.v
.val_lbl_id
,
4894 add_dwarf_attr (die
, &attr
);
4897 /* Add a section offset attribute value to a DIE, an offset into the
4898 debug_line section. */
4901 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4906 attr
.dw_attr
= attr_kind
;
4907 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
4908 attr
.dw_attr_val
.val_entry
= NULL
;
4909 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4910 add_dwarf_attr (die
, &attr
);
4913 /* Add a section offset attribute value to a DIE, an offset into the
4914 debug_loclists section. */
4917 add_AT_loclistsptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4922 attr
.dw_attr
= attr_kind
;
4923 attr
.dw_attr_val
.val_class
= dw_val_class_loclistsptr
;
4924 attr
.dw_attr_val
.val_entry
= NULL
;
4925 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4926 add_dwarf_attr (die
, &attr
);
4929 /* Add a section offset attribute value to a DIE, an offset into the
4930 debug_macinfo section. */
4933 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4938 attr
.dw_attr
= attr_kind
;
4939 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
4940 attr
.dw_attr_val
.val_entry
= NULL
;
4941 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4942 add_dwarf_attr (die
, &attr
);
4945 /* Add an offset attribute value to a DIE. */
4948 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4949 unsigned HOST_WIDE_INT offset
)
4953 attr
.dw_attr
= attr_kind
;
4954 attr
.dw_attr_val
.val_class
= dw_val_class_offset
;
4955 attr
.dw_attr_val
.val_entry
= NULL
;
4956 attr
.dw_attr_val
.v
.val_offset
= offset
;
4957 add_dwarf_attr (die
, &attr
);
4960 /* Add a range_list attribute value to a DIE. When using
4961 dwarf_split_debug_info, address attributes in dies destined for the
4962 final executable should be direct references--setting the parameter
4963 force_direct ensures this behavior. */
4965 #define UNRELOCATED_OFFSET ((addr_table_entry *) 1)
4966 #define RELOCATED_OFFSET (NULL)
4969 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4970 long unsigned int offset
, bool force_direct
)
4974 attr
.dw_attr
= attr_kind
;
4975 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
4976 /* For the range_list attribute, use val_entry to store whether the
4977 offset should follow split-debug-info or normal semantics. This
4978 value is read in output_range_list_offset. */
4979 if (dwarf_split_debug_info
&& !force_direct
)
4980 attr
.dw_attr_val
.val_entry
= UNRELOCATED_OFFSET
;
4982 attr
.dw_attr_val
.val_entry
= RELOCATED_OFFSET
;
4983 attr
.dw_attr_val
.v
.val_offset
= offset
;
4984 add_dwarf_attr (die
, &attr
);
4987 /* Return the start label of a delta attribute. */
4989 static inline const char *
4990 AT_vms_delta1 (dw_attr_node
*a
)
4992 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
4993 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
4996 /* Return the end label of a delta attribute. */
4998 static inline const char *
4999 AT_vms_delta2 (dw_attr_node
*a
)
5001 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
5002 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
5005 static inline const char *
5006 AT_lbl (dw_attr_node
*a
)
5008 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
5009 || AT_class (a
) == dw_val_class_lineptr
5010 || AT_class (a
) == dw_val_class_macptr
5011 || AT_class (a
) == dw_val_class_loclistsptr
5012 || AT_class (a
) == dw_val_class_high_pc
));
5013 return a
->dw_attr_val
.v
.val_lbl_id
;
5016 /* Get the attribute of type attr_kind. */
5018 static dw_attr_node
*
5019 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5023 dw_die_ref spec
= NULL
;
5028 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5029 if (a
->dw_attr
== attr_kind
)
5031 else if (a
->dw_attr
== DW_AT_specification
5032 || a
->dw_attr
== DW_AT_abstract_origin
)
5036 return get_AT (spec
, attr_kind
);
5041 /* Returns the parent of the declaration of DIE. */
5044 get_die_parent (dw_die_ref die
)
5051 if ((t
= get_AT_ref (die
, DW_AT_abstract_origin
))
5052 || (t
= get_AT_ref (die
, DW_AT_specification
)))
5055 return die
->die_parent
;
5058 /* Return the "low pc" attribute value, typically associated with a subprogram
5059 DIE. Return null if the "low pc" attribute is either not present, or if it
5060 cannot be represented as an assembler label identifier. */
5062 static inline const char *
5063 get_AT_low_pc (dw_die_ref die
)
5065 dw_attr_node
*a
= get_AT (die
, DW_AT_low_pc
);
5067 return a
? AT_lbl (a
) : NULL
;
5070 /* Return the "high pc" attribute value, typically associated with a subprogram
5071 DIE. Return null if the "high pc" attribute is either not present, or if it
5072 cannot be represented as an assembler label identifier. */
5074 static inline const char *
5075 get_AT_hi_pc (dw_die_ref die
)
5077 dw_attr_node
*a
= get_AT (die
, DW_AT_high_pc
);
5079 return a
? AT_lbl (a
) : NULL
;
5082 /* Return the value of the string attribute designated by ATTR_KIND, or
5083 NULL if it is not present. */
5085 static inline const char *
5086 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5088 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5090 return a
? AT_string (a
) : NULL
;
5093 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5094 if it is not present. */
5097 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5099 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5101 return a
? AT_flag (a
) : 0;
5104 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5105 if it is not present. */
5107 static inline unsigned
5108 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5110 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5112 return a
? AT_unsigned (a
) : 0;
5115 static inline dw_die_ref
5116 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5118 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5120 return a
? AT_ref (a
) : NULL
;
5123 static inline struct dwarf_file_data
*
5124 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5126 dw_attr_node
*a
= get_AT (die
, attr_kind
);
5128 return a
? AT_file (a
) : NULL
;
5131 /* Return TRUE if the language is C++. */
5136 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5138 return (lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
5139 || lang
== DW_LANG_C_plus_plus_11
|| lang
== DW_LANG_C_plus_plus_14
);
5142 /* Return TRUE if DECL was created by the C++ frontend. */
5145 is_cxx (const_tree decl
)
5149 const_tree context
= get_ultimate_context (decl
);
5150 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5151 return strncmp (TRANSLATION_UNIT_LANGUAGE (context
), "GNU C++", 7) == 0;
5156 /* Return TRUE if the language is Fortran. */
5161 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5163 return (lang
== DW_LANG_Fortran77
5164 || lang
== DW_LANG_Fortran90
5165 || lang
== DW_LANG_Fortran95
5166 || lang
== DW_LANG_Fortran03
5167 || lang
== DW_LANG_Fortran08
);
5171 is_fortran (const_tree decl
)
5175 const_tree context
= get_ultimate_context (decl
);
5176 if (context
&& TRANSLATION_UNIT_LANGUAGE (context
))
5177 return (strncmp (TRANSLATION_UNIT_LANGUAGE (context
),
5178 "GNU Fortran", 11) == 0
5179 || strcmp (TRANSLATION_UNIT_LANGUAGE (context
),
5182 return is_fortran ();
5185 /* Return TRUE if the language is Ada. */
5190 unsigned int lang
= get_AT_unsigned (comp_unit_die (), DW_AT_language
);
5192 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
5195 /* Remove the specified attribute if present. Return TRUE if removal
5199 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5207 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
5208 if (a
->dw_attr
== attr_kind
)
5210 if (AT_class (a
) == dw_val_class_str
)
5211 if (a
->dw_attr_val
.v
.val_str
->refcount
)
5212 a
->dw_attr_val
.v
.val_str
->refcount
--;
5214 /* vec::ordered_remove should help reduce the number of abbrevs
5216 die
->die_attr
->ordered_remove (ix
);
5222 /* Remove CHILD from its parent. PREV must have the property that
5223 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
5226 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
5228 gcc_assert (child
->die_parent
== prev
->die_parent
);
5229 gcc_assert (prev
->die_sib
== child
);
5232 gcc_assert (child
->die_parent
->die_child
== child
);
5236 prev
->die_sib
= child
->die_sib
;
5237 if (child
->die_parent
->die_child
== child
)
5238 child
->die_parent
->die_child
= prev
;
5239 child
->die_sib
= NULL
;
5242 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
5243 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
5246 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
5248 dw_die_ref parent
= old_child
->die_parent
;
5250 gcc_assert (parent
== prev
->die_parent
);
5251 gcc_assert (prev
->die_sib
== old_child
);
5253 new_child
->die_parent
= parent
;
5254 if (prev
== old_child
)
5256 gcc_assert (parent
->die_child
== old_child
);
5257 new_child
->die_sib
= new_child
;
5261 prev
->die_sib
= new_child
;
5262 new_child
->die_sib
= old_child
->die_sib
;
5264 if (old_child
->die_parent
->die_child
== old_child
)
5265 old_child
->die_parent
->die_child
= new_child
;
5266 old_child
->die_sib
= NULL
;
5269 /* Move all children from OLD_PARENT to NEW_PARENT. */
5272 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
5275 new_parent
->die_child
= old_parent
->die_child
;
5276 old_parent
->die_child
= NULL
;
5277 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
5280 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
5284 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
5290 dw_die_ref prev
= c
;
5292 while (c
->die_tag
== tag
)
5294 remove_child_with_prev (c
, prev
);
5295 c
->die_parent
= NULL
;
5296 /* Might have removed every child. */
5297 if (die
->die_child
== NULL
)
5301 } while (c
!= die
->die_child
);
5304 /* Add a CHILD_DIE as the last child of DIE. */
5307 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
5309 /* FIXME this should probably be an assert. */
5310 if (! die
|| ! child_die
)
5312 gcc_assert (die
!= child_die
);
5314 child_die
->die_parent
= die
;
5317 child_die
->die_sib
= die
->die_child
->die_sib
;
5318 die
->die_child
->die_sib
= child_die
;
5321 child_die
->die_sib
= child_die
;
5322 die
->die_child
= child_die
;
5325 /* Like add_child_die, but put CHILD_DIE after AFTER_DIE. */
5328 add_child_die_after (dw_die_ref die
, dw_die_ref child_die
,
5329 dw_die_ref after_die
)
5335 && die
!= child_die
);
5337 child_die
->die_parent
= die
;
5338 child_die
->die_sib
= after_die
->die_sib
;
5339 after_die
->die_sib
= child_die
;
5340 if (die
->die_child
== after_die
)
5341 die
->die_child
= child_die
;
5344 /* Unassociate CHILD from its parent, and make its parent be
5348 reparent_child (dw_die_ref child
, dw_die_ref new_parent
)
5350 for (dw_die_ref p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
5351 if (p
->die_sib
== child
)
5353 remove_child_with_prev (child
, p
);
5356 add_child_die (new_parent
, child
);
5359 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5360 is the specification, to the end of PARENT's list of children.
5361 This is done by removing and re-adding it. */
5364 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
5366 /* We want the declaration DIE from inside the class, not the
5367 specification DIE at toplevel. */
5368 if (child
->die_parent
!= parent
)
5370 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5376 gcc_assert (child
->die_parent
== parent
5377 || (child
->die_parent
5378 == get_AT_ref (parent
, DW_AT_specification
)));
5380 reparent_child (child
, parent
);
5383 /* Create and return a new die with TAG_VALUE as tag. */
5385 static inline dw_die_ref
5386 new_die_raw (enum dwarf_tag tag_value
)
5388 dw_die_ref die
= ggc_cleared_alloc
<die_node
> ();
5389 die
->die_tag
= tag_value
;
5393 /* Create and return a new die with a parent of PARENT_DIE. If
5394 PARENT_DIE is NULL, the new DIE is placed in limbo and an
5395 associated tree T must be supplied to determine parenthood
5398 static inline dw_die_ref
5399 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5401 dw_die_ref die
= new_die_raw (tag_value
);
5403 if (parent_die
!= NULL
)
5404 add_child_die (parent_die
, die
);
5407 limbo_die_node
*limbo_node
;
5409 /* No DIEs created after early dwarf should end up in limbo,
5410 because the limbo list should not persist past LTO
5412 if (tag_value
!= DW_TAG_compile_unit
5413 /* These are allowed because they're generated while
5414 breaking out COMDAT units late. */
5415 && tag_value
!= DW_TAG_type_unit
5416 && tag_value
!= DW_TAG_skeleton_unit
5418 /* Allow nested functions to live in limbo because they will
5419 only temporarily live there, as decls_for_scope will fix
5421 && (TREE_CODE (t
) != FUNCTION_DECL
5422 || !decl_function_context (t
))
5423 /* Same as nested functions above but for types. Types that
5424 are local to a function will be fixed in
5426 && (!RECORD_OR_UNION_TYPE_P (t
)
5427 || !TYPE_CONTEXT (t
)
5428 || TREE_CODE (TYPE_CONTEXT (t
)) != FUNCTION_DECL
)
5429 /* FIXME debug-early: Allow late limbo DIE creation for LTO,
5430 especially in the ltrans stage, but once we implement LTO
5431 dwarf streaming, we should remove this exception. */
5434 fprintf (stderr
, "symbol ended up in limbo too late:");
5435 debug_generic_stmt (t
);
5439 limbo_node
= ggc_cleared_alloc
<limbo_die_node
> ();
5440 limbo_node
->die
= die
;
5441 limbo_node
->created_for
= t
;
5442 limbo_node
->next
= limbo_die_list
;
5443 limbo_die_list
= limbo_node
;
5449 /* Return the DIE associated with the given type specifier. */
5451 static inline dw_die_ref
5452 lookup_type_die (tree type
)
5454 dw_die_ref die
= TYPE_SYMTAB_DIE (type
);
5455 if (die
&& die
->removed
)
5457 TYPE_SYMTAB_DIE (type
) = NULL
;
5463 /* Given a TYPE_DIE representing the type TYPE, if TYPE is an
5464 anonymous type named by the typedef TYPE_DIE, return the DIE of the
5465 anonymous type instead the one of the naming typedef. */
5467 static inline dw_die_ref
5468 strip_naming_typedef (tree type
, dw_die_ref type_die
)
5471 && TREE_CODE (type
) == RECORD_TYPE
5473 && type_die
->die_tag
== DW_TAG_typedef
5474 && is_naming_typedef_decl (TYPE_NAME (type
)))
5475 type_die
= get_AT_ref (type_die
, DW_AT_type
);
5479 /* Like lookup_type_die, but if type is an anonymous type named by a
5480 typedef[1], return the DIE of the anonymous type instead the one of
5481 the naming typedef. This is because in gen_typedef_die, we did
5482 equate the anonymous struct named by the typedef with the DIE of
5483 the naming typedef. So by default, lookup_type_die on an anonymous
5484 struct yields the DIE of the naming typedef.
5486 [1]: Read the comment of is_naming_typedef_decl to learn about what
5487 a naming typedef is. */
5489 static inline dw_die_ref
5490 lookup_type_die_strip_naming_typedef (tree type
)
5492 dw_die_ref die
= lookup_type_die (type
);
5493 return strip_naming_typedef (type
, die
);
5496 /* Equate a DIE to a given type specifier. */
5499 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5501 TYPE_SYMTAB_DIE (type
) = type_die
;
5504 /* Returns a hash value for X (which really is a die_struct). */
5507 decl_die_hasher::hash (die_node
*x
)
5509 return (hashval_t
) x
->decl_id
;
5512 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5515 decl_die_hasher::equal (die_node
*x
, tree y
)
5517 return (x
->decl_id
== DECL_UID (y
));
5520 /* Return the DIE associated with a given declaration. */
5522 static inline dw_die_ref
5523 lookup_decl_die (tree decl
)
5525 dw_die_ref
*die
= decl_die_table
->find_slot_with_hash (decl
, DECL_UID (decl
),
5529 if ((*die
)->removed
)
5531 decl_die_table
->clear_slot (die
);
5538 /* For DECL which might have early dwarf output query a SYMBOL + OFFSET
5539 style reference. Return true if we found one refering to a DIE for
5540 DECL, otherwise return false. */
5543 dwarf2out_die_ref_for_decl (tree decl
, const char **sym
,
5544 unsigned HOST_WIDE_INT
*off
)
5548 if (flag_wpa
&& !decl_die_table
)
5551 if (TREE_CODE (decl
) == BLOCK
)
5552 die
= BLOCK_DIE (decl
);
5554 die
= lookup_decl_die (decl
);
5558 /* During WPA stage we currently use DIEs to store the
5559 decl <-> label + offset map. That's quite inefficient but it
5563 dw_die_ref ref
= get_AT_ref (die
, DW_AT_abstract_origin
);
5566 gcc_assert (die
== comp_unit_die ());
5569 *off
= ref
->die_offset
;
5570 *sym
= ref
->die_id
.die_symbol
;
5574 /* Similar to get_ref_die_offset_label, but using the "correct"
5576 *off
= die
->die_offset
;
5577 while (die
->die_parent
)
5578 die
= die
->die_parent
;
5579 /* For the containing CU DIE we compute a die_symbol in
5580 compute_comp_unit_symbol. */
5581 gcc_assert (die
->die_tag
== DW_TAG_compile_unit
5582 && die
->die_id
.die_symbol
!= NULL
);
5583 *sym
= die
->die_id
.die_symbol
;
5587 /* Add a reference of kind ATTR_KIND to a DIE at SYMBOL + OFFSET to DIE. */
5590 add_AT_external_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5591 const char *symbol
, HOST_WIDE_INT offset
)
5593 /* Create a fake DIE that contains the reference. Don't use
5594 new_die because we don't want to end up in the limbo list. */
5595 dw_die_ref ref
= new_die_raw (die
->die_tag
);
5596 ref
->die_id
.die_symbol
= IDENTIFIER_POINTER (get_identifier (symbol
));
5597 ref
->die_offset
= offset
;
5598 ref
->with_offset
= 1;
5599 add_AT_die_ref (die
, attr_kind
, ref
);
5602 /* Create a DIE for DECL if required and add a reference to a DIE
5603 at SYMBOL + OFFSET which contains attributes dumped early. */
5606 dwarf2out_register_external_die (tree decl
, const char *sym
,
5607 unsigned HOST_WIDE_INT off
)
5609 if (debug_info_level
== DINFO_LEVEL_NONE
)
5612 if (flag_wpa
&& !decl_die_table
)
5613 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (1000);
5616 = TREE_CODE (decl
) == BLOCK
? BLOCK_DIE (decl
) : lookup_decl_die (decl
);
5620 dw_die_ref parent
= NULL
;
5621 /* Need to lookup a DIE for the decls context - the containing
5622 function or translation unit. */
5623 if (TREE_CODE (decl
) == BLOCK
)
5625 ctx
= BLOCK_SUPERCONTEXT (decl
);
5626 /* ??? We do not output DIEs for all scopes thus skip as
5627 many DIEs as needed. */
5628 while (TREE_CODE (ctx
) == BLOCK
5629 && !BLOCK_DIE (ctx
))
5630 ctx
= BLOCK_SUPERCONTEXT (ctx
);
5633 ctx
= DECL_CONTEXT (decl
);
5634 while (ctx
&& TYPE_P (ctx
))
5635 ctx
= TYPE_CONTEXT (ctx
);
5638 if (TREE_CODE (ctx
) == BLOCK
)
5639 parent
= BLOCK_DIE (ctx
);
5640 else if (TREE_CODE (ctx
) == TRANSLATION_UNIT_DECL
5641 /* Keep the 1:1 association during WPA. */
5643 /* Otherwise all late annotations go to the main CU which
5644 imports the original CUs. */
5645 parent
= comp_unit_die ();
5646 else if (TREE_CODE (ctx
) == FUNCTION_DECL
5647 && TREE_CODE (decl
) != PARM_DECL
5648 && TREE_CODE (decl
) != BLOCK
)
5649 /* Leave function local entities parent determination to when
5650 we process scope vars. */
5653 parent
= lookup_decl_die (ctx
);
5656 /* In some cases the FEs fail to set DECL_CONTEXT properly.
5657 Handle this case gracefully by globalizing stuff. */
5658 parent
= comp_unit_die ();
5659 /* Create a DIE "stub". */
5660 switch (TREE_CODE (decl
))
5662 case TRANSLATION_UNIT_DECL
:
5665 die
= comp_unit_die ();
5666 dw_die_ref import
= new_die (DW_TAG_imported_unit
, die
, NULL_TREE
);
5667 add_AT_external_die_ref (import
, DW_AT_import
, sym
, off
);
5668 /* We re-target all CU decls to the LTRANS CU DIE, so no need
5669 to create a DIE for the original CUs. */
5672 /* Keep the 1:1 association during WPA. */
5673 die
= new_die (DW_TAG_compile_unit
, NULL
, decl
);
5675 case NAMESPACE_DECL
:
5676 if (is_fortran (decl
))
5677 die
= new_die (DW_TAG_module
, parent
, decl
);
5679 die
= new_die (DW_TAG_namespace
, parent
, decl
);
5682 die
= new_die (DW_TAG_subprogram
, parent
, decl
);
5685 die
= new_die (DW_TAG_variable
, parent
, decl
);
5688 die
= new_die (DW_TAG_variable
, parent
, decl
);
5691 die
= new_die (DW_TAG_formal_parameter
, parent
, decl
);
5694 die
= new_die (DW_TAG_constant
, parent
, decl
);
5697 die
= new_die (DW_TAG_label
, parent
, decl
);
5700 die
= new_die (DW_TAG_lexical_block
, parent
, decl
);
5705 if (TREE_CODE (decl
) == BLOCK
)
5706 BLOCK_DIE (decl
) = die
;
5708 equate_decl_number_to_die (decl
, die
);
5710 /* Add a reference to the DIE providing early debug at $sym + off. */
5711 add_AT_external_die_ref (die
, DW_AT_abstract_origin
, sym
, off
);
5714 /* Returns a hash value for X (which really is a var_loc_list). */
5717 decl_loc_hasher::hash (var_loc_list
*x
)
5719 return (hashval_t
) x
->decl_id
;
5722 /* Return nonzero if decl_id of var_loc_list X is the same as
5726 decl_loc_hasher::equal (var_loc_list
*x
, const_tree y
)
5728 return (x
->decl_id
== DECL_UID (y
));
5731 /* Return the var_loc list associated with a given declaration. */
5733 static inline var_loc_list
*
5734 lookup_decl_loc (const_tree decl
)
5736 if (!decl_loc_table
)
5738 return decl_loc_table
->find_with_hash (decl
, DECL_UID (decl
));
5741 /* Returns a hash value for X (which really is a cached_dw_loc_list_list). */
5744 dw_loc_list_hasher::hash (cached_dw_loc_list
*x
)
5746 return (hashval_t
) x
->decl_id
;
5749 /* Return nonzero if decl_id of cached_dw_loc_list X is the same as
5753 dw_loc_list_hasher::equal (cached_dw_loc_list
*x
, const_tree y
)
5755 return (x
->decl_id
== DECL_UID (y
));
5758 /* Equate a DIE to a particular declaration. */
5761 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
5763 unsigned int decl_id
= DECL_UID (decl
);
5765 *decl_die_table
->find_slot_with_hash (decl
, decl_id
, INSERT
) = decl_die
;
5766 decl_die
->decl_id
= decl_id
;
5769 /* Return how many bits covers PIECE EXPR_LIST. */
5771 static HOST_WIDE_INT
5772 decl_piece_bitsize (rtx piece
)
5774 int ret
= (int) GET_MODE (piece
);
5777 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
5778 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
5779 return INTVAL (XEXP (XEXP (piece
, 0), 0));
5782 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
5785 decl_piece_varloc_ptr (rtx piece
)
5787 if ((int) GET_MODE (piece
))
5788 return &XEXP (piece
, 0);
5790 return &XEXP (XEXP (piece
, 0), 1);
5793 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
5794 Next is the chain of following piece nodes. */
5796 static rtx_expr_list
*
5797 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
5799 if (bitsize
> 0 && bitsize
<= (int) MAX_MACHINE_MODE
)
5800 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
5802 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
5807 /* Return rtx that should be stored into loc field for
5808 LOC_NOTE and BITPOS/BITSIZE. */
5811 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
5812 HOST_WIDE_INT bitsize
)
5816 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
5818 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
5823 /* This function either modifies location piece list *DEST in
5824 place (if SRC and INNER is NULL), or copies location piece list
5825 *SRC to *DEST while modifying it. Location BITPOS is modified
5826 to contain LOC_NOTE, any pieces overlapping it are removed resp.
5827 not copied and if needed some padding around it is added.
5828 When modifying in place, DEST should point to EXPR_LIST where
5829 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
5830 to the start of the whole list and INNER points to the EXPR_LIST
5831 where earlier pieces cover PIECE_BITPOS bits. */
5834 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
5835 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
5836 HOST_WIDE_INT bitsize
, rtx loc_note
)
5839 bool copy
= inner
!= NULL
;
5843 /* First copy all nodes preceding the current bitpos. */
5844 while (src
!= inner
)
5846 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5847 decl_piece_bitsize (*src
), NULL_RTX
);
5848 dest
= &XEXP (*dest
, 1);
5849 src
= &XEXP (*src
, 1);
5852 /* Add padding if needed. */
5853 if (bitpos
!= piece_bitpos
)
5855 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
5856 copy
? NULL_RTX
: *dest
);
5857 dest
= &XEXP (*dest
, 1);
5859 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
5862 /* A piece with correct bitpos and bitsize already exist,
5863 just update the location for it and return. */
5864 *decl_piece_varloc_ptr (*dest
) = loc_note
;
5867 /* Add the piece that changed. */
5868 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
5869 dest
= &XEXP (*dest
, 1);
5870 /* Skip over pieces that overlap it. */
5871 diff
= bitpos
- piece_bitpos
+ bitsize
;
5874 while (diff
> 0 && *src
)
5877 diff
-= decl_piece_bitsize (piece
);
5879 src
= &XEXP (piece
, 1);
5882 *src
= XEXP (piece
, 1);
5883 free_EXPR_LIST_node (piece
);
5886 /* Add padding if needed. */
5887 if (diff
< 0 && *src
)
5891 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
5892 dest
= &XEXP (*dest
, 1);
5896 /* Finally copy all nodes following it. */
5899 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
5900 decl_piece_bitsize (*src
), NULL_RTX
);
5901 dest
= &XEXP (*dest
, 1);
5902 src
= &XEXP (*src
, 1);
5906 /* Add a variable location node to the linked list for DECL. */
5908 static struct var_loc_node
*
5909 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
)
5911 unsigned int decl_id
;
5913 struct var_loc_node
*loc
= NULL
;
5914 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
5916 if (VAR_P (decl
) && DECL_HAS_DEBUG_EXPR_P (decl
))
5918 tree realdecl
= DECL_DEBUG_EXPR (decl
);
5919 if (handled_component_p (realdecl
)
5920 || (TREE_CODE (realdecl
) == MEM_REF
5921 && TREE_CODE (TREE_OPERAND (realdecl
, 0)) == ADDR_EXPR
))
5924 tree innerdecl
= get_ref_base_and_extent_hwi (realdecl
, &bitpos
,
5925 &bitsize
, &reverse
);
5927 || !DECL_P (innerdecl
)
5928 || DECL_IGNORED_P (innerdecl
)
5929 || TREE_STATIC (innerdecl
)
5931 || bitpos
+ bitsize
> 256)
5937 decl_id
= DECL_UID (decl
);
5939 = decl_loc_table
->find_slot_with_hash (decl
, decl_id
, INSERT
);
5942 temp
= ggc_cleared_alloc
<var_loc_list
> ();
5943 temp
->decl_id
= decl_id
;
5949 /* For PARM_DECLs try to keep around the original incoming value,
5950 even if that means we'll emit a zero-range .debug_loc entry. */
5952 && temp
->first
== temp
->last
5953 && TREE_CODE (decl
) == PARM_DECL
5954 && NOTE_P (temp
->first
->loc
)
5955 && NOTE_VAR_LOCATION_DECL (temp
->first
->loc
) == decl
5956 && DECL_INCOMING_RTL (decl
)
5957 && NOTE_VAR_LOCATION_LOC (temp
->first
->loc
)
5958 && GET_CODE (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
))
5959 == GET_CODE (DECL_INCOMING_RTL (decl
))
5960 && prev_real_insn (as_a
<rtx_insn
*> (temp
->first
->loc
)) == NULL_RTX
5962 || !rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->first
->loc
),
5963 NOTE_VAR_LOCATION_LOC (loc_note
))
5964 || (NOTE_VAR_LOCATION_STATUS (temp
->first
->loc
)
5965 != NOTE_VAR_LOCATION_STATUS (loc_note
))))
5967 loc
= ggc_cleared_alloc
<var_loc_node
> ();
5968 temp
->first
->next
= loc
;
5970 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
5972 else if (temp
->last
)
5974 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
5975 rtx
*piece_loc
= NULL
, last_loc_note
;
5976 HOST_WIDE_INT piece_bitpos
= 0;
5980 gcc_assert (last
->next
== NULL
);
5982 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
5984 piece_loc
= &last
->loc
;
5987 HOST_WIDE_INT cur_bitsize
= decl_piece_bitsize (*piece_loc
);
5988 if (piece_bitpos
+ cur_bitsize
> bitpos
)
5990 piece_bitpos
+= cur_bitsize
;
5991 piece_loc
= &XEXP (*piece_loc
, 1);
5995 /* TEMP->LAST here is either pointer to the last but one or
5996 last element in the chained list, LAST is pointer to the
5998 if (label
&& strcmp (last
->label
, label
) == 0)
6000 /* For SRA optimized variables if there weren't any real
6001 insns since last note, just modify the last node. */
6002 if (piece_loc
!= NULL
)
6004 adjust_piece_list (piece_loc
, NULL
, NULL
,
6005 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6008 /* If the last note doesn't cover any instructions, remove it. */
6009 if (temp
->last
!= last
)
6011 temp
->last
->next
= NULL
;
6014 gcc_assert (strcmp (last
->label
, label
) != 0);
6018 gcc_assert (temp
->first
== temp
->last
6019 || (temp
->first
->next
== temp
->last
6020 && TREE_CODE (decl
) == PARM_DECL
));
6021 memset (temp
->last
, '\0', sizeof (*temp
->last
));
6022 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6026 if (bitsize
== -1 && NOTE_P (last
->loc
))
6027 last_loc_note
= last
->loc
;
6028 else if (piece_loc
!= NULL
6029 && *piece_loc
!= NULL_RTX
6030 && piece_bitpos
== bitpos
6031 && decl_piece_bitsize (*piece_loc
) == bitsize
)
6032 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
6034 last_loc_note
= NULL_RTX
;
6035 /* If the current location is the same as the end of the list,
6036 and either both or neither of the locations is uninitialized,
6037 we have nothing to do. */
6038 if (last_loc_note
== NULL_RTX
6039 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
6040 NOTE_VAR_LOCATION_LOC (loc_note
)))
6041 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6042 != NOTE_VAR_LOCATION_STATUS (loc_note
))
6043 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
6044 == VAR_INIT_STATUS_UNINITIALIZED
)
6045 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
6046 == VAR_INIT_STATUS_UNINITIALIZED
))))
6048 /* Add LOC to the end of list and update LAST. If the last
6049 element of the list has been removed above, reuse its
6050 memory for the new node, otherwise allocate a new one. */
6054 memset (loc
, '\0', sizeof (*loc
));
6057 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6058 if (bitsize
== -1 || piece_loc
== NULL
)
6059 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6061 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
6062 bitpos
, piece_bitpos
, bitsize
, loc_note
);
6064 /* Ensure TEMP->LAST will point either to the new last but one
6065 element of the chain, or to the last element in it. */
6066 if (last
!= temp
->last
)
6074 loc
= ggc_cleared_alloc
<var_loc_node
> ();
6077 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
6082 /* Keep track of the number of spaces used to indent the
6083 output of the debugging routines that print the structure of
6084 the DIE internal representation. */
6085 static int print_indent
;
6087 /* Indent the line the number of spaces given by print_indent. */
6090 print_spaces (FILE *outfile
)
6092 fprintf (outfile
, "%*s", print_indent
, "");
6095 /* Print a type signature in hex. */
6098 print_signature (FILE *outfile
, char *sig
)
6102 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
6103 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
6107 print_discr_value (FILE *outfile
, dw_discr_value
*discr_value
)
6109 if (discr_value
->pos
)
6110 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, discr_value
->v
.sval
);
6112 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, discr_value
->v
.uval
);
6115 static void print_loc_descr (dw_loc_descr_ref
, FILE *);
6117 /* Print the value associated to the VAL DWARF value node to OUTFILE. If
6118 RECURSE, output location descriptor operations. */
6121 print_dw_val (dw_val_node
*val
, bool recurse
, FILE *outfile
)
6123 switch (val
->val_class
)
6125 case dw_val_class_addr
:
6126 fprintf (outfile
, "address");
6128 case dw_val_class_offset
:
6129 fprintf (outfile
, "offset");
6131 case dw_val_class_loc
:
6132 fprintf (outfile
, "location descriptor");
6133 if (val
->v
.val_loc
== NULL
)
6134 fprintf (outfile
, " -> <null>\n");
6137 fprintf (outfile
, ":\n");
6139 print_loc_descr (val
->v
.val_loc
, outfile
);
6143 fprintf (outfile
, " (%p)\n", (void *) val
->v
.val_loc
);
6145 case dw_val_class_loc_list
:
6146 fprintf (outfile
, "location list -> label:%s",
6147 val
->v
.val_loc_list
->ll_symbol
);
6149 case dw_val_class_range_list
:
6150 fprintf (outfile
, "range list");
6152 case dw_val_class_const
:
6153 case dw_val_class_const_implicit
:
6154 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, val
->v
.val_int
);
6156 case dw_val_class_unsigned_const
:
6157 case dw_val_class_unsigned_const_implicit
:
6158 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, val
->v
.val_unsigned
);
6160 case dw_val_class_const_double
:
6161 fprintf (outfile
, "constant (" HOST_WIDE_INT_PRINT_DEC
","\
6162 HOST_WIDE_INT_PRINT_UNSIGNED
")",
6163 val
->v
.val_double
.high
,
6164 val
->v
.val_double
.low
);
6166 case dw_val_class_wide_int
:
6168 int i
= val
->v
.val_wide
->get_len ();
6169 fprintf (outfile
, "constant (");
6171 if (val
->v
.val_wide
->elt (i
- 1) == 0)
6172 fprintf (outfile
, "0x");
6173 fprintf (outfile
, HOST_WIDE_INT_PRINT_HEX
,
6174 val
->v
.val_wide
->elt (--i
));
6176 fprintf (outfile
, HOST_WIDE_INT_PRINT_PADDED_HEX
,
6177 val
->v
.val_wide
->elt (i
));
6178 fprintf (outfile
, ")");
6181 case dw_val_class_vec
:
6182 fprintf (outfile
, "floating-point or vector constant");
6184 case dw_val_class_flag
:
6185 fprintf (outfile
, "%u", val
->v
.val_flag
);
6187 case dw_val_class_die_ref
:
6188 if (val
->v
.val_die_ref
.die
!= NULL
)
6190 dw_die_ref die
= val
->v
.val_die_ref
.die
;
6192 if (die
->comdat_type_p
)
6194 fprintf (outfile
, "die -> signature: ");
6195 print_signature (outfile
,
6196 die
->die_id
.die_type_node
->signature
);
6198 else if (die
->die_id
.die_symbol
)
6200 fprintf (outfile
, "die -> label: %s", die
->die_id
.die_symbol
);
6201 if (die
->with_offset
)
6202 fprintf (outfile
, " + %ld", die
->die_offset
);
6205 fprintf (outfile
, "die -> %ld", die
->die_offset
);
6206 fprintf (outfile
, " (%p)", (void *) die
);
6209 fprintf (outfile
, "die -> <null>");
6211 case dw_val_class_vms_delta
:
6212 fprintf (outfile
, "delta: @slotcount(%s-%s)",
6213 val
->v
.val_vms_delta
.lbl2
, val
->v
.val_vms_delta
.lbl1
);
6215 case dw_val_class_lbl_id
:
6216 case dw_val_class_lineptr
:
6217 case dw_val_class_macptr
:
6218 case dw_val_class_loclistsptr
:
6219 case dw_val_class_high_pc
:
6220 fprintf (outfile
, "label: %s", val
->v
.val_lbl_id
);
6222 case dw_val_class_str
:
6223 if (val
->v
.val_str
->str
!= NULL
)
6224 fprintf (outfile
, "\"%s\"", val
->v
.val_str
->str
);
6226 fprintf (outfile
, "<null>");
6228 case dw_val_class_file
:
6229 case dw_val_class_file_implicit
:
6230 fprintf (outfile
, "\"%s\" (%d)", val
->v
.val_file
->filename
,
6231 val
->v
.val_file
->emitted_number
);
6233 case dw_val_class_data8
:
6237 for (i
= 0; i
< 8; i
++)
6238 fprintf (outfile
, "%02x", val
->v
.val_data8
[i
]);
6241 case dw_val_class_discr_value
:
6242 print_discr_value (outfile
, &val
->v
.val_discr_value
);
6244 case dw_val_class_discr_list
:
6245 for (dw_discr_list_ref node
= val
->v
.val_discr_list
;
6247 node
= node
->dw_discr_next
)
6249 if (node
->dw_discr_range
)
6251 fprintf (outfile
, " .. ");
6252 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6253 print_discr_value (outfile
, &node
->dw_discr_upper_bound
);
6256 print_discr_value (outfile
, &node
->dw_discr_lower_bound
);
6258 if (node
->dw_discr_next
!= NULL
)
6259 fprintf (outfile
, " | ");
6266 /* Likewise, for a DIE attribute. */
6269 print_attribute (dw_attr_node
*a
, bool recurse
, FILE *outfile
)
6271 print_dw_val (&a
->dw_attr_val
, recurse
, outfile
);
6275 /* Print the list of operands in the LOC location description to OUTFILE. This
6276 routine is a debugging aid only. */
6279 print_loc_descr (dw_loc_descr_ref loc
, FILE *outfile
)
6281 dw_loc_descr_ref l
= loc
;
6285 print_spaces (outfile
);
6286 fprintf (outfile
, "<null>\n");
6290 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
6292 print_spaces (outfile
);
6293 fprintf (outfile
, "(%p) %s",
6295 dwarf_stack_op_name (l
->dw_loc_opc
));
6296 if (l
->dw_loc_oprnd1
.val_class
!= dw_val_class_none
)
6298 fprintf (outfile
, " ");
6299 print_dw_val (&l
->dw_loc_oprnd1
, false, outfile
);
6301 if (l
->dw_loc_oprnd2
.val_class
!= dw_val_class_none
)
6303 fprintf (outfile
, ", ");
6304 print_dw_val (&l
->dw_loc_oprnd2
, false, outfile
);
6306 fprintf (outfile
, "\n");
6310 /* Print the information associated with a given DIE, and its children.
6311 This routine is a debugging aid only. */
6314 print_die (dw_die_ref die
, FILE *outfile
)
6320 print_spaces (outfile
);
6321 fprintf (outfile
, "DIE %4ld: %s (%p)\n",
6322 die
->die_offset
, dwarf_tag_name (die
->die_tag
),
6324 print_spaces (outfile
);
6325 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
6326 fprintf (outfile
, " offset: %ld", die
->die_offset
);
6327 fprintf (outfile
, " mark: %d\n", die
->die_mark
);
6329 if (die
->comdat_type_p
)
6331 print_spaces (outfile
);
6332 fprintf (outfile
, " signature: ");
6333 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
6334 fprintf (outfile
, "\n");
6337 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6339 print_spaces (outfile
);
6340 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
6342 print_attribute (a
, true, outfile
);
6343 fprintf (outfile
, "\n");
6346 if (die
->die_child
!= NULL
)
6349 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
6352 if (print_indent
== 0)
6353 fprintf (outfile
, "\n");
6356 /* Print the list of operations in the LOC location description. */
6359 debug_dwarf_loc_descr (dw_loc_descr_ref loc
)
6361 print_loc_descr (loc
, stderr
);
6364 /* Print the information collected for a given DIE. */
6367 debug_dwarf_die (dw_die_ref die
)
6369 print_die (die
, stderr
);
6373 debug (die_struct
&ref
)
6375 print_die (&ref
, stderr
);
6379 debug (die_struct
*ptr
)
6384 fprintf (stderr
, "<nil>\n");
6388 /* Print all DWARF information collected for the compilation unit.
6389 This routine is a debugging aid only. */
6395 print_die (comp_unit_die (), stderr
);
6398 /* Verify the DIE tree structure. */
6401 verify_die (dw_die_ref die
)
6403 gcc_assert (!die
->die_mark
);
6404 if (die
->die_parent
== NULL
6405 && die
->die_sib
== NULL
)
6407 /* Verify the die_sib list is cyclic. */
6414 while (x
&& !x
->die_mark
);
6415 gcc_assert (x
== die
);
6419 /* Verify all dies have the same parent. */
6420 gcc_assert (x
->die_parent
== die
->die_parent
);
6423 /* Verify the child has the proper parent and recurse. */
6424 gcc_assert (x
->die_child
->die_parent
== x
);
6425 verify_die (x
->die_child
);
6430 while (x
&& x
->die_mark
);
6433 /* Sanity checks on DIEs. */
6436 check_die (dw_die_ref die
)
6440 bool inline_found
= false;
6441 int n_location
= 0, n_low_pc
= 0, n_high_pc
= 0, n_artificial
= 0;
6442 int n_decl_line
= 0, n_decl_column
= 0, n_decl_file
= 0;
6443 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6448 if (a
->dw_attr_val
.v
.val_unsigned
)
6449 inline_found
= true;
6451 case DW_AT_location
:
6460 case DW_AT_artificial
:
6463 case DW_AT_decl_column
:
6466 case DW_AT_decl_line
:
6469 case DW_AT_decl_file
:
6476 if (n_location
> 1 || n_low_pc
> 1 || n_high_pc
> 1 || n_artificial
> 1
6477 || n_decl_column
> 1 || n_decl_line
> 1 || n_decl_file
> 1)
6479 fprintf (stderr
, "Duplicate attributes in DIE:\n");
6480 debug_dwarf_die (die
);
6485 /* A debugging information entry that is a member of an abstract
6486 instance tree [that has DW_AT_inline] should not contain any
6487 attributes which describe aspects of the subroutine which vary
6488 between distinct inlined expansions or distinct out-of-line
6490 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6491 gcc_assert (a
->dw_attr
!= DW_AT_low_pc
6492 && a
->dw_attr
!= DW_AT_high_pc
6493 && a
->dw_attr
!= DW_AT_location
6494 && a
->dw_attr
!= DW_AT_frame_base
6495 && a
->dw_attr
!= DW_AT_call_all_calls
6496 && a
->dw_attr
!= DW_AT_GNU_all_call_sites
);
6500 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6501 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6502 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
6504 /* Calculate the checksum of a location expression. */
6507 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
6510 inchash::hash hstate
;
6513 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
6515 hash_loc_operands (loc
, hstate
);
6516 hash
= hstate
.end();
6520 /* Calculate the checksum of an attribute. */
6523 attr_checksum (dw_attr_node
*at
, struct md5_ctx
*ctx
, int *mark
)
6525 dw_loc_descr_ref loc
;
6528 CHECKSUM (at
->dw_attr
);
6530 /* We don't care that this was compiled with a different compiler
6531 snapshot; if the output is the same, that's what matters. */
6532 if (at
->dw_attr
== DW_AT_producer
)
6535 switch (AT_class (at
))
6537 case dw_val_class_const
:
6538 case dw_val_class_const_implicit
:
6539 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
6541 case dw_val_class_unsigned_const
:
6542 case dw_val_class_unsigned_const_implicit
:
6543 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
6545 case dw_val_class_const_double
:
6546 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
6548 case dw_val_class_wide_int
:
6549 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
6550 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
6551 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
6553 case dw_val_class_vec
:
6554 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
6555 (at
->dw_attr_val
.v
.val_vec
.length
6556 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
6558 case dw_val_class_flag
:
6559 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
6561 case dw_val_class_str
:
6562 CHECKSUM_STRING (AT_string (at
));
6565 case dw_val_class_addr
:
6567 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
6568 CHECKSUM_STRING (XSTR (r
, 0));
6571 case dw_val_class_offset
:
6572 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
6575 case dw_val_class_loc
:
6576 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
6577 loc_checksum (loc
, ctx
);
6580 case dw_val_class_die_ref
:
6581 die_checksum (AT_ref (at
), ctx
, mark
);
6584 case dw_val_class_fde_ref
:
6585 case dw_val_class_vms_delta
:
6586 case dw_val_class_lbl_id
:
6587 case dw_val_class_lineptr
:
6588 case dw_val_class_macptr
:
6589 case dw_val_class_loclistsptr
:
6590 case dw_val_class_high_pc
:
6593 case dw_val_class_file
:
6594 case dw_val_class_file_implicit
:
6595 CHECKSUM_STRING (AT_file (at
)->filename
);
6598 case dw_val_class_data8
:
6599 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
6607 /* Calculate the checksum of a DIE. */
6610 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6616 /* To avoid infinite recursion. */
6619 CHECKSUM (die
->die_mark
);
6622 die
->die_mark
= ++(*mark
);
6624 CHECKSUM (die
->die_tag
);
6626 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6627 attr_checksum (a
, ctx
, mark
);
6629 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
6633 #undef CHECKSUM_BLOCK
6634 #undef CHECKSUM_STRING
6636 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
6637 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6638 #define CHECKSUM_BLOCK(FOO, SIZE) md5_process_bytes ((FOO), (SIZE), ctx)
6639 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
6640 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
6641 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
6642 #define CHECKSUM_ATTR(FOO) \
6643 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
6645 /* Calculate the checksum of a number in signed LEB128 format. */
6648 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
6655 byte
= (value
& 0x7f);
6657 more
= !((value
== 0 && (byte
& 0x40) == 0)
6658 || (value
== -1 && (byte
& 0x40) != 0));
6667 /* Calculate the checksum of a number in unsigned LEB128 format. */
6670 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
6674 unsigned char byte
= (value
& 0x7f);
6677 /* More bytes to follow. */
6685 /* Checksum the context of the DIE. This adds the names of any
6686 surrounding namespaces or structures to the checksum. */
6689 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
6693 int tag
= die
->die_tag
;
6695 if (tag
!= DW_TAG_namespace
6696 && tag
!= DW_TAG_structure_type
6697 && tag
!= DW_TAG_class_type
)
6700 name
= get_AT_string (die
, DW_AT_name
);
6702 spec
= get_AT_ref (die
, DW_AT_specification
);
6706 if (die
->die_parent
!= NULL
)
6707 checksum_die_context (die
->die_parent
, ctx
);
6709 CHECKSUM_ULEB128 ('C');
6710 CHECKSUM_ULEB128 (tag
);
6712 CHECKSUM_STRING (name
);
6715 /* Calculate the checksum of a location expression. */
6718 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
6720 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
6721 were emitted as a DW_FORM_sdata instead of a location expression. */
6722 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
6724 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6725 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
6729 /* Otherwise, just checksum the raw location expression. */
6732 inchash::hash hstate
;
6735 CHECKSUM_ULEB128 (loc
->dtprel
);
6736 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
6737 hash_loc_operands (loc
, hstate
);
6738 hash
= hstate
.end ();
6740 loc
= loc
->dw_loc_next
;
6744 /* Calculate the checksum of an attribute. */
6747 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_node
*at
,
6748 struct md5_ctx
*ctx
, int *mark
)
6750 dw_loc_descr_ref loc
;
6753 if (AT_class (at
) == dw_val_class_die_ref
)
6755 dw_die_ref target_die
= AT_ref (at
);
6757 /* For pointer and reference types, we checksum only the (qualified)
6758 name of the target type (if there is a name). For friend entries,
6759 we checksum only the (qualified) name of the target type or function.
6760 This allows the checksum to remain the same whether the target type
6761 is complete or not. */
6762 if ((at
->dw_attr
== DW_AT_type
6763 && (tag
== DW_TAG_pointer_type
6764 || tag
== DW_TAG_reference_type
6765 || tag
== DW_TAG_rvalue_reference_type
6766 || tag
== DW_TAG_ptr_to_member_type
))
6767 || (at
->dw_attr
== DW_AT_friend
6768 && tag
== DW_TAG_friend
))
6770 dw_attr_node
*name_attr
= get_AT (target_die
, DW_AT_name
);
6772 if (name_attr
!= NULL
)
6774 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
6778 CHECKSUM_ULEB128 ('N');
6779 CHECKSUM_ULEB128 (at
->dw_attr
);
6780 if (decl
->die_parent
!= NULL
)
6781 checksum_die_context (decl
->die_parent
, ctx
);
6782 CHECKSUM_ULEB128 ('E');
6783 CHECKSUM_STRING (AT_string (name_attr
));
6788 /* For all other references to another DIE, we check to see if the
6789 target DIE has already been visited. If it has, we emit a
6790 backward reference; if not, we descend recursively. */
6791 if (target_die
->die_mark
> 0)
6793 CHECKSUM_ULEB128 ('R');
6794 CHECKSUM_ULEB128 (at
->dw_attr
);
6795 CHECKSUM_ULEB128 (target_die
->die_mark
);
6799 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
6803 target_die
->die_mark
= ++(*mark
);
6804 CHECKSUM_ULEB128 ('T');
6805 CHECKSUM_ULEB128 (at
->dw_attr
);
6806 if (decl
->die_parent
!= NULL
)
6807 checksum_die_context (decl
->die_parent
, ctx
);
6808 die_checksum_ordered (target_die
, ctx
, mark
);
6813 CHECKSUM_ULEB128 ('A');
6814 CHECKSUM_ULEB128 (at
->dw_attr
);
6816 switch (AT_class (at
))
6818 case dw_val_class_const
:
6819 case dw_val_class_const_implicit
:
6820 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6821 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
6824 case dw_val_class_unsigned_const
:
6825 case dw_val_class_unsigned_const_implicit
:
6826 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6827 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
6830 case dw_val_class_const_double
:
6831 CHECKSUM_ULEB128 (DW_FORM_block
);
6832 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
6833 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
6836 case dw_val_class_wide_int
:
6837 CHECKSUM_ULEB128 (DW_FORM_block
);
6838 CHECKSUM_ULEB128 (get_full_len (*at
->dw_attr_val
.v
.val_wide
)
6839 * HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
6840 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_wide
->get_val (),
6841 get_full_len (*at
->dw_attr_val
.v
.val_wide
)
6842 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
6845 case dw_val_class_vec
:
6846 CHECKSUM_ULEB128 (DW_FORM_block
);
6847 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_vec
.length
6848 * at
->dw_attr_val
.v
.val_vec
.elt_size
);
6849 CHECKSUM_BLOCK (at
->dw_attr_val
.v
.val_vec
.array
,
6850 (at
->dw_attr_val
.v
.val_vec
.length
6851 * at
->dw_attr_val
.v
.val_vec
.elt_size
));
6854 case dw_val_class_flag
:
6855 CHECKSUM_ULEB128 (DW_FORM_flag
);
6856 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
6859 case dw_val_class_str
:
6860 CHECKSUM_ULEB128 (DW_FORM_string
);
6861 CHECKSUM_STRING (AT_string (at
));
6864 case dw_val_class_addr
:
6866 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
6867 CHECKSUM_ULEB128 (DW_FORM_string
);
6868 CHECKSUM_STRING (XSTR (r
, 0));
6871 case dw_val_class_offset
:
6872 CHECKSUM_ULEB128 (DW_FORM_sdata
);
6873 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
6876 case dw_val_class_loc
:
6877 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
6878 loc_checksum_ordered (loc
, ctx
);
6881 case dw_val_class_fde_ref
:
6882 case dw_val_class_lbl_id
:
6883 case dw_val_class_lineptr
:
6884 case dw_val_class_macptr
:
6885 case dw_val_class_loclistsptr
:
6886 case dw_val_class_high_pc
:
6889 case dw_val_class_file
:
6890 case dw_val_class_file_implicit
:
6891 CHECKSUM_ULEB128 (DW_FORM_string
);
6892 CHECKSUM_STRING (AT_file (at
)->filename
);
6895 case dw_val_class_data8
:
6896 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
6904 struct checksum_attributes
6906 dw_attr_node
*at_name
;
6907 dw_attr_node
*at_type
;
6908 dw_attr_node
*at_friend
;
6909 dw_attr_node
*at_accessibility
;
6910 dw_attr_node
*at_address_class
;
6911 dw_attr_node
*at_alignment
;
6912 dw_attr_node
*at_allocated
;
6913 dw_attr_node
*at_artificial
;
6914 dw_attr_node
*at_associated
;
6915 dw_attr_node
*at_binary_scale
;
6916 dw_attr_node
*at_bit_offset
;
6917 dw_attr_node
*at_bit_size
;
6918 dw_attr_node
*at_bit_stride
;
6919 dw_attr_node
*at_byte_size
;
6920 dw_attr_node
*at_byte_stride
;
6921 dw_attr_node
*at_const_value
;
6922 dw_attr_node
*at_containing_type
;
6923 dw_attr_node
*at_count
;
6924 dw_attr_node
*at_data_location
;
6925 dw_attr_node
*at_data_member_location
;
6926 dw_attr_node
*at_decimal_scale
;
6927 dw_attr_node
*at_decimal_sign
;
6928 dw_attr_node
*at_default_value
;
6929 dw_attr_node
*at_digit_count
;
6930 dw_attr_node
*at_discr
;
6931 dw_attr_node
*at_discr_list
;
6932 dw_attr_node
*at_discr_value
;
6933 dw_attr_node
*at_encoding
;
6934 dw_attr_node
*at_endianity
;
6935 dw_attr_node
*at_explicit
;
6936 dw_attr_node
*at_is_optional
;
6937 dw_attr_node
*at_location
;
6938 dw_attr_node
*at_lower_bound
;
6939 dw_attr_node
*at_mutable
;
6940 dw_attr_node
*at_ordering
;
6941 dw_attr_node
*at_picture_string
;
6942 dw_attr_node
*at_prototyped
;
6943 dw_attr_node
*at_small
;
6944 dw_attr_node
*at_segment
;
6945 dw_attr_node
*at_string_length
;
6946 dw_attr_node
*at_string_length_bit_size
;
6947 dw_attr_node
*at_string_length_byte_size
;
6948 dw_attr_node
*at_threads_scaled
;
6949 dw_attr_node
*at_upper_bound
;
6950 dw_attr_node
*at_use_location
;
6951 dw_attr_node
*at_use_UTF8
;
6952 dw_attr_node
*at_variable_parameter
;
6953 dw_attr_node
*at_virtuality
;
6954 dw_attr_node
*at_visibility
;
6955 dw_attr_node
*at_vtable_elem_location
;
6958 /* Collect the attributes that we will want to use for the checksum. */
6961 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
6966 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
6977 attrs
->at_friend
= a
;
6979 case DW_AT_accessibility
:
6980 attrs
->at_accessibility
= a
;
6982 case DW_AT_address_class
:
6983 attrs
->at_address_class
= a
;
6985 case DW_AT_alignment
:
6986 attrs
->at_alignment
= a
;
6988 case DW_AT_allocated
:
6989 attrs
->at_allocated
= a
;
6991 case DW_AT_artificial
:
6992 attrs
->at_artificial
= a
;
6994 case DW_AT_associated
:
6995 attrs
->at_associated
= a
;
6997 case DW_AT_binary_scale
:
6998 attrs
->at_binary_scale
= a
;
7000 case DW_AT_bit_offset
:
7001 attrs
->at_bit_offset
= a
;
7003 case DW_AT_bit_size
:
7004 attrs
->at_bit_size
= a
;
7006 case DW_AT_bit_stride
:
7007 attrs
->at_bit_stride
= a
;
7009 case DW_AT_byte_size
:
7010 attrs
->at_byte_size
= a
;
7012 case DW_AT_byte_stride
:
7013 attrs
->at_byte_stride
= a
;
7015 case DW_AT_const_value
:
7016 attrs
->at_const_value
= a
;
7018 case DW_AT_containing_type
:
7019 attrs
->at_containing_type
= a
;
7022 attrs
->at_count
= a
;
7024 case DW_AT_data_location
:
7025 attrs
->at_data_location
= a
;
7027 case DW_AT_data_member_location
:
7028 attrs
->at_data_member_location
= a
;
7030 case DW_AT_decimal_scale
:
7031 attrs
->at_decimal_scale
= a
;
7033 case DW_AT_decimal_sign
:
7034 attrs
->at_decimal_sign
= a
;
7036 case DW_AT_default_value
:
7037 attrs
->at_default_value
= a
;
7039 case DW_AT_digit_count
:
7040 attrs
->at_digit_count
= a
;
7043 attrs
->at_discr
= a
;
7045 case DW_AT_discr_list
:
7046 attrs
->at_discr_list
= a
;
7048 case DW_AT_discr_value
:
7049 attrs
->at_discr_value
= a
;
7051 case DW_AT_encoding
:
7052 attrs
->at_encoding
= a
;
7054 case DW_AT_endianity
:
7055 attrs
->at_endianity
= a
;
7057 case DW_AT_explicit
:
7058 attrs
->at_explicit
= a
;
7060 case DW_AT_is_optional
:
7061 attrs
->at_is_optional
= a
;
7063 case DW_AT_location
:
7064 attrs
->at_location
= a
;
7066 case DW_AT_lower_bound
:
7067 attrs
->at_lower_bound
= a
;
7070 attrs
->at_mutable
= a
;
7072 case DW_AT_ordering
:
7073 attrs
->at_ordering
= a
;
7075 case DW_AT_picture_string
:
7076 attrs
->at_picture_string
= a
;
7078 case DW_AT_prototyped
:
7079 attrs
->at_prototyped
= a
;
7082 attrs
->at_small
= a
;
7085 attrs
->at_segment
= a
;
7087 case DW_AT_string_length
:
7088 attrs
->at_string_length
= a
;
7090 case DW_AT_string_length_bit_size
:
7091 attrs
->at_string_length_bit_size
= a
;
7093 case DW_AT_string_length_byte_size
:
7094 attrs
->at_string_length_byte_size
= a
;
7096 case DW_AT_threads_scaled
:
7097 attrs
->at_threads_scaled
= a
;
7099 case DW_AT_upper_bound
:
7100 attrs
->at_upper_bound
= a
;
7102 case DW_AT_use_location
:
7103 attrs
->at_use_location
= a
;
7105 case DW_AT_use_UTF8
:
7106 attrs
->at_use_UTF8
= a
;
7108 case DW_AT_variable_parameter
:
7109 attrs
->at_variable_parameter
= a
;
7111 case DW_AT_virtuality
:
7112 attrs
->at_virtuality
= a
;
7114 case DW_AT_visibility
:
7115 attrs
->at_visibility
= a
;
7117 case DW_AT_vtable_elem_location
:
7118 attrs
->at_vtable_elem_location
= a
;
7126 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
7129 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
7133 struct checksum_attributes attrs
;
7135 CHECKSUM_ULEB128 ('D');
7136 CHECKSUM_ULEB128 (die
->die_tag
);
7138 memset (&attrs
, 0, sizeof (attrs
));
7140 decl
= get_AT_ref (die
, DW_AT_specification
);
7142 collect_checksum_attributes (&attrs
, decl
);
7143 collect_checksum_attributes (&attrs
, die
);
7145 CHECKSUM_ATTR (attrs
.at_name
);
7146 CHECKSUM_ATTR (attrs
.at_accessibility
);
7147 CHECKSUM_ATTR (attrs
.at_address_class
);
7148 CHECKSUM_ATTR (attrs
.at_allocated
);
7149 CHECKSUM_ATTR (attrs
.at_artificial
);
7150 CHECKSUM_ATTR (attrs
.at_associated
);
7151 CHECKSUM_ATTR (attrs
.at_binary_scale
);
7152 CHECKSUM_ATTR (attrs
.at_bit_offset
);
7153 CHECKSUM_ATTR (attrs
.at_bit_size
);
7154 CHECKSUM_ATTR (attrs
.at_bit_stride
);
7155 CHECKSUM_ATTR (attrs
.at_byte_size
);
7156 CHECKSUM_ATTR (attrs
.at_byte_stride
);
7157 CHECKSUM_ATTR (attrs
.at_const_value
);
7158 CHECKSUM_ATTR (attrs
.at_containing_type
);
7159 CHECKSUM_ATTR (attrs
.at_count
);
7160 CHECKSUM_ATTR (attrs
.at_data_location
);
7161 CHECKSUM_ATTR (attrs
.at_data_member_location
);
7162 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
7163 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
7164 CHECKSUM_ATTR (attrs
.at_default_value
);
7165 CHECKSUM_ATTR (attrs
.at_digit_count
);
7166 CHECKSUM_ATTR (attrs
.at_discr
);
7167 CHECKSUM_ATTR (attrs
.at_discr_list
);
7168 CHECKSUM_ATTR (attrs
.at_discr_value
);
7169 CHECKSUM_ATTR (attrs
.at_encoding
);
7170 CHECKSUM_ATTR (attrs
.at_endianity
);
7171 CHECKSUM_ATTR (attrs
.at_explicit
);
7172 CHECKSUM_ATTR (attrs
.at_is_optional
);
7173 CHECKSUM_ATTR (attrs
.at_location
);
7174 CHECKSUM_ATTR (attrs
.at_lower_bound
);
7175 CHECKSUM_ATTR (attrs
.at_mutable
);
7176 CHECKSUM_ATTR (attrs
.at_ordering
);
7177 CHECKSUM_ATTR (attrs
.at_picture_string
);
7178 CHECKSUM_ATTR (attrs
.at_prototyped
);
7179 CHECKSUM_ATTR (attrs
.at_small
);
7180 CHECKSUM_ATTR (attrs
.at_segment
);
7181 CHECKSUM_ATTR (attrs
.at_string_length
);
7182 CHECKSUM_ATTR (attrs
.at_string_length_bit_size
);
7183 CHECKSUM_ATTR (attrs
.at_string_length_byte_size
);
7184 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
7185 CHECKSUM_ATTR (attrs
.at_upper_bound
);
7186 CHECKSUM_ATTR (attrs
.at_use_location
);
7187 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
7188 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
7189 CHECKSUM_ATTR (attrs
.at_virtuality
);
7190 CHECKSUM_ATTR (attrs
.at_visibility
);
7191 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
7192 CHECKSUM_ATTR (attrs
.at_type
);
7193 CHECKSUM_ATTR (attrs
.at_friend
);
7194 CHECKSUM_ATTR (attrs
.at_alignment
);
7196 /* Checksum the child DIEs. */
7199 dw_attr_node
*name_attr
;
7202 name_attr
= get_AT (c
, DW_AT_name
);
7203 if (is_template_instantiation (c
))
7205 /* Ignore instantiations of member type and function templates. */
7207 else if (name_attr
!= NULL
7208 && (is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
))
7210 /* Use a shallow checksum for named nested types and member
7212 CHECKSUM_ULEB128 ('S');
7213 CHECKSUM_ULEB128 (c
->die_tag
);
7214 CHECKSUM_STRING (AT_string (name_attr
));
7218 /* Use a deep checksum for other children. */
7219 /* Mark this DIE so it gets processed when unmarking. */
7220 if (c
->die_mark
== 0)
7222 die_checksum_ordered (c
, ctx
, mark
);
7224 } while (c
!= die
->die_child
);
7226 CHECKSUM_ULEB128 (0);
7229 /* Add a type name and tag to a hash. */
7231 die_odr_checksum (int tag
, const char *name
, md5_ctx
*ctx
)
7233 CHECKSUM_ULEB128 (tag
);
7234 CHECKSUM_STRING (name
);
7238 #undef CHECKSUM_STRING
7239 #undef CHECKSUM_ATTR
7240 #undef CHECKSUM_LEB128
7241 #undef CHECKSUM_ULEB128
7243 /* Generate the type signature for DIE. This is computed by generating an
7244 MD5 checksum over the DIE's tag, its relevant attributes, and its
7245 children. Attributes that are references to other DIEs are processed
7246 by recursion, using the MARK field to prevent infinite recursion.
7247 If the DIE is nested inside a namespace or another type, we also
7248 need to include that context in the signature. The lower 64 bits
7249 of the resulting MD5 checksum comprise the signature. */
7252 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
7256 unsigned char checksum
[16];
7261 name
= get_AT_string (die
, DW_AT_name
);
7262 decl
= get_AT_ref (die
, DW_AT_specification
);
7263 parent
= get_die_parent (die
);
7265 /* First, compute a signature for just the type name (and its surrounding
7266 context, if any. This is stored in the type unit DIE for link-time
7267 ODR (one-definition rule) checking. */
7269 if (is_cxx () && name
!= NULL
)
7271 md5_init_ctx (&ctx
);
7273 /* Checksum the names of surrounding namespaces and structures. */
7275 checksum_die_context (parent
, &ctx
);
7277 /* Checksum the current DIE. */
7278 die_odr_checksum (die
->die_tag
, name
, &ctx
);
7279 md5_finish_ctx (&ctx
, checksum
);
7281 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
7284 /* Next, compute the complete type signature. */
7286 md5_init_ctx (&ctx
);
7288 die
->die_mark
= mark
;
7290 /* Checksum the names of surrounding namespaces and structures. */
7292 checksum_die_context (parent
, &ctx
);
7294 /* Checksum the DIE and its children. */
7295 die_checksum_ordered (die
, &ctx
, &mark
);
7296 unmark_all_dies (die
);
7297 md5_finish_ctx (&ctx
, checksum
);
7299 /* Store the signature in the type node and link the type DIE and the
7300 type node together. */
7301 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
7302 DWARF_TYPE_SIGNATURE_SIZE
);
7303 die
->comdat_type_p
= true;
7304 die
->die_id
.die_type_node
= type_node
;
7305 type_node
->type_die
= die
;
7307 /* If the DIE is a specification, link its declaration to the type node
7311 decl
->comdat_type_p
= true;
7312 decl
->die_id
.die_type_node
= type_node
;
7316 /* Do the location expressions look same? */
7318 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
7320 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
7321 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
7322 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
7325 /* Do the values look the same? */
7327 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
7329 dw_loc_descr_ref loc1
, loc2
;
7332 if (v1
->val_class
!= v2
->val_class
)
7335 switch (v1
->val_class
)
7337 case dw_val_class_const
:
7338 case dw_val_class_const_implicit
:
7339 return v1
->v
.val_int
== v2
->v
.val_int
;
7340 case dw_val_class_unsigned_const
:
7341 case dw_val_class_unsigned_const_implicit
:
7342 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
7343 case dw_val_class_const_double
:
7344 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
7345 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
7346 case dw_val_class_wide_int
:
7347 return *v1
->v
.val_wide
== *v2
->v
.val_wide
;
7348 case dw_val_class_vec
:
7349 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
7350 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
7352 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
7353 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
7356 case dw_val_class_flag
:
7357 return v1
->v
.val_flag
== v2
->v
.val_flag
;
7358 case dw_val_class_str
:
7359 return !strcmp (v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
7361 case dw_val_class_addr
:
7362 r1
= v1
->v
.val_addr
;
7363 r2
= v2
->v
.val_addr
;
7364 if (GET_CODE (r1
) != GET_CODE (r2
))
7366 return !rtx_equal_p (r1
, r2
);
7368 case dw_val_class_offset
:
7369 return v1
->v
.val_offset
== v2
->v
.val_offset
;
7371 case dw_val_class_loc
:
7372 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
7374 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
7375 if (!same_loc_p (loc1
, loc2
, mark
))
7377 return !loc1
&& !loc2
;
7379 case dw_val_class_die_ref
:
7380 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
7382 case dw_val_class_fde_ref
:
7383 case dw_val_class_vms_delta
:
7384 case dw_val_class_lbl_id
:
7385 case dw_val_class_lineptr
:
7386 case dw_val_class_macptr
:
7387 case dw_val_class_loclistsptr
:
7388 case dw_val_class_high_pc
:
7391 case dw_val_class_file
:
7392 case dw_val_class_file_implicit
:
7393 return v1
->v
.val_file
== v2
->v
.val_file
;
7395 case dw_val_class_data8
:
7396 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
7403 /* Do the attributes look the same? */
7406 same_attr_p (dw_attr_node
*at1
, dw_attr_node
*at2
, int *mark
)
7408 if (at1
->dw_attr
!= at2
->dw_attr
)
7411 /* We don't care that this was compiled with a different compiler
7412 snapshot; if the output is the same, that's what matters. */
7413 if (at1
->dw_attr
== DW_AT_producer
)
7416 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
7419 /* Do the dies look the same? */
7422 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
7428 /* To avoid infinite recursion. */
7430 return die1
->die_mark
== die2
->die_mark
;
7431 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
7433 if (die1
->die_tag
!= die2
->die_tag
)
7436 if (vec_safe_length (die1
->die_attr
) != vec_safe_length (die2
->die_attr
))
7439 FOR_EACH_VEC_SAFE_ELT (die1
->die_attr
, ix
, a1
)
7440 if (!same_attr_p (a1
, &(*die2
->die_attr
)[ix
], mark
))
7443 c1
= die1
->die_child
;
7444 c2
= die2
->die_child
;
7453 if (!same_die_p (c1
, c2
, mark
))
7457 if (c1
== die1
->die_child
)
7459 if (c2
== die2
->die_child
)
7469 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7470 children, and set die_symbol. */
7473 compute_comp_unit_symbol (dw_die_ref unit_die
)
7475 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
7476 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
7477 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
7480 unsigned char checksum
[16];
7483 /* Compute the checksum of the DIE, then append part of it as hex digits to
7484 the name filename of the unit. */
7486 md5_init_ctx (&ctx
);
7488 die_checksum (unit_die
, &ctx
, &mark
);
7489 unmark_all_dies (unit_die
);
7490 md5_finish_ctx (&ctx
, checksum
);
7492 /* When we this for comp_unit_die () we have a DW_AT_name that might
7493 not start with a letter but with anything valid for filenames and
7494 clean_symbol_name doesn't fix that up. Prepend 'g' if the first
7495 character is not a letter. */
7496 sprintf (name
, "%s%s.", ISALPHA (*base
) ? "" : "g", base
);
7497 clean_symbol_name (name
);
7499 p
= name
+ strlen (name
);
7500 for (i
= 0; i
< 4; i
++)
7502 sprintf (p
, "%.2x", checksum
[i
]);
7506 unit_die
->die_id
.die_symbol
= xstrdup (name
);
7509 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7512 is_type_die (dw_die_ref die
)
7514 switch (die
->die_tag
)
7516 case DW_TAG_array_type
:
7517 case DW_TAG_class_type
:
7518 case DW_TAG_interface_type
:
7519 case DW_TAG_enumeration_type
:
7520 case DW_TAG_pointer_type
:
7521 case DW_TAG_reference_type
:
7522 case DW_TAG_rvalue_reference_type
:
7523 case DW_TAG_string_type
:
7524 case DW_TAG_structure_type
:
7525 case DW_TAG_subroutine_type
:
7526 case DW_TAG_union_type
:
7527 case DW_TAG_ptr_to_member_type
:
7528 case DW_TAG_set_type
:
7529 case DW_TAG_subrange_type
:
7530 case DW_TAG_base_type
:
7531 case DW_TAG_const_type
:
7532 case DW_TAG_file_type
:
7533 case DW_TAG_packed_type
:
7534 case DW_TAG_volatile_type
:
7535 case DW_TAG_typedef
:
7542 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
7543 Basically, we want to choose the bits that are likely to be shared between
7544 compilations (types) and leave out the bits that are specific to individual
7545 compilations (functions). */
7548 is_comdat_die (dw_die_ref c
)
7550 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
7551 we do for stabs. The advantage is a greater likelihood of sharing between
7552 objects that don't include headers in the same order (and therefore would
7553 put the base types in a different comdat). jason 8/28/00 */
7555 if (c
->die_tag
== DW_TAG_base_type
)
7558 if (c
->die_tag
== DW_TAG_pointer_type
7559 || c
->die_tag
== DW_TAG_reference_type
7560 || c
->die_tag
== DW_TAG_rvalue_reference_type
7561 || c
->die_tag
== DW_TAG_const_type
7562 || c
->die_tag
== DW_TAG_volatile_type
)
7564 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
7566 return t
? is_comdat_die (t
) : 0;
7569 return is_type_die (c
);
7572 /* Returns true iff C is a compile-unit DIE. */
7575 is_cu_die (dw_die_ref c
)
7577 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7578 || c
->die_tag
== DW_TAG_skeleton_unit
);
7581 /* Returns true iff C is a unit DIE of some sort. */
7584 is_unit_die (dw_die_ref c
)
7586 return c
&& (c
->die_tag
== DW_TAG_compile_unit
7587 || c
->die_tag
== DW_TAG_partial_unit
7588 || c
->die_tag
== DW_TAG_type_unit
7589 || c
->die_tag
== DW_TAG_skeleton_unit
);
7592 /* Returns true iff C is a namespace DIE. */
7595 is_namespace_die (dw_die_ref c
)
7597 return c
&& c
->die_tag
== DW_TAG_namespace
;
7600 /* Returns true iff C is a class or structure DIE. */
7603 is_class_die (dw_die_ref c
)
7605 return c
&& (c
->die_tag
== DW_TAG_class_type
7606 || c
->die_tag
== DW_TAG_structure_type
);
7609 /* Return non-zero if this DIE is a template parameter. */
7612 is_template_parameter (dw_die_ref die
)
7614 switch (die
->die_tag
)
7616 case DW_TAG_template_type_param
:
7617 case DW_TAG_template_value_param
:
7618 case DW_TAG_GNU_template_template_param
:
7619 case DW_TAG_GNU_template_parameter_pack
:
7626 /* Return non-zero if this DIE represents a template instantiation. */
7629 is_template_instantiation (dw_die_ref die
)
7633 if (!is_type_die (die
) && die
->die_tag
!= DW_TAG_subprogram
)
7635 FOR_EACH_CHILD (die
, c
, if (is_template_parameter (c
)) return true);
7640 gen_internal_sym (const char *prefix
)
7642 char buf
[MAX_ARTIFICIAL_LABEL_BYTES
];
7644 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
7645 return xstrdup (buf
);
7648 /* Return non-zero if this DIE is a declaration. */
7651 is_declaration_die (dw_die_ref die
)
7656 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7657 if (a
->dw_attr
== DW_AT_declaration
)
7663 /* Return non-zero if this DIE is nested inside a subprogram. */
7666 is_nested_in_subprogram (dw_die_ref die
)
7668 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
7672 return local_scope_p (decl
);
7675 /* Return non-zero if this DIE contains a defining declaration of a
7679 contains_subprogram_definition (dw_die_ref die
)
7683 if (die
->die_tag
== DW_TAG_subprogram
&& ! is_declaration_die (die
))
7685 FOR_EACH_CHILD (die
, c
, if (contains_subprogram_definition (c
)) return 1);
7689 /* Return non-zero if this is a type DIE that should be moved to a
7690 COMDAT .debug_types section or .debug_info section with DW_UT_*type
7694 should_move_die_to_comdat (dw_die_ref die
)
7696 switch (die
->die_tag
)
7698 case DW_TAG_class_type
:
7699 case DW_TAG_structure_type
:
7700 case DW_TAG_enumeration_type
:
7701 case DW_TAG_union_type
:
7702 /* Don't move declarations, inlined instances, types nested in a
7703 subprogram, or types that contain subprogram definitions. */
7704 if (is_declaration_die (die
)
7705 || get_AT (die
, DW_AT_abstract_origin
)
7706 || is_nested_in_subprogram (die
)
7707 || contains_subprogram_definition (die
))
7710 case DW_TAG_array_type
:
7711 case DW_TAG_interface_type
:
7712 case DW_TAG_pointer_type
:
7713 case DW_TAG_reference_type
:
7714 case DW_TAG_rvalue_reference_type
:
7715 case DW_TAG_string_type
:
7716 case DW_TAG_subroutine_type
:
7717 case DW_TAG_ptr_to_member_type
:
7718 case DW_TAG_set_type
:
7719 case DW_TAG_subrange_type
:
7720 case DW_TAG_base_type
:
7721 case DW_TAG_const_type
:
7722 case DW_TAG_file_type
:
7723 case DW_TAG_packed_type
:
7724 case DW_TAG_volatile_type
:
7725 case DW_TAG_typedef
:
7731 /* Make a clone of DIE. */
7734 clone_die (dw_die_ref die
)
7736 dw_die_ref clone
= new_die_raw (die
->die_tag
);
7740 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7741 add_dwarf_attr (clone
, a
);
7746 /* Make a clone of the tree rooted at DIE. */
7749 clone_tree (dw_die_ref die
)
7752 dw_die_ref clone
= clone_die (die
);
7754 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree (c
)));
7759 /* Make a clone of DIE as a declaration. */
7762 clone_as_declaration (dw_die_ref die
)
7769 /* If the DIE is already a declaration, just clone it. */
7770 if (is_declaration_die (die
))
7771 return clone_die (die
);
7773 /* If the DIE is a specification, just clone its declaration DIE. */
7774 decl
= get_AT_ref (die
, DW_AT_specification
);
7777 clone
= clone_die (decl
);
7778 if (die
->comdat_type_p
)
7779 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7783 clone
= new_die_raw (die
->die_tag
);
7785 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
7787 /* We don't want to copy over all attributes.
7788 For example we don't want DW_AT_byte_size because otherwise we will no
7789 longer have a declaration and GDB will treat it as a definition. */
7793 case DW_AT_abstract_origin
:
7794 case DW_AT_artificial
:
7795 case DW_AT_containing_type
:
7796 case DW_AT_external
:
7799 case DW_AT_virtuality
:
7800 case DW_AT_linkage_name
:
7801 case DW_AT_MIPS_linkage_name
:
7802 add_dwarf_attr (clone
, a
);
7804 case DW_AT_byte_size
:
7805 case DW_AT_alignment
:
7811 if (die
->comdat_type_p
)
7812 add_AT_die_ref (clone
, DW_AT_signature
, die
);
7814 add_AT_flag (clone
, DW_AT_declaration
, 1);
7819 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
7821 struct decl_table_entry
7827 /* Helpers to manipulate hash table of copied declarations. */
7829 /* Hashtable helpers. */
7831 struct decl_table_entry_hasher
: free_ptr_hash
<decl_table_entry
>
7833 typedef die_struct
*compare_type
;
7834 static inline hashval_t
hash (const decl_table_entry
*);
7835 static inline bool equal (const decl_table_entry
*, const die_struct
*);
7839 decl_table_entry_hasher::hash (const decl_table_entry
*entry
)
7841 return htab_hash_pointer (entry
->orig
);
7845 decl_table_entry_hasher::equal (const decl_table_entry
*entry1
,
7846 const die_struct
*entry2
)
7848 return entry1
->orig
== entry2
;
7851 typedef hash_table
<decl_table_entry_hasher
> decl_hash_type
;
7853 /* Copy DIE and its ancestors, up to, but not including, the compile unit
7854 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
7855 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
7856 to check if the ancestor has already been copied into UNIT. */
7859 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
,
7860 decl_hash_type
*decl_table
)
7862 dw_die_ref parent
= die
->die_parent
;
7863 dw_die_ref new_parent
= unit
;
7865 decl_table_entry
**slot
= NULL
;
7866 struct decl_table_entry
*entry
= NULL
;
7870 /* Check if the entry has already been copied to UNIT. */
7871 slot
= decl_table
->find_slot_with_hash (die
, htab_hash_pointer (die
),
7873 if (*slot
!= HTAB_EMPTY_ENTRY
)
7879 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
7880 entry
= XCNEW (struct decl_table_entry
);
7888 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
7891 if (!is_unit_die (parent
))
7892 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
7895 copy
= clone_as_declaration (die
);
7896 add_child_die (new_parent
, copy
);
7900 /* Record the pointer to the copy. */
7906 /* Copy the declaration context to the new type unit DIE. This includes
7907 any surrounding namespace or type declarations. If the DIE has an
7908 AT_specification attribute, it also includes attributes and children
7909 attached to the specification, and returns a pointer to the original
7910 parent of the declaration DIE. Returns NULL otherwise. */
7913 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
7916 dw_die_ref new_decl
;
7917 dw_die_ref orig_parent
= NULL
;
7919 decl
= get_AT_ref (die
, DW_AT_specification
);
7928 /* The original DIE will be changed to a declaration, and must
7929 be moved to be a child of the original declaration DIE. */
7930 orig_parent
= decl
->die_parent
;
7932 /* Copy the type node pointer from the new DIE to the original
7933 declaration DIE so we can forward references later. */
7934 decl
->comdat_type_p
= true;
7935 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
7937 remove_AT (die
, DW_AT_specification
);
7939 FOR_EACH_VEC_SAFE_ELT (decl
->die_attr
, ix
, a
)
7941 if (a
->dw_attr
!= DW_AT_name
7942 && a
->dw_attr
!= DW_AT_declaration
7943 && a
->dw_attr
!= DW_AT_external
)
7944 add_dwarf_attr (die
, a
);
7947 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree (c
)));
7950 if (decl
->die_parent
!= NULL
7951 && !is_unit_die (decl
->die_parent
))
7953 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
7954 if (new_decl
!= NULL
)
7956 remove_AT (new_decl
, DW_AT_signature
);
7957 add_AT_specification (die
, new_decl
);
7964 /* Generate the skeleton ancestor tree for the given NODE, then clone
7965 the DIE and add the clone into the tree. */
7968 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
7970 if (node
->new_die
!= NULL
)
7973 node
->new_die
= clone_as_declaration (node
->old_die
);
7975 if (node
->parent
!= NULL
)
7977 generate_skeleton_ancestor_tree (node
->parent
);
7978 add_child_die (node
->parent
->new_die
, node
->new_die
);
7982 /* Generate a skeleton tree of DIEs containing any declarations that are
7983 found in the original tree. We traverse the tree looking for declaration
7984 DIEs, and construct the skeleton from the bottom up whenever we find one. */
7987 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
7989 skeleton_chain_node node
;
7992 dw_die_ref prev
= NULL
;
7993 dw_die_ref next
= NULL
;
7995 node
.parent
= parent
;
7997 first
= c
= parent
->old_die
->die_child
;
8001 if (prev
== NULL
|| prev
->die_sib
== c
)
8004 next
= (c
== first
? NULL
: c
->die_sib
);
8006 node
.new_die
= NULL
;
8007 if (is_declaration_die (c
))
8009 if (is_template_instantiation (c
))
8011 /* Instantiated templates do not need to be cloned into the
8012 type unit. Just move the DIE and its children back to
8013 the skeleton tree (in the main CU). */
8014 remove_child_with_prev (c
, prev
);
8015 add_child_die (parent
->new_die
, c
);
8018 else if (c
->comdat_type_p
)
8020 /* This is the skeleton of earlier break_out_comdat_types
8021 type. Clone the existing DIE, but keep the children
8022 under the original (which is in the main CU). */
8023 dw_die_ref clone
= clone_die (c
);
8025 replace_child (c
, clone
, prev
);
8026 generate_skeleton_ancestor_tree (parent
);
8027 add_child_die (parent
->new_die
, c
);
8033 /* Clone the existing DIE, move the original to the skeleton
8034 tree (which is in the main CU), and put the clone, with
8035 all the original's children, where the original came from
8036 (which is about to be moved to the type unit). */
8037 dw_die_ref clone
= clone_die (c
);
8038 move_all_children (c
, clone
);
8040 /* If the original has a DW_AT_object_pointer attribute,
8041 it would now point to a child DIE just moved to the
8042 cloned tree, so we need to remove that attribute from
8044 remove_AT (c
, DW_AT_object_pointer
);
8046 replace_child (c
, clone
, prev
);
8047 generate_skeleton_ancestor_tree (parent
);
8048 add_child_die (parent
->new_die
, c
);
8049 node
.old_die
= clone
;
8054 generate_skeleton_bottom_up (&node
);
8055 } while (next
!= NULL
);
8058 /* Wrapper function for generate_skeleton_bottom_up. */
8061 generate_skeleton (dw_die_ref die
)
8063 skeleton_chain_node node
;
8066 node
.new_die
= NULL
;
8069 /* If this type definition is nested inside another type,
8070 and is not an instantiation of a template, always leave
8071 at least a declaration in its place. */
8072 if (die
->die_parent
!= NULL
8073 && is_type_die (die
->die_parent
)
8074 && !is_template_instantiation (die
))
8075 node
.new_die
= clone_as_declaration (die
);
8077 generate_skeleton_bottom_up (&node
);
8078 return node
.new_die
;
8081 /* Remove the CHILD DIE from its parent, possibly replacing it with a cloned
8082 declaration. The original DIE is moved to a new compile unit so that
8083 existing references to it follow it to the new location. If any of the
8084 original DIE's descendants is a declaration, we need to replace the
8085 original DIE with a skeleton tree and move the declarations back into the
8089 remove_child_or_replace_with_skeleton (dw_die_ref unit
, dw_die_ref child
,
8092 dw_die_ref skeleton
, orig_parent
;
8094 /* Copy the declaration context to the type unit DIE. If the returned
8095 ORIG_PARENT is not NULL, the skeleton needs to be added as a child of
8097 orig_parent
= copy_declaration_context (unit
, child
);
8099 skeleton
= generate_skeleton (child
);
8100 if (skeleton
== NULL
)
8101 remove_child_with_prev (child
, prev
);
8104 skeleton
->comdat_type_p
= true;
8105 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
8107 /* If the original DIE was a specification, we need to put
8108 the skeleton under the parent DIE of the declaration.
8109 This leaves the original declaration in the tree, but
8110 it will be pruned later since there are no longer any
8111 references to it. */
8112 if (orig_parent
!= NULL
)
8114 remove_child_with_prev (child
, prev
);
8115 add_child_die (orig_parent
, skeleton
);
8118 replace_child (child
, skeleton
, prev
);
8125 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8126 comdat_type_node
*type_node
,
8127 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
);
8129 /* Helper for copy_dwarf_procs_ref_in_dies. Make a copy of the DIE DWARF
8130 procedure, put it under TYPE_NODE and return the copy. Continue looking for
8131 DWARF procedure references in the DW_AT_location attribute. */
8134 copy_dwarf_procedure (dw_die_ref die
,
8135 comdat_type_node
*type_node
,
8136 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8138 gcc_assert (die
->die_tag
== DW_TAG_dwarf_procedure
);
8140 /* DWARF procedures are not supposed to have children... */
8141 gcc_assert (die
->die_child
== NULL
);
8143 /* ... and they are supposed to have only one attribute: DW_AT_location. */
8144 gcc_assert (vec_safe_length (die
->die_attr
) == 1
8145 && ((*die
->die_attr
)[0].dw_attr
== DW_AT_location
));
8147 /* Do not copy more than once DWARF procedures. */
8149 dw_die_ref
&die_copy
= copied_dwarf_procs
.get_or_insert (die
, &existed
);
8153 die_copy
= clone_die (die
);
8154 add_child_die (type_node
->root_die
, die_copy
);
8155 copy_dwarf_procs_ref_in_attrs (die_copy
, type_node
, copied_dwarf_procs
);
8159 /* Helper for copy_dwarf_procs_ref_in_dies. Look for references to DWARF
8160 procedures in DIE's attributes. */
8163 copy_dwarf_procs_ref_in_attrs (dw_die_ref die
,
8164 comdat_type_node
*type_node
,
8165 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8170 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, i
, a
)
8172 dw_loc_descr_ref loc
;
8174 if (a
->dw_attr_val
.val_class
!= dw_val_class_loc
)
8177 for (loc
= a
->dw_attr_val
.v
.val_loc
; loc
!= NULL
; loc
= loc
->dw_loc_next
)
8179 switch (loc
->dw_loc_opc
)
8183 case DW_OP_call_ref
:
8184 gcc_assert (loc
->dw_loc_oprnd1
.val_class
8185 == dw_val_class_die_ref
);
8186 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
8187 = copy_dwarf_procedure (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
,
8189 copied_dwarf_procs
);
8198 /* Copy DWARF procedures that are referenced by the DIE tree to TREE_NODE and
8199 rewrite references to point to the copies.
8201 References are looked for in DIE's attributes and recursively in all its
8202 children attributes that are location descriptions. COPIED_DWARF_PROCS is a
8203 mapping from old DWARF procedures to their copy. It is used not to copy
8204 twice the same DWARF procedure under TYPE_NODE. */
8207 copy_dwarf_procs_ref_in_dies (dw_die_ref die
,
8208 comdat_type_node
*type_node
,
8209 hash_map
<dw_die_ref
, dw_die_ref
> &copied_dwarf_procs
)
8213 copy_dwarf_procs_ref_in_attrs (die
, type_node
, copied_dwarf_procs
);
8214 FOR_EACH_CHILD (die
, c
, copy_dwarf_procs_ref_in_dies (c
,
8216 copied_dwarf_procs
));
8219 /* Traverse the DIE and set up additional .debug_types or .debug_info
8220 DW_UT_*type sections for each type worthy of being placed in a COMDAT
8224 break_out_comdat_types (dw_die_ref die
)
8228 dw_die_ref prev
= NULL
;
8229 dw_die_ref next
= NULL
;
8230 dw_die_ref unit
= NULL
;
8232 first
= c
= die
->die_child
;
8236 if (prev
== NULL
|| prev
->die_sib
== c
)
8239 next
= (c
== first
? NULL
: c
->die_sib
);
8240 if (should_move_die_to_comdat (c
))
8242 dw_die_ref replacement
;
8243 comdat_type_node
*type_node
;
8245 /* Break out nested types into their own type units. */
8246 break_out_comdat_types (c
);
8248 /* Create a new type unit DIE as the root for the new tree, and
8249 add it to the list of comdat types. */
8250 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
8251 add_AT_unsigned (unit
, DW_AT_language
,
8252 get_AT_unsigned (comp_unit_die (), DW_AT_language
));
8253 type_node
= ggc_cleared_alloc
<comdat_type_node
> ();
8254 type_node
->root_die
= unit
;
8255 type_node
->next
= comdat_type_list
;
8256 comdat_type_list
= type_node
;
8258 /* Generate the type signature. */
8259 generate_type_signature (c
, type_node
);
8261 /* Copy the declaration context, attributes, and children of the
8262 declaration into the new type unit DIE, then remove this DIE
8263 from the main CU (or replace it with a skeleton if necessary). */
8264 replacement
= remove_child_or_replace_with_skeleton (unit
, c
, prev
);
8265 type_node
->skeleton_die
= replacement
;
8267 /* Add the DIE to the new compunit. */
8268 add_child_die (unit
, c
);
8270 /* Types can reference DWARF procedures for type size or data location
8271 expressions. Calls in DWARF expressions cannot target procedures
8272 that are not in the same section. So we must copy DWARF procedures
8273 along with this type and then rewrite references to them. */
8274 hash_map
<dw_die_ref
, dw_die_ref
> copied_dwarf_procs
;
8275 copy_dwarf_procs_ref_in_dies (c
, type_node
, copied_dwarf_procs
);
8277 if (replacement
!= NULL
)
8280 else if (c
->die_tag
== DW_TAG_namespace
8281 || c
->die_tag
== DW_TAG_class_type
8282 || c
->die_tag
== DW_TAG_structure_type
8283 || c
->die_tag
== DW_TAG_union_type
)
8285 /* Look for nested types that can be broken out. */
8286 break_out_comdat_types (c
);
8288 } while (next
!= NULL
);
8291 /* Like clone_tree, but copy DW_TAG_subprogram DIEs as declarations.
8292 Enter all the cloned children into the hash table decl_table. */
8295 clone_tree_partial (dw_die_ref die
, decl_hash_type
*decl_table
)
8299 struct decl_table_entry
*entry
;
8300 decl_table_entry
**slot
;
8302 if (die
->die_tag
== DW_TAG_subprogram
)
8303 clone
= clone_as_declaration (die
);
8305 clone
= clone_die (die
);
8307 slot
= decl_table
->find_slot_with_hash (die
,
8308 htab_hash_pointer (die
), INSERT
);
8310 /* Assert that DIE isn't in the hash table yet. If it would be there
8311 before, the ancestors would be necessarily there as well, therefore
8312 clone_tree_partial wouldn't be called. */
8313 gcc_assert (*slot
== HTAB_EMPTY_ENTRY
);
8315 entry
= XCNEW (struct decl_table_entry
);
8317 entry
->copy
= clone
;
8320 if (die
->die_tag
!= DW_TAG_subprogram
)
8321 FOR_EACH_CHILD (die
, c
,
8322 add_child_die (clone
, clone_tree_partial (c
, decl_table
)));
8327 /* Walk the DIE and its children, looking for references to incomplete
8328 or trivial types that are unmarked (i.e., that are not in the current
8332 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, decl_hash_type
*decl_table
)
8338 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8340 if (AT_class (a
) == dw_val_class_die_ref
)
8342 dw_die_ref targ
= AT_ref (a
);
8343 decl_table_entry
**slot
;
8344 struct decl_table_entry
*entry
;
8346 if (targ
->die_mark
!= 0 || targ
->comdat_type_p
)
8349 slot
= decl_table
->find_slot_with_hash (targ
,
8350 htab_hash_pointer (targ
),
8353 if (*slot
!= HTAB_EMPTY_ENTRY
)
8355 /* TARG has already been copied, so we just need to
8356 modify the reference to point to the copy. */
8358 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
8362 dw_die_ref parent
= unit
;
8363 dw_die_ref copy
= clone_die (targ
);
8365 /* Record in DECL_TABLE that TARG has been copied.
8366 Need to do this now, before the recursive call,
8367 because DECL_TABLE may be expanded and SLOT
8368 would no longer be a valid pointer. */
8369 entry
= XCNEW (struct decl_table_entry
);
8374 /* If TARG is not a declaration DIE, we need to copy its
8376 if (!is_declaration_die (targ
))
8380 add_child_die (copy
,
8381 clone_tree_partial (c
, decl_table
)));
8384 /* Make sure the cloned tree is marked as part of the
8388 /* If TARG has surrounding context, copy its ancestor tree
8389 into the new type unit. */
8390 if (targ
->die_parent
!= NULL
8391 && !is_unit_die (targ
->die_parent
))
8392 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
8395 add_child_die (parent
, copy
);
8396 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
8398 /* Make sure the newly-copied DIE is walked. If it was
8399 installed in a previously-added context, it won't
8400 get visited otherwise. */
8403 /* Find the highest point of the newly-added tree,
8404 mark each node along the way, and walk from there. */
8405 parent
->die_mark
= 1;
8406 while (parent
->die_parent
8407 && parent
->die_parent
->die_mark
== 0)
8409 parent
= parent
->die_parent
;
8410 parent
->die_mark
= 1;
8412 copy_decls_walk (unit
, parent
, decl_table
);
8418 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
8421 /* Copy declarations for "unworthy" types into the new comdat section.
8422 Incomplete types, modified types, and certain other types aren't broken
8423 out into comdat sections of their own, so they don't have a signature,
8424 and we need to copy the declaration into the same section so that we
8425 don't have an external reference. */
8428 copy_decls_for_unworthy_types (dw_die_ref unit
)
8431 decl_hash_type
decl_table (10);
8432 copy_decls_walk (unit
, unit
, &decl_table
);
8436 /* Traverse the DIE and add a sibling attribute if it may have the
8437 effect of speeding up access to siblings. To save some space,
8438 avoid generating sibling attributes for DIE's without children. */
8441 add_sibling_attributes (dw_die_ref die
)
8445 if (! die
->die_child
)
8448 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
8449 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
8451 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
8454 /* Output all location lists for the DIE and its children. */
8457 output_location_lists (dw_die_ref die
)
8463 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8464 if (AT_class (a
) == dw_val_class_loc_list
)
8465 output_loc_list (AT_loc_list (a
));
8467 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
8470 /* During assign_location_list_indexes and output_loclists_offset the
8471 current index, after it the number of assigned indexes (i.e. how
8472 large the .debug_loclists* offset table should be). */
8473 static unsigned int loc_list_idx
;
8475 /* Output all location list offsets for the DIE and its children. */
8478 output_loclists_offsets (dw_die_ref die
)
8484 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8485 if (AT_class (a
) == dw_val_class_loc_list
)
8487 dw_loc_list_ref l
= AT_loc_list (a
);
8488 if (l
->offset_emitted
)
8490 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l
->ll_symbol
,
8491 loc_section_label
, NULL
);
8492 gcc_assert (l
->hash
== loc_list_idx
);
8494 l
->offset_emitted
= true;
8497 FOR_EACH_CHILD (die
, c
, output_loclists_offsets (c
));
8500 /* Recursively set indexes of location lists. */
8503 assign_location_list_indexes (dw_die_ref die
)
8509 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8510 if (AT_class (a
) == dw_val_class_loc_list
)
8512 dw_loc_list_ref list
= AT_loc_list (a
);
8513 if (!list
->num_assigned
)
8515 list
->num_assigned
= true;
8516 list
->hash
= loc_list_idx
++;
8520 FOR_EACH_CHILD (die
, c
, assign_location_list_indexes (c
));
8523 /* We want to limit the number of external references, because they are
8524 larger than local references: a relocation takes multiple words, and
8525 even a sig8 reference is always eight bytes, whereas a local reference
8526 can be as small as one byte (though DW_FORM_ref is usually 4 in GCC).
8527 So if we encounter multiple external references to the same type DIE, we
8528 make a local typedef stub for it and redirect all references there.
8530 This is the element of the hash table for keeping track of these
8540 /* Hashtable helpers. */
8542 struct external_ref_hasher
: free_ptr_hash
<external_ref
>
8544 static inline hashval_t
hash (const external_ref
*);
8545 static inline bool equal (const external_ref
*, const external_ref
*);
8549 external_ref_hasher::hash (const external_ref
*r
)
8551 dw_die_ref die
= r
->type
;
8554 /* We can't use the address of the DIE for hashing, because
8555 that will make the order of the stub DIEs non-deterministic. */
8556 if (! die
->comdat_type_p
)
8557 /* We have a symbol; use it to compute a hash. */
8558 h
= htab_hash_string (die
->die_id
.die_symbol
);
8561 /* We have a type signature; use a subset of the bits as the hash.
8562 The 8-byte signature is at least as large as hashval_t. */
8563 comdat_type_node
*type_node
= die
->die_id
.die_type_node
;
8564 memcpy (&h
, type_node
->signature
, sizeof (h
));
8570 external_ref_hasher::equal (const external_ref
*r1
, const external_ref
*r2
)
8572 return r1
->type
== r2
->type
;
8575 typedef hash_table
<external_ref_hasher
> external_ref_hash_type
;
8577 /* Return a pointer to the external_ref for references to DIE. */
8579 static struct external_ref
*
8580 lookup_external_ref (external_ref_hash_type
*map
, dw_die_ref die
)
8582 struct external_ref ref
, *ref_p
;
8583 external_ref
**slot
;
8586 slot
= map
->find_slot (&ref
, INSERT
);
8587 if (*slot
!= HTAB_EMPTY_ENTRY
)
8590 ref_p
= XCNEW (struct external_ref
);
8596 /* Subroutine of optimize_external_refs, below.
8598 If we see a type skeleton, record it as our stub. If we see external
8599 references, remember how many we've seen. */
8602 optimize_external_refs_1 (dw_die_ref die
, external_ref_hash_type
*map
)
8607 struct external_ref
*ref_p
;
8609 if (is_type_die (die
)
8610 && (c
= get_AT_ref (die
, DW_AT_signature
)))
8612 /* This is a local skeleton; use it for local references. */
8613 ref_p
= lookup_external_ref (map
, c
);
8617 /* Scan the DIE references, and remember any that refer to DIEs from
8618 other CUs (i.e. those which are not marked). */
8619 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8620 if (AT_class (a
) == dw_val_class_die_ref
8621 && (c
= AT_ref (a
))->die_mark
== 0
8624 ref_p
= lookup_external_ref (map
, c
);
8628 FOR_EACH_CHILD (die
, c
, optimize_external_refs_1 (c
, map
));
8631 /* htab_traverse callback function for optimize_external_refs, below. SLOT
8632 points to an external_ref, DATA is the CU we're processing. If we don't
8633 already have a local stub, and we have multiple refs, build a stub. */
8636 dwarf2_build_local_stub (external_ref
**slot
, dw_die_ref data
)
8638 struct external_ref
*ref_p
= *slot
;
8640 if (ref_p
->stub
== NULL
&& ref_p
->n_refs
> 1 && !dwarf_strict
)
8642 /* We have multiple references to this type, so build a small stub.
8643 Both of these forms are a bit dodgy from the perspective of the
8644 DWARF standard, since technically they should have names. */
8645 dw_die_ref cu
= data
;
8646 dw_die_ref type
= ref_p
->type
;
8647 dw_die_ref stub
= NULL
;
8649 if (type
->comdat_type_p
)
8651 /* If we refer to this type via sig8, use AT_signature. */
8652 stub
= new_die (type
->die_tag
, cu
, NULL_TREE
);
8653 add_AT_die_ref (stub
, DW_AT_signature
, type
);
8657 /* Otherwise, use a typedef with no name. */
8658 stub
= new_die (DW_TAG_typedef
, cu
, NULL_TREE
);
8659 add_AT_die_ref (stub
, DW_AT_type
, type
);
8668 /* DIE is a unit; look through all the DIE references to see if there are
8669 any external references to types, and if so, create local stubs for
8670 them which will be applied in build_abbrev_table. This is useful because
8671 references to local DIEs are smaller. */
8673 static external_ref_hash_type
*
8674 optimize_external_refs (dw_die_ref die
)
8676 external_ref_hash_type
*map
= new external_ref_hash_type (10);
8677 optimize_external_refs_1 (die
, map
);
8678 map
->traverse
<dw_die_ref
, dwarf2_build_local_stub
> (die
);
8682 /* The following 3 variables are temporaries that are computed only during the
8683 build_abbrev_table call and used and released during the following
8684 optimize_abbrev_table call. */
8686 /* First abbrev_id that can be optimized based on usage. */
8687 static unsigned int abbrev_opt_start
;
8689 /* Maximum abbrev_id of a base type plus one (we can't optimize DIEs with
8690 abbrev_id smaller than this, because they must be already sized
8691 during build_abbrev_table). */
8692 static unsigned int abbrev_opt_base_type_end
;
8694 /* Vector of usage counts during build_abbrev_table. Indexed by
8695 abbrev_id - abbrev_opt_start. */
8696 static vec
<unsigned int> abbrev_usage_count
;
8698 /* Vector of all DIEs added with die_abbrev >= abbrev_opt_start. */
8699 static vec
<dw_die_ref
> sorted_abbrev_dies
;
8701 /* The format of each DIE (and its attribute value pairs) is encoded in an
8702 abbreviation table. This routine builds the abbreviation table and assigns
8703 a unique abbreviation id for each abbreviation entry. The children of each
8704 die are visited recursively. */
8707 build_abbrev_table (dw_die_ref die
, external_ref_hash_type
*extern_map
)
8709 unsigned int abbrev_id
= 0;
8715 /* Scan the DIE references, and replace any that refer to
8716 DIEs from other CUs (i.e. those which are not marked) with
8717 the local stubs we built in optimize_external_refs. */
8718 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8719 if (AT_class (a
) == dw_val_class_die_ref
8720 && (c
= AT_ref (a
))->die_mark
== 0)
8722 struct external_ref
*ref_p
;
8723 gcc_assert (AT_ref (a
)->comdat_type_p
|| AT_ref (a
)->die_id
.die_symbol
);
8725 ref_p
= lookup_external_ref (extern_map
, c
);
8726 if (ref_p
->stub
&& ref_p
->stub
!= die
)
8727 change_AT_die_ref (a
, ref_p
->stub
);
8729 /* We aren't changing this reference, so mark it external. */
8730 set_AT_ref_external (a
, 1);
8733 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
8735 dw_attr_node
*die_a
, *abbrev_a
;
8741 if (abbrev
->die_tag
!= die
->die_tag
)
8743 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
8746 if (vec_safe_length (abbrev
->die_attr
) != vec_safe_length (die
->die_attr
))
8749 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, die_a
)
8751 abbrev_a
= &(*abbrev
->die_attr
)[ix
];
8752 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
8753 || (value_format (abbrev_a
) != value_format (die_a
)))
8763 if (abbrev_id
>= vec_safe_length (abbrev_die_table
))
8765 vec_safe_push (abbrev_die_table
, die
);
8766 if (abbrev_opt_start
)
8767 abbrev_usage_count
.safe_push (0);
8769 if (abbrev_opt_start
&& abbrev_id
>= abbrev_opt_start
)
8771 abbrev_usage_count
[abbrev_id
- abbrev_opt_start
]++;
8772 sorted_abbrev_dies
.safe_push (die
);
8775 die
->die_abbrev
= abbrev_id
;
8776 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
, extern_map
));
8779 /* Callback function for sorted_abbrev_dies vector sorting. We sort
8780 by die_abbrev's usage count, from the most commonly used
8781 abbreviation to the least. */
8784 die_abbrev_cmp (const void *p1
, const void *p2
)
8786 dw_die_ref die1
= *(const dw_die_ref
*) p1
;
8787 dw_die_ref die2
= *(const dw_die_ref
*) p2
;
8789 gcc_checking_assert (die1
->die_abbrev
>= abbrev_opt_start
);
8790 gcc_checking_assert (die2
->die_abbrev
>= abbrev_opt_start
);
8792 if (die1
->die_abbrev
>= abbrev_opt_base_type_end
8793 && die2
->die_abbrev
>= abbrev_opt_base_type_end
)
8795 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
8796 > abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
8798 if (abbrev_usage_count
[die1
->die_abbrev
- abbrev_opt_start
]
8799 < abbrev_usage_count
[die2
->die_abbrev
- abbrev_opt_start
])
8803 /* Stabilize the sort. */
8804 if (die1
->die_abbrev
< die2
->die_abbrev
)
8806 if (die1
->die_abbrev
> die2
->die_abbrev
)
8812 /* Convert dw_val_class_const and dw_val_class_unsigned_const class attributes
8813 of DIEs in between sorted_abbrev_dies[first_id] and abbrev_dies[end_id - 1]
8814 into dw_val_class_const_implicit or
8815 dw_val_class_unsigned_const_implicit. */
8818 optimize_implicit_const (unsigned int first_id
, unsigned int end
,
8819 vec
<bool> &implicit_consts
)
8821 /* It never makes sense if there is just one DIE using the abbreviation. */
8822 if (end
< first_id
+ 2)
8827 dw_die_ref die
= sorted_abbrev_dies
[first_id
];
8828 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8829 if (implicit_consts
[ix
])
8831 enum dw_val_class new_class
= dw_val_class_none
;
8832 switch (AT_class (a
))
8834 case dw_val_class_unsigned_const
:
8835 if ((HOST_WIDE_INT
) AT_unsigned (a
) < 0)
8838 /* The .debug_abbrev section will grow by
8839 size_of_sleb128 (AT_unsigned (a)) and we avoid the constants
8840 in all the DIEs using that abbreviation. */
8841 if (constant_size (AT_unsigned (a
)) * (end
- first_id
)
8842 <= (unsigned) size_of_sleb128 (AT_unsigned (a
)))
8845 new_class
= dw_val_class_unsigned_const_implicit
;
8848 case dw_val_class_const
:
8849 new_class
= dw_val_class_const_implicit
;
8852 case dw_val_class_file
:
8853 new_class
= dw_val_class_file_implicit
;
8859 for (i
= first_id
; i
< end
; i
++)
8860 (*sorted_abbrev_dies
[i
]->die_attr
)[ix
].dw_attr_val
.val_class
8865 /* Attempt to optimize abbreviation table from abbrev_opt_start
8866 abbreviation above. */
8869 optimize_abbrev_table (void)
8871 if (abbrev_opt_start
8872 && vec_safe_length (abbrev_die_table
) > abbrev_opt_start
8873 && (dwarf_version
>= 5 || vec_safe_length (abbrev_die_table
) > 127))
8875 auto_vec
<bool, 32> implicit_consts
;
8876 sorted_abbrev_dies
.qsort (die_abbrev_cmp
);
8878 unsigned int abbrev_id
= abbrev_opt_start
- 1;
8879 unsigned int first_id
= ~0U;
8880 unsigned int last_abbrev_id
= 0;
8883 if (abbrev_opt_base_type_end
> abbrev_opt_start
)
8884 abbrev_id
= abbrev_opt_base_type_end
- 1;
8885 /* Reassign abbreviation ids from abbrev_opt_start above, so that
8886 most commonly used abbreviations come first. */
8887 FOR_EACH_VEC_ELT (sorted_abbrev_dies
, i
, die
)
8892 /* If calc_base_type_die_sizes has been called, the CU and
8893 base types after it can't be optimized, because we've already
8894 calculated their DIE offsets. We've sorted them first. */
8895 if (die
->die_abbrev
< abbrev_opt_base_type_end
)
8897 if (die
->die_abbrev
!= last_abbrev_id
)
8899 last_abbrev_id
= die
->die_abbrev
;
8900 if (dwarf_version
>= 5 && first_id
!= ~0U)
8901 optimize_implicit_const (first_id
, i
, implicit_consts
);
8903 (*abbrev_die_table
)[abbrev_id
] = die
;
8904 if (dwarf_version
>= 5)
8907 implicit_consts
.truncate (0);
8909 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8910 switch (AT_class (a
))
8912 case dw_val_class_const
:
8913 case dw_val_class_unsigned_const
:
8914 case dw_val_class_file
:
8915 implicit_consts
.safe_push (true);
8918 implicit_consts
.safe_push (false);
8923 else if (dwarf_version
>= 5)
8925 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8926 if (!implicit_consts
[ix
])
8930 dw_attr_node
*other_a
8931 = &(*(*abbrev_die_table
)[abbrev_id
]->die_attr
)[ix
];
8932 if (!dw_val_equal_p (&a
->dw_attr_val
,
8933 &other_a
->dw_attr_val
))
8934 implicit_consts
[ix
] = false;
8937 die
->die_abbrev
= abbrev_id
;
8939 gcc_assert (abbrev_id
== vec_safe_length (abbrev_die_table
) - 1);
8940 if (dwarf_version
>= 5 && first_id
!= ~0U)
8941 optimize_implicit_const (first_id
, i
, implicit_consts
);
8944 abbrev_opt_start
= 0;
8945 abbrev_opt_base_type_end
= 0;
8946 abbrev_usage_count
.release ();
8947 sorted_abbrev_dies
.release ();
8950 /* Return the power-of-two number of bytes necessary to represent VALUE. */
8953 constant_size (unsigned HOST_WIDE_INT value
)
8960 log
= floor_log2 (value
);
8963 log
= 1 << (floor_log2 (log
) + 1);
8968 /* Return the size of a DIE as it is represented in the
8969 .debug_info section. */
8971 static unsigned long
8972 size_of_die (dw_die_ref die
)
8974 unsigned long size
= 0;
8977 enum dwarf_form form
;
8979 size
+= size_of_uleb128 (die
->die_abbrev
);
8980 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
8982 switch (AT_class (a
))
8984 case dw_val_class_addr
:
8985 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
8987 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
8988 size
+= size_of_uleb128 (AT_index (a
));
8991 size
+= DWARF2_ADDR_SIZE
;
8993 case dw_val_class_offset
:
8994 size
+= DWARF_OFFSET_SIZE
;
8996 case dw_val_class_loc
:
8998 unsigned long lsize
= size_of_locs (AT_loc (a
));
9001 if (dwarf_version
>= 4)
9002 size
+= size_of_uleb128 (lsize
);
9004 size
+= constant_size (lsize
);
9008 case dw_val_class_loc_list
:
9009 if (dwarf_split_debug_info
&& dwarf_version
>= 5)
9011 gcc_assert (AT_loc_list (a
)->num_assigned
);
9012 size
+= size_of_uleb128 (AT_loc_list (a
)->hash
);
9015 size
+= DWARF_OFFSET_SIZE
;
9017 case dw_val_class_range_list
:
9018 if (value_format (a
) == DW_FORM_rnglistx
)
9020 gcc_assert (rnglist_idx
);
9021 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
9022 size
+= size_of_uleb128 (r
->idx
);
9025 size
+= DWARF_OFFSET_SIZE
;
9027 case dw_val_class_const
:
9028 size
+= size_of_sleb128 (AT_int (a
));
9030 case dw_val_class_unsigned_const
:
9032 int csize
= constant_size (AT_unsigned (a
));
9033 if (dwarf_version
== 3
9034 && a
->dw_attr
== DW_AT_data_member_location
9036 size
+= size_of_uleb128 (AT_unsigned (a
));
9041 case dw_val_class_const_implicit
:
9042 case dw_val_class_unsigned_const_implicit
:
9043 case dw_val_class_file_implicit
:
9044 /* These occupy no size in the DIE, just an extra sleb128 in
9047 case dw_val_class_const_double
:
9048 size
+= HOST_BITS_PER_DOUBLE_INT
/ HOST_BITS_PER_CHAR
;
9049 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
9052 case dw_val_class_wide_int
:
9053 size
+= (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9054 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
9055 if (get_full_len (*a
->dw_attr_val
.v
.val_wide
)
9056 * HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
9059 case dw_val_class_vec
:
9060 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
9061 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
9062 + a
->dw_attr_val
.v
.val_vec
.length
9063 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
9065 case dw_val_class_flag
:
9066 if (dwarf_version
>= 4)
9067 /* Currently all add_AT_flag calls pass in 1 as last argument,
9068 so DW_FORM_flag_present can be used. If that ever changes,
9069 we'll need to use DW_FORM_flag and have some optimization
9070 in build_abbrev_table that will change those to
9071 DW_FORM_flag_present if it is set to 1 in all DIEs using
9072 the same abbrev entry. */
9073 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9077 case dw_val_class_die_ref
:
9078 if (AT_ref_external (a
))
9080 /* In DWARF4, we use DW_FORM_ref_sig8; for earlier versions
9081 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
9082 is sized by target address length, whereas in DWARF3
9083 it's always sized as an offset. */
9084 if (use_debug_types
)
9085 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
9086 else if (dwarf_version
== 2)
9087 size
+= DWARF2_ADDR_SIZE
;
9089 size
+= DWARF_OFFSET_SIZE
;
9092 size
+= DWARF_OFFSET_SIZE
;
9094 case dw_val_class_fde_ref
:
9095 size
+= DWARF_OFFSET_SIZE
;
9097 case dw_val_class_lbl_id
:
9098 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9100 gcc_assert (AT_index (a
) != NO_INDEX_ASSIGNED
);
9101 size
+= size_of_uleb128 (AT_index (a
));
9104 size
+= DWARF2_ADDR_SIZE
;
9106 case dw_val_class_lineptr
:
9107 case dw_val_class_macptr
:
9108 case dw_val_class_loclistsptr
:
9109 size
+= DWARF_OFFSET_SIZE
;
9111 case dw_val_class_str
:
9112 form
= AT_string_form (a
);
9113 if (form
== DW_FORM_strp
|| form
== DW_FORM_line_strp
)
9114 size
+= DWARF_OFFSET_SIZE
;
9115 else if (form
== DW_FORM_GNU_str_index
)
9116 size
+= size_of_uleb128 (AT_index (a
));
9118 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
9120 case dw_val_class_file
:
9121 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
9123 case dw_val_class_data8
:
9126 case dw_val_class_vms_delta
:
9127 size
+= DWARF_OFFSET_SIZE
;
9129 case dw_val_class_high_pc
:
9130 size
+= DWARF2_ADDR_SIZE
;
9132 case dw_val_class_discr_value
:
9133 size
+= size_of_discr_value (&a
->dw_attr_val
.v
.val_discr_value
);
9135 case dw_val_class_discr_list
:
9137 unsigned block_size
= size_of_discr_list (AT_discr_list (a
));
9139 /* This is a block, so we have the block length and then its
9141 size
+= constant_size (block_size
) + block_size
;
9152 /* Size the debugging information associated with a given DIE. Visits the
9153 DIE's children recursively. Updates the global variable next_die_offset, on
9154 each time through. Uses the current value of next_die_offset to update the
9155 die_offset field in each DIE. */
9158 calc_die_sizes (dw_die_ref die
)
9162 gcc_assert (die
->die_offset
== 0
9163 || (unsigned long int) die
->die_offset
== next_die_offset
);
9164 die
->die_offset
= next_die_offset
;
9165 next_die_offset
+= size_of_die (die
);
9167 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
9169 if (die
->die_child
!= NULL
)
9170 /* Count the null byte used to terminate sibling lists. */
9171 next_die_offset
+= 1;
9174 /* Size just the base type children at the start of the CU.
9175 This is needed because build_abbrev needs to size locs
9176 and sizing of type based stack ops needs to know die_offset
9177 values for the base types. */
9180 calc_base_type_die_sizes (void)
9182 unsigned long die_offset
= (dwarf_split_debug_info
9183 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
9184 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
9186 dw_die_ref base_type
;
9187 #if ENABLE_ASSERT_CHECKING
9188 dw_die_ref prev
= comp_unit_die ()->die_child
;
9191 die_offset
+= size_of_die (comp_unit_die ());
9192 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
9194 #if ENABLE_ASSERT_CHECKING
9195 gcc_assert (base_type
->die_offset
== 0
9196 && prev
->die_sib
== base_type
9197 && base_type
->die_child
== NULL
9198 && base_type
->die_abbrev
);
9201 if (abbrev_opt_start
9202 && base_type
->die_abbrev
>= abbrev_opt_base_type_end
)
9203 abbrev_opt_base_type_end
= base_type
->die_abbrev
+ 1;
9204 base_type
->die_offset
= die_offset
;
9205 die_offset
+= size_of_die (base_type
);
9209 /* Set the marks for a die and its children. We do this so
9210 that we know whether or not a reference needs to use FORM_ref_addr; only
9211 DIEs in the same CU will be marked. We used to clear out the offset
9212 and use that as the flag, but ran into ordering problems. */
9215 mark_dies (dw_die_ref die
)
9219 gcc_assert (!die
->die_mark
);
9222 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
9225 /* Clear the marks for a die and its children. */
9228 unmark_dies (dw_die_ref die
)
9232 if (! use_debug_types
)
9233 gcc_assert (die
->die_mark
);
9236 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
9239 /* Clear the marks for a die, its children and referred dies. */
9242 unmark_all_dies (dw_die_ref die
)
9252 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
9254 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
9255 if (AT_class (a
) == dw_val_class_die_ref
)
9256 unmark_all_dies (AT_ref (a
));
9259 /* Calculate if the entry should appear in the final output file. It may be
9260 from a pruned a type. */
9263 include_pubname_in_output (vec
<pubname_entry
, va_gc
> *table
, pubname_entry
*p
)
9265 /* By limiting gnu pubnames to definitions only, gold can generate a
9266 gdb index without entries for declarations, which don't include
9267 enough information to be useful. */
9268 if (debug_generate_pub_sections
== 2 && is_declaration_die (p
->die
))
9271 if (table
== pubname_table
)
9273 /* Enumerator names are part of the pubname table, but the
9274 parent DW_TAG_enumeration_type die may have been pruned.
9275 Don't output them if that is the case. */
9276 if (p
->die
->die_tag
== DW_TAG_enumerator
&&
9277 (p
->die
->die_parent
== NULL
9278 || !p
->die
->die_parent
->die_perennial_p
))
9281 /* Everything else in the pubname table is included. */
9285 /* The pubtypes table shouldn't include types that have been
9287 return (p
->die
->die_offset
!= 0
9288 || !flag_eliminate_unused_debug_types
);
9291 /* Return the size of the .debug_pubnames or .debug_pubtypes table
9292 generated for the compilation unit. */
9294 static unsigned long
9295 size_of_pubnames (vec
<pubname_entry
, va_gc
> *names
)
9300 int space_for_flags
= (debug_generate_pub_sections
== 2) ? 1 : 0;
9302 size
= DWARF_PUBNAMES_HEADER_SIZE
;
9303 FOR_EACH_VEC_ELT (*names
, i
, p
)
9304 if (include_pubname_in_output (names
, p
))
9305 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1 + space_for_flags
;
9307 size
+= DWARF_OFFSET_SIZE
;
9311 /* Return the size of the information in the .debug_aranges section. */
9313 static unsigned long
9314 size_of_aranges (void)
9318 size
= DWARF_ARANGES_HEADER_SIZE
;
9320 /* Count the address/length pair for this compilation unit. */
9321 if (text_section_used
)
9322 size
+= 2 * DWARF2_ADDR_SIZE
;
9323 if (cold_text_section_used
)
9324 size
+= 2 * DWARF2_ADDR_SIZE
;
9325 if (have_multiple_function_sections
)
9330 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
9332 if (DECL_IGNORED_P (fde
->decl
))
9334 if (!fde
->in_std_section
)
9335 size
+= 2 * DWARF2_ADDR_SIZE
;
9336 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
9337 size
+= 2 * DWARF2_ADDR_SIZE
;
9341 /* Count the two zero words used to terminated the address range table. */
9342 size
+= 2 * DWARF2_ADDR_SIZE
;
9346 /* Select the encoding of an attribute value. */
9348 static enum dwarf_form
9349 value_format (dw_attr_node
*a
)
9351 switch (AT_class (a
))
9353 case dw_val_class_addr
:
9354 /* Only very few attributes allow DW_FORM_addr. */
9359 case DW_AT_entry_pc
:
9360 case DW_AT_trampoline
:
9361 return (AT_index (a
) == NOT_INDEXED
9362 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
9366 switch (DWARF2_ADDR_SIZE
)
9369 return DW_FORM_data1
;
9371 return DW_FORM_data2
;
9373 return DW_FORM_data4
;
9375 return DW_FORM_data8
;
9379 case dw_val_class_loc_list
:
9380 if (dwarf_split_debug_info
9381 && dwarf_version
>= 5
9382 && AT_loc_list (a
)->num_assigned
)
9383 return DW_FORM_loclistx
;
9385 case dw_val_class_range_list
:
9386 /* For range lists in DWARF 5, use DW_FORM_rnglistx from .debug_info.dwo
9387 but in .debug_info use DW_FORM_sec_offset, which is shorter if we
9388 care about sizes of .debug* sections in shared libraries and
9389 executables and don't take into account relocations that affect just
9390 relocatable objects - for DW_FORM_rnglistx we'd have to emit offset
9391 table in the .debug_rnglists section. */
9392 if (dwarf_split_debug_info
9393 && dwarf_version
>= 5
9394 && AT_class (a
) == dw_val_class_range_list
9396 && a
->dw_attr_val
.val_entry
!= RELOCATED_OFFSET
)
9397 return DW_FORM_rnglistx
;
9398 if (dwarf_version
>= 4)
9399 return DW_FORM_sec_offset
;
9401 case dw_val_class_vms_delta
:
9402 case dw_val_class_offset
:
9403 switch (DWARF_OFFSET_SIZE
)
9406 return DW_FORM_data4
;
9408 return DW_FORM_data8
;
9412 case dw_val_class_loc
:
9413 if (dwarf_version
>= 4)
9414 return DW_FORM_exprloc
;
9415 switch (constant_size (size_of_locs (AT_loc (a
))))
9418 return DW_FORM_block1
;
9420 return DW_FORM_block2
;
9422 return DW_FORM_block4
;
9426 case dw_val_class_const
:
9427 return DW_FORM_sdata
;
9428 case dw_val_class_unsigned_const
:
9429 switch (constant_size (AT_unsigned (a
)))
9432 return DW_FORM_data1
;
9434 return DW_FORM_data2
;
9436 /* In DWARF3 DW_AT_data_member_location with
9437 DW_FORM_data4 or DW_FORM_data8 is a loclistptr, not
9438 constant, so we need to use DW_FORM_udata if we need
9439 a large constant. */
9440 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9441 return DW_FORM_udata
;
9442 return DW_FORM_data4
;
9444 if (dwarf_version
== 3 && a
->dw_attr
== DW_AT_data_member_location
)
9445 return DW_FORM_udata
;
9446 return DW_FORM_data8
;
9450 case dw_val_class_const_implicit
:
9451 case dw_val_class_unsigned_const_implicit
:
9452 case dw_val_class_file_implicit
:
9453 return DW_FORM_implicit_const
;
9454 case dw_val_class_const_double
:
9455 switch (HOST_BITS_PER_WIDE_INT
)
9458 return DW_FORM_data2
;
9460 return DW_FORM_data4
;
9462 return DW_FORM_data8
;
9464 if (dwarf_version
>= 5)
9465 return DW_FORM_data16
;
9468 return DW_FORM_block1
;
9470 case dw_val_class_wide_int
:
9471 switch (get_full_len (*a
->dw_attr_val
.v
.val_wide
) * HOST_BITS_PER_WIDE_INT
)
9474 return DW_FORM_data1
;
9476 return DW_FORM_data2
;
9478 return DW_FORM_data4
;
9480 return DW_FORM_data8
;
9482 if (dwarf_version
>= 5)
9483 return DW_FORM_data16
;
9486 return DW_FORM_block1
;
9488 case dw_val_class_vec
:
9489 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
9490 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
9493 return DW_FORM_block1
;
9495 return DW_FORM_block2
;
9497 return DW_FORM_block4
;
9501 case dw_val_class_flag
:
9502 if (dwarf_version
>= 4)
9504 /* Currently all add_AT_flag calls pass in 1 as last argument,
9505 so DW_FORM_flag_present can be used. If that ever changes,
9506 we'll need to use DW_FORM_flag and have some optimization
9507 in build_abbrev_table that will change those to
9508 DW_FORM_flag_present if it is set to 1 in all DIEs using
9509 the same abbrev entry. */
9510 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
9511 return DW_FORM_flag_present
;
9513 return DW_FORM_flag
;
9514 case dw_val_class_die_ref
:
9515 if (AT_ref_external (a
))
9516 return use_debug_types
? DW_FORM_ref_sig8
: DW_FORM_ref_addr
;
9519 case dw_val_class_fde_ref
:
9520 return DW_FORM_data
;
9521 case dw_val_class_lbl_id
:
9522 return (AT_index (a
) == NOT_INDEXED
9523 ? DW_FORM_addr
: DW_FORM_GNU_addr_index
);
9524 case dw_val_class_lineptr
:
9525 case dw_val_class_macptr
:
9526 case dw_val_class_loclistsptr
:
9527 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
9528 case dw_val_class_str
:
9529 return AT_string_form (a
);
9530 case dw_val_class_file
:
9531 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
9534 return DW_FORM_data1
;
9536 return DW_FORM_data2
;
9538 return DW_FORM_data4
;
9543 case dw_val_class_data8
:
9544 return DW_FORM_data8
;
9546 case dw_val_class_high_pc
:
9547 switch (DWARF2_ADDR_SIZE
)
9550 return DW_FORM_data1
;
9552 return DW_FORM_data2
;
9554 return DW_FORM_data4
;
9556 return DW_FORM_data8
;
9561 case dw_val_class_discr_value
:
9562 return (a
->dw_attr_val
.v
.val_discr_value
.pos
9565 case dw_val_class_discr_list
:
9566 switch (constant_size (size_of_discr_list (AT_discr_list (a
))))
9569 return DW_FORM_block1
;
9571 return DW_FORM_block2
;
9573 return DW_FORM_block4
;
9583 /* Output the encoding of an attribute value. */
9586 output_value_format (dw_attr_node
*a
)
9588 enum dwarf_form form
= value_format (a
);
9590 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
9593 /* Given a die and id, produce the appropriate abbreviations. */
9596 output_die_abbrevs (unsigned long abbrev_id
, dw_die_ref abbrev
)
9599 dw_attr_node
*a_attr
;
9601 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
9602 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
9603 dwarf_tag_name (abbrev
->die_tag
));
9605 if (abbrev
->die_child
!= NULL
)
9606 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
9608 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
9610 for (ix
= 0; vec_safe_iterate (abbrev
->die_attr
, ix
, &a_attr
); ix
++)
9612 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
9613 dwarf_attr_name (a_attr
->dw_attr
));
9614 output_value_format (a_attr
);
9615 if (value_format (a_attr
) == DW_FORM_implicit_const
)
9617 if (AT_class (a_attr
) == dw_val_class_file_implicit
)
9619 int f
= maybe_emit_file (a_attr
->dw_attr_val
.v
.val_file
);
9620 const char *filename
= a_attr
->dw_attr_val
.v
.val_file
->filename
;
9621 dw2_asm_output_data_sleb128 (f
, "(%s)", filename
);
9624 dw2_asm_output_data_sleb128 (a_attr
->dw_attr_val
.v
.val_int
, NULL
);
9628 dw2_asm_output_data (1, 0, NULL
);
9629 dw2_asm_output_data (1, 0, NULL
);
9633 /* Output the .debug_abbrev section which defines the DIE abbreviation
9637 output_abbrev_section (void)
9639 unsigned int abbrev_id
;
9642 FOR_EACH_VEC_SAFE_ELT (abbrev_die_table
, abbrev_id
, abbrev
)
9644 output_die_abbrevs (abbrev_id
, abbrev
);
9646 /* Terminate the table. */
9647 dw2_asm_output_data (1, 0, NULL
);
9650 /* Return a new location list, given the begin and end range, and the
9653 static inline dw_loc_list_ref
9654 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
9655 const char *section
)
9657 dw_loc_list_ref retlist
= ggc_cleared_alloc
<dw_loc_list_node
> ();
9659 retlist
->begin
= begin
;
9660 retlist
->begin_entry
= NULL
;
9662 retlist
->expr
= expr
;
9663 retlist
->section
= section
;
9668 /* Generate a new internal symbol for this location list node, if it
9669 hasn't got one yet. */
9672 gen_llsym (dw_loc_list_ref list
)
9674 gcc_assert (!list
->ll_symbol
);
9675 list
->ll_symbol
= gen_internal_sym ("LLST");
9678 /* Output the location list given to us. */
9681 output_loc_list (dw_loc_list_ref list_head
)
9683 if (list_head
->emitted
)
9685 list_head
->emitted
= true;
9687 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
9689 dw_loc_list_ref curr
= list_head
;
9690 const char *last_section
= NULL
;
9691 const char *base_label
= NULL
;
9693 /* Walk the location list, and output each range + expression. */
9694 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
9697 /* Don't output an entry that starts and ends at the same address. */
9698 if (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
)
9700 size
= size_of_locs (curr
->expr
);
9701 /* If the expression is too large, drop it on the floor. We could
9702 perhaps put it into DW_TAG_dwarf_procedure and refer to that
9703 in the expression, but >= 64KB expressions for a single value
9704 in a single range are unlikely very useful. */
9705 if (dwarf_version
< 5 && size
> 0xffff)
9707 if (dwarf_version
>= 5)
9709 if (dwarf_split_debug_info
)
9711 /* For -gsplit-dwarf, emit DW_LLE_starx_length, which has
9712 uleb128 index into .debug_addr and uleb128 length. */
9713 dw2_asm_output_data (1, DW_LLE_startx_length
,
9714 "DW_LLE_startx_length (%s)",
9715 list_head
->ll_symbol
);
9716 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
9717 "Location list range start index "
9718 "(%s)", curr
->begin
);
9719 /* FIXME: This will ICE ifndef HAVE_AS_LEB128.
9720 For that case we probably need to emit DW_LLE_startx_endx,
9721 but we'd need 2 .debug_addr entries rather than just one. */
9722 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
9723 "Location list length (%s)",
9724 list_head
->ll_symbol
);
9726 else if (!have_multiple_function_sections
&& HAVE_AS_LEB128
)
9728 /* If all code is in .text section, the base address is
9729 already provided by the CU attributes. Use
9730 DW_LLE_offset_pair where both addresses are uleb128 encoded
9731 offsets against that base. */
9732 dw2_asm_output_data (1, DW_LLE_offset_pair
,
9733 "DW_LLE_offset_pair (%s)",
9734 list_head
->ll_symbol
);
9735 dw2_asm_output_delta_uleb128 (curr
->begin
, curr
->section
,
9736 "Location list begin address (%s)",
9737 list_head
->ll_symbol
);
9738 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->section
,
9739 "Location list end address (%s)",
9740 list_head
->ll_symbol
);
9742 else if (HAVE_AS_LEB128
)
9744 /* Otherwise, find out how many consecutive entries could share
9745 the same base entry. If just one, emit DW_LLE_start_length,
9746 otherwise emit DW_LLE_base_address for the base address
9747 followed by a series of DW_LLE_offset_pair. */
9748 if (last_section
== NULL
|| curr
->section
!= last_section
)
9750 dw_loc_list_ref curr2
;
9751 for (curr2
= curr
->dw_loc_next
; curr2
!= NULL
;
9752 curr2
= curr2
->dw_loc_next
)
9754 if (strcmp (curr2
->begin
, curr2
->end
) == 0
9759 if (curr2
== NULL
|| curr
->section
!= curr2
->section
)
9760 last_section
= NULL
;
9763 last_section
= curr
->section
;
9764 base_label
= curr
->begin
;
9765 dw2_asm_output_data (1, DW_LLE_base_address
,
9766 "DW_LLE_base_address (%s)",
9767 list_head
->ll_symbol
);
9768 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, base_label
,
9769 "Base address (%s)",
9770 list_head
->ll_symbol
);
9773 /* Only one entry with the same base address. Use
9774 DW_LLE_start_length with absolute address and uleb128
9776 if (last_section
== NULL
)
9778 dw2_asm_output_data (1, DW_LLE_start_length
,
9779 "DW_LLE_start_length (%s)",
9780 list_head
->ll_symbol
);
9781 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
9782 "Location list begin address (%s)",
9783 list_head
->ll_symbol
);
9784 dw2_asm_output_delta_uleb128 (curr
->end
, curr
->begin
,
9785 "Location list length "
9786 "(%s)", list_head
->ll_symbol
);
9788 /* Otherwise emit DW_LLE_offset_pair, relative to above emitted
9789 DW_LLE_base_address. */
9792 dw2_asm_output_data (1, DW_LLE_offset_pair
,
9793 "DW_LLE_offset_pair (%s)",
9794 list_head
->ll_symbol
);
9795 dw2_asm_output_delta_uleb128 (curr
->begin
, base_label
,
9796 "Location list begin address "
9797 "(%s)", list_head
->ll_symbol
);
9798 dw2_asm_output_delta_uleb128 (curr
->end
, base_label
,
9799 "Location list end address "
9800 "(%s)", list_head
->ll_symbol
);
9803 /* The assembler does not support .uleb128 directive. Emit
9804 DW_LLE_start_end with a pair of absolute addresses. */
9807 dw2_asm_output_data (1, DW_LLE_start_end
,
9808 "DW_LLE_start_end (%s)",
9809 list_head
->ll_symbol
);
9810 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
9811 "Location list begin address (%s)",
9812 list_head
->ll_symbol
);
9813 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
9814 "Location list end address (%s)",
9815 list_head
->ll_symbol
);
9818 else if (dwarf_split_debug_info
)
9820 /* For -gsplit-dwarf -gdwarf-{2,3,4} emit index into .debug_addr
9821 and 4 byte length. */
9822 dw2_asm_output_data (1, DW_LLE_GNU_start_length_entry
,
9823 "Location list start/length entry (%s)",
9824 list_head
->ll_symbol
);
9825 dw2_asm_output_data_uleb128 (curr
->begin_entry
->index
,
9826 "Location list range start index (%s)",
9828 /* The length field is 4 bytes. If we ever need to support
9829 an 8-byte length, we can add a new DW_LLE code or fall back
9830 to DW_LLE_GNU_start_end_entry. */
9831 dw2_asm_output_delta (4, curr
->end
, curr
->begin
,
9832 "Location list range length (%s)",
9833 list_head
->ll_symbol
);
9835 else if (!have_multiple_function_sections
)
9837 /* Pair of relative addresses against start of text section. */
9838 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
9839 "Location list begin address (%s)",
9840 list_head
->ll_symbol
);
9841 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
9842 "Location list end address (%s)",
9843 list_head
->ll_symbol
);
9847 /* Pair of absolute addresses. */
9848 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
9849 "Location list begin address (%s)",
9850 list_head
->ll_symbol
);
9851 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
9852 "Location list end address (%s)",
9853 list_head
->ll_symbol
);
9856 /* Output the block length for this list of location operations. */
9857 if (dwarf_version
>= 5)
9858 dw2_asm_output_data_uleb128 (size
, "Location expression size");
9861 gcc_assert (size
<= 0xffff);
9862 dw2_asm_output_data (2, size
, "Location expression size");
9865 output_loc_sequence (curr
->expr
, -1);
9868 /* And finally list termination. */
9869 if (dwarf_version
>= 5)
9870 dw2_asm_output_data (1, DW_LLE_end_of_list
,
9871 "DW_LLE_end_of_list (%s)", list_head
->ll_symbol
);
9872 else if (dwarf_split_debug_info
)
9873 dw2_asm_output_data (1, DW_LLE_GNU_end_of_list_entry
,
9874 "Location list terminator (%s)",
9875 list_head
->ll_symbol
);
9878 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
9879 "Location list terminator begin (%s)",
9880 list_head
->ll_symbol
);
9881 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
9882 "Location list terminator end (%s)",
9883 list_head
->ll_symbol
);
9887 /* Output a range_list offset into the .debug_ranges or .debug_rnglists
9888 section. Emit a relocated reference if val_entry is NULL, otherwise,
9889 emit an indirect reference. */
9892 output_range_list_offset (dw_attr_node
*a
)
9894 const char *name
= dwarf_attr_name (a
->dw_attr
);
9896 if (a
->dw_attr_val
.val_entry
== RELOCATED_OFFSET
)
9898 if (dwarf_version
>= 5)
9900 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
9901 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, r
->label
,
9902 debug_ranges_section
, "%s", name
);
9906 char *p
= strchr (ranges_section_label
, '\0');
9907 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
9908 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
);
9909 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
9910 debug_ranges_section
, "%s", name
);
9914 else if (dwarf_version
>= 5)
9916 dw_ranges
*r
= &(*ranges_table
)[a
->dw_attr_val
.v
.val_offset
];
9917 gcc_assert (rnglist_idx
);
9918 dw2_asm_output_data_uleb128 (r
->idx
, "%s", name
);
9921 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
9922 a
->dw_attr_val
.v
.val_offset
* 2 * DWARF2_ADDR_SIZE
,
9923 "%s (offset from %s)", name
, ranges_section_label
);
9926 /* Output the offset into the debug_loc section. */
9929 output_loc_list_offset (dw_attr_node
*a
)
9931 char *sym
= AT_loc_list (a
)->ll_symbol
;
9934 if (!dwarf_split_debug_info
)
9935 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
9936 "%s", dwarf_attr_name (a
->dw_attr
));
9937 else if (dwarf_version
>= 5)
9939 gcc_assert (AT_loc_list (a
)->num_assigned
);
9940 dw2_asm_output_data_uleb128 (AT_loc_list (a
)->hash
, "%s (%s)",
9941 dwarf_attr_name (a
->dw_attr
),
9945 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
, loc_section_label
,
9946 "%s", dwarf_attr_name (a
->dw_attr
));
9949 /* Output an attribute's index or value appropriately. */
9952 output_attr_index_or_value (dw_attr_node
*a
)
9954 const char *name
= dwarf_attr_name (a
->dw_attr
);
9956 if (dwarf_split_debug_info
&& AT_index (a
) != NOT_INDEXED
)
9958 dw2_asm_output_data_uleb128 (AT_index (a
), "%s", name
);
9961 switch (AT_class (a
))
9963 case dw_val_class_addr
:
9964 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
9966 case dw_val_class_high_pc
:
9967 case dw_val_class_lbl_id
:
9968 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
9975 /* Output a type signature. */
9978 output_signature (const char *sig
, const char *name
)
9982 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
9983 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
9986 /* Output a discriminant value. */
9989 output_discr_value (dw_discr_value
*discr_value
, const char *name
)
9991 if (discr_value
->pos
)
9992 dw2_asm_output_data_uleb128 (discr_value
->v
.uval
, "%s", name
);
9994 dw2_asm_output_data_sleb128 (discr_value
->v
.sval
, "%s", name
);
9997 /* Output the DIE and its attributes. Called recursively to generate
9998 the definitions of each child DIE. */
10001 output_die (dw_die_ref die
)
10005 unsigned long size
;
10008 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
10009 (unsigned long)die
->die_offset
,
10010 dwarf_tag_name (die
->die_tag
));
10012 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
10014 const char *name
= dwarf_attr_name (a
->dw_attr
);
10016 switch (AT_class (a
))
10018 case dw_val_class_addr
:
10019 output_attr_index_or_value (a
);
10022 case dw_val_class_offset
:
10023 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
10027 case dw_val_class_range_list
:
10028 output_range_list_offset (a
);
10031 case dw_val_class_loc
:
10032 size
= size_of_locs (AT_loc (a
));
10034 /* Output the block length for this list of location operations. */
10035 if (dwarf_version
>= 4)
10036 dw2_asm_output_data_uleb128 (size
, "%s", name
);
10038 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
10040 output_loc_sequence (AT_loc (a
), -1);
10043 case dw_val_class_const
:
10044 /* ??? It would be slightly more efficient to use a scheme like is
10045 used for unsigned constants below, but gdb 4.x does not sign
10046 extend. Gdb 5.x does sign extend. */
10047 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
10050 case dw_val_class_unsigned_const
:
10052 int csize
= constant_size (AT_unsigned (a
));
10053 if (dwarf_version
== 3
10054 && a
->dw_attr
== DW_AT_data_member_location
10056 dw2_asm_output_data_uleb128 (AT_unsigned (a
), "%s", name
);
10058 dw2_asm_output_data (csize
, AT_unsigned (a
), "%s", name
);
10062 case dw_val_class_const_implicit
:
10063 if (flag_debug_asm
)
10064 fprintf (asm_out_file
, "\t\t\t%s %s ("
10065 HOST_WIDE_INT_PRINT_DEC
")\n",
10066 ASM_COMMENT_START
, name
, AT_int (a
));
10069 case dw_val_class_unsigned_const_implicit
:
10070 if (flag_debug_asm
)
10071 fprintf (asm_out_file
, "\t\t\t%s %s ("
10072 HOST_WIDE_INT_PRINT_HEX
")\n",
10073 ASM_COMMENT_START
, name
, AT_unsigned (a
));
10076 case dw_val_class_const_double
:
10078 unsigned HOST_WIDE_INT first
, second
;
10080 if (HOST_BITS_PER_WIDE_INT
>= DWARF_LARGEST_DATA_FORM_BITS
)
10081 dw2_asm_output_data (1,
10082 HOST_BITS_PER_DOUBLE_INT
10083 / HOST_BITS_PER_CHAR
,
10086 if (WORDS_BIG_ENDIAN
)
10088 first
= a
->dw_attr_val
.v
.val_double
.high
;
10089 second
= a
->dw_attr_val
.v
.val_double
.low
;
10093 first
= a
->dw_attr_val
.v
.val_double
.low
;
10094 second
= a
->dw_attr_val
.v
.val_double
.high
;
10097 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10098 first
, "%s", name
);
10099 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10104 case dw_val_class_wide_int
:
10107 int len
= get_full_len (*a
->dw_attr_val
.v
.val_wide
);
10108 int l
= HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
10109 if (len
* HOST_BITS_PER_WIDE_INT
> DWARF_LARGEST_DATA_FORM_BITS
)
10110 dw2_asm_output_data (1, get_full_len (*a
->dw_attr_val
.v
.val_wide
)
10113 if (WORDS_BIG_ENDIAN
)
10114 for (i
= len
- 1; i
>= 0; --i
)
10116 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10121 for (i
= 0; i
< len
; ++i
)
10123 dw2_asm_output_data (l
, a
->dw_attr_val
.v
.val_wide
->elt (i
),
10130 case dw_val_class_vec
:
10132 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
10133 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
10137 dw2_asm_output_data (constant_size (len
* elt_size
),
10138 len
* elt_size
, "%s", name
);
10139 if (elt_size
> sizeof (HOST_WIDE_INT
))
10144 for (i
= 0, p
= (unsigned char *) a
->dw_attr_val
.v
.val_vec
.array
;
10146 i
++, p
+= elt_size
)
10147 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
10148 "fp or vector constant word %u", i
);
10152 case dw_val_class_flag
:
10153 if (dwarf_version
>= 4)
10155 /* Currently all add_AT_flag calls pass in 1 as last argument,
10156 so DW_FORM_flag_present can be used. If that ever changes,
10157 we'll need to use DW_FORM_flag and have some optimization
10158 in build_abbrev_table that will change those to
10159 DW_FORM_flag_present if it is set to 1 in all DIEs using
10160 the same abbrev entry. */
10161 gcc_assert (AT_flag (a
) == 1);
10162 if (flag_debug_asm
)
10163 fprintf (asm_out_file
, "\t\t\t%s %s\n",
10164 ASM_COMMENT_START
, name
);
10167 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
10170 case dw_val_class_loc_list
:
10171 output_loc_list_offset (a
);
10174 case dw_val_class_die_ref
:
10175 if (AT_ref_external (a
))
10177 if (AT_ref (a
)->comdat_type_p
)
10179 comdat_type_node
*type_node
10180 = AT_ref (a
)->die_id
.die_type_node
;
10182 gcc_assert (type_node
);
10183 output_signature (type_node
->signature
, name
);
10187 const char *sym
= AT_ref (a
)->die_id
.die_symbol
;
10191 /* In DWARF2, DW_FORM_ref_addr is sized by target address
10192 length, whereas in DWARF3 it's always sized as an
10194 if (dwarf_version
== 2)
10195 size
= DWARF2_ADDR_SIZE
;
10197 size
= DWARF_OFFSET_SIZE
;
10198 /* ??? We cannot unconditionally output die_offset if
10199 non-zero - others might create references to those
10201 And we do not clear its DIE offset after outputting it
10202 (and the label refers to the actual DIEs, not the
10203 DWARF CU unit header which is when using label + offset
10204 would be the correct thing to do).
10205 ??? This is the reason for the with_offset flag. */
10206 if (AT_ref (a
)->with_offset
)
10207 dw2_asm_output_offset (size
, sym
, AT_ref (a
)->die_offset
,
10208 debug_info_section
, "%s", name
);
10210 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
10216 gcc_assert (AT_ref (a
)->die_offset
);
10217 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
10222 case dw_val_class_fde_ref
:
10224 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
10226 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
10227 a
->dw_attr_val
.v
.val_fde_index
* 2);
10228 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
10233 case dw_val_class_vms_delta
:
10234 #ifdef ASM_OUTPUT_DWARF_VMS_DELTA
10235 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
10236 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
10239 dw2_asm_output_delta (DWARF_OFFSET_SIZE
,
10240 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
10245 case dw_val_class_lbl_id
:
10246 output_attr_index_or_value (a
);
10249 case dw_val_class_lineptr
:
10250 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10251 debug_line_section
, "%s", name
);
10254 case dw_val_class_macptr
:
10255 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10256 debug_macinfo_section
, "%s", name
);
10259 case dw_val_class_loclistsptr
:
10260 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
10261 debug_loc_section
, "%s", name
);
10264 case dw_val_class_str
:
10265 if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_strp
)
10266 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
10267 a
->dw_attr_val
.v
.val_str
->label
,
10269 "%s: \"%s\"", name
, AT_string (a
));
10270 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_line_strp
)
10271 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
10272 a
->dw_attr_val
.v
.val_str
->label
,
10273 debug_line_str_section
,
10274 "%s: \"%s\"", name
, AT_string (a
));
10275 else if (a
->dw_attr_val
.v
.val_str
->form
== DW_FORM_GNU_str_index
)
10276 dw2_asm_output_data_uleb128 (AT_index (a
),
10277 "%s: \"%s\"", name
, AT_string (a
));
10279 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
10282 case dw_val_class_file
:
10284 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
10286 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
10287 a
->dw_attr_val
.v
.val_file
->filename
);
10291 case dw_val_class_file_implicit
:
10292 if (flag_debug_asm
)
10293 fprintf (asm_out_file
, "\t\t\t%s %s (%d, %s)\n",
10294 ASM_COMMENT_START
, name
,
10295 maybe_emit_file (a
->dw_attr_val
.v
.val_file
),
10296 a
->dw_attr_val
.v
.val_file
->filename
);
10299 case dw_val_class_data8
:
10303 for (i
= 0; i
< 8; i
++)
10304 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
10305 i
== 0 ? "%s" : NULL
, name
);
10309 case dw_val_class_high_pc
:
10310 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, AT_lbl (a
),
10311 get_AT_low_pc (die
), "DW_AT_high_pc");
10314 case dw_val_class_discr_value
:
10315 output_discr_value (&a
->dw_attr_val
.v
.val_discr_value
, name
);
10318 case dw_val_class_discr_list
:
10320 dw_discr_list_ref list
= AT_discr_list (a
);
10321 const int size
= size_of_discr_list (list
);
10323 /* This is a block, so output its length first. */
10324 dw2_asm_output_data (constant_size (size
), size
,
10325 "%s: block size", name
);
10327 for (; list
!= NULL
; list
= list
->dw_discr_next
)
10329 /* One byte for the discriminant value descriptor, and then as
10330 many LEB128 numbers as required. */
10331 if (list
->dw_discr_range
)
10332 dw2_asm_output_data (1, DW_DSC_range
,
10333 "%s: DW_DSC_range", name
);
10335 dw2_asm_output_data (1, DW_DSC_label
,
10336 "%s: DW_DSC_label", name
);
10338 output_discr_value (&list
->dw_discr_lower_bound
, name
);
10339 if (list
->dw_discr_range
)
10340 output_discr_value (&list
->dw_discr_upper_bound
, name
);
10346 gcc_unreachable ();
10350 FOR_EACH_CHILD (die
, c
, output_die (c
));
10352 /* Add null byte to terminate sibling list. */
10353 if (die
->die_child
!= NULL
)
10354 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
10355 (unsigned long) die
->die_offset
);
10358 /* Output the compilation unit that appears at the beginning of the
10359 .debug_info section, and precedes the DIE descriptions. */
10362 output_compilation_unit_header (enum dwarf_unit_type ut
)
10364 if (!XCOFF_DEBUGGING_INFO
)
10366 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10367 dw2_asm_output_data (4, 0xffffffff,
10368 "Initial length escape value indicating 64-bit DWARF extension");
10369 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
10370 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
10371 "Length of Compilation Unit Info");
10374 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
10375 if (dwarf_version
>= 5)
10380 case DW_UT_compile
: name
= "DW_UT_compile"; break;
10381 case DW_UT_type
: name
= "DW_UT_type"; break;
10382 case DW_UT_split_compile
: name
= "DW_UT_split_compile"; break;
10383 case DW_UT_split_type
: name
= "DW_UT_split_type"; break;
10384 default: gcc_unreachable ();
10386 dw2_asm_output_data (1, ut
, "%s", name
);
10387 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
10389 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
10390 debug_abbrev_section
,
10391 "Offset Into Abbrev. Section");
10392 if (dwarf_version
< 5)
10393 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
10396 /* Output the compilation unit DIE and its children. */
10399 output_comp_unit (dw_die_ref die
, int output_if_empty
,
10400 const unsigned char *dwo_id
)
10402 const char *secname
, *oldsym
;
10405 /* Unless we are outputting main CU, we may throw away empty ones. */
10406 if (!output_if_empty
&& die
->die_child
== NULL
)
10409 /* Even if there are no children of this DIE, we must output the information
10410 about the compilation unit. Otherwise, on an empty translation unit, we
10411 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
10412 will then complain when examining the file. First mark all the DIEs in
10413 this CU so we know which get local refs. */
10416 external_ref_hash_type
*extern_map
= optimize_external_refs (die
);
10418 /* For now, optimize only the main CU, in order to optimize the rest
10419 we'd need to see all of them earlier. Leave the rest for post-linking
10421 if (die
== comp_unit_die ())
10422 abbrev_opt_start
= vec_safe_length (abbrev_die_table
);
10424 build_abbrev_table (die
, extern_map
);
10426 optimize_abbrev_table ();
10430 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10431 next_die_offset
= (dwo_id
10432 ? DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
10433 : DWARF_COMPILE_UNIT_HEADER_SIZE
);
10434 calc_die_sizes (die
);
10436 oldsym
= die
->die_id
.die_symbol
;
10437 if (oldsym
&& die
->comdat_type_p
)
10439 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
10441 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
10443 die
->die_id
.die_symbol
= NULL
;
10444 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
10448 switch_to_section (debug_info_section
);
10449 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
10450 info_section_emitted
= true;
10453 /* For LTO cross unit DIE refs we want a symbol on the start of the
10454 debuginfo section, not on the CU DIE. */
10455 if ((flag_generate_lto
|| flag_generate_offload
) && oldsym
)
10457 /* ??? No way to get visibility assembled without a decl. */
10458 tree decl
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
10459 get_identifier (oldsym
), char_type_node
);
10460 TREE_PUBLIC (decl
) = true;
10461 TREE_STATIC (decl
) = true;
10462 DECL_ARTIFICIAL (decl
) = true;
10463 DECL_VISIBILITY (decl
) = VISIBILITY_HIDDEN
;
10464 DECL_VISIBILITY_SPECIFIED (decl
) = true;
10465 targetm
.asm_out
.assemble_visibility (decl
, VISIBILITY_HIDDEN
);
10466 #ifdef ASM_WEAKEN_LABEL
10467 /* We prefer a .weak because that handles duplicates from duplicate
10468 archive members in a graceful way. */
10469 ASM_WEAKEN_LABEL (asm_out_file
, oldsym
);
10471 targetm
.asm_out
.globalize_label (asm_out_file
, oldsym
);
10473 ASM_OUTPUT_LABEL (asm_out_file
, oldsym
);
10476 /* Output debugging information. */
10477 output_compilation_unit_header (dwo_id
10478 ? DW_UT_split_compile
: DW_UT_compile
);
10479 if (dwarf_version
>= 5)
10481 if (dwo_id
!= NULL
)
10482 for (int i
= 0; i
< 8; i
++)
10483 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
10487 /* Leave the marks on the main CU, so we can check them in
10488 output_pubnames. */
10492 die
->die_id
.die_symbol
= oldsym
;
10496 /* Whether to generate the DWARF accelerator tables in .debug_pubnames
10497 and .debug_pubtypes. This is configured per-target, but can be
10498 overridden by the -gpubnames or -gno-pubnames options. */
10501 want_pubnames (void)
10503 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
10505 if (debug_generate_pub_sections
!= -1)
10506 return debug_generate_pub_sections
;
10507 return targetm
.want_debug_pub_sections
;
10510 /* Add the DW_AT_GNU_pubnames and DW_AT_GNU_pubtypes attributes. */
10513 add_AT_pubnames (dw_die_ref die
)
10515 if (want_pubnames ())
10516 add_AT_flag (die
, DW_AT_GNU_pubnames
, 1);
10519 /* Add a string attribute value to a skeleton DIE. */
10522 add_skeleton_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
,
10526 struct indirect_string_node
*node
;
10528 if (! skeleton_debug_str_hash
)
10529 skeleton_debug_str_hash
10530 = hash_table
<indirect_string_hasher
>::create_ggc (10);
10532 node
= find_AT_string_in_table (str
, skeleton_debug_str_hash
);
10533 find_string_form (node
);
10534 if (node
->form
== DW_FORM_GNU_str_index
)
10535 node
->form
= DW_FORM_strp
;
10537 attr
.dw_attr
= attr_kind
;
10538 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
10539 attr
.dw_attr_val
.val_entry
= NULL
;
10540 attr
.dw_attr_val
.v
.val_str
= node
;
10541 add_dwarf_attr (die
, &attr
);
10544 /* Helper function to generate top-level dies for skeleton debug_info and
10548 add_top_level_skeleton_die_attrs (dw_die_ref die
)
10550 const char *dwo_file_name
= concat (aux_base_name
, ".dwo", NULL
);
10551 const char *comp_dir
= comp_dir_string ();
10553 add_skeleton_AT_string (die
, dwarf_AT (DW_AT_dwo_name
), dwo_file_name
);
10554 if (comp_dir
!= NULL
)
10555 add_skeleton_AT_string (die
, DW_AT_comp_dir
, comp_dir
);
10556 add_AT_pubnames (die
);
10557 add_AT_lineptr (die
, DW_AT_GNU_addr_base
, debug_addr_section_label
);
10560 /* Output skeleton debug sections that point to the dwo file. */
10563 output_skeleton_debug_sections (dw_die_ref comp_unit
,
10564 const unsigned char *dwo_id
)
10566 /* These attributes will be found in the full debug_info section. */
10567 remove_AT (comp_unit
, DW_AT_producer
);
10568 remove_AT (comp_unit
, DW_AT_language
);
10570 switch_to_section (debug_skeleton_info_section
);
10571 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_info_section_label
);
10573 /* Produce the skeleton compilation-unit header. This one differs enough from
10574 a normal CU header that it's better not to call output_compilation_unit
10576 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10577 dw2_asm_output_data (4, 0xffffffff,
10578 "Initial length escape value indicating 64-bit "
10579 "DWARF extension");
10581 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
10582 DWARF_COMPILE_UNIT_SKELETON_HEADER_SIZE
10583 - DWARF_INITIAL_LENGTH_SIZE
10584 + size_of_die (comp_unit
),
10585 "Length of Compilation Unit Info");
10586 dw2_asm_output_data (2, dwarf_version
, "DWARF version number");
10587 if (dwarf_version
>= 5)
10589 dw2_asm_output_data (1, DW_UT_skeleton
, "DW_UT_skeleton");
10590 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
10592 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_abbrev_section_label
,
10593 debug_skeleton_abbrev_section
,
10594 "Offset Into Abbrev. Section");
10595 if (dwarf_version
< 5)
10596 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
10598 for (int i
= 0; i
< 8; i
++)
10599 dw2_asm_output_data (1, dwo_id
[i
], i
== 0 ? "DWO id" : NULL
);
10601 comp_unit
->die_abbrev
= SKELETON_COMP_DIE_ABBREV
;
10602 output_die (comp_unit
);
10604 /* Build the skeleton debug_abbrev section. */
10605 switch_to_section (debug_skeleton_abbrev_section
);
10606 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_abbrev_section_label
);
10608 output_die_abbrevs (SKELETON_COMP_DIE_ABBREV
, comp_unit
);
10610 dw2_asm_output_data (1, 0, "end of skeleton .debug_abbrev");
10613 /* Output a comdat type unit DIE and its children. */
10616 output_comdat_type_unit (comdat_type_node
*node
)
10618 const char *secname
;
10621 #if defined (OBJECT_FORMAT_ELF)
10625 /* First mark all the DIEs in this CU so we know which get local refs. */
10626 mark_dies (node
->root_die
);
10628 external_ref_hash_type
*extern_map
= optimize_external_refs (node
->root_die
);
10630 build_abbrev_table (node
->root_die
, extern_map
);
10635 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10636 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
10637 calc_die_sizes (node
->root_die
);
10639 #if defined (OBJECT_FORMAT_ELF)
10640 if (dwarf_version
>= 5)
10642 if (!dwarf_split_debug_info
)
10643 secname
= ".debug_info";
10645 secname
= ".debug_info.dwo";
10647 else if (!dwarf_split_debug_info
)
10648 secname
= ".debug_types";
10650 secname
= ".debug_types.dwo";
10652 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
10653 sprintf (tmp
, dwarf_version
>= 5 ? "wi." : "wt.");
10654 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
10655 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
10656 comdat_key
= get_identifier (tmp
);
10657 targetm
.asm_out
.named_section (secname
,
10658 SECTION_DEBUG
| SECTION_LINKONCE
,
10661 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
10662 sprintf (tmp
, (dwarf_version
>= 5
10663 ? ".gnu.linkonce.wi." : ".gnu.linkonce.wt."));
10664 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
10665 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
10667 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
10670 /* Output debugging information. */
10671 output_compilation_unit_header (dwarf_split_debug_info
10672 ? DW_UT_split_type
: DW_UT_type
);
10673 output_signature (node
->signature
, "Type Signature");
10674 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
10675 "Offset to Type DIE");
10676 output_die (node
->root_die
);
10678 unmark_dies (node
->root_die
);
10681 /* Return the DWARF2/3 pubname associated with a decl. */
10683 static const char *
10684 dwarf2_name (tree decl
, int scope
)
10686 if (DECL_NAMELESS (decl
))
10688 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
10691 /* Add a new entry to .debug_pubnames if appropriate. */
10694 add_pubname_string (const char *str
, dw_die_ref die
)
10699 e
.name
= xstrdup (str
);
10700 vec_safe_push (pubname_table
, e
);
10704 add_pubname (tree decl
, dw_die_ref die
)
10706 if (!want_pubnames ())
10709 /* Don't add items to the table when we expect that the consumer will have
10710 just read the enclosing die. For example, if the consumer is looking at a
10711 class_member, it will either be inside the class already, or will have just
10712 looked up the class to find the member. Either way, searching the class is
10713 faster than searching the index. */
10714 if ((TREE_PUBLIC (decl
) && !class_scope_p (die
->die_parent
))
10715 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
10717 const char *name
= dwarf2_name (decl
, 1);
10720 add_pubname_string (name
, die
);
10724 /* Add an enumerator to the pubnames section. */
10727 add_enumerator_pubname (const char *scope_name
, dw_die_ref die
)
10731 gcc_assert (scope_name
);
10732 e
.name
= concat (scope_name
, get_AT_string (die
, DW_AT_name
), NULL
);
10734 vec_safe_push (pubname_table
, e
);
10737 /* Add a new entry to .debug_pubtypes if appropriate. */
10740 add_pubtype (tree decl
, dw_die_ref die
)
10744 if (!want_pubnames ())
10747 if ((TREE_PUBLIC (decl
)
10748 || is_cu_die (die
->die_parent
) || is_namespace_die (die
->die_parent
))
10749 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
10752 const char *scope_name
= "";
10753 const char *sep
= is_cxx () ? "::" : ".";
10756 scope
= TYPE_P (decl
) ? TYPE_CONTEXT (decl
) : NULL
;
10757 if (scope
&& TREE_CODE (scope
) == NAMESPACE_DECL
)
10759 scope_name
= lang_hooks
.dwarf_name (scope
, 1);
10760 if (scope_name
!= NULL
&& scope_name
[0] != '\0')
10761 scope_name
= concat (scope_name
, sep
, NULL
);
10767 name
= type_tag (decl
);
10769 name
= lang_hooks
.dwarf_name (decl
, 1);
10771 /* If we don't have a name for the type, there's no point in adding
10772 it to the table. */
10773 if (name
!= NULL
&& name
[0] != '\0')
10776 e
.name
= concat (scope_name
, name
, NULL
);
10777 vec_safe_push (pubtype_table
, e
);
10780 /* Although it might be more consistent to add the pubinfo for the
10781 enumerators as their dies are created, they should only be added if the
10782 enum type meets the criteria above. So rather than re-check the parent
10783 enum type whenever an enumerator die is created, just output them all
10784 here. This isn't protected by the name conditional because anonymous
10785 enums don't have names. */
10786 if (die
->die_tag
== DW_TAG_enumeration_type
)
10790 FOR_EACH_CHILD (die
, c
, add_enumerator_pubname (scope_name
, c
));
10795 /* Output a single entry in the pubnames table. */
10798 output_pubname (dw_offset die_offset
, pubname_entry
*entry
)
10800 dw_die_ref die
= entry
->die
;
10801 int is_static
= get_AT_flag (die
, DW_AT_external
) ? 0 : 1;
10803 dw2_asm_output_data (DWARF_OFFSET_SIZE
, die_offset
, "DIE offset");
10805 if (debug_generate_pub_sections
== 2)
10807 /* This logic follows gdb's method for determining the value of the flag
10809 uint32_t flags
= GDB_INDEX_SYMBOL_KIND_NONE
;
10810 switch (die
->die_tag
)
10812 case DW_TAG_typedef
:
10813 case DW_TAG_base_type
:
10814 case DW_TAG_subrange_type
:
10815 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
10816 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
10818 case DW_TAG_enumerator
:
10819 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
10820 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
10822 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
10824 case DW_TAG_subprogram
:
10825 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
10826 GDB_INDEX_SYMBOL_KIND_FUNCTION
);
10828 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
10830 case DW_TAG_constant
:
10831 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
10832 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
10833 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
10835 case DW_TAG_variable
:
10836 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
,
10837 GDB_INDEX_SYMBOL_KIND_VARIABLE
);
10838 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, is_static
);
10840 case DW_TAG_namespace
:
10841 case DW_TAG_imported_declaration
:
10842 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
10844 case DW_TAG_class_type
:
10845 case DW_TAG_interface_type
:
10846 case DW_TAG_structure_type
:
10847 case DW_TAG_union_type
:
10848 case DW_TAG_enumeration_type
:
10849 GDB_INDEX_SYMBOL_KIND_SET_VALUE(flags
, GDB_INDEX_SYMBOL_KIND_TYPE
);
10851 GDB_INDEX_SYMBOL_STATIC_SET_VALUE(flags
, 1);
10854 /* An unusual tag. Leave the flag-byte empty. */
10857 dw2_asm_output_data (1, flags
>> GDB_INDEX_CU_BITSIZE
,
10858 "GDB-index flags");
10861 dw2_asm_output_nstring (entry
->name
, -1, "external name");
10865 /* Output the public names table used to speed up access to externally
10866 visible names; or the public types table used to find type definitions. */
10869 output_pubnames (vec
<pubname_entry
, va_gc
> *names
)
10872 unsigned long pubnames_length
= size_of_pubnames (names
);
10873 pubname_entry
*pub
;
10875 if (!XCOFF_DEBUGGING_INFO
)
10877 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10878 dw2_asm_output_data (4, 0xffffffff,
10879 "Initial length escape value indicating 64-bit DWARF extension");
10880 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
10881 "Pub Info Length");
10884 /* Version number for pubnames/pubtypes is independent of dwarf version. */
10885 dw2_asm_output_data (2, 2, "DWARF Version");
10887 if (dwarf_split_debug_info
)
10888 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
10889 debug_skeleton_info_section
,
10890 "Offset of Compilation Unit Info");
10892 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
10893 debug_info_section
,
10894 "Offset of Compilation Unit Info");
10895 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
10896 "Compilation Unit Length");
10898 FOR_EACH_VEC_ELT (*names
, i
, pub
)
10900 if (include_pubname_in_output (names
, pub
))
10902 dw_offset die_offset
= pub
->die
->die_offset
;
10904 /* We shouldn't see pubnames for DIEs outside of the main CU. */
10905 if (names
== pubname_table
&& pub
->die
->die_tag
!= DW_TAG_enumerator
)
10906 gcc_assert (pub
->die
->die_mark
);
10908 /* If we're putting types in their own .debug_types sections,
10909 the .debug_pubtypes table will still point to the compile
10910 unit (not the type unit), so we want to use the offset of
10911 the skeleton DIE (if there is one). */
10912 if (pub
->die
->comdat_type_p
&& names
== pubtype_table
)
10914 comdat_type_node
*type_node
= pub
->die
->die_id
.die_type_node
;
10916 if (type_node
!= NULL
)
10917 die_offset
= (type_node
->skeleton_die
!= NULL
10918 ? type_node
->skeleton_die
->die_offset
10919 : comp_unit_die ()->die_offset
);
10922 output_pubname (die_offset
, pub
);
10926 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
10929 /* Output public names and types tables if necessary. */
10932 output_pubtables (void)
10934 if (!want_pubnames () || !info_section_emitted
)
10937 switch_to_section (debug_pubnames_section
);
10938 output_pubnames (pubname_table
);
10939 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
10940 It shouldn't hurt to emit it always, since pure DWARF2 consumers
10941 simply won't look for the section. */
10942 switch_to_section (debug_pubtypes_section
);
10943 output_pubnames (pubtype_table
);
10947 /* Output the information that goes into the .debug_aranges table.
10948 Namely, define the beginning and ending address range of the
10949 text section generated for this compilation unit. */
10952 output_aranges (void)
10955 unsigned long aranges_length
= size_of_aranges ();
10957 if (!XCOFF_DEBUGGING_INFO
)
10959 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
10960 dw2_asm_output_data (4, 0xffffffff,
10961 "Initial length escape value indicating 64-bit DWARF extension");
10962 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
10963 "Length of Address Ranges Info");
10966 /* Version number for aranges is still 2, even up to DWARF5. */
10967 dw2_asm_output_data (2, 2, "DWARF Version");
10968 if (dwarf_split_debug_info
)
10969 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_skeleton_info_section_label
,
10970 debug_skeleton_info_section
,
10971 "Offset of Compilation Unit Info");
10973 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
10974 debug_info_section
,
10975 "Offset of Compilation Unit Info");
10976 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
10977 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
10979 /* We need to align to twice the pointer size here. */
10980 if (DWARF_ARANGES_PAD_SIZE
)
10982 /* Pad using a 2 byte words so that padding is correct for any
10984 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
10985 2 * DWARF2_ADDR_SIZE
);
10986 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
10987 dw2_asm_output_data (2, 0, NULL
);
10990 /* It is necessary not to output these entries if the sections were
10991 not used; if the sections were not used, the length will be 0 and
10992 the address may end up as 0 if the section is discarded by ld
10993 --gc-sections, leaving an invalid (0, 0) entry that can be
10994 confused with the terminator. */
10995 if (text_section_used
)
10997 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
10998 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
10999 text_section_label
, "Length");
11001 if (cold_text_section_used
)
11003 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
11005 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
11006 cold_text_section_label
, "Length");
11009 if (have_multiple_function_sections
)
11014 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
11016 if (DECL_IGNORED_P (fde
->decl
))
11018 if (!fde
->in_std_section
)
11020 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
11022 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_end
,
11023 fde
->dw_fde_begin
, "Length");
11025 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
11027 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_begin
,
11029 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, fde
->dw_fde_second_end
,
11030 fde
->dw_fde_second_begin
, "Length");
11035 /* Output the terminator words. */
11036 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11037 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11040 /* Add a new entry to .debug_ranges. Return its index into
11041 ranges_table vector. */
11043 static unsigned int
11044 add_ranges_num (int num
, bool maybe_new_sec
)
11046 dw_ranges r
= { NULL
, num
, 0, maybe_new_sec
};
11047 vec_safe_push (ranges_table
, r
);
11048 return vec_safe_length (ranges_table
) - 1;
11051 /* Add a new entry to .debug_ranges corresponding to a block, or a
11052 range terminator if BLOCK is NULL. MAYBE_NEW_SEC is true if
11053 this entry might be in a different section from previous range. */
11055 static unsigned int
11056 add_ranges (const_tree block
, bool maybe_new_sec
)
11058 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0, maybe_new_sec
);
11061 /* Note that (*rnglist_table)[offset] is either a head of a rnglist
11062 chain, or middle entry of a chain that will be directly referred to. */
11065 note_rnglist_head (unsigned int offset
)
11067 if (dwarf_version
< 5 || (*ranges_table
)[offset
].label
)
11069 (*ranges_table
)[offset
].label
= gen_internal_sym ("LLRL");
11072 /* Add a new entry to .debug_ranges corresponding to a pair of labels.
11073 When using dwarf_split_debug_info, address attributes in dies destined
11074 for the final executable should be direct references--setting the
11075 parameter force_direct ensures this behavior. */
11078 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
11079 bool *added
, bool force_direct
)
11081 unsigned int in_use
= vec_safe_length (ranges_by_label
);
11082 unsigned int offset
;
11083 dw_ranges_by_label rbl
= { begin
, end
};
11084 vec_safe_push (ranges_by_label
, rbl
);
11085 offset
= add_ranges_num (-(int)in_use
- 1, true);
11088 add_AT_range_list (die
, DW_AT_ranges
, offset
, force_direct
);
11090 note_rnglist_head (offset
);
11094 /* Emit .debug_ranges section. */
11097 output_ranges (void)
11100 static const char *const start_fmt
= "Offset %#x";
11101 const char *fmt
= start_fmt
;
11104 switch_to_section (debug_ranges_section
);
11105 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11106 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11108 int block_num
= r
->num
;
11112 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11113 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11115 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11116 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11118 /* If all code is in the text section, then the compilation
11119 unit base address defaults to DW_AT_low_pc, which is the
11120 base of the text section. */
11121 if (!have_multiple_function_sections
)
11123 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
11124 text_section_label
,
11125 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11126 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
11127 text_section_label
, NULL
);
11130 /* Otherwise, the compilation unit base address is zero,
11131 which allows us to use absolute addresses, and not worry
11132 about whether the target supports cross-section
11136 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11137 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11138 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
11144 /* Negative block_num stands for an index into ranges_by_label. */
11145 else if (block_num
< 0)
11147 int lab_idx
= - block_num
- 1;
11149 if (!have_multiple_function_sections
)
11151 gcc_unreachable ();
11153 /* If we ever use add_ranges_by_labels () for a single
11154 function section, all we have to do is to take out
11155 the #if 0 above. */
11156 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11157 (*ranges_by_label
)[lab_idx
].begin
,
11158 text_section_label
,
11159 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11160 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11161 (*ranges_by_label
)[lab_idx
].end
,
11162 text_section_label
, NULL
);
11167 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11168 (*ranges_by_label
)[lab_idx
].begin
,
11169 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11170 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11171 (*ranges_by_label
)[lab_idx
].end
,
11177 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11178 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11184 /* Non-zero if .debug_line_str should be used for .debug_line section
11185 strings or strings that are likely shareable with those. */
11186 #define DWARF5_USE_DEBUG_LINE_STR \
11187 (!DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET \
11188 && (DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) != 0 \
11189 /* FIXME: there is no .debug_line_str.dwo section, \
11190 for -gsplit-dwarf we should use DW_FORM_strx instead. */ \
11191 && !dwarf_split_debug_info)
11193 /* Assign .debug_rnglists indexes. */
11196 index_rnglists (void)
11201 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11203 r
->idx
= rnglist_idx
++;
11206 /* Emit .debug_rnglists section. */
11209 output_rnglists (unsigned generation
)
11213 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
11214 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
11215 char basebuf
[MAX_ARTIFICIAL_LABEL_BYTES
];
11217 switch_to_section (debug_ranges_section
);
11218 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
11219 /* There are up to 4 unique ranges labels per generation.
11220 See also init_sections_and_labels. */
11221 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_RANGES_SECTION_LABEL
,
11222 2 + generation
* 4);
11223 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_RANGES_SECTION_LABEL
,
11224 3 + generation
* 4);
11225 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11226 dw2_asm_output_data (4, 0xffffffff,
11227 "Initial length escape value indicating "
11228 "64-bit DWARF extension");
11229 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
11230 "Length of Range Lists");
11231 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
11232 dw2_asm_output_data (2, dwarf_version
, "DWARF Version");
11233 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
11234 dw2_asm_output_data (1, 0, "Segment Size");
11235 /* Emit the offset table only for -gsplit-dwarf. If we don't care
11236 about relocation sizes and primarily care about the size of .debug*
11237 sections in linked shared libraries and executables, then
11238 the offset table plus corresponding DW_FORM_rnglistx uleb128 indexes
11239 into it are usually larger than just DW_FORM_sec_offset offsets
11240 into the .debug_rnglists section. */
11241 dw2_asm_output_data (4, dwarf_split_debug_info
? rnglist_idx
: 0,
11242 "Offset Entry Count");
11243 if (dwarf_split_debug_info
)
11245 ASM_OUTPUT_LABEL (asm_out_file
, ranges_base_label
);
11246 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11248 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, r
->label
,
11249 ranges_base_label
, NULL
);
11252 const char *lab
= "";
11253 unsigned int len
= vec_safe_length (ranges_table
);
11254 const char *base
= NULL
;
11255 FOR_EACH_VEC_SAFE_ELT (ranges_table
, i
, r
)
11257 int block_num
= r
->num
;
11261 ASM_OUTPUT_LABEL (asm_out_file
, r
->label
);
11264 if (HAVE_AS_LEB128
&& (r
->label
|| r
->maybe_new_sec
))
11268 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11269 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11271 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11272 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11274 if (HAVE_AS_LEB128
)
11276 /* If all code is in the text section, then the compilation
11277 unit base address defaults to DW_AT_low_pc, which is the
11278 base of the text section. */
11279 if (!have_multiple_function_sections
)
11281 dw2_asm_output_data (1, DW_RLE_offset_pair
,
11282 "DW_RLE_offset_pair (%s)", lab
);
11283 dw2_asm_output_delta_uleb128 (blabel
, text_section_label
,
11284 "Range begin address (%s)", lab
);
11285 dw2_asm_output_delta_uleb128 (elabel
, text_section_label
,
11286 "Range end address (%s)", lab
);
11291 dw_ranges
*r2
= NULL
;
11293 r2
= &(*ranges_table
)[i
+ 1];
11296 && r2
->label
== NULL
11297 && !r2
->maybe_new_sec
)
11299 dw2_asm_output_data (1, DW_RLE_base_address
,
11300 "DW_RLE_base_address (%s)", lab
);
11301 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11302 "Base address (%s)", lab
);
11303 strcpy (basebuf
, blabel
);
11309 dw2_asm_output_data (1, DW_RLE_offset_pair
,
11310 "DW_RLE_offset_pair (%s)", lab
);
11311 dw2_asm_output_delta_uleb128 (blabel
, base
,
11312 "Range begin address (%s)", lab
);
11313 dw2_asm_output_delta_uleb128 (elabel
, base
,
11314 "Range end address (%s)", lab
);
11317 dw2_asm_output_data (1, DW_RLE_start_length
,
11318 "DW_RLE_start_length (%s)", lab
);
11319 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11320 "Range begin address (%s)", lab
);
11321 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
11322 "Range length (%s)", lab
);
11326 dw2_asm_output_data (1, DW_RLE_start_end
,
11327 "DW_RLE_start_end (%s)", lab
);
11328 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11329 "Range begin address (%s)", lab
);
11330 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
11331 "Range end address (%s)", lab
);
11335 /* Negative block_num stands for an index into ranges_by_label. */
11336 else if (block_num
< 0)
11338 int lab_idx
= - block_num
- 1;
11339 const char *blabel
= (*ranges_by_label
)[lab_idx
].begin
;
11340 const char *elabel
= (*ranges_by_label
)[lab_idx
].end
;
11342 if (!have_multiple_function_sections
)
11343 gcc_unreachable ();
11344 if (HAVE_AS_LEB128
)
11346 dw2_asm_output_data (1, DW_RLE_start_length
,
11347 "DW_RLE_start_length (%s)", lab
);
11348 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11349 "Range begin address (%s)", lab
);
11350 dw2_asm_output_delta_uleb128 (elabel
, blabel
,
11351 "Range length (%s)", lab
);
11355 dw2_asm_output_data (1, DW_RLE_start_end
,
11356 "DW_RLE_start_end (%s)", lab
);
11357 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11358 "Range begin address (%s)", lab
);
11359 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
,
11360 "Range end address (%s)", lab
);
11364 dw2_asm_output_data (1, DW_RLE_end_of_list
,
11365 "DW_RLE_end_of_list (%s)", lab
);
11367 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
11370 /* Data structure containing information about input files. */
11373 const char *path
; /* Complete file name. */
11374 const char *fname
; /* File name part. */
11375 int length
; /* Length of entire string. */
11376 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
11377 int dir_idx
; /* Index in directory table. */
11380 /* Data structure containing information about directories with source
11384 const char *path
; /* Path including directory name. */
11385 int length
; /* Path length. */
11386 int prefix
; /* Index of directory entry which is a prefix. */
11387 int count
; /* Number of files in this directory. */
11388 int dir_idx
; /* Index of directory used as base. */
11391 /* Callback function for file_info comparison. We sort by looking at
11392 the directories in the path. */
11395 file_info_cmp (const void *p1
, const void *p2
)
11397 const struct file_info
*const s1
= (const struct file_info
*) p1
;
11398 const struct file_info
*const s2
= (const struct file_info
*) p2
;
11399 const unsigned char *cp1
;
11400 const unsigned char *cp2
;
11402 /* Take care of file names without directories. We need to make sure that
11403 we return consistent values to qsort since some will get confused if
11404 we return the same value when identical operands are passed in opposite
11405 orders. So if neither has a directory, return 0 and otherwise return
11406 1 or -1 depending on which one has the directory. */
11407 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
11408 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
11410 cp1
= (const unsigned char *) s1
->path
;
11411 cp2
= (const unsigned char *) s2
->path
;
11417 /* Reached the end of the first path? If so, handle like above. */
11418 if ((cp1
== (const unsigned char *) s1
->fname
)
11419 || (cp2
== (const unsigned char *) s2
->fname
))
11420 return ((cp2
== (const unsigned char *) s2
->fname
)
11421 - (cp1
== (const unsigned char *) s1
->fname
));
11423 /* Character of current path component the same? */
11424 else if (*cp1
!= *cp2
)
11425 return *cp1
- *cp2
;
11429 struct file_name_acquire_data
11431 struct file_info
*files
;
11436 /* Traversal function for the hash table. */
11439 file_name_acquire (dwarf_file_data
**slot
, file_name_acquire_data
*fnad
)
11441 struct dwarf_file_data
*d
= *slot
;
11442 struct file_info
*fi
;
11445 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
11447 if (! d
->emitted_number
)
11450 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
11452 fi
= fnad
->files
+ fnad
->used_files
++;
11454 /* Skip all leading "./". */
11456 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
11459 /* Create a new array entry. */
11461 fi
->length
= strlen (f
);
11464 /* Search for the file name part. */
11465 f
= strrchr (f
, DIR_SEPARATOR
);
11466 #if defined (DIR_SEPARATOR_2)
11468 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
11472 if (f
== NULL
|| f
< g
)
11478 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
11482 /* Helper function for output_file_names. Emit a FORM encoded
11483 string STR, with assembly comment start ENTRY_KIND and
11487 output_line_string (enum dwarf_form form
, const char *str
,
11488 const char *entry_kind
, unsigned int idx
)
11492 case DW_FORM_string
:
11493 dw2_asm_output_nstring (str
, -1, "%s: %#x", entry_kind
, idx
);
11495 case DW_FORM_line_strp
:
11496 if (!debug_line_str_hash
)
11497 debug_line_str_hash
11498 = hash_table
<indirect_string_hasher
>::create_ggc (10);
11500 struct indirect_string_node
*node
;
11501 node
= find_AT_string_in_table (str
, debug_line_str_hash
);
11502 set_indirect_string (node
);
11504 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
11505 debug_line_str_section
, "%s: %#x: \"%s\"",
11506 entry_kind
, 0, node
->str
);
11509 gcc_unreachable ();
11513 /* Output the directory table and the file name table. We try to minimize
11514 the total amount of memory needed. A heuristic is used to avoid large
11515 slowdowns with many input files. */
11518 output_file_names (void)
11520 struct file_name_acquire_data fnad
;
11522 struct file_info
*files
;
11523 struct dir_info
*dirs
;
11531 if (!last_emitted_file
)
11533 if (dwarf_version
>= 5)
11535 dw2_asm_output_data (1, 0, "Directory entry format count");
11536 dw2_asm_output_data_uleb128 (0, "Directories count");
11537 dw2_asm_output_data (1, 0, "File name entry format count");
11538 dw2_asm_output_data_uleb128 (0, "File names count");
11542 dw2_asm_output_data (1, 0, "End directory table");
11543 dw2_asm_output_data (1, 0, "End file name table");
11548 numfiles
= last_emitted_file
->emitted_number
;
11550 /* Allocate the various arrays we need. */
11551 files
= XALLOCAVEC (struct file_info
, numfiles
);
11552 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
11554 fnad
.files
= files
;
11555 fnad
.used_files
= 0;
11556 fnad
.max_files
= numfiles
;
11557 file_table
->traverse
<file_name_acquire_data
*, file_name_acquire
> (&fnad
);
11558 gcc_assert (fnad
.used_files
== fnad
.max_files
);
11560 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
11562 /* Find all the different directories used. */
11563 dirs
[0].path
= files
[0].path
;
11564 dirs
[0].length
= files
[0].fname
- files
[0].path
;
11565 dirs
[0].prefix
= -1;
11567 dirs
[0].dir_idx
= 0;
11568 files
[0].dir_idx
= 0;
11571 for (i
= 1; i
< numfiles
; i
++)
11572 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
11573 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
11574 dirs
[ndirs
- 1].length
) == 0)
11576 /* Same directory as last entry. */
11577 files
[i
].dir_idx
= ndirs
- 1;
11578 ++dirs
[ndirs
- 1].count
;
11584 /* This is a new directory. */
11585 dirs
[ndirs
].path
= files
[i
].path
;
11586 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
11587 dirs
[ndirs
].count
= 1;
11588 dirs
[ndirs
].dir_idx
= ndirs
;
11589 files
[i
].dir_idx
= ndirs
;
11591 /* Search for a prefix. */
11592 dirs
[ndirs
].prefix
= -1;
11593 for (j
= 0; j
< ndirs
; j
++)
11594 if (dirs
[j
].length
< dirs
[ndirs
].length
11595 && dirs
[j
].length
> 1
11596 && (dirs
[ndirs
].prefix
== -1
11597 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
11598 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
11599 dirs
[ndirs
].prefix
= j
;
11604 /* Now to the actual work. We have to find a subset of the directories which
11605 allow expressing the file name using references to the directory table
11606 with the least amount of characters. We do not do an exhaustive search
11607 where we would have to check out every combination of every single
11608 possible prefix. Instead we use a heuristic which provides nearly optimal
11609 results in most cases and never is much off. */
11610 saved
= XALLOCAVEC (int, ndirs
);
11611 savehere
= XALLOCAVEC (int, ndirs
);
11613 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
11614 for (i
= 0; i
< ndirs
; i
++)
11619 /* We can always save some space for the current directory. But this
11620 does not mean it will be enough to justify adding the directory. */
11621 savehere
[i
] = dirs
[i
].length
;
11622 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
11624 for (j
= i
+ 1; j
< ndirs
; j
++)
11627 if (saved
[j
] < dirs
[i
].length
)
11629 /* Determine whether the dirs[i] path is a prefix of the
11633 k
= dirs
[j
].prefix
;
11634 while (k
!= -1 && k
!= (int) i
)
11635 k
= dirs
[k
].prefix
;
11639 /* Yes it is. We can possibly save some memory by
11640 writing the filenames in dirs[j] relative to
11642 savehere
[j
] = dirs
[i
].length
;
11643 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
11648 /* Check whether we can save enough to justify adding the dirs[i]
11650 if (total
> dirs
[i
].length
+ 1)
11652 /* It's worthwhile adding. */
11653 for (j
= i
; j
< ndirs
; j
++)
11654 if (savehere
[j
] > 0)
11656 /* Remember how much we saved for this directory so far. */
11657 saved
[j
] = savehere
[j
];
11659 /* Remember the prefix directory. */
11660 dirs
[j
].dir_idx
= i
;
11665 /* Emit the directory name table. */
11666 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
11667 enum dwarf_form str_form
= DW_FORM_string
;
11668 enum dwarf_form idx_form
= DW_FORM_udata
;
11669 if (dwarf_version
>= 5)
11671 const char *comp_dir
= comp_dir_string ();
11672 if (comp_dir
== NULL
)
11674 dw2_asm_output_data (1, 1, "Directory entry format count");
11675 if (DWARF5_USE_DEBUG_LINE_STR
)
11676 str_form
= DW_FORM_line_strp
;
11677 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
11678 dw2_asm_output_data_uleb128 (str_form
, "%s",
11679 get_DW_FORM_name (str_form
));
11680 dw2_asm_output_data_uleb128 (ndirs
+ idx_offset
, "Directories count");
11681 if (str_form
== DW_FORM_string
)
11683 dw2_asm_output_nstring (comp_dir
, -1, "Directory Entry: %#x", 0);
11684 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
11685 dw2_asm_output_nstring (dirs
[i
].path
,
11687 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
11688 "Directory Entry: %#x", i
+ idx_offset
);
11692 output_line_string (str_form
, comp_dir
, "Directory Entry", 0);
11693 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
11696 = ggc_alloc_string (dirs
[i
].path
,
11698 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
);
11699 output_line_string (str_form
, str
, "Directory Entry",
11700 (unsigned) i
+ idx_offset
);
11706 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
11707 dw2_asm_output_nstring (dirs
[i
].path
,
11709 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
11710 "Directory Entry: %#x", i
+ idx_offset
);
11712 dw2_asm_output_data (1, 0, "End directory table");
11715 /* We have to emit them in the order of emitted_number since that's
11716 used in the debug info generation. To do this efficiently we
11717 generate a back-mapping of the indices first. */
11718 backmap
= XALLOCAVEC (int, numfiles
);
11719 for (i
= 0; i
< numfiles
; i
++)
11720 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
11722 if (dwarf_version
>= 5)
11724 const char *filename0
= get_AT_string (comp_unit_die (), DW_AT_name
);
11725 if (filename0
== NULL
)
11727 /* DW_LNCT_directory_index can use DW_FORM_udata, DW_FORM_data1 and
11728 DW_FORM_data2. Choose one based on the number of directories
11729 and how much space would they occupy in each encoding.
11730 If we have at most 256 directories, all indexes fit into
11731 a single byte, so DW_FORM_data1 is most compact (if there
11732 are at most 128 directories, DW_FORM_udata would be as
11733 compact as that, but not shorter and slower to decode). */
11734 if (ndirs
+ idx_offset
<= 256)
11735 idx_form
= DW_FORM_data1
;
11736 /* If there are more than 65536 directories, we have to use
11737 DW_FORM_udata, DW_FORM_data2 can't refer to them.
11738 Otherwise, compute what space would occupy if all the indexes
11739 used DW_FORM_udata - sum - and compare that to how large would
11740 be DW_FORM_data2 encoding, and pick the more efficient one. */
11741 else if (ndirs
+ idx_offset
<= 65536)
11743 unsigned HOST_WIDE_INT sum
= 1;
11744 for (i
= 0; i
< numfiles
; i
++)
11746 int file_idx
= backmap
[i
];
11747 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
11748 sum
+= size_of_uleb128 (dir_idx
);
11750 if (sum
>= HOST_WIDE_INT_UC (2) * (numfiles
+ 1))
11751 idx_form
= DW_FORM_data2
;
11753 #ifdef VMS_DEBUGGING_INFO
11754 dw2_asm_output_data (1, 4, "File name entry format count");
11756 dw2_asm_output_data (1, 2, "File name entry format count");
11758 dw2_asm_output_data_uleb128 (DW_LNCT_path
, "DW_LNCT_path");
11759 dw2_asm_output_data_uleb128 (str_form
, "%s",
11760 get_DW_FORM_name (str_form
));
11761 dw2_asm_output_data_uleb128 (DW_LNCT_directory_index
,
11762 "DW_LNCT_directory_index");
11763 dw2_asm_output_data_uleb128 (idx_form
, "%s",
11764 get_DW_FORM_name (idx_form
));
11765 #ifdef VMS_DEBUGGING_INFO
11766 dw2_asm_output_data_uleb128 (DW_LNCT_timestamp
, "DW_LNCT_timestamp");
11767 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
11768 dw2_asm_output_data_uleb128 (DW_LNCT_size
, "DW_LNCT_size");
11769 dw2_asm_output_data_uleb128 (DW_FORM_udata
, "DW_FORM_udata");
11771 dw2_asm_output_data_uleb128 (numfiles
+ 1, "File names count");
11773 output_line_string (str_form
, filename0
, "File Entry", 0);
11775 /* Include directory index. */
11776 if (idx_form
!= DW_FORM_udata
)
11777 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
11780 dw2_asm_output_data_uleb128 (0, NULL
);
11782 #ifdef VMS_DEBUGGING_INFO
11783 dw2_asm_output_data_uleb128 (0, NULL
);
11784 dw2_asm_output_data_uleb128 (0, NULL
);
11788 /* Now write all the file names. */
11789 for (i
= 0; i
< numfiles
; i
++)
11791 int file_idx
= backmap
[i
];
11792 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
11794 #ifdef VMS_DEBUGGING_INFO
11795 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
11797 /* Setting these fields can lead to debugger miscomparisons,
11798 but VMS Debug requires them to be set correctly. */
11803 int maxfilelen
= (strlen (files
[file_idx
].path
)
11804 + dirs
[dir_idx
].length
11805 + MAX_VMS_VERSION_LEN
+ 1);
11806 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
11808 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
11809 snprintf (filebuf
, maxfilelen
, "%s;%d",
11810 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
11812 output_line_string (str_form
, filebuf
, "File Entry", (unsigned) i
+ 1);
11814 /* Include directory index. */
11815 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
11816 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
11817 dir_idx
+ idx_offset
, NULL
);
11819 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
11821 /* Modification time. */
11822 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
11823 &cdt
, 0, 0, 0) == 0)
11826 /* File length in bytes. */
11827 dw2_asm_output_data_uleb128 ((vms_file_stats_name (files
[file_idx
].path
,
11828 0, &siz
, 0, 0) == 0)
11831 output_line_string (str_form
,
11832 files
[file_idx
].path
+ dirs
[dir_idx
].length
,
11833 "File Entry", (unsigned) i
+ 1);
11835 /* Include directory index. */
11836 if (dwarf_version
>= 5 && idx_form
!= DW_FORM_udata
)
11837 dw2_asm_output_data (idx_form
== DW_FORM_data1
? 1 : 2,
11838 dir_idx
+ idx_offset
, NULL
);
11840 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
11842 if (dwarf_version
>= 5)
11845 /* Modification time. */
11846 dw2_asm_output_data_uleb128 (0, NULL
);
11848 /* File length in bytes. */
11849 dw2_asm_output_data_uleb128 (0, NULL
);
11850 #endif /* VMS_DEBUGGING_INFO */
11853 if (dwarf_version
< 5)
11854 dw2_asm_output_data (1, 0, "End file name table");
11858 /* Output one line number table into the .debug_line section. */
11861 output_one_line_info_table (dw_line_info_table
*table
)
11863 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
11864 unsigned int current_line
= 1;
11865 bool current_is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
11866 dw_line_info_entry
*ent
;
11869 FOR_EACH_VEC_SAFE_ELT (table
->entries
, i
, ent
)
11871 switch (ent
->opcode
)
11873 case LI_set_address
:
11874 /* ??? Unfortunately, we have little choice here currently, and
11875 must always use the most general form. GCC does not know the
11876 address delta itself, so we can't use DW_LNS_advance_pc. Many
11877 ports do have length attributes which will give an upper bound
11878 on the address range. We could perhaps use length attributes
11879 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
11880 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, ent
->val
);
11882 /* This can handle any delta. This takes
11883 4+DWARF2_ADDR_SIZE bytes. */
11884 dw2_asm_output_data (1, 0, "set address %s", line_label
);
11885 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
11886 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
11887 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
11891 if (ent
->val
== current_line
)
11893 /* We still need to start a new row, so output a copy insn. */
11894 dw2_asm_output_data (1, DW_LNS_copy
,
11895 "copy line %u", current_line
);
11899 int line_offset
= ent
->val
- current_line
;
11900 int line_delta
= line_offset
- DWARF_LINE_BASE
;
11902 current_line
= ent
->val
;
11903 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
11905 /* This can handle deltas from -10 to 234, using the current
11906 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE.
11907 This takes 1 byte. */
11908 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
11909 "line %u", current_line
);
11913 /* This can handle any delta. This takes at least 4 bytes,
11914 depending on the value being encoded. */
11915 dw2_asm_output_data (1, DW_LNS_advance_line
,
11916 "advance to line %u", current_line
);
11917 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
11918 dw2_asm_output_data (1, DW_LNS_copy
, NULL
);
11924 dw2_asm_output_data (1, DW_LNS_set_file
, "set file %u", ent
->val
);
11925 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
11928 case LI_set_column
:
11929 dw2_asm_output_data (1, DW_LNS_set_column
, "column %u", ent
->val
);
11930 dw2_asm_output_data_uleb128 (ent
->val
, "%u", ent
->val
);
11933 case LI_negate_stmt
:
11934 current_is_stmt
= !current_is_stmt
;
11935 dw2_asm_output_data (1, DW_LNS_negate_stmt
,
11936 "is_stmt %d", current_is_stmt
);
11939 case LI_set_prologue_end
:
11940 dw2_asm_output_data (1, DW_LNS_set_prologue_end
,
11941 "set prologue end");
11944 case LI_set_epilogue_begin
:
11945 dw2_asm_output_data (1, DW_LNS_set_epilogue_begin
,
11946 "set epilogue begin");
11949 case LI_set_discriminator
:
11950 dw2_asm_output_data (1, 0, "discriminator %u", ent
->val
);
11951 dw2_asm_output_data_uleb128 (1 + size_of_uleb128 (ent
->val
), NULL
);
11952 dw2_asm_output_data (1, DW_LNE_set_discriminator
, NULL
);
11953 dw2_asm_output_data_uleb128 (ent
->val
, NULL
);
11958 /* Emit debug info for the address of the end of the table. */
11959 dw2_asm_output_data (1, 0, "set address %s", table
->end_label
);
11960 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
11961 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
11962 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, table
->end_label
, NULL
);
11964 dw2_asm_output_data (1, 0, "end sequence");
11965 dw2_asm_output_data_uleb128 (1, NULL
);
11966 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
11969 /* Output the source line number correspondence information. This
11970 information goes into the .debug_line section. */
11973 output_line_info (bool prologue_only
)
11975 static unsigned int generation
;
11976 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
], l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
11977 char p1
[MAX_ARTIFICIAL_LABEL_BYTES
], p2
[MAX_ARTIFICIAL_LABEL_BYTES
];
11978 bool saw_one
= false;
11981 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, generation
);
11982 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, generation
);
11983 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, generation
);
11984 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, generation
++);
11986 if (!XCOFF_DEBUGGING_INFO
)
11988 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11989 dw2_asm_output_data (4, 0xffffffff,
11990 "Initial length escape value indicating 64-bit DWARF extension");
11991 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
11992 "Length of Source Line Info");
11995 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
11997 dw2_asm_output_data (2, dwarf_version
, "DWARF Version");
11998 if (dwarf_version
>= 5)
12000 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
12001 dw2_asm_output_data (1, 0, "Segment Size");
12003 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
12004 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
12006 /* Define the architecture-dependent minimum instruction length (in bytes).
12007 In this implementation of DWARF, this field is used for information
12008 purposes only. Since GCC generates assembly language, we have no
12009 a priori knowledge of how many instruction bytes are generated for each
12010 source line, and therefore can use only the DW_LNE_set_address and
12011 DW_LNS_fixed_advance_pc line information commands. Accordingly, we fix
12012 this as '1', which is "correct enough" for all architectures,
12013 and don't let the target override. */
12014 dw2_asm_output_data (1, 1, "Minimum Instruction Length");
12016 if (dwarf_version
>= 4)
12017 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
12018 "Maximum Operations Per Instruction");
12019 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
12020 "Default is_stmt_start flag");
12021 dw2_asm_output_data (1, DWARF_LINE_BASE
,
12022 "Line Base Value (Special Opcodes)");
12023 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
12024 "Line Range Value (Special Opcodes)");
12025 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
12026 "Special Opcode Base");
12028 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
12033 case DW_LNS_advance_pc
:
12034 case DW_LNS_advance_line
:
12035 case DW_LNS_set_file
:
12036 case DW_LNS_set_column
:
12037 case DW_LNS_fixed_advance_pc
:
12038 case DW_LNS_set_isa
:
12046 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
12050 /* Write out the information about the files we use. */
12051 output_file_names ();
12052 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
12055 /* Output the marker for the end of the line number info. */
12056 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12060 if (separate_line_info
)
12062 dw_line_info_table
*table
;
12065 FOR_EACH_VEC_ELT (*separate_line_info
, i
, table
)
12068 output_one_line_info_table (table
);
12072 if (cold_text_section_line_info
&& cold_text_section_line_info
->in_use
)
12074 output_one_line_info_table (cold_text_section_line_info
);
12078 /* ??? Some Darwin linkers crash on a .debug_line section with no
12079 sequences. Further, merely a DW_LNE_end_sequence entry is not
12080 sufficient -- the address column must also be initialized.
12081 Make sure to output at least one set_address/end_sequence pair,
12082 choosing .text since that section is always present. */
12083 if (text_section_line_info
->in_use
|| !saw_one
)
12084 output_one_line_info_table (text_section_line_info
);
12086 /* Output the marker for the end of the line number info. */
12087 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12090 /* Return true if DW_AT_endianity should be emitted according to REVERSE. */
12093 need_endianity_attribute_p (bool reverse
)
12095 return reverse
&& (dwarf_version
>= 3 || !dwarf_strict
);
12098 /* Given a pointer to a tree node for some base type, return a pointer to
12099 a DIE that describes the given type. REVERSE is true if the type is
12100 to be interpreted in the reverse storage order wrt the target order.
12102 This routine must only be called for GCC type nodes that correspond to
12103 Dwarf base (fundamental) types. */
12106 base_type_die (tree type
, bool reverse
)
12108 dw_die_ref base_type_result
;
12109 enum dwarf_type encoding
;
12110 bool fpt_used
= false;
12111 struct fixed_point_type_info fpt_info
;
12112 tree type_bias
= NULL_TREE
;
12114 /* If this is a subtype that should not be emitted as a subrange type,
12115 use the base type. See subrange_type_for_debug_p. */
12116 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
12117 type
= TREE_TYPE (type
);
12119 switch (TREE_CODE (type
))
12122 if ((dwarf_version
>= 4 || !dwarf_strict
)
12123 && TYPE_NAME (type
)
12124 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
12125 && DECL_IS_BUILTIN (TYPE_NAME (type
))
12126 && DECL_NAME (TYPE_NAME (type
)))
12128 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
12129 if (strcmp (name
, "char16_t") == 0
12130 || strcmp (name
, "char32_t") == 0)
12132 encoding
= DW_ATE_UTF
;
12136 if ((dwarf_version
>= 3 || !dwarf_strict
)
12137 && lang_hooks
.types
.get_fixed_point_type_info
)
12139 memset (&fpt_info
, 0, sizeof (fpt_info
));
12140 if (lang_hooks
.types
.get_fixed_point_type_info (type
, &fpt_info
))
12143 encoding
= ((TYPE_UNSIGNED (type
))
12144 ? DW_ATE_unsigned_fixed
12145 : DW_ATE_signed_fixed
);
12149 if (TYPE_STRING_FLAG (type
))
12151 if (TYPE_UNSIGNED (type
))
12152 encoding
= DW_ATE_unsigned_char
;
12154 encoding
= DW_ATE_signed_char
;
12156 else if (TYPE_UNSIGNED (type
))
12157 encoding
= DW_ATE_unsigned
;
12159 encoding
= DW_ATE_signed
;
12162 && lang_hooks
.types
.get_type_bias
)
12163 type_bias
= lang_hooks
.types
.get_type_bias (type
);
12167 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
12169 if (dwarf_version
>= 3 || !dwarf_strict
)
12170 encoding
= DW_ATE_decimal_float
;
12172 encoding
= DW_ATE_lo_user
;
12175 encoding
= DW_ATE_float
;
12178 case FIXED_POINT_TYPE
:
12179 if (!(dwarf_version
>= 3 || !dwarf_strict
))
12180 encoding
= DW_ATE_lo_user
;
12181 else if (TYPE_UNSIGNED (type
))
12182 encoding
= DW_ATE_unsigned_fixed
;
12184 encoding
= DW_ATE_signed_fixed
;
12187 /* Dwarf2 doesn't know anything about complex ints, so use
12188 a user defined type for it. */
12190 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
12191 encoding
= DW_ATE_complex_float
;
12193 encoding
= DW_ATE_lo_user
;
12197 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
12198 encoding
= DW_ATE_boolean
;
12202 /* No other TREE_CODEs are Dwarf fundamental types. */
12203 gcc_unreachable ();
12206 base_type_result
= new_die_raw (DW_TAG_base_type
);
12208 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
12209 int_size_in_bytes (type
));
12210 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
12212 if (need_endianity_attribute_p (reverse
))
12213 add_AT_unsigned (base_type_result
, DW_AT_endianity
,
12214 BYTES_BIG_ENDIAN
? DW_END_little
: DW_END_big
);
12216 add_alignment_attribute (base_type_result
, type
);
12220 switch (fpt_info
.scale_factor_kind
)
12222 case fixed_point_scale_factor_binary
:
12223 add_AT_int (base_type_result
, DW_AT_binary_scale
,
12224 fpt_info
.scale_factor
.binary
);
12227 case fixed_point_scale_factor_decimal
:
12228 add_AT_int (base_type_result
, DW_AT_decimal_scale
,
12229 fpt_info
.scale_factor
.decimal
);
12232 case fixed_point_scale_factor_arbitrary
:
12233 /* Arbitrary scale factors cannot be described in standard DWARF,
12237 /* Describe the scale factor as a rational constant. */
12238 const dw_die_ref scale_factor
12239 = new_die (DW_TAG_constant
, comp_unit_die (), type
);
12241 add_AT_unsigned (scale_factor
, DW_AT_GNU_numerator
,
12242 fpt_info
.scale_factor
.arbitrary
.numerator
);
12243 add_AT_int (scale_factor
, DW_AT_GNU_denominator
,
12244 fpt_info
.scale_factor
.arbitrary
.denominator
);
12246 add_AT_die_ref (base_type_result
, DW_AT_small
, scale_factor
);
12251 gcc_unreachable ();
12256 add_scalar_info (base_type_result
, DW_AT_GNU_bias
, type_bias
,
12257 dw_scalar_form_constant
12258 | dw_scalar_form_exprloc
12259 | dw_scalar_form_reference
,
12262 return base_type_result
;
12265 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
12266 named 'auto' in its type: return true for it, false otherwise. */
12269 is_cxx_auto (tree type
)
12273 tree name
= TYPE_IDENTIFIER (type
);
12274 if (name
== get_identifier ("auto")
12275 || name
== get_identifier ("decltype(auto)"))
12281 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
12282 given input type is a Dwarf "fundamental" type. Otherwise return null. */
12285 is_base_type (tree type
)
12287 switch (TREE_CODE (type
))
12291 case FIXED_POINT_TYPE
:
12294 case POINTER_BOUNDS_TYPE
:
12301 case QUAL_UNION_TYPE
:
12302 case ENUMERAL_TYPE
:
12303 case FUNCTION_TYPE
:
12306 case REFERENCE_TYPE
:
12314 if (is_cxx_auto (type
))
12316 gcc_unreachable ();
12322 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
12323 node, return the size in bits for the type if it is a constant, or else
12324 return the alignment for the type if the type's size is not constant, or
12325 else return BITS_PER_WORD if the type actually turns out to be an
12326 ERROR_MARK node. */
12328 static inline unsigned HOST_WIDE_INT
12329 simple_type_size_in_bits (const_tree type
)
12331 if (TREE_CODE (type
) == ERROR_MARK
)
12332 return BITS_PER_WORD
;
12333 else if (TYPE_SIZE (type
) == NULL_TREE
)
12335 else if (tree_fits_uhwi_p (TYPE_SIZE (type
)))
12336 return tree_to_uhwi (TYPE_SIZE (type
));
12338 return TYPE_ALIGN (type
);
12341 /* Similarly, but return an offset_int instead of UHWI. */
12343 static inline offset_int
12344 offset_int_type_size_in_bits (const_tree type
)
12346 if (TREE_CODE (type
) == ERROR_MARK
)
12347 return BITS_PER_WORD
;
12348 else if (TYPE_SIZE (type
) == NULL_TREE
)
12350 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
12351 return wi::to_offset (TYPE_SIZE (type
));
12353 return TYPE_ALIGN (type
);
12356 /* Given a pointer to a tree node for a subrange type, return a pointer
12357 to a DIE that describes the given type. */
12360 subrange_type_die (tree type
, tree low
, tree high
, tree bias
,
12361 dw_die_ref context_die
)
12363 dw_die_ref subrange_die
;
12364 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
12366 if (context_die
== NULL
)
12367 context_die
= comp_unit_die ();
12369 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
12371 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
12373 /* The size of the subrange type and its base type do not match,
12374 so we need to generate a size attribute for the subrange type. */
12375 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
12378 add_alignment_attribute (subrange_die
, type
);
12381 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
, NULL
);
12383 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
, NULL
);
12384 if (bias
&& !dwarf_strict
)
12385 add_scalar_info (subrange_die
, DW_AT_GNU_bias
, bias
,
12386 dw_scalar_form_constant
12387 | dw_scalar_form_exprloc
12388 | dw_scalar_form_reference
,
12391 return subrange_die
;
12394 /* Returns the (const and/or volatile) cv_qualifiers associated with
12395 the decl node. This will normally be augmented with the
12396 cv_qualifiers of the underlying type in add_type_attribute. */
12399 decl_quals (const_tree decl
)
12401 return ((TREE_READONLY (decl
)
12402 /* The C++ front-end correctly marks reference-typed
12403 variables as readonly, but from a language (and debug
12404 info) standpoint they are not const-qualified. */
12405 && TREE_CODE (TREE_TYPE (decl
)) != REFERENCE_TYPE
12406 ? TYPE_QUAL_CONST
: TYPE_UNQUALIFIED
)
12407 | (TREE_THIS_VOLATILE (decl
)
12408 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
));
12411 /* Determine the TYPE whose qualifiers match the largest strict subset
12412 of the given TYPE_QUALS, and return its qualifiers. Ignore all
12413 qualifiers outside QUAL_MASK. */
12416 get_nearest_type_subqualifiers (tree type
, int type_quals
, int qual_mask
)
12419 int best_rank
= 0, best_qual
= 0, max_rank
;
12421 type_quals
&= qual_mask
;
12422 max_rank
= popcount_hwi (type_quals
) - 1;
12424 for (t
= TYPE_MAIN_VARIANT (type
); t
&& best_rank
< max_rank
;
12425 t
= TYPE_NEXT_VARIANT (t
))
12427 int q
= TYPE_QUALS (t
) & qual_mask
;
12429 if ((q
& type_quals
) == q
&& q
!= type_quals
12430 && check_base_type (t
, type
))
12432 int rank
= popcount_hwi (q
);
12434 if (rank
> best_rank
)
12445 struct dwarf_qual_info_t
{ int q
; enum dwarf_tag t
; };
12446 static const dwarf_qual_info_t dwarf_qual_info
[] =
12448 { TYPE_QUAL_CONST
, DW_TAG_const_type
},
12449 { TYPE_QUAL_VOLATILE
, DW_TAG_volatile_type
},
12450 { TYPE_QUAL_RESTRICT
, DW_TAG_restrict_type
},
12451 { TYPE_QUAL_ATOMIC
, DW_TAG_atomic_type
}
12453 static const unsigned int dwarf_qual_info_size
12454 = sizeof (dwarf_qual_info
) / sizeof (dwarf_qual_info
[0]);
12456 /* If DIE is a qualified DIE of some base DIE with the same parent,
12457 return the base DIE, otherwise return NULL. Set MASK to the
12458 qualifiers added compared to the returned DIE. */
12461 qualified_die_p (dw_die_ref die
, int *mask
, unsigned int depth
)
12464 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
12465 if (die
->die_tag
== dwarf_qual_info
[i
].t
)
12467 if (i
== dwarf_qual_info_size
)
12469 if (vec_safe_length (die
->die_attr
) != 1)
12471 dw_die_ref type
= get_AT_ref (die
, DW_AT_type
);
12472 if (type
== NULL
|| type
->die_parent
!= die
->die_parent
)
12474 *mask
|= dwarf_qual_info
[i
].q
;
12477 dw_die_ref ret
= qualified_die_p (type
, mask
, depth
- 1);
12484 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
12485 entry that chains the modifiers specified by CV_QUALS in front of the
12486 given type. REVERSE is true if the type is to be interpreted in the
12487 reverse storage order wrt the target order. */
12490 modified_type_die (tree type
, int cv_quals
, bool reverse
,
12491 dw_die_ref context_die
)
12493 enum tree_code code
= TREE_CODE (type
);
12494 dw_die_ref mod_type_die
;
12495 dw_die_ref sub_die
= NULL
;
12496 tree item_type
= NULL
;
12497 tree qualified_type
;
12498 tree name
, low
, high
;
12499 dw_die_ref mod_scope
;
12500 /* Only these cv-qualifiers are currently handled. */
12501 const int cv_qual_mask
= (TYPE_QUAL_CONST
| TYPE_QUAL_VOLATILE
12502 | TYPE_QUAL_RESTRICT
| TYPE_QUAL_ATOMIC
|
12503 ENCODE_QUAL_ADDR_SPACE(~0U));
12504 const bool reverse_base_type
12505 = need_endianity_attribute_p (reverse
) && is_base_type (type
);
12507 if (code
== ERROR_MARK
)
12510 if (lang_hooks
.types
.get_debug_type
)
12512 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
12514 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
12515 return modified_type_die (debug_type
, cv_quals
, reverse
, context_die
);
12518 cv_quals
&= cv_qual_mask
;
12520 /* Don't emit DW_TAG_restrict_type for DWARFv2, since it is a type
12521 tag modifier (and not an attribute) old consumers won't be able
12523 if (dwarf_version
< 3)
12524 cv_quals
&= ~TYPE_QUAL_RESTRICT
;
12526 /* Likewise for DW_TAG_atomic_type for DWARFv5. */
12527 if (dwarf_version
< 5)
12528 cv_quals
&= ~TYPE_QUAL_ATOMIC
;
12530 /* See if we already have the appropriately qualified variant of
12532 qualified_type
= get_qualified_type (type
, cv_quals
);
12534 if (qualified_type
== sizetype
)
12536 /* Try not to expose the internal sizetype type's name. */
12537 if (TYPE_NAME (qualified_type
)
12538 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
12540 tree t
= TREE_TYPE (TYPE_NAME (qualified_type
));
12542 gcc_checking_assert (TREE_CODE (t
) == INTEGER_TYPE
12543 && (TYPE_PRECISION (t
)
12544 == TYPE_PRECISION (qualified_type
))
12545 && (TYPE_UNSIGNED (t
)
12546 == TYPE_UNSIGNED (qualified_type
)));
12547 qualified_type
= t
;
12549 else if (qualified_type
== sizetype
12550 && TREE_CODE (sizetype
) == TREE_CODE (size_type_node
)
12551 && TYPE_PRECISION (sizetype
) == TYPE_PRECISION (size_type_node
)
12552 && TYPE_UNSIGNED (sizetype
) == TYPE_UNSIGNED (size_type_node
))
12553 qualified_type
= size_type_node
;
12556 /* If we do, then we can just use its DIE, if it exists. */
12557 if (qualified_type
)
12559 mod_type_die
= lookup_type_die (qualified_type
);
12561 /* DW_AT_endianity doesn't come from a qualifier on the type, so it is
12562 dealt with specially: the DIE with the attribute, if it exists, is
12563 placed immediately after the regular DIE for the same base type. */
12565 && (!reverse_base_type
12566 || ((mod_type_die
= mod_type_die
->die_sib
) != NULL
12567 && get_AT_unsigned (mod_type_die
, DW_AT_endianity
))))
12568 return mod_type_die
;
12571 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
12573 /* Handle C typedef types. */
12575 && TREE_CODE (name
) == TYPE_DECL
12576 && DECL_ORIGINAL_TYPE (name
)
12577 && !DECL_ARTIFICIAL (name
))
12579 tree dtype
= TREE_TYPE (name
);
12581 /* Skip the typedef for base types with DW_AT_endianity, no big deal. */
12582 if (qualified_type
== dtype
&& !reverse_base_type
)
12584 tree origin
= decl_ultimate_origin (name
);
12586 /* Typedef variants that have an abstract origin don't get their own
12587 type DIE (see gen_typedef_die), so fall back on the ultimate
12588 abstract origin instead. */
12589 if (origin
!= NULL
&& origin
!= name
)
12590 return modified_type_die (TREE_TYPE (origin
), cv_quals
, reverse
,
12593 /* For a named type, use the typedef. */
12594 gen_type_die (qualified_type
, context_die
);
12595 return lookup_type_die (qualified_type
);
12599 int dquals
= TYPE_QUALS_NO_ADDR_SPACE (dtype
);
12600 dquals
&= cv_qual_mask
;
12601 if ((dquals
& ~cv_quals
) != TYPE_UNQUALIFIED
12602 || (cv_quals
== dquals
&& DECL_ORIGINAL_TYPE (name
) != type
))
12603 /* cv-unqualified version of named type. Just use
12604 the unnamed type to which it refers. */
12605 return modified_type_die (DECL_ORIGINAL_TYPE (name
), cv_quals
,
12606 reverse
, context_die
);
12607 /* Else cv-qualified version of named type; fall through. */
12611 mod_scope
= scope_die_for (type
, context_die
);
12615 int sub_quals
= 0, first_quals
= 0;
12617 dw_die_ref first
= NULL
, last
= NULL
;
12619 /* Determine a lesser qualified type that most closely matches
12620 this one. Then generate DW_TAG_* entries for the remaining
12622 sub_quals
= get_nearest_type_subqualifiers (type
, cv_quals
,
12624 if (sub_quals
&& use_debug_types
)
12626 bool needed
= false;
12627 /* If emitting type units, make sure the order of qualifiers
12628 is canonical. Thus, start from unqualified type if
12629 an earlier qualifier is missing in sub_quals, but some later
12630 one is present there. */
12631 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
12632 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
12634 else if (needed
&& (dwarf_qual_info
[i
].q
& cv_quals
))
12640 mod_type_die
= modified_type_die (type
, sub_quals
, reverse
, context_die
);
12641 if (mod_scope
&& mod_type_die
&& mod_type_die
->die_parent
== mod_scope
)
12643 /* As not all intermediate qualified DIEs have corresponding
12644 tree types, ensure that qualified DIEs in the same scope
12645 as their DW_AT_type are emitted after their DW_AT_type,
12646 only with other qualified DIEs for the same type possibly
12647 in between them. Determine the range of such qualified
12648 DIEs now (first being the base type, last being corresponding
12649 last qualified DIE for it). */
12650 unsigned int count
= 0;
12651 first
= qualified_die_p (mod_type_die
, &first_quals
,
12652 dwarf_qual_info_size
);
12654 first
= mod_type_die
;
12655 gcc_assert ((first_quals
& ~sub_quals
) == 0);
12656 for (count
= 0, last
= first
;
12657 count
< (1U << dwarf_qual_info_size
);
12658 count
++, last
= last
->die_sib
)
12661 if (last
== mod_scope
->die_child
)
12663 if (qualified_die_p (last
->die_sib
, &quals
, dwarf_qual_info_size
)
12669 for (i
= 0; i
< dwarf_qual_info_size
; i
++)
12670 if (dwarf_qual_info
[i
].q
& cv_quals
& ~sub_quals
)
12673 if (first
&& first
!= last
)
12675 for (d
= first
->die_sib
; ; d
= d
->die_sib
)
12678 qualified_die_p (d
, &quals
, dwarf_qual_info_size
);
12679 if (quals
== (first_quals
| dwarf_qual_info
[i
].q
))
12695 d
= new_die_raw (dwarf_qual_info
[i
].t
);
12696 add_child_die_after (mod_scope
, d
, last
);
12700 d
= new_die (dwarf_qual_info
[i
].t
, mod_scope
, type
);
12702 add_AT_die_ref (d
, DW_AT_type
, mod_type_die
);
12704 first_quals
|= dwarf_qual_info
[i
].q
;
12707 else if (code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
)
12709 dwarf_tag tag
= DW_TAG_pointer_type
;
12710 if (code
== REFERENCE_TYPE
)
12712 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
12713 tag
= DW_TAG_rvalue_reference_type
;
12715 tag
= DW_TAG_reference_type
;
12717 mod_type_die
= new_die (tag
, mod_scope
, type
);
12719 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
12720 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
12721 add_alignment_attribute (mod_type_die
, type
);
12722 item_type
= TREE_TYPE (type
);
12724 addr_space_t as
= TYPE_ADDR_SPACE (item_type
);
12725 if (!ADDR_SPACE_GENERIC_P (as
))
12727 int action
= targetm
.addr_space
.debug (as
);
12730 /* Positive values indicate an address_class. */
12731 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, action
);
12735 /* Negative values indicate an (inverted) segment base reg. */
12737 = one_reg_loc_descriptor (~action
, VAR_INIT_STATUS_INITIALIZED
);
12738 add_AT_loc (mod_type_die
, DW_AT_segment
, d
);
12742 else if (code
== INTEGER_TYPE
12743 && TREE_TYPE (type
) != NULL_TREE
12744 && subrange_type_for_debug_p (type
, &low
, &high
))
12746 tree bias
= NULL_TREE
;
12747 if (lang_hooks
.types
.get_type_bias
)
12748 bias
= lang_hooks
.types
.get_type_bias (type
);
12749 mod_type_die
= subrange_type_die (type
, low
, high
, bias
, context_die
);
12750 item_type
= TREE_TYPE (type
);
12752 else if (is_base_type (type
))
12754 mod_type_die
= base_type_die (type
, reverse
);
12756 /* The DIE with DW_AT_endianity is placed right after the naked DIE. */
12757 if (reverse_base_type
)
12759 dw_die_ref after_die
12760 = modified_type_die (type
, cv_quals
, false, context_die
);
12761 add_child_die_after (comp_unit_die (), mod_type_die
, after_die
);
12764 add_child_die (comp_unit_die (), mod_type_die
);
12766 add_pubtype (type
, mod_type_die
);
12770 gen_type_die (type
, context_die
);
12772 /* We have to get the type_main_variant here (and pass that to the
12773 `lookup_type_die' routine) because the ..._TYPE node we have
12774 might simply be a *copy* of some original type node (where the
12775 copy was created to help us keep track of typedef names) and
12776 that copy might have a different TYPE_UID from the original
12778 if (TREE_CODE (type
) == FUNCTION_TYPE
12779 || TREE_CODE (type
) == METHOD_TYPE
)
12781 /* For function/method types, can't just use type_main_variant here,
12782 because that can have different ref-qualifiers for C++,
12783 but try to canonicalize. */
12784 tree main
= TYPE_MAIN_VARIANT (type
);
12785 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
12786 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
12787 && check_base_type (t
, main
)
12788 && check_lang_type (t
, type
))
12789 return lookup_type_die (t
);
12790 return lookup_type_die (type
);
12792 else if (TREE_CODE (type
) != VECTOR_TYPE
12793 && TREE_CODE (type
) != ARRAY_TYPE
)
12794 return lookup_type_die (type_main_variant (type
));
12796 /* Vectors have the debugging information in the type,
12797 not the main variant. */
12798 return lookup_type_die (type
);
12801 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
12802 don't output a DW_TAG_typedef, since there isn't one in the
12803 user's program; just attach a DW_AT_name to the type.
12804 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
12805 if the base type already has the same name. */
12807 && ((TREE_CODE (name
) != TYPE_DECL
12808 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
12809 || (cv_quals
== TYPE_UNQUALIFIED
)))
12810 || (TREE_CODE (name
) == TYPE_DECL
12811 && TREE_TYPE (name
) == qualified_type
12812 && DECL_NAME (name
))))
12814 if (TREE_CODE (name
) == TYPE_DECL
)
12815 /* Could just call add_name_and_src_coords_attributes here,
12816 but since this is a builtin type it doesn't have any
12817 useful source coordinates anyway. */
12818 name
= DECL_NAME (name
);
12819 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
12821 /* This probably indicates a bug. */
12822 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
12824 name
= TYPE_IDENTIFIER (type
);
12825 add_name_attribute (mod_type_die
,
12826 name
? IDENTIFIER_POINTER (name
) : "__unknown__");
12829 if (qualified_type
&& !reverse_base_type
)
12830 equate_type_number_to_die (qualified_type
, mod_type_die
);
12833 /* We must do this after the equate_type_number_to_die call, in case
12834 this is a recursive type. This ensures that the modified_type_die
12835 recursion will terminate even if the type is recursive. Recursive
12836 types are possible in Ada. */
12837 sub_die
= modified_type_die (item_type
,
12838 TYPE_QUALS_NO_ADDR_SPACE (item_type
),
12842 if (sub_die
!= NULL
)
12843 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
12845 add_gnat_descriptive_type_attribute (mod_type_die
, type
, context_die
);
12846 if (TYPE_ARTIFICIAL (type
))
12847 add_AT_flag (mod_type_die
, DW_AT_artificial
, 1);
12849 return mod_type_die
;
12852 /* Generate DIEs for the generic parameters of T.
12853 T must be either a generic type or a generic function.
12854 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
12857 gen_generic_params_dies (tree t
)
12861 dw_die_ref die
= NULL
;
12864 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
12868 die
= lookup_type_die (t
);
12869 else if (DECL_P (t
))
12870 die
= lookup_decl_die (t
);
12874 parms
= lang_hooks
.get_innermost_generic_parms (t
);
12876 /* T has no generic parameter. It means T is neither a generic type
12877 or function. End of story. */
12880 parms_num
= TREE_VEC_LENGTH (parms
);
12881 args
= lang_hooks
.get_innermost_generic_args (t
);
12882 if (TREE_CHAIN (args
) && TREE_CODE (TREE_CHAIN (args
)) == INTEGER_CST
)
12883 non_default
= int_cst_value (TREE_CHAIN (args
));
12885 non_default
= TREE_VEC_LENGTH (args
);
12886 for (i
= 0; i
< parms_num
; i
++)
12888 tree parm
, arg
, arg_pack_elems
;
12889 dw_die_ref parm_die
;
12891 parm
= TREE_VEC_ELT (parms
, i
);
12892 arg
= TREE_VEC_ELT (args
, i
);
12893 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
12894 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
12896 if (parm
&& TREE_VALUE (parm
) && arg
)
12898 /* If PARM represents a template parameter pack,
12899 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
12900 by DW_TAG_template_*_parameter DIEs for the argument
12901 pack elements of ARG. Note that ARG would then be
12902 an argument pack. */
12903 if (arg_pack_elems
)
12904 parm_die
= template_parameter_pack_die (TREE_VALUE (parm
),
12908 parm_die
= generic_parameter_die (TREE_VALUE (parm
), arg
,
12909 true /* emit name */, die
);
12910 if (i
>= non_default
)
12911 add_AT_flag (parm_die
, DW_AT_default_value
, 1);
12916 /* Create and return a DIE for PARM which should be
12917 the representation of a generic type parameter.
12918 For instance, in the C++ front end, PARM would be a template parameter.
12919 ARG is the argument to PARM.
12920 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
12922 PARENT_DIE is the parent DIE which the new created DIE should be added to,
12923 as a child node. */
12926 generic_parameter_die (tree parm
, tree arg
,
12928 dw_die_ref parent_die
)
12930 dw_die_ref tmpl_die
= NULL
;
12931 const char *name
= NULL
;
12933 if (!parm
|| !DECL_NAME (parm
) || !arg
)
12936 /* We support non-type generic parameters and arguments,
12937 type generic parameters and arguments, as well as
12938 generic generic parameters (a.k.a. template template parameters in C++)
12940 if (TREE_CODE (parm
) == PARM_DECL
)
12941 /* PARM is a nontype generic parameter */
12942 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
12943 else if (TREE_CODE (parm
) == TYPE_DECL
)
12944 /* PARM is a type generic parameter. */
12945 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
12946 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
12947 /* PARM is a generic generic parameter.
12948 Its DIE is a GNU extension. It shall have a
12949 DW_AT_name attribute to represent the name of the template template
12950 parameter, and a DW_AT_GNU_template_name attribute to represent the
12951 name of the template template argument. */
12952 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
12955 gcc_unreachable ();
12961 /* If PARM is a generic parameter pack, it means we are
12962 emitting debug info for a template argument pack element.
12963 In other terms, ARG is a template argument pack element.
12964 In that case, we don't emit any DW_AT_name attribute for
12968 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
12970 add_AT_string (tmpl_die
, DW_AT_name
, name
);
12973 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
12975 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
12976 TMPL_DIE should have a child DW_AT_type attribute that is set
12977 to the type of the argument to PARM, which is ARG.
12978 If PARM is a type generic parameter, TMPL_DIE should have a
12979 child DW_AT_type that is set to ARG. */
12980 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
12981 add_type_attribute (tmpl_die
, tmpl_type
,
12982 (TREE_THIS_VOLATILE (tmpl_type
)
12983 ? TYPE_QUAL_VOLATILE
: TYPE_UNQUALIFIED
),
12984 false, parent_die
);
12988 /* So TMPL_DIE is a DIE representing a
12989 a generic generic template parameter, a.k.a template template
12990 parameter in C++ and arg is a template. */
12992 /* The DW_AT_GNU_template_name attribute of the DIE must be set
12993 to the name of the argument. */
12994 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
12996 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
12999 if (TREE_CODE (parm
) == PARM_DECL
)
13000 /* So PARM is a non-type generic parameter.
13001 DWARF3 5.6.8 says we must set a DW_AT_const_value child
13002 attribute of TMPL_DIE which value represents the value
13004 We must be careful here:
13005 The value of ARG might reference some function decls.
13006 We might currently be emitting debug info for a generic
13007 type and types are emitted before function decls, we don't
13008 know if the function decls referenced by ARG will actually be
13009 emitted after cgraph computations.
13010 So must defer the generation of the DW_AT_const_value to
13011 after cgraph is ready. */
13012 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
13018 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
13019 PARM_PACK must be a template parameter pack. The returned DIE
13020 will be child DIE of PARENT_DIE. */
13023 template_parameter_pack_die (tree parm_pack
,
13024 tree parm_pack_args
,
13025 dw_die_ref parent_die
)
13030 gcc_assert (parent_die
&& parm_pack
);
13032 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
13033 add_name_and_src_coords_attributes (die
, parm_pack
);
13034 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
13035 generic_parameter_die (parm_pack
,
13036 TREE_VEC_ELT (parm_pack_args
, j
),
13037 false /* Don't emit DW_AT_name */,
13042 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
13043 an enumerated type. */
13046 type_is_enum (const_tree type
)
13048 return TREE_CODE (type
) == ENUMERAL_TYPE
;
13051 /* Return the DBX register number described by a given RTL node. */
13053 static unsigned int
13054 dbx_reg_number (const_rtx rtl
)
13056 unsigned regno
= REGNO (rtl
);
13058 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
13060 #ifdef LEAF_REG_REMAP
13061 if (crtl
->uses_only_leaf_regs
)
13063 int leaf_reg
= LEAF_REG_REMAP (regno
);
13064 if (leaf_reg
!= -1)
13065 regno
= (unsigned) leaf_reg
;
13069 regno
= DBX_REGISTER_NUMBER (regno
);
13070 gcc_assert (regno
!= INVALID_REGNUM
);
13074 /* Optionally add a DW_OP_piece term to a location description expression.
13075 DW_OP_piece is only added if the location description expression already
13076 doesn't end with DW_OP_piece. */
13079 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
13081 dw_loc_descr_ref loc
;
13083 if (*list_head
!= NULL
)
13085 /* Find the end of the chain. */
13086 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
13089 if (loc
->dw_loc_opc
!= DW_OP_piece
)
13090 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
13094 /* Return a location descriptor that designates a machine register or
13095 zero if there is none. */
13097 static dw_loc_descr_ref
13098 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
13102 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
13105 /* We only use "frame base" when we're sure we're talking about the
13106 post-prologue local stack frame. We do this by *not* running
13107 register elimination until this point, and recognizing the special
13108 argument pointer and soft frame pointer rtx's.
13109 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
13110 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
13111 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
13113 dw_loc_descr_ref result
= NULL
;
13115 if (dwarf_version
>= 4 || !dwarf_strict
)
13117 result
= mem_loc_descriptor (rtl
, GET_MODE (rtl
), VOIDmode
,
13120 add_loc_descr (&result
,
13121 new_loc_descr (DW_OP_stack_value
, 0, 0));
13126 regs
= targetm
.dwarf_register_span (rtl
);
13128 if (REG_NREGS (rtl
) > 1 || regs
)
13129 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
13132 unsigned int dbx_regnum
= dbx_reg_number (rtl
);
13133 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
13135 return one_reg_loc_descriptor (dbx_regnum
, initialized
);
13139 /* Return a location descriptor that designates a machine register for
13140 a given hard register number. */
13142 static dw_loc_descr_ref
13143 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
13145 dw_loc_descr_ref reg_loc_descr
;
13149 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
13151 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
13153 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13154 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13156 return reg_loc_descr
;
13159 /* Given an RTL of a register, return a location descriptor that
13160 designates a value that spans more than one register. */
13162 static dw_loc_descr_ref
13163 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
13164 enum var_init_status initialized
)
13167 dw_loc_descr_ref loc_result
= NULL
;
13169 /* Simple, contiguous registers. */
13170 if (regs
== NULL_RTX
)
13172 unsigned reg
= REGNO (rtl
);
13175 #ifdef LEAF_REG_REMAP
13176 if (crtl
->uses_only_leaf_regs
)
13178 int leaf_reg
= LEAF_REG_REMAP (reg
);
13179 if (leaf_reg
!= -1)
13180 reg
= (unsigned) leaf_reg
;
13184 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
13185 nregs
= REG_NREGS (rtl
);
13187 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
13192 dw_loc_descr_ref t
;
13194 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
13195 VAR_INIT_STATUS_INITIALIZED
);
13196 add_loc_descr (&loc_result
, t
);
13197 add_loc_descr_op_piece (&loc_result
, size
);
13203 /* Now onto stupid register sets in non contiguous locations. */
13205 gcc_assert (GET_CODE (regs
) == PARALLEL
);
13207 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
13210 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
13212 dw_loc_descr_ref t
;
13214 t
= one_reg_loc_descriptor (dbx_reg_number (XVECEXP (regs
, 0, i
)),
13215 VAR_INIT_STATUS_INITIALIZED
);
13216 add_loc_descr (&loc_result
, t
);
13217 add_loc_descr_op_piece (&loc_result
, size
);
13220 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13221 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13225 static unsigned long size_of_int_loc_descriptor (HOST_WIDE_INT
);
13227 /* Return a location descriptor that designates a constant i,
13228 as a compound operation from constant (i >> shift), constant shift
13231 static dw_loc_descr_ref
13232 int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
13234 dw_loc_descr_ref ret
= int_loc_descriptor (i
>> shift
);
13235 add_loc_descr (&ret
, int_loc_descriptor (shift
));
13236 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
13240 /* Return a location descriptor that designates constant POLY_I. */
13242 static dw_loc_descr_ref
13243 int_loc_descriptor (poly_int64 poly_i
)
13245 enum dwarf_location_atom op
;
13248 if (!poly_i
.is_constant (&i
))
13250 /* Create location descriptions for the non-constant part and
13251 add any constant offset at the end. */
13252 dw_loc_descr_ref ret
= NULL
;
13253 HOST_WIDE_INT constant
= poly_i
.coeffs
[0];
13254 for (unsigned int j
= 1; j
< NUM_POLY_INT_COEFFS
; ++j
)
13256 HOST_WIDE_INT coeff
= poly_i
.coeffs
[j
];
13259 dw_loc_descr_ref start
= ret
;
13260 unsigned int factor
;
13262 unsigned int regno
= targetm
.dwarf_poly_indeterminate_value
13263 (j
, &factor
, &bias
);
13265 /* Add COEFF * ((REGNO / FACTOR) - BIAS) to the value:
13266 add COEFF * (REGNO / FACTOR) now and subtract
13267 COEFF * BIAS from the final constant part. */
13268 constant
-= coeff
* bias
;
13269 add_loc_descr (&ret
, new_reg_loc_descr (regno
, 0));
13270 if (coeff
% factor
== 0)
13274 int amount
= exact_log2 (factor
);
13275 gcc_assert (amount
>= 0);
13276 add_loc_descr (&ret
, int_loc_descriptor (amount
));
13277 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
13281 add_loc_descr (&ret
, int_loc_descriptor (coeff
));
13282 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
13285 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
13288 loc_descr_plus_const (&ret
, constant
);
13292 /* Pick the smallest representation of a constant, rather than just
13293 defaulting to the LEB encoding. */
13296 int clz
= clz_hwi (i
);
13297 int ctz
= ctz_hwi (i
);
13299 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
13300 else if (i
<= 0xff)
13301 op
= DW_OP_const1u
;
13302 else if (i
<= 0xffff)
13303 op
= DW_OP_const2u
;
13304 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
13305 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
13306 /* DW_OP_litX DW_OP_litY DW_OP_shl takes just 3 bytes and
13307 DW_OP_litX DW_OP_const1u Y DW_OP_shl takes just 4 bytes,
13308 while DW_OP_const4u is 5 bytes. */
13309 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 5);
13310 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13311 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
13312 /* DW_OP_const1u X DW_OP_litY DW_OP_shl takes just 4 bytes,
13313 while DW_OP_const4u is 5 bytes. */
13314 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
13316 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
13317 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
13320 /* As i >= 2**31, the double cast above will yield a negative number.
13321 Since wrapping is defined in DWARF expressions we can output big
13322 positive integers as small negative ones, regardless of the size
13325 Here, since the evaluator will handle 32-bit values and since i >=
13326 2**31, we know it's going to be interpreted as a negative literal:
13327 store it this way if we can do better than 5 bytes this way. */
13328 return int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
13330 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
13331 op
= DW_OP_const4u
;
13333 /* Past this point, i >= 0x100000000 and thus DW_OP_constu will take at
13334 least 6 bytes: see if we can do better before falling back to it. */
13335 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13336 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
13337 /* DW_OP_const1u X DW_OP_const1u Y DW_OP_shl takes just 5 bytes. */
13338 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 8);
13339 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
13340 && clz
+ 16 + (size_of_uleb128 (i
) > 5 ? 255 : 31)
13341 >= HOST_BITS_PER_WIDE_INT
)
13342 /* DW_OP_const2u X DW_OP_litY DW_OP_shl takes just 5 bytes,
13343 DW_OP_const2u X DW_OP_const1u Y DW_OP_shl takes 6 bytes. */
13344 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 16);
13345 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
13346 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
13347 && size_of_uleb128 (i
) > 6)
13348 /* DW_OP_const4u X DW_OP_litY DW_OP_shl takes just 7 bytes. */
13349 return int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
- clz
- 32);
13356 op
= DW_OP_const1s
;
13357 else if (i
>= -0x8000)
13358 op
= DW_OP_const2s
;
13359 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
13361 if (size_of_int_loc_descriptor (i
) < 5)
13363 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
13364 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
13367 op
= DW_OP_const4s
;
13371 if (size_of_int_loc_descriptor (i
)
13372 < (unsigned long) 1 + size_of_sleb128 (i
))
13374 dw_loc_descr_ref ret
= int_loc_descriptor (-i
);
13375 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
13382 return new_loc_descr (op
, i
, 0);
13385 /* Likewise, for unsigned constants. */
13387 static dw_loc_descr_ref
13388 uint_loc_descriptor (unsigned HOST_WIDE_INT i
)
13390 const unsigned HOST_WIDE_INT max_int
= INTTYPE_MAXIMUM (HOST_WIDE_INT
);
13391 const unsigned HOST_WIDE_INT max_uint
13392 = INTTYPE_MAXIMUM (unsigned HOST_WIDE_INT
);
13394 /* If possible, use the clever signed constants handling. */
13396 return int_loc_descriptor ((HOST_WIDE_INT
) i
);
13398 /* Here, we are left with positive numbers that cannot be represented as
13399 HOST_WIDE_INT, i.e.:
13400 max (HOST_WIDE_INT) < i <= max (unsigned HOST_WIDE_INT)
13402 Using DW_OP_const4/8/./u operation to encode them consumes a lot of bytes
13403 whereas may be better to output a negative integer: thanks to integer
13404 wrapping, we know that:
13405 x = x - 2 ** DWARF2_ADDR_SIZE
13406 = x - 2 * (max (HOST_WIDE_INT) + 1)
13407 So numbers close to max (unsigned HOST_WIDE_INT) could be represented as
13408 small negative integers. Let's try that in cases it will clearly improve
13409 the encoding: there is no gain turning DW_OP_const4u into
13411 if (DWARF2_ADDR_SIZE
* 8 == HOST_BITS_PER_WIDE_INT
13412 && ((DWARF2_ADDR_SIZE
== 4 && i
> max_uint
- 0x8000)
13413 || (DWARF2_ADDR_SIZE
== 8 && i
> max_uint
- 0x80000000)))
13415 const unsigned HOST_WIDE_INT first_shift
= i
- max_int
- 1;
13417 /* Now, -1 < first_shift <= max (HOST_WIDE_INT)
13418 i.e. 0 <= first_shift <= max (HOST_WIDE_INT). */
13419 const HOST_WIDE_INT second_shift
13420 = (HOST_WIDE_INT
) first_shift
- (HOST_WIDE_INT
) max_int
- 1;
13422 /* So we finally have:
13423 -max (HOST_WIDE_INT) - 1 <= second_shift <= -1.
13424 i.e. min (HOST_WIDE_INT) <= second_shift < 0. */
13425 return int_loc_descriptor (second_shift
);
13428 /* Last chance: fallback to a simple constant operation. */
13429 return new_loc_descr
13430 ((HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
13436 /* Generate and return a location description that computes the unsigned
13437 comparison of the two stack top entries (a OP b where b is the top-most
13438 entry and a is the second one). The KIND of comparison can be LT_EXPR,
13439 LE_EXPR, GT_EXPR or GE_EXPR. */
13441 static dw_loc_descr_ref
13442 uint_comparison_loc_list (enum tree_code kind
)
13444 enum dwarf_location_atom op
, flip_op
;
13445 dw_loc_descr_ref ret
, bra_node
, jmp_node
, tmp
;
13462 gcc_unreachable ();
13465 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
13466 jmp_node
= new_loc_descr (DW_OP_skip
, 0, 0);
13468 /* Until DWARFv4, operations all work on signed integers. It is nevertheless
13469 possible to perform unsigned comparisons: we just have to distinguish
13472 1. when a and b have the same sign (as signed integers); then we should
13473 return: a OP(signed) b;
13475 2. when a is a negative signed integer while b is a positive one, then a
13476 is a greater unsigned integer than b; likewise when a and b's roles
13479 So first, compare the sign of the two operands. */
13480 ret
= new_loc_descr (DW_OP_over
, 0, 0);
13481 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
13482 add_loc_descr (&ret
, new_loc_descr (DW_OP_xor
, 0, 0));
13483 /* If they have different signs (i.e. they have different sign bits), then
13484 the stack top value has now the sign bit set and thus it's smaller than
13486 add_loc_descr (&ret
, new_loc_descr (DW_OP_lit0
, 0, 0));
13487 add_loc_descr (&ret
, new_loc_descr (DW_OP_lt
, 0, 0));
13488 add_loc_descr (&ret
, bra_node
);
13490 /* We are in case 1. At this point, we know both operands have the same
13491 sign, to it's safe to use the built-in signed comparison. */
13492 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
13493 add_loc_descr (&ret
, jmp_node
);
13495 /* We are in case 2. Here, we know both operands do not have the same sign,
13496 so we have to flip the signed comparison. */
13497 flip_op
= (kind
== LT_EXPR
|| kind
== LE_EXPR
) ? DW_OP_gt
: DW_OP_lt
;
13498 tmp
= new_loc_descr (flip_op
, 0, 0);
13499 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13500 bra_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
13501 add_loc_descr (&ret
, tmp
);
13503 /* This dummy operation is necessary to make the two branches join. */
13504 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
13505 jmp_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
13506 jmp_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
13507 add_loc_descr (&ret
, tmp
);
13512 /* Likewise, but takes the location description lists (might be destructive on
13513 them). Return NULL if either is NULL or if concatenation fails. */
13515 static dw_loc_list_ref
13516 loc_list_from_uint_comparison (dw_loc_list_ref left
, dw_loc_list_ref right
,
13517 enum tree_code kind
)
13519 if (left
== NULL
|| right
== NULL
)
13522 add_loc_list (&left
, right
);
13526 add_loc_descr_to_each (left
, uint_comparison_loc_list (kind
));
13530 /* Return size_of_locs (int_shift_loc_descriptor (i, shift))
13531 without actually allocating it. */
13533 static unsigned long
13534 size_of_int_shift_loc_descriptor (HOST_WIDE_INT i
, int shift
)
13536 return size_of_int_loc_descriptor (i
>> shift
)
13537 + size_of_int_loc_descriptor (shift
)
13541 /* Return size_of_locs (int_loc_descriptor (i)) without
13542 actually allocating it. */
13544 static unsigned long
13545 size_of_int_loc_descriptor (HOST_WIDE_INT i
)
13554 else if (i
<= 0xff)
13556 else if (i
<= 0xffff)
13560 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 5
13561 && clz
+ 5 + 255 >= HOST_BITS_PER_WIDE_INT
)
13562 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
13564 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13565 && clz
+ 8 + 31 >= HOST_BITS_PER_WIDE_INT
)
13566 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
13568 else if (DWARF2_ADDR_SIZE
== 4 && i
> 0x7fffffff
13569 && size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
)
13571 return size_of_int_loc_descriptor ((HOST_WIDE_INT
) (int32_t) i
);
13572 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
<= 0xffffffff)
13574 s
= size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
13575 if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 8
13576 && clz
+ 8 + 255 >= HOST_BITS_PER_WIDE_INT
)
13577 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
13579 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 16
13580 && clz
+ 16 + (s
> 5 ? 255 : 31) >= HOST_BITS_PER_WIDE_INT
)
13581 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
13583 else if (clz
+ ctz
>= HOST_BITS_PER_WIDE_INT
- 32
13584 && clz
+ 32 + 31 >= HOST_BITS_PER_WIDE_INT
13586 return size_of_int_shift_loc_descriptor (i
, HOST_BITS_PER_WIDE_INT
13595 else if (i
>= -0x8000)
13597 else if (HOST_BITS_PER_WIDE_INT
== 32 || i
>= -0x80000000)
13599 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
13601 s
= size_of_int_loc_descriptor (-i
) + 1;
13609 unsigned long r
= 1 + size_of_sleb128 (i
);
13610 if (-(unsigned HOST_WIDE_INT
) i
!= (unsigned HOST_WIDE_INT
) i
)
13612 s
= size_of_int_loc_descriptor (-i
) + 1;
13621 /* Return loc description representing "address" of integer value.
13622 This can appear only as toplevel expression. */
13624 static dw_loc_descr_ref
13625 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
13628 dw_loc_descr_ref loc_result
= NULL
;
13630 if (!(dwarf_version
>= 4 || !dwarf_strict
))
13633 litsize
= size_of_int_loc_descriptor (i
);
13634 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
13635 is more compact. For DW_OP_stack_value we need:
13636 litsize + 1 (DW_OP_stack_value)
13637 and for DW_OP_implicit_value:
13638 1 (DW_OP_implicit_value) + 1 (length) + size. */
13639 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
13641 loc_result
= int_loc_descriptor (i
);
13642 add_loc_descr (&loc_result
,
13643 new_loc_descr (DW_OP_stack_value
, 0, 0));
13647 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13649 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
13650 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
13654 /* Return a location descriptor that designates a base+offset location. */
13656 static dw_loc_descr_ref
13657 based_loc_descr (rtx reg
, poly_int64 offset
,
13658 enum var_init_status initialized
)
13660 unsigned int regno
;
13661 dw_loc_descr_ref result
;
13662 dw_fde_ref fde
= cfun
->fde
;
13664 /* We only use "frame base" when we're sure we're talking about the
13665 post-prologue local stack frame. We do this by *not* running
13666 register elimination until this point, and recognizing the special
13667 argument pointer and soft frame pointer rtx's. */
13668 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
13670 rtx elim
= (ira_use_lra_p
13671 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
13672 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
13676 elim
= strip_offset_and_add (elim
, &offset
);
13677 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
13678 && (elim
== hard_frame_pointer_rtx
13679 || elim
== stack_pointer_rtx
))
13680 || elim
== (frame_pointer_needed
13681 ? hard_frame_pointer_rtx
13682 : stack_pointer_rtx
));
13684 /* If drap register is used to align stack, use frame
13685 pointer + offset to access stack variables. If stack
13686 is aligned without drap, use stack pointer + offset to
13687 access stack variables. */
13688 if (crtl
->stack_realign_tried
13689 && reg
== frame_pointer_rtx
)
13692 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
13693 ? HARD_FRAME_POINTER_REGNUM
13695 return new_reg_loc_descr (base_reg
, offset
);
13698 gcc_assert (frame_pointer_fb_offset_valid
);
13699 offset
+= frame_pointer_fb_offset
;
13700 HOST_WIDE_INT const_offset
;
13701 if (offset
.is_constant (&const_offset
))
13702 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
13705 dw_loc_descr_ref ret
= new_loc_descr (DW_OP_fbreg
, 0, 0);
13706 loc_descr_plus_const (&ret
, offset
);
13712 regno
= REGNO (reg
);
13713 #ifdef LEAF_REG_REMAP
13714 if (crtl
->uses_only_leaf_regs
)
13716 int leaf_reg
= LEAF_REG_REMAP (regno
);
13717 if (leaf_reg
!= -1)
13718 regno
= (unsigned) leaf_reg
;
13721 regno
= DWARF_FRAME_REGNUM (regno
);
13723 HOST_WIDE_INT const_offset
;
13724 if (!optimize
&& fde
13725 && (fde
->drap_reg
== regno
|| fde
->vdrap_reg
== regno
)
13726 && offset
.is_constant (&const_offset
))
13728 /* Use cfa+offset to represent the location of arguments passed
13729 on the stack when drap is used to align stack.
13730 Only do this when not optimizing, for optimized code var-tracking
13731 is supposed to track where the arguments live and the register
13732 used as vdrap or drap in some spot might be used for something
13733 else in other part of the routine. */
13734 return new_loc_descr (DW_OP_fbreg
, const_offset
, 0);
13737 result
= new_reg_loc_descr (regno
, offset
);
13739 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13740 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13745 /* Return true if this RTL expression describes a base+offset calculation. */
13748 is_based_loc (const_rtx rtl
)
13750 return (GET_CODE (rtl
) == PLUS
13751 && ((REG_P (XEXP (rtl
, 0))
13752 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
13753 && CONST_INT_P (XEXP (rtl
, 1)))));
13756 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
13759 static dw_loc_descr_ref
13760 tls_mem_loc_descriptor (rtx mem
)
13763 dw_loc_descr_ref loc_result
;
13765 if (MEM_EXPR (mem
) == NULL_TREE
|| !MEM_OFFSET_KNOWN_P (mem
))
13768 base
= get_base_address (MEM_EXPR (mem
));
13771 || !DECL_THREAD_LOCAL_P (base
))
13774 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1, NULL
);
13775 if (loc_result
== NULL
)
13778 if (maybe_ne (MEM_OFFSET (mem
), 0))
13779 loc_descr_plus_const (&loc_result
, MEM_OFFSET (mem
));
13784 /* Output debug info about reason why we failed to expand expression as dwarf
13788 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
13790 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
13792 fprintf (dump_file
, "Failed to expand as dwarf: ");
13794 print_generic_expr (dump_file
, expr
, dump_flags
);
13797 fprintf (dump_file
, "\n");
13798 print_rtl (dump_file
, rtl
);
13800 fprintf (dump_file
, "\nReason: %s\n", reason
);
13804 /* Helper function for const_ok_for_output. */
13807 const_ok_for_output_1 (rtx rtl
)
13809 if (targetm
.const_not_ok_for_debug_p (rtl
))
13811 if (GET_CODE (rtl
) != UNSPEC
)
13813 expansion_failed (NULL_TREE
, rtl
,
13814 "Expression rejected for debug by the backend.\n");
13818 /* If delegitimize_address couldn't do anything with the UNSPEC, and
13819 the target hook doesn't explicitly allow it in debug info, assume
13820 we can't express it in the debug info. */
13821 /* Don't complain about TLS UNSPECs, those are just too hard to
13822 delegitimize. Note this could be a non-decl SYMBOL_REF such as
13823 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
13824 rather than DECL_THREAD_LOCAL_P is not just an optimization. */
13826 && (XVECLEN (rtl
, 0) == 0
13827 || GET_CODE (XVECEXP (rtl
, 0, 0)) != SYMBOL_REF
13828 || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl
, 0, 0)) == TLS_MODEL_NONE
))
13829 inform (current_function_decl
13830 ? DECL_SOURCE_LOCATION (current_function_decl
)
13831 : UNKNOWN_LOCATION
,
13832 #if NUM_UNSPEC_VALUES > 0
13833 "non-delegitimized UNSPEC %s (%d) found in variable location",
13834 ((XINT (rtl
, 1) >= 0 && XINT (rtl
, 1) < NUM_UNSPEC_VALUES
)
13835 ? unspec_strings
[XINT (rtl
, 1)] : "unknown"),
13838 "non-delegitimized UNSPEC %d found in variable location",
13841 expansion_failed (NULL_TREE
, rtl
,
13842 "UNSPEC hasn't been delegitimized.\n");
13846 if (CONST_POLY_INT_P (rtl
))
13849 if (targetm
.const_not_ok_for_debug_p (rtl
))
13851 expansion_failed (NULL_TREE
, rtl
,
13852 "Expression rejected for debug by the backend.\n");
13856 /* FIXME: Refer to PR60655. It is possible for simplification
13857 of rtl expressions in var tracking to produce such expressions.
13858 We should really identify / validate expressions
13859 enclosed in CONST that can be handled by assemblers on various
13860 targets and only handle legitimate cases here. */
13861 switch (GET_CODE (rtl
))
13872 if (CONSTANT_POOL_ADDRESS_P (rtl
))
13875 get_pool_constant_mark (rtl
, &marked
);
13876 /* If all references to this pool constant were optimized away,
13877 it was not output and thus we can't represent it. */
13880 expansion_failed (NULL_TREE
, rtl
,
13881 "Constant was removed from constant pool.\n");
13886 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
13889 /* Avoid references to external symbols in debug info, on several targets
13890 the linker might even refuse to link when linking a shared library,
13891 and in many other cases the relocations for .debug_info/.debug_loc are
13892 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
13893 to be defined within the same shared library or executable are fine. */
13894 if (SYMBOL_REF_EXTERNAL_P (rtl
))
13896 tree decl
= SYMBOL_REF_DECL (rtl
);
13898 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
13900 expansion_failed (NULL_TREE
, rtl
,
13901 "Symbol not defined in current TU.\n");
13909 /* Return true if constant RTL can be emitted in DW_OP_addr or
13910 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
13911 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
13914 const_ok_for_output (rtx rtl
)
13916 if (GET_CODE (rtl
) == SYMBOL_REF
)
13917 return const_ok_for_output_1 (rtl
);
13919 if (GET_CODE (rtl
) == CONST
)
13921 subrtx_var_iterator::array_type array
;
13922 FOR_EACH_SUBRTX_VAR (iter
, array
, XEXP (rtl
, 0), ALL
)
13923 if (!const_ok_for_output_1 (*iter
))
13931 /* Return a reference to DW_TAG_base_type corresponding to MODE and UNSIGNEDP
13932 if possible, NULL otherwise. */
13935 base_type_for_mode (machine_mode mode
, bool unsignedp
)
13937 dw_die_ref type_die
;
13938 tree type
= lang_hooks
.types
.type_for_mode (mode
, unsignedp
);
13942 switch (TREE_CODE (type
))
13950 type_die
= lookup_type_die (type
);
13952 type_die
= modified_type_die (type
, TYPE_UNQUALIFIED
, false,
13954 if (type_die
== NULL
|| type_die
->die_tag
!= DW_TAG_base_type
)
13959 /* For OP descriptor assumed to be in unsigned MODE, convert it to a unsigned
13960 type matching MODE, or, if MODE is narrower than or as wide as
13961 DWARF2_ADDR_SIZE, untyped. Return NULL if the conversion is not
13964 static dw_loc_descr_ref
13965 convert_descriptor_to_mode (scalar_int_mode mode
, dw_loc_descr_ref op
)
13967 machine_mode outer_mode
= mode
;
13968 dw_die_ref type_die
;
13969 dw_loc_descr_ref cvt
;
13971 if (GET_MODE_SIZE (mode
) <= DWARF2_ADDR_SIZE
)
13973 add_loc_descr (&op
, new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0));
13976 type_die
= base_type_for_mode (outer_mode
, 1);
13977 if (type_die
== NULL
)
13979 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
13980 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
13981 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
13982 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
13983 add_loc_descr (&op
, cvt
);
13987 /* Return location descriptor for comparison OP with operands OP0 and OP1. */
13989 static dw_loc_descr_ref
13990 compare_loc_descriptor (enum dwarf_location_atom op
, dw_loc_descr_ref op0
,
13991 dw_loc_descr_ref op1
)
13993 dw_loc_descr_ref ret
= op0
;
13994 add_loc_descr (&ret
, op1
);
13995 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
13996 if (STORE_FLAG_VALUE
!= 1)
13998 add_loc_descr (&ret
, int_loc_descriptor (STORE_FLAG_VALUE
));
13999 add_loc_descr (&ret
, new_loc_descr (DW_OP_mul
, 0, 0));
14004 /* Subroutine of scompare_loc_descriptor for the case in which we're
14005 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
14006 and in which OP_MODE is bigger than DWARF2_ADDR_SIZE. */
14008 static dw_loc_descr_ref
14009 scompare_loc_descriptor_wide (enum dwarf_location_atom op
,
14010 scalar_int_mode op_mode
,
14011 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
14013 dw_die_ref type_die
= base_type_for_mode (op_mode
, 0);
14014 dw_loc_descr_ref cvt
;
14016 if (type_die
== NULL
)
14018 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14019 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14020 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14021 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14022 add_loc_descr (&op0
, cvt
);
14023 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14024 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14025 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14026 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14027 add_loc_descr (&op1
, cvt
);
14028 return compare_loc_descriptor (op
, op0
, op1
);
14031 /* Subroutine of scompare_loc_descriptor for the case in which we're
14032 comparing two scalar integer operands OP0 and OP1 that have mode OP_MODE,
14033 and in which OP_MODE is smaller than DWARF2_ADDR_SIZE. */
14035 static dw_loc_descr_ref
14036 scompare_loc_descriptor_narrow (enum dwarf_location_atom op
, rtx rtl
,
14037 scalar_int_mode op_mode
,
14038 dw_loc_descr_ref op0
, dw_loc_descr_ref op1
)
14040 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
)) * BITS_PER_UNIT
;
14041 /* For eq/ne, if the operands are known to be zero-extended,
14042 there is no need to do the fancy shifting up. */
14043 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
14045 dw_loc_descr_ref last0
, last1
;
14046 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
14048 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
14050 /* deref_size zero extends, and for constants we can check
14051 whether they are zero extended or not. */
14052 if (((last0
->dw_loc_opc
== DW_OP_deref_size
14053 && last0
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
14054 || (CONST_INT_P (XEXP (rtl
, 0))
14055 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
14056 == (INTVAL (XEXP (rtl
, 0)) & GET_MODE_MASK (op_mode
))))
14057 && ((last1
->dw_loc_opc
== DW_OP_deref_size
14058 && last1
->dw_loc_oprnd1
.v
.val_int
<= GET_MODE_SIZE (op_mode
))
14059 || (CONST_INT_P (XEXP (rtl
, 1))
14060 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 1))
14061 == (INTVAL (XEXP (rtl
, 1)) & GET_MODE_MASK (op_mode
)))))
14062 return compare_loc_descriptor (op
, op0
, op1
);
14064 /* EQ/NE comparison against constant in narrower type than
14065 DWARF2_ADDR_SIZE can be performed either as
14066 DW_OP_const1u <shift> DW_OP_shl DW_OP_const* <cst << shift>
14069 DW_OP_const*u <mode_mask> DW_OP_and DW_OP_const* <cst & mode_mask>
14070 DW_OP_{eq,ne}. Pick whatever is shorter. */
14071 if (CONST_INT_P (XEXP (rtl
, 1))
14072 && GET_MODE_BITSIZE (op_mode
) < HOST_BITS_PER_WIDE_INT
14073 && (size_of_int_loc_descriptor (shift
) + 1
14074 + size_of_int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
)
14075 >= size_of_int_loc_descriptor (GET_MODE_MASK (op_mode
)) + 1
14076 + size_of_int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
14077 & GET_MODE_MASK (op_mode
))))
14079 add_loc_descr (&op0
, int_loc_descriptor (GET_MODE_MASK (op_mode
)));
14080 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14081 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1))
14082 & GET_MODE_MASK (op_mode
));
14083 return compare_loc_descriptor (op
, op0
, op1
);
14086 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14087 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14088 if (CONST_INT_P (XEXP (rtl
, 1)))
14089 op1
= int_loc_descriptor (UINTVAL (XEXP (rtl
, 1)) << shift
);
14092 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14093 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14095 return compare_loc_descriptor (op
, op0
, op1
);
14098 /* Return location descriptor for unsigned comparison OP RTL. */
14100 static dw_loc_descr_ref
14101 scompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
14102 machine_mode mem_mode
)
14104 machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
14105 dw_loc_descr_ref op0
, op1
;
14107 if (op_mode
== VOIDmode
)
14108 op_mode
= GET_MODE (XEXP (rtl
, 1));
14109 if (op_mode
== VOIDmode
)
14112 scalar_int_mode int_op_mode
;
14114 && dwarf_version
< 5
14115 && (!is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
)
14116 || GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
))
14119 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
14120 VAR_INIT_STATUS_INITIALIZED
);
14121 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
14122 VAR_INIT_STATUS_INITIALIZED
);
14124 if (op0
== NULL
|| op1
== NULL
)
14127 if (is_a
<scalar_int_mode
> (op_mode
, &int_op_mode
))
14129 if (GET_MODE_SIZE (int_op_mode
) < DWARF2_ADDR_SIZE
)
14130 return scompare_loc_descriptor_narrow (op
, rtl
, int_op_mode
, op0
, op1
);
14132 if (GET_MODE_SIZE (int_op_mode
) > DWARF2_ADDR_SIZE
)
14133 return scompare_loc_descriptor_wide (op
, int_op_mode
, op0
, op1
);
14135 return compare_loc_descriptor (op
, op0
, op1
);
14138 /* Return location descriptor for unsigned comparison OP RTL. */
14140 static dw_loc_descr_ref
14141 ucompare_loc_descriptor (enum dwarf_location_atom op
, rtx rtl
,
14142 machine_mode mem_mode
)
14144 dw_loc_descr_ref op0
, op1
;
14146 machine_mode test_op_mode
= GET_MODE (XEXP (rtl
, 0));
14147 if (test_op_mode
== VOIDmode
)
14148 test_op_mode
= GET_MODE (XEXP (rtl
, 1));
14150 scalar_int_mode op_mode
;
14151 if (!is_a
<scalar_int_mode
> (test_op_mode
, &op_mode
))
14155 && dwarf_version
< 5
14156 && GET_MODE_SIZE (op_mode
) > DWARF2_ADDR_SIZE
)
14159 op0
= mem_loc_descriptor (XEXP (rtl
, 0), op_mode
, mem_mode
,
14160 VAR_INIT_STATUS_INITIALIZED
);
14161 op1
= mem_loc_descriptor (XEXP (rtl
, 1), op_mode
, mem_mode
,
14162 VAR_INIT_STATUS_INITIALIZED
);
14164 if (op0
== NULL
|| op1
== NULL
)
14167 if (GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
14169 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
14170 dw_loc_descr_ref last0
, last1
;
14171 for (last0
= op0
; last0
->dw_loc_next
!= NULL
; last0
= last0
->dw_loc_next
)
14173 for (last1
= op1
; last1
->dw_loc_next
!= NULL
; last1
= last1
->dw_loc_next
)
14175 if (CONST_INT_P (XEXP (rtl
, 0)))
14176 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
14177 /* deref_size zero extends, so no need to mask it again. */
14178 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
14179 || last0
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
14181 add_loc_descr (&op0
, int_loc_descriptor (mask
));
14182 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14184 if (CONST_INT_P (XEXP (rtl
, 1)))
14185 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
14186 /* deref_size zero extends, so no need to mask it again. */
14187 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
14188 || last1
->dw_loc_oprnd1
.v
.val_int
> GET_MODE_SIZE (op_mode
))
14190 add_loc_descr (&op1
, int_loc_descriptor (mask
));
14191 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
14194 else if (GET_MODE_SIZE (op_mode
) == DWARF2_ADDR_SIZE
)
14196 HOST_WIDE_INT bias
= 1;
14197 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
14198 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14199 if (CONST_INT_P (XEXP (rtl
, 1)))
14200 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
14201 + INTVAL (XEXP (rtl
, 1)));
14203 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
14206 return compare_loc_descriptor (op
, op0
, op1
);
14209 /* Return location descriptor for {U,S}{MIN,MAX}. */
14211 static dw_loc_descr_ref
14212 minmax_loc_descriptor (rtx rtl
, machine_mode mode
,
14213 machine_mode mem_mode
)
14215 enum dwarf_location_atom op
;
14216 dw_loc_descr_ref op0
, op1
, ret
;
14217 dw_loc_descr_ref bra_node
, drop_node
;
14219 scalar_int_mode int_mode
;
14221 && dwarf_version
< 5
14222 && (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
14223 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
))
14226 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14227 VAR_INIT_STATUS_INITIALIZED
);
14228 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
14229 VAR_INIT_STATUS_INITIALIZED
);
14231 if (op0
== NULL
|| op1
== NULL
)
14234 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
14235 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
14236 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
14237 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
14239 /* Checked by the caller. */
14240 int_mode
= as_a
<scalar_int_mode
> (mode
);
14241 if (GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
14243 HOST_WIDE_INT mask
= GET_MODE_MASK (int_mode
);
14244 add_loc_descr (&op0
, int_loc_descriptor (mask
));
14245 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
14246 add_loc_descr (&op1
, int_loc_descriptor (mask
));
14247 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
14249 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
14251 HOST_WIDE_INT bias
= 1;
14252 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
14253 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14254 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
14257 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14258 && GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
)
14260 int shift
= (DWARF2_ADDR_SIZE
- GET_MODE_SIZE (int_mode
)) * BITS_PER_UNIT
;
14261 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14262 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14263 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14264 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14266 else if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14267 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
14269 dw_die_ref type_die
= base_type_for_mode (int_mode
, 0);
14270 dw_loc_descr_ref cvt
;
14271 if (type_die
== NULL
)
14273 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14274 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14275 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14276 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14277 add_loc_descr (&op0
, cvt
);
14278 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14279 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14280 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14281 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14282 add_loc_descr (&op1
, cvt
);
14285 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
14290 add_loc_descr (&ret
, op1
);
14291 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
14292 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14293 add_loc_descr (&ret
, bra_node
);
14294 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14295 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
14296 add_loc_descr (&ret
, drop_node
);
14297 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14298 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
14299 if ((GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == SMAX
)
14300 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
14301 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
14302 ret
= convert_descriptor_to_mode (int_mode
, ret
);
14306 /* Helper function for mem_loc_descriptor. Perform OP binary op,
14307 but after converting arguments to type_die, afterwards
14308 convert back to unsigned. */
14310 static dw_loc_descr_ref
14311 typed_binop (enum dwarf_location_atom op
, rtx rtl
, dw_die_ref type_die
,
14312 scalar_int_mode mode
, machine_mode mem_mode
)
14314 dw_loc_descr_ref cvt
, op0
, op1
;
14316 if (type_die
== NULL
)
14318 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14319 VAR_INIT_STATUS_INITIALIZED
);
14320 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
14321 VAR_INIT_STATUS_INITIALIZED
);
14322 if (op0
== NULL
|| op1
== NULL
)
14324 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14325 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14326 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14327 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14328 add_loc_descr (&op0
, cvt
);
14329 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14330 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14331 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14332 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14333 add_loc_descr (&op1
, cvt
);
14334 add_loc_descr (&op0
, op1
);
14335 add_loc_descr (&op0
, new_loc_descr (op
, 0, 0));
14336 return convert_descriptor_to_mode (mode
, op0
);
14339 /* CLZ (where constV is CLZ_DEFINED_VALUE_AT_ZERO computed value,
14340 const0 is DW_OP_lit0 or corresponding typed constant,
14341 const1 is DW_OP_lit1 or corresponding typed constant
14342 and constMSB is constant with just the MSB bit set
14344 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
14345 L1: const0 DW_OP_swap
14346 L2: DW_OP_dup constMSB DW_OP_and DW_OP_bra <L3> const1 DW_OP_shl
14347 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
14352 DW_OP_dup DW_OP_bra <L1> DW_OP_drop constV DW_OP_skip <L4>
14353 L1: const0 DW_OP_swap
14354 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
14355 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
14360 DW_OP_dup DW_OP_bra <L1> DW_OP_drop const0 DW_OP_skip <L4>
14361 L1: const1 DW_OP_swap
14362 L2: DW_OP_dup const1 DW_OP_and DW_OP_bra <L3> const1 DW_OP_shr
14363 DW_OP_swap DW_OP_plus_uconst <1> DW_OP_swap DW_OP_skip <L2>
14367 static dw_loc_descr_ref
14368 clz_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
14369 machine_mode mem_mode
)
14371 dw_loc_descr_ref op0
, ret
, tmp
;
14372 HOST_WIDE_INT valv
;
14373 dw_loc_descr_ref l1jump
, l1label
;
14374 dw_loc_descr_ref l2jump
, l2label
;
14375 dw_loc_descr_ref l3jump
, l3label
;
14376 dw_loc_descr_ref l4jump
, l4label
;
14379 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
14382 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14383 VAR_INIT_STATUS_INITIALIZED
);
14387 if (GET_CODE (rtl
) == CLZ
)
14389 if (!CLZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
14390 valv
= GET_MODE_BITSIZE (mode
);
14392 else if (GET_CODE (rtl
) == FFS
)
14394 else if (!CTZ_DEFINED_VALUE_AT_ZERO (mode
, valv
))
14395 valv
= GET_MODE_BITSIZE (mode
);
14396 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
14397 l1jump
= new_loc_descr (DW_OP_bra
, 0, 0);
14398 add_loc_descr (&ret
, l1jump
);
14399 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
14400 tmp
= mem_loc_descriptor (GEN_INT (valv
), mode
, mem_mode
,
14401 VAR_INIT_STATUS_INITIALIZED
);
14404 add_loc_descr (&ret
, tmp
);
14405 l4jump
= new_loc_descr (DW_OP_skip
, 0, 0);
14406 add_loc_descr (&ret
, l4jump
);
14407 l1label
= mem_loc_descriptor (GET_CODE (rtl
) == FFS
14408 ? const1_rtx
: const0_rtx
,
14410 VAR_INIT_STATUS_INITIALIZED
);
14411 if (l1label
== NULL
)
14413 add_loc_descr (&ret
, l1label
);
14414 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14415 l2label
= new_loc_descr (DW_OP_dup
, 0, 0);
14416 add_loc_descr (&ret
, l2label
);
14417 if (GET_CODE (rtl
) != CLZ
)
14419 else if (GET_MODE_BITSIZE (mode
) <= HOST_BITS_PER_WIDE_INT
)
14420 msb
= GEN_INT (HOST_WIDE_INT_1U
14421 << (GET_MODE_BITSIZE (mode
) - 1));
14423 msb
= immed_wide_int_const
14424 (wi::set_bit_in_zero (GET_MODE_PRECISION (mode
) - 1,
14425 GET_MODE_PRECISION (mode
)), mode
);
14426 if (GET_CODE (msb
) == CONST_INT
&& INTVAL (msb
) < 0)
14427 tmp
= new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
14428 ? DW_OP_const4u
: HOST_BITS_PER_WIDE_INT
== 64
14429 ? DW_OP_const8u
: DW_OP_constu
, INTVAL (msb
), 0);
14431 tmp
= mem_loc_descriptor (msb
, mode
, mem_mode
,
14432 VAR_INIT_STATUS_INITIALIZED
);
14435 add_loc_descr (&ret
, tmp
);
14436 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
14437 l3jump
= new_loc_descr (DW_OP_bra
, 0, 0);
14438 add_loc_descr (&ret
, l3jump
);
14439 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
14440 VAR_INIT_STATUS_INITIALIZED
);
14443 add_loc_descr (&ret
, tmp
);
14444 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == CLZ
14445 ? DW_OP_shl
: DW_OP_shr
, 0, 0));
14446 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14447 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, 1, 0));
14448 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14449 l2jump
= new_loc_descr (DW_OP_skip
, 0, 0);
14450 add_loc_descr (&ret
, l2jump
);
14451 l3label
= new_loc_descr (DW_OP_drop
, 0, 0);
14452 add_loc_descr (&ret
, l3label
);
14453 l4label
= new_loc_descr (DW_OP_nop
, 0, 0);
14454 add_loc_descr (&ret
, l4label
);
14455 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14456 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
14457 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14458 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
14459 l3jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14460 l3jump
->dw_loc_oprnd1
.v
.val_loc
= l3label
;
14461 l4jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14462 l4jump
->dw_loc_oprnd1
.v
.val_loc
= l4label
;
14466 /* POPCOUNT (const0 is DW_OP_lit0 or corresponding typed constant,
14467 const1 is DW_OP_lit1 or corresponding typed constant):
14469 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
14470 DW_OP_plus DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
14474 L1: DW_OP_dup DW_OP_bra <L2> DW_OP_dup DW_OP_rot const1 DW_OP_and
14475 DW_OP_xor DW_OP_swap const1 DW_OP_shr DW_OP_skip <L1>
14478 static dw_loc_descr_ref
14479 popcount_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
14480 machine_mode mem_mode
)
14482 dw_loc_descr_ref op0
, ret
, tmp
;
14483 dw_loc_descr_ref l1jump
, l1label
;
14484 dw_loc_descr_ref l2jump
, l2label
;
14486 if (GET_MODE (XEXP (rtl
, 0)) != mode
)
14489 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14490 VAR_INIT_STATUS_INITIALIZED
);
14494 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
14495 VAR_INIT_STATUS_INITIALIZED
);
14498 add_loc_descr (&ret
, tmp
);
14499 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14500 l1label
= new_loc_descr (DW_OP_dup
, 0, 0);
14501 add_loc_descr (&ret
, l1label
);
14502 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
14503 add_loc_descr (&ret
, l2jump
);
14504 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
14505 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
14506 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
14507 VAR_INIT_STATUS_INITIALIZED
);
14510 add_loc_descr (&ret
, tmp
);
14511 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
14512 add_loc_descr (&ret
, new_loc_descr (GET_CODE (rtl
) == POPCOUNT
14513 ? DW_OP_plus
: DW_OP_xor
, 0, 0));
14514 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14515 tmp
= mem_loc_descriptor (const1_rtx
, mode
, mem_mode
,
14516 VAR_INIT_STATUS_INITIALIZED
);
14517 add_loc_descr (&ret
, tmp
);
14518 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
14519 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
14520 add_loc_descr (&ret
, l1jump
);
14521 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
14522 add_loc_descr (&ret
, l2label
);
14523 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14524 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
14525 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14526 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
14530 /* BSWAP (constS is initial shift count, either 56 or 24):
14532 L1: DW_OP_pick <2> constS DW_OP_pick <3> DW_OP_minus DW_OP_shr
14533 const255 DW_OP_and DW_OP_pick <2> DW_OP_shl DW_OP_or
14534 DW_OP_swap DW_OP_dup const0 DW_OP_eq DW_OP_bra <L2> const8
14535 DW_OP_minus DW_OP_swap DW_OP_skip <L1>
14536 L2: DW_OP_drop DW_OP_swap DW_OP_drop */
14538 static dw_loc_descr_ref
14539 bswap_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
14540 machine_mode mem_mode
)
14542 dw_loc_descr_ref op0
, ret
, tmp
;
14543 dw_loc_descr_ref l1jump
, l1label
;
14544 dw_loc_descr_ref l2jump
, l2label
;
14546 if (BITS_PER_UNIT
!= 8
14547 || (GET_MODE_BITSIZE (mode
) != 32
14548 && GET_MODE_BITSIZE (mode
) != 64))
14551 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14552 VAR_INIT_STATUS_INITIALIZED
);
14557 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
14559 VAR_INIT_STATUS_INITIALIZED
);
14562 add_loc_descr (&ret
, tmp
);
14563 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
14564 VAR_INIT_STATUS_INITIALIZED
);
14567 add_loc_descr (&ret
, tmp
);
14568 l1label
= new_loc_descr (DW_OP_pick
, 2, 0);
14569 add_loc_descr (&ret
, l1label
);
14570 tmp
= mem_loc_descriptor (GEN_INT (GET_MODE_BITSIZE (mode
) - 8),
14572 VAR_INIT_STATUS_INITIALIZED
);
14573 add_loc_descr (&ret
, tmp
);
14574 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 3, 0));
14575 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
14576 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
14577 tmp
= mem_loc_descriptor (GEN_INT (255), mode
, mem_mode
,
14578 VAR_INIT_STATUS_INITIALIZED
);
14581 add_loc_descr (&ret
, tmp
);
14582 add_loc_descr (&ret
, new_loc_descr (DW_OP_and
, 0, 0));
14583 add_loc_descr (&ret
, new_loc_descr (DW_OP_pick
, 2, 0));
14584 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
14585 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
14586 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14587 add_loc_descr (&ret
, new_loc_descr (DW_OP_dup
, 0, 0));
14588 tmp
= mem_loc_descriptor (const0_rtx
, mode
, mem_mode
,
14589 VAR_INIT_STATUS_INITIALIZED
);
14590 add_loc_descr (&ret
, tmp
);
14591 add_loc_descr (&ret
, new_loc_descr (DW_OP_eq
, 0, 0));
14592 l2jump
= new_loc_descr (DW_OP_bra
, 0, 0);
14593 add_loc_descr (&ret
, l2jump
);
14594 tmp
= mem_loc_descriptor (GEN_INT (8), mode
, mem_mode
,
14595 VAR_INIT_STATUS_INITIALIZED
);
14596 add_loc_descr (&ret
, tmp
);
14597 add_loc_descr (&ret
, new_loc_descr (DW_OP_minus
, 0, 0));
14598 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14599 l1jump
= new_loc_descr (DW_OP_skip
, 0, 0);
14600 add_loc_descr (&ret
, l1jump
);
14601 l2label
= new_loc_descr (DW_OP_drop
, 0, 0);
14602 add_loc_descr (&ret
, l2label
);
14603 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14604 add_loc_descr (&ret
, new_loc_descr (DW_OP_drop
, 0, 0));
14605 l1jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14606 l1jump
->dw_loc_oprnd1
.v
.val_loc
= l1label
;
14607 l2jump
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14608 l2jump
->dw_loc_oprnd1
.v
.val_loc
= l2label
;
14612 /* ROTATE (constMASK is mode mask, BITSIZE is bitsize of mode):
14613 DW_OP_over DW_OP_over DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
14614 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_neg
14615 DW_OP_plus_uconst <BITSIZE> DW_OP_shr DW_OP_or
14617 ROTATERT is similar:
14618 DW_OP_over DW_OP_over DW_OP_neg DW_OP_plus_uconst <BITSIZE>
14619 DW_OP_shl [ constMASK DW_OP_and ] DW_OP_rot
14620 [ DW_OP_swap constMASK DW_OP_and DW_OP_swap ] DW_OP_shr DW_OP_or */
14622 static dw_loc_descr_ref
14623 rotate_loc_descriptor (rtx rtl
, scalar_int_mode mode
,
14624 machine_mode mem_mode
)
14626 rtx rtlop1
= XEXP (rtl
, 1);
14627 dw_loc_descr_ref op0
, op1
, ret
, mask
[2] = { NULL
, NULL
};
14630 if (is_narrower_int_mode (GET_MODE (rtlop1
), mode
))
14631 rtlop1
= gen_rtx_ZERO_EXTEND (mode
, rtlop1
);
14632 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
14633 VAR_INIT_STATUS_INITIALIZED
);
14634 op1
= mem_loc_descriptor (rtlop1
, mode
, mem_mode
,
14635 VAR_INIT_STATUS_INITIALIZED
);
14636 if (op0
== NULL
|| op1
== NULL
)
14638 if (GET_MODE_SIZE (mode
) < DWARF2_ADDR_SIZE
)
14639 for (i
= 0; i
< 2; i
++)
14641 if (GET_MODE_BITSIZE (mode
) < HOST_BITS_PER_WIDE_INT
)
14642 mask
[i
] = mem_loc_descriptor (GEN_INT (GET_MODE_MASK (mode
)),
14644 VAR_INIT_STATUS_INITIALIZED
);
14645 else if (GET_MODE_BITSIZE (mode
) == HOST_BITS_PER_WIDE_INT
)
14646 mask
[i
] = new_loc_descr (HOST_BITS_PER_WIDE_INT
== 32
14648 : HOST_BITS_PER_WIDE_INT
== 64
14649 ? DW_OP_const8u
: DW_OP_constu
,
14650 GET_MODE_MASK (mode
), 0);
14653 if (mask
[i
] == NULL
)
14655 add_loc_descr (&mask
[i
], new_loc_descr (DW_OP_and
, 0, 0));
14658 add_loc_descr (&ret
, op1
);
14659 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
14660 add_loc_descr (&ret
, new_loc_descr (DW_OP_over
, 0, 0));
14661 if (GET_CODE (rtl
) == ROTATERT
)
14663 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14664 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
14665 GET_MODE_BITSIZE (mode
), 0));
14667 add_loc_descr (&ret
, new_loc_descr (DW_OP_shl
, 0, 0));
14668 if (mask
[0] != NULL
)
14669 add_loc_descr (&ret
, mask
[0]);
14670 add_loc_descr (&ret
, new_loc_descr (DW_OP_rot
, 0, 0));
14671 if (mask
[1] != NULL
)
14673 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14674 add_loc_descr (&ret
, mask
[1]);
14675 add_loc_descr (&ret
, new_loc_descr (DW_OP_swap
, 0, 0));
14677 if (GET_CODE (rtl
) == ROTATE
)
14679 add_loc_descr (&ret
, new_loc_descr (DW_OP_neg
, 0, 0));
14680 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
,
14681 GET_MODE_BITSIZE (mode
), 0));
14683 add_loc_descr (&ret
, new_loc_descr (DW_OP_shr
, 0, 0));
14684 add_loc_descr (&ret
, new_loc_descr (DW_OP_or
, 0, 0));
14688 /* Helper function for mem_loc_descriptor. Return DW_OP_GNU_parameter_ref
14689 for DEBUG_PARAMETER_REF RTL. */
14691 static dw_loc_descr_ref
14692 parameter_ref_descriptor (rtx rtl
)
14694 dw_loc_descr_ref ret
;
14699 gcc_assert (TREE_CODE (DEBUG_PARAMETER_REF_DECL (rtl
)) == PARM_DECL
);
14700 /* With LTO during LTRANS we get the late DIE that refers to the early
14701 DIE, thus we add another indirection here. This seems to confuse
14702 gdb enough to make gcc.dg/guality/pr68860-1.c FAIL with LTO. */
14703 ref
= lookup_decl_die (DEBUG_PARAMETER_REF_DECL (rtl
));
14704 ret
= new_loc_descr (DW_OP_GNU_parameter_ref
, 0, 0);
14707 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14708 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
14709 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14713 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
14714 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_PARAMETER_REF_DECL (rtl
);
14719 /* The following routine converts the RTL for a variable or parameter
14720 (resident in memory) into an equivalent Dwarf representation of a
14721 mechanism for getting the address of that same variable onto the top of a
14722 hypothetical "address evaluation" stack.
14724 When creating memory location descriptors, we are effectively transforming
14725 the RTL for a memory-resident object into its Dwarf postfix expression
14726 equivalent. This routine recursively descends an RTL tree, turning
14727 it into Dwarf postfix code as it goes.
14729 MODE is the mode that should be assumed for the rtl if it is VOIDmode.
14731 MEM_MODE is the mode of the memory reference, needed to handle some
14732 autoincrement addressing modes.
14734 Return 0 if we can't represent the location. */
14737 mem_loc_descriptor (rtx rtl
, machine_mode mode
,
14738 machine_mode mem_mode
,
14739 enum var_init_status initialized
)
14741 dw_loc_descr_ref mem_loc_result
= NULL
;
14742 enum dwarf_location_atom op
;
14743 dw_loc_descr_ref op0
, op1
;
14744 rtx inner
= NULL_RTX
;
14747 if (mode
== VOIDmode
)
14748 mode
= GET_MODE (rtl
);
14750 /* Note that for a dynamically sized array, the location we will generate a
14751 description of here will be the lowest numbered location which is
14752 actually within the array. That's *not* necessarily the same as the
14753 zeroth element of the array. */
14755 rtl
= targetm
.delegitimize_address (rtl
);
14757 if (mode
!= GET_MODE (rtl
) && GET_MODE (rtl
) != VOIDmode
)
14760 scalar_int_mode int_mode
, inner_mode
, op1_mode
;
14761 switch (GET_CODE (rtl
))
14766 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
, initialized
);
14769 /* The case of a subreg may arise when we have a local (register)
14770 variable or a formal (register) parameter which doesn't quite fill
14771 up an entire register. For now, just assume that it is
14772 legitimate to make the Dwarf info refer to the whole register which
14773 contains the given subreg. */
14774 if (!subreg_lowpart_p (rtl
))
14776 inner
= SUBREG_REG (rtl
);
14779 if (inner
== NULL_RTX
)
14780 inner
= XEXP (rtl
, 0);
14781 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14782 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
14783 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
14784 #ifdef POINTERS_EXTEND_UNSIGNED
14785 || (int_mode
== Pmode
&& mem_mode
!= VOIDmode
)
14788 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
)
14790 mem_loc_result
= mem_loc_descriptor (inner
,
14792 mem_mode
, initialized
);
14795 if (dwarf_strict
&& dwarf_version
< 5)
14797 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14798 && is_a
<scalar_int_mode
> (GET_MODE (inner
), &inner_mode
)
14799 ? GET_MODE_SIZE (int_mode
) <= GET_MODE_SIZE (inner_mode
)
14800 : GET_MODE_SIZE (mode
) == GET_MODE_SIZE (GET_MODE (inner
)))
14802 dw_die_ref type_die
;
14803 dw_loc_descr_ref cvt
;
14805 mem_loc_result
= mem_loc_descriptor (inner
,
14807 mem_mode
, initialized
);
14808 if (mem_loc_result
== NULL
)
14810 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
14811 if (type_die
== NULL
)
14813 mem_loc_result
= NULL
;
14816 if (GET_MODE_SIZE (mode
)
14817 != GET_MODE_SIZE (GET_MODE (inner
)))
14818 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14820 cvt
= new_loc_descr (dwarf_OP (DW_OP_reinterpret
), 0, 0);
14821 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14822 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
14823 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14824 add_loc_descr (&mem_loc_result
, cvt
);
14825 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
14826 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
14828 /* Convert it to untyped afterwards. */
14829 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14830 add_loc_descr (&mem_loc_result
, cvt
);
14836 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
14837 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
14838 && rtl
!= arg_pointer_rtx
14839 && rtl
!= frame_pointer_rtx
14840 #ifdef POINTERS_EXTEND_UNSIGNED
14841 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
14845 dw_die_ref type_die
;
14846 unsigned int dbx_regnum
;
14848 if (dwarf_strict
&& dwarf_version
< 5)
14850 if (REGNO (rtl
) > FIRST_PSEUDO_REGISTER
)
14852 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
14853 if (type_die
== NULL
)
14856 dbx_regnum
= dbx_reg_number (rtl
);
14857 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
14859 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_regval_type
),
14861 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
14862 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
14863 mem_loc_result
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
14866 /* Whenever a register number forms a part of the description of the
14867 method for calculating the (dynamic) address of a memory resident
14868 object, DWARF rules require the register number be referred to as
14869 a "base register". This distinction is not based in any way upon
14870 what category of register the hardware believes the given register
14871 belongs to. This is strictly DWARF terminology we're dealing with
14872 here. Note that in cases where the location of a memory-resident
14873 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
14874 OP_CONST (0)) the actual DWARF location descriptor that we generate
14875 may just be OP_BASEREG (basereg). This may look deceptively like
14876 the object in question was allocated to a register (rather than in
14877 memory) so DWARF consumers need to be aware of the subtle
14878 distinction between OP_REG and OP_BASEREG. */
14879 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
14880 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
14881 else if (stack_realign_drap
14883 && crtl
->args
.internal_arg_pointer
== rtl
14884 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
14886 /* If RTL is internal_arg_pointer, which has been optimized
14887 out, use DRAP instead. */
14888 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
14889 VAR_INIT_STATUS_INITIALIZED
);
14895 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
14896 || !is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
))
14898 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
14899 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
14902 else if (GET_CODE (rtl
) == ZERO_EXTEND
14903 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
14904 && GET_MODE_BITSIZE (inner_mode
) < HOST_BITS_PER_WIDE_INT
14905 /* If DW_OP_const{1,2,4}u won't be used, it is shorter
14906 to expand zero extend as two shifts instead of
14908 && GET_MODE_SIZE (inner_mode
) <= 4)
14910 mem_loc_result
= op0
;
14911 add_loc_descr (&mem_loc_result
,
14912 int_loc_descriptor (GET_MODE_MASK (inner_mode
)));
14913 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_and
, 0, 0));
14915 else if (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
)
14917 int shift
= DWARF2_ADDR_SIZE
- GET_MODE_SIZE (inner_mode
);
14918 shift
*= BITS_PER_UNIT
;
14919 if (GET_CODE (rtl
) == SIGN_EXTEND
)
14923 mem_loc_result
= op0
;
14924 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
14925 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
14926 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
14927 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
14929 else if (!dwarf_strict
|| dwarf_version
>= 5)
14931 dw_die_ref type_die1
, type_die2
;
14932 dw_loc_descr_ref cvt
;
14934 type_die1
= base_type_for_mode (inner_mode
,
14935 GET_CODE (rtl
) == ZERO_EXTEND
);
14936 if (type_die1
== NULL
)
14938 type_die2
= base_type_for_mode (int_mode
, 1);
14939 if (type_die2
== NULL
)
14941 mem_loc_result
= op0
;
14942 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14943 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14944 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die1
;
14945 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14946 add_loc_descr (&mem_loc_result
, cvt
);
14947 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
14948 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
14949 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die2
;
14950 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
14951 add_loc_descr (&mem_loc_result
, cvt
);
14957 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
14958 if (new_rtl
!= rtl
)
14960 mem_loc_result
= mem_loc_descriptor (new_rtl
, mode
, mem_mode
,
14962 if (mem_loc_result
!= NULL
)
14963 return mem_loc_result
;
14966 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0),
14967 get_address_mode (rtl
), mode
,
14968 VAR_INIT_STATUS_INITIALIZED
);
14969 if (mem_loc_result
== NULL
)
14970 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
14971 if (mem_loc_result
!= NULL
)
14973 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
14974 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
14976 dw_die_ref type_die
;
14977 dw_loc_descr_ref deref
;
14979 if (dwarf_strict
&& dwarf_version
< 5)
14982 = base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
14983 if (type_die
== NULL
)
14985 deref
= new_loc_descr (dwarf_OP (DW_OP_deref_type
),
14986 GET_MODE_SIZE (mode
), 0);
14987 deref
->dw_loc_oprnd2
.val_class
= dw_val_class_die_ref
;
14988 deref
->dw_loc_oprnd2
.v
.val_die_ref
.die
= type_die
;
14989 deref
->dw_loc_oprnd2
.v
.val_die_ref
.external
= 0;
14990 add_loc_descr (&mem_loc_result
, deref
);
14992 else if (GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
)
14993 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
14995 add_loc_descr (&mem_loc_result
,
14996 new_loc_descr (DW_OP_deref_size
,
14997 GET_MODE_SIZE (int_mode
), 0));
15002 return mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
, initialized
);
15005 /* Some ports can transform a symbol ref into a label ref, because
15006 the symbol ref is too far away and has to be dumped into a constant
15010 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15011 || (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
15012 #ifdef POINTERS_EXTEND_UNSIGNED
15013 && (int_mode
!= Pmode
|| mem_mode
== VOIDmode
)
15017 if (GET_CODE (rtl
) == SYMBOL_REF
15018 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
15020 dw_loc_descr_ref temp
;
15022 /* If this is not defined, we have no way to emit the data. */
15023 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
15026 temp
= new_addr_loc_descr (rtl
, dtprel_true
);
15028 /* We check for DWARF 5 here because gdb did not implement
15029 DW_OP_form_tls_address until after 7.12. */
15030 mem_loc_result
= new_loc_descr ((dwarf_version
>= 5
15031 ? DW_OP_form_tls_address
15032 : DW_OP_GNU_push_tls_address
),
15034 add_loc_descr (&mem_loc_result
, temp
);
15039 if (!const_ok_for_output (rtl
))
15041 if (GET_CODE (rtl
) == CONST
)
15042 switch (GET_CODE (XEXP (rtl
, 0)))
15046 goto try_const_unop
;
15049 goto try_const_unop
;
15052 arg
= XEXP (XEXP (rtl
, 0), 0);
15053 if (!CONSTANT_P (arg
))
15054 arg
= gen_rtx_CONST (int_mode
, arg
);
15055 op0
= mem_loc_descriptor (arg
, int_mode
, mem_mode
,
15059 mem_loc_result
= op0
;
15060 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15064 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
,
15065 mem_mode
, initialized
);
15072 mem_loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
15073 vec_safe_push (used_rtx_array
, rtl
);
15079 case DEBUG_IMPLICIT_PTR
:
15080 expansion_failed (NULL_TREE
, rtl
,
15081 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
15085 if (dwarf_strict
&& dwarf_version
< 5)
15087 if (REG_P (ENTRY_VALUE_EXP (rtl
)))
15089 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15090 || GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15091 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
15092 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15095 unsigned int dbx_regnum
= dbx_reg_number (ENTRY_VALUE_EXP (rtl
));
15096 if (dbx_regnum
== IGNORED_DWARF_REGNUM
)
15098 op0
= one_reg_loc_descriptor (dbx_regnum
,
15099 VAR_INIT_STATUS_INITIALIZED
);
15102 else if (MEM_P (ENTRY_VALUE_EXP (rtl
))
15103 && REG_P (XEXP (ENTRY_VALUE_EXP (rtl
), 0)))
15105 op0
= mem_loc_descriptor (ENTRY_VALUE_EXP (rtl
), mode
,
15106 VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15107 if (op0
&& op0
->dw_loc_opc
== DW_OP_fbreg
)
15111 gcc_unreachable ();
15114 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_entry_value
), 0, 0);
15115 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15116 mem_loc_result
->dw_loc_oprnd1
.v
.val_loc
= op0
;
15119 case DEBUG_PARAMETER_REF
:
15120 mem_loc_result
= parameter_ref_descriptor (rtl
);
15124 /* Extract the PLUS expression nested inside and fall into
15125 PLUS code below. */
15126 rtl
= XEXP (rtl
, 1);
15131 /* Turn these into a PLUS expression and fall into the PLUS code
15133 rtl
= gen_rtx_PLUS (mode
, XEXP (rtl
, 0),
15134 gen_int_mode (GET_CODE (rtl
) == PRE_INC
15135 ? GET_MODE_UNIT_SIZE (mem_mode
)
15136 : -GET_MODE_UNIT_SIZE (mem_mode
),
15143 if (is_based_loc (rtl
)
15144 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15145 && (GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15146 || XEXP (rtl
, 0) == arg_pointer_rtx
15147 || XEXP (rtl
, 0) == frame_pointer_rtx
))
15148 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
15149 INTVAL (XEXP (rtl
, 1)),
15150 VAR_INIT_STATUS_INITIALIZED
);
15153 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15154 VAR_INIT_STATUS_INITIALIZED
);
15155 if (mem_loc_result
== 0)
15158 if (CONST_INT_P (XEXP (rtl
, 1))
15159 && (GET_MODE_SIZE (as_a
<scalar_int_mode
> (mode
))
15160 <= DWARF2_ADDR_SIZE
))
15161 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
15164 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15165 VAR_INIT_STATUS_INITIALIZED
);
15168 add_loc_descr (&mem_loc_result
, op1
);
15169 add_loc_descr (&mem_loc_result
,
15170 new_loc_descr (DW_OP_plus
, 0, 0));
15175 /* If a pseudo-reg is optimized away, it is possible for it to
15176 be replaced with a MEM containing a multiply or shift. */
15186 if ((!dwarf_strict
|| dwarf_version
>= 5)
15187 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15188 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15190 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
15191 base_type_for_mode (mode
, 0),
15192 int_mode
, mem_mode
);
15215 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
))
15217 op0
= mem_loc_descriptor (XEXP (rtl
, 0), int_mode
, mem_mode
,
15218 VAR_INIT_STATUS_INITIALIZED
);
15220 rtx rtlop1
= XEXP (rtl
, 1);
15221 if (is_a
<scalar_int_mode
> (GET_MODE (rtlop1
), &op1_mode
)
15222 && GET_MODE_BITSIZE (op1_mode
) < GET_MODE_BITSIZE (int_mode
))
15223 rtlop1
= gen_rtx_ZERO_EXTEND (int_mode
, rtlop1
);
15224 op1
= mem_loc_descriptor (rtlop1
, int_mode
, mem_mode
,
15225 VAR_INIT_STATUS_INITIALIZED
);
15228 if (op0
== 0 || op1
== 0)
15231 mem_loc_result
= op0
;
15232 add_loc_descr (&mem_loc_result
, op1
);
15233 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15249 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15250 VAR_INIT_STATUS_INITIALIZED
);
15251 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15252 VAR_INIT_STATUS_INITIALIZED
);
15254 if (op0
== 0 || op1
== 0)
15257 mem_loc_result
= op0
;
15258 add_loc_descr (&mem_loc_result
, op1
);
15259 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15263 if ((!dwarf_strict
|| dwarf_version
>= 5)
15264 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15265 && GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15267 mem_loc_result
= typed_binop (DW_OP_mod
, rtl
,
15268 base_type_for_mode (mode
, 0),
15269 int_mode
, mem_mode
);
15273 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15274 VAR_INIT_STATUS_INITIALIZED
);
15275 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15276 VAR_INIT_STATUS_INITIALIZED
);
15278 if (op0
== 0 || op1
== 0)
15281 mem_loc_result
= op0
;
15282 add_loc_descr (&mem_loc_result
, op1
);
15283 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
15284 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
15285 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
15286 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
15287 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
15291 if ((!dwarf_strict
|| dwarf_version
>= 5)
15292 && is_a
<scalar_int_mode
> (mode
, &int_mode
))
15294 if (GET_MODE_SIZE (int_mode
) > DWARF2_ADDR_SIZE
)
15299 mem_loc_result
= typed_binop (DW_OP_div
, rtl
,
15300 base_type_for_mode (int_mode
, 1),
15301 int_mode
, mem_mode
);
15318 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
, mem_mode
,
15319 VAR_INIT_STATUS_INITIALIZED
);
15324 mem_loc_result
= op0
;
15325 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15329 if (!is_a
<scalar_int_mode
> (mode
, &int_mode
)
15330 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15331 #ifdef POINTERS_EXTEND_UNSIGNED
15332 || (int_mode
== Pmode
15333 && mem_mode
!= VOIDmode
15334 && trunc_int_for_mode (INTVAL (rtl
), ptr_mode
) == INTVAL (rtl
))
15338 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
15341 if ((!dwarf_strict
|| dwarf_version
>= 5)
15342 && (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
15343 || GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_DOUBLE_INT
))
15345 dw_die_ref type_die
= base_type_for_mode (int_mode
, 1);
15346 scalar_int_mode amode
;
15347 if (type_die
== NULL
)
15349 if (INTVAL (rtl
) >= 0
15350 && (int_mode_for_size (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
, 0)
15352 && trunc_int_for_mode (INTVAL (rtl
), amode
) == INTVAL (rtl
)
15353 /* const DW_OP_convert <XXX> vs.
15354 DW_OP_const_type <XXX, 1, const>. */
15355 && size_of_int_loc_descriptor (INTVAL (rtl
)) + 1 + 1
15356 < (unsigned long) 1 + 1 + 1 + GET_MODE_SIZE (int_mode
))
15358 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
15359 op0
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15360 op0
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15361 op0
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15362 op0
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15363 add_loc_descr (&mem_loc_result
, op0
);
15364 return mem_loc_result
;
15366 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0,
15368 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15369 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15370 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15371 if (GET_MODE_BITSIZE (int_mode
) == HOST_BITS_PER_WIDE_INT
)
15372 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
15375 mem_loc_result
->dw_loc_oprnd2
.val_class
15376 = dw_val_class_const_double
;
15377 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
15378 = double_int::from_shwi (INTVAL (rtl
));
15384 if (!dwarf_strict
|| dwarf_version
>= 5)
15386 dw_die_ref type_die
;
15388 /* Note that if TARGET_SUPPORTS_WIDE_INT == 0, a
15389 CONST_DOUBLE rtx could represent either a large integer
15390 or a floating-point constant. If TARGET_SUPPORTS_WIDE_INT != 0,
15391 the value is always a floating point constant.
15393 When it is an integer, a CONST_DOUBLE is used whenever
15394 the constant requires 2 HWIs to be adequately represented.
15395 We output CONST_DOUBLEs as blocks. */
15396 if (mode
== VOIDmode
15397 || (GET_MODE (rtl
) == VOIDmode
15398 && GET_MODE_BITSIZE (mode
) != HOST_BITS_PER_DOUBLE_INT
))
15400 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15401 if (type_die
== NULL
)
15403 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
15404 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15405 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15406 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15407 #if TARGET_SUPPORTS_WIDE_INT == 0
15408 if (!SCALAR_FLOAT_MODE_P (mode
))
15410 mem_loc_result
->dw_loc_oprnd2
.val_class
15411 = dw_val_class_const_double
;
15412 mem_loc_result
->dw_loc_oprnd2
.v
.val_double
15413 = rtx_to_double_int (rtl
);
15418 scalar_float_mode float_mode
= as_a
<scalar_float_mode
> (mode
);
15419 unsigned int length
= GET_MODE_SIZE (float_mode
);
15420 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
15422 insert_float (rtl
, array
);
15423 mem_loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
15424 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
15425 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
15426 mem_loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
15431 case CONST_WIDE_INT
:
15432 if (!dwarf_strict
|| dwarf_version
>= 5)
15434 dw_die_ref type_die
;
15436 type_die
= base_type_for_mode (mode
, SCALAR_INT_MODE_P (mode
));
15437 if (type_die
== NULL
)
15439 mem_loc_result
= new_loc_descr (dwarf_OP (DW_OP_const_type
), 0, 0);
15440 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15441 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15442 mem_loc_result
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15443 mem_loc_result
->dw_loc_oprnd2
.val_class
15444 = dw_val_class_wide_int
;
15445 mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
15446 *mem_loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, mode
);
15450 case CONST_POLY_INT
:
15451 mem_loc_result
= int_loc_descriptor (rtx_to_poly_int64 (rtl
));
15455 mem_loc_result
= scompare_loc_descriptor (DW_OP_eq
, rtl
, mem_mode
);
15459 mem_loc_result
= scompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
15463 mem_loc_result
= scompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
15467 mem_loc_result
= scompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
15471 mem_loc_result
= scompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
15475 mem_loc_result
= scompare_loc_descriptor (DW_OP_ne
, rtl
, mem_mode
);
15479 mem_loc_result
= ucompare_loc_descriptor (DW_OP_ge
, rtl
, mem_mode
);
15483 mem_loc_result
= ucompare_loc_descriptor (DW_OP_gt
, rtl
, mem_mode
);
15487 mem_loc_result
= ucompare_loc_descriptor (DW_OP_le
, rtl
, mem_mode
);
15491 mem_loc_result
= ucompare_loc_descriptor (DW_OP_lt
, rtl
, mem_mode
);
15496 if (!SCALAR_INT_MODE_P (mode
))
15501 mem_loc_result
= minmax_loc_descriptor (rtl
, mode
, mem_mode
);
15506 if (CONST_INT_P (XEXP (rtl
, 1))
15507 && CONST_INT_P (XEXP (rtl
, 2))
15508 && is_a
<scalar_int_mode
> (mode
, &int_mode
)
15509 && is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &inner_mode
)
15510 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
15511 && GET_MODE_SIZE (inner_mode
) <= DWARF2_ADDR_SIZE
15512 && ((unsigned) INTVAL (XEXP (rtl
, 1))
15513 + (unsigned) INTVAL (XEXP (rtl
, 2))
15514 <= GET_MODE_BITSIZE (int_mode
)))
15517 op0
= mem_loc_descriptor (XEXP (rtl
, 0), inner_mode
,
15518 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
15521 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
15525 mem_loc_result
= op0
;
15526 size
= INTVAL (XEXP (rtl
, 1));
15527 shift
= INTVAL (XEXP (rtl
, 2));
15528 if (BITS_BIG_ENDIAN
)
15529 shift
= GET_MODE_BITSIZE (inner_mode
) - shift
- size
;
15530 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
15532 add_loc_descr (&mem_loc_result
,
15533 int_loc_descriptor (DWARF2_ADDR_SIZE
15535 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
15537 if (size
!= (int) DWARF2_ADDR_SIZE
)
15539 add_loc_descr (&mem_loc_result
,
15540 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
15541 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
15548 dw_loc_descr_ref op2
, bra_node
, drop_node
;
15549 op0
= mem_loc_descriptor (XEXP (rtl
, 0),
15550 GET_MODE (XEXP (rtl
, 0)) == VOIDmode
15551 ? word_mode
: GET_MODE (XEXP (rtl
, 0)),
15552 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
15553 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
, mem_mode
,
15554 VAR_INIT_STATUS_INITIALIZED
);
15555 op2
= mem_loc_descriptor (XEXP (rtl
, 2), mode
, mem_mode
,
15556 VAR_INIT_STATUS_INITIALIZED
);
15557 if (op0
== NULL
|| op1
== NULL
|| op2
== NULL
)
15560 mem_loc_result
= op1
;
15561 add_loc_descr (&mem_loc_result
, op2
);
15562 add_loc_descr (&mem_loc_result
, op0
);
15563 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
15564 add_loc_descr (&mem_loc_result
, bra_node
);
15565 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
15566 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
15567 add_loc_descr (&mem_loc_result
, drop_node
);
15568 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15569 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
15574 case FLOAT_TRUNCATE
:
15576 case UNSIGNED_FLOAT
:
15579 if (!dwarf_strict
|| dwarf_version
>= 5)
15581 dw_die_ref type_die
;
15582 dw_loc_descr_ref cvt
;
15584 op0
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (XEXP (rtl
, 0)),
15585 mem_mode
, VAR_INIT_STATUS_INITIALIZED
);
15588 if (is_a
<scalar_int_mode
> (GET_MODE (XEXP (rtl
, 0)), &int_mode
)
15589 && (GET_CODE (rtl
) == FLOAT
15590 || GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
))
15592 type_die
= base_type_for_mode (int_mode
,
15593 GET_CODE (rtl
) == UNSIGNED_FLOAT
);
15594 if (type_die
== NULL
)
15596 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15597 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15598 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15599 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15600 add_loc_descr (&op0
, cvt
);
15602 type_die
= base_type_for_mode (mode
, GET_CODE (rtl
) == UNSIGNED_FIX
);
15603 if (type_die
== NULL
)
15605 cvt
= new_loc_descr (dwarf_OP (DW_OP_convert
), 0, 0);
15606 cvt
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15607 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.die
= type_die
;
15608 cvt
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15609 add_loc_descr (&op0
, cvt
);
15610 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
15611 && (GET_CODE (rtl
) == FIX
15612 || GET_MODE_SIZE (int_mode
) < DWARF2_ADDR_SIZE
))
15614 op0
= convert_descriptor_to_mode (int_mode
, op0
);
15618 mem_loc_result
= op0
;
15625 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
15626 mem_loc_result
= clz_loc_descriptor (rtl
, int_mode
, mem_mode
);
15631 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
15632 mem_loc_result
= popcount_loc_descriptor (rtl
, int_mode
, mem_mode
);
15636 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
15637 mem_loc_result
= bswap_loc_descriptor (rtl
, int_mode
, mem_mode
);
15642 if (is_a
<scalar_int_mode
> (mode
, &int_mode
))
15643 mem_loc_result
= rotate_loc_descriptor (rtl
, int_mode
, mem_mode
);
15647 /* In theory, we could implement the above. */
15648 /* DWARF cannot represent the unsigned compare operations
15673 case FRACT_CONVERT
:
15674 case UNSIGNED_FRACT_CONVERT
:
15676 case UNSIGNED_SAT_FRACT
:
15682 case VEC_DUPLICATE
:
15687 case STRICT_LOW_PART
:
15692 /* If delegitimize_address couldn't do anything with the UNSPEC, we
15693 can't express it in the debug info. This can happen e.g. with some
15698 resolve_one_addr (&rtl
);
15701 /* RTL sequences inside PARALLEL record a series of DWARF operations for
15702 the expression. An UNSPEC rtx represents a raw DWARF operation,
15703 new_loc_descr is called for it to build the operation directly.
15704 Otherwise mem_loc_descriptor is called recursively. */
15708 dw_loc_descr_ref exp_result
= NULL
;
15710 for (; index
< XVECLEN (rtl
, 0); index
++)
15712 rtx elem
= XVECEXP (rtl
, 0, index
);
15713 if (GET_CODE (elem
) == UNSPEC
)
15715 /* Each DWARF operation UNSPEC contain two operands, if
15716 one operand is not used for the operation, const0_rtx is
15718 gcc_assert (XVECLEN (elem
, 0) == 2);
15720 HOST_WIDE_INT dw_op
= XINT (elem
, 1);
15721 HOST_WIDE_INT oprnd1
= INTVAL (XVECEXP (elem
, 0, 0));
15722 HOST_WIDE_INT oprnd2
= INTVAL (XVECEXP (elem
, 0, 1));
15724 = new_loc_descr ((enum dwarf_location_atom
) dw_op
, oprnd1
,
15729 = mem_loc_descriptor (elem
, mode
, mem_mode
,
15730 VAR_INIT_STATUS_INITIALIZED
);
15732 if (!mem_loc_result
)
15733 mem_loc_result
= exp_result
;
15735 add_loc_descr (&mem_loc_result
, exp_result
);
15744 print_rtl (stderr
, rtl
);
15745 gcc_unreachable ();
15750 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
15751 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
15753 return mem_loc_result
;
15756 /* Return a descriptor that describes the concatenation of two locations.
15757 This is typically a complex variable. */
15759 static dw_loc_descr_ref
15760 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
15762 dw_loc_descr_ref cc_loc_result
= NULL
;
15763 dw_loc_descr_ref x0_ref
15764 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15765 dw_loc_descr_ref x1_ref
15766 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15768 if (x0_ref
== 0 || x1_ref
== 0)
15771 cc_loc_result
= x0_ref
;
15772 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x0
)));
15774 add_loc_descr (&cc_loc_result
, x1_ref
);
15775 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x1
)));
15777 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
15778 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
15780 return cc_loc_result
;
15783 /* Return a descriptor that describes the concatenation of N
15786 static dw_loc_descr_ref
15787 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
15790 dw_loc_descr_ref cc_loc_result
= NULL
;
15791 unsigned int n
= XVECLEN (concatn
, 0);
15793 for (i
= 0; i
< n
; ++i
)
15795 dw_loc_descr_ref ref
;
15796 rtx x
= XVECEXP (concatn
, 0, i
);
15798 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
15802 add_loc_descr (&cc_loc_result
, ref
);
15803 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x
)));
15806 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
15807 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
15809 return cc_loc_result
;
15812 /* Helper function for loc_descriptor. Return DW_OP_implicit_pointer
15813 for DEBUG_IMPLICIT_PTR RTL. */
15815 static dw_loc_descr_ref
15816 implicit_ptr_descriptor (rtx rtl
, HOST_WIDE_INT offset
)
15818 dw_loc_descr_ref ret
;
15821 if (dwarf_strict
&& dwarf_version
< 5)
15823 gcc_assert (TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == VAR_DECL
15824 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == PARM_DECL
15825 || TREE_CODE (DEBUG_IMPLICIT_PTR_DECL (rtl
)) == RESULT_DECL
);
15826 ref
= lookup_decl_die (DEBUG_IMPLICIT_PTR_DECL (rtl
));
15827 ret
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
15828 ret
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
15831 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
15832 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
15833 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
15837 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
15838 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= DEBUG_IMPLICIT_PTR_DECL (rtl
);
15843 /* Output a proper Dwarf location descriptor for a variable or parameter
15844 which is either allocated in a register or in a memory location. For a
15845 register, we just generate an OP_REG and the register number. For a
15846 memory location we provide a Dwarf postfix expression describing how to
15847 generate the (dynamic) address of the object onto the address stack.
15849 MODE is mode of the decl if this loc_descriptor is going to be used in
15850 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
15851 allowed, VOIDmode otherwise.
15853 If we don't know how to describe it, return 0. */
15855 static dw_loc_descr_ref
15856 loc_descriptor (rtx rtl
, machine_mode mode
,
15857 enum var_init_status initialized
)
15859 dw_loc_descr_ref loc_result
= NULL
;
15860 scalar_int_mode int_mode
;
15862 switch (GET_CODE (rtl
))
15865 /* The case of a subreg may arise when we have a local (register)
15866 variable or a formal (register) parameter which doesn't quite fill
15867 up an entire register. For now, just assume that it is
15868 legitimate to make the Dwarf info refer to the whole register which
15869 contains the given subreg. */
15870 if (REG_P (SUBREG_REG (rtl
)) && subreg_lowpart_p (rtl
))
15871 loc_result
= loc_descriptor (SUBREG_REG (rtl
),
15872 GET_MODE (SUBREG_REG (rtl
)), initialized
);
15878 loc_result
= reg_loc_descriptor (rtl
, initialized
);
15882 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
15883 GET_MODE (rtl
), initialized
);
15884 if (loc_result
== NULL
)
15885 loc_result
= tls_mem_loc_descriptor (rtl
);
15886 if (loc_result
== NULL
)
15888 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
15889 if (new_rtl
!= rtl
)
15890 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
15895 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
15900 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
15905 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
15907 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
15908 if (GET_CODE (loc
) == EXPR_LIST
)
15909 loc
= XEXP (loc
, 0);
15910 loc_result
= loc_descriptor (loc
, mode
, initialized
);
15914 rtl
= XEXP (rtl
, 1);
15919 rtvec par_elems
= XVEC (rtl
, 0);
15920 int num_elem
= GET_NUM_ELEM (par_elems
);
15924 /* Create the first one, so we have something to add to. */
15925 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
15926 VOIDmode
, initialized
);
15927 if (loc_result
== NULL
)
15929 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
15930 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
15931 for (i
= 1; i
< num_elem
; i
++)
15933 dw_loc_descr_ref temp
;
15935 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
15936 VOIDmode
, initialized
);
15939 add_loc_descr (&loc_result
, temp
);
15940 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
15941 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
15947 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
15949 int_mode
= as_a
<scalar_int_mode
> (mode
);
15950 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (int_mode
),
15956 if (mode
== VOIDmode
)
15957 mode
= GET_MODE (rtl
);
15959 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
15961 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
15963 /* Note that a CONST_DOUBLE rtx could represent either an integer
15964 or a floating-point constant. A CONST_DOUBLE is used whenever
15965 the constant requires more than one word in order to be
15966 adequately represented. We output CONST_DOUBLEs as blocks. */
15967 scalar_mode smode
= as_a
<scalar_mode
> (mode
);
15968 loc_result
= new_loc_descr (DW_OP_implicit_value
,
15969 GET_MODE_SIZE (smode
), 0);
15970 #if TARGET_SUPPORTS_WIDE_INT == 0
15971 if (!SCALAR_FLOAT_MODE_P (smode
))
15973 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
15974 loc_result
->dw_loc_oprnd2
.v
.val_double
15975 = rtx_to_double_int (rtl
);
15980 unsigned int length
= GET_MODE_SIZE (smode
);
15981 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
15983 insert_float (rtl
, array
);
15984 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
15985 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
15986 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
15987 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
15992 case CONST_WIDE_INT
:
15993 if (mode
== VOIDmode
)
15994 mode
= GET_MODE (rtl
);
15996 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
15998 int_mode
= as_a
<scalar_int_mode
> (mode
);
15999 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16000 GET_MODE_SIZE (int_mode
), 0);
16001 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_wide_int
;
16002 loc_result
->dw_loc_oprnd2
.v
.val_wide
= ggc_alloc
<wide_int
> ();
16003 *loc_result
->dw_loc_oprnd2
.v
.val_wide
= rtx_mode_t (rtl
, int_mode
);
16008 if (mode
== VOIDmode
)
16009 mode
= GET_MODE (rtl
);
16011 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
16013 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
16014 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
16015 unsigned char *array
16016 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
16019 machine_mode imode
= GET_MODE_INNER (mode
);
16021 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
16022 switch (GET_MODE_CLASS (mode
))
16024 case MODE_VECTOR_INT
:
16025 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
16027 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
16028 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
16032 case MODE_VECTOR_FLOAT
:
16033 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
16035 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
16036 insert_float (elt
, p
);
16041 gcc_unreachable ();
16044 loc_result
= new_loc_descr (DW_OP_implicit_value
,
16045 length
* elt_size
, 0);
16046 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
16047 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
16048 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
16049 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
16054 if (mode
== VOIDmode
16055 || CONST_SCALAR_INT_P (XEXP (rtl
, 0))
16056 || CONST_DOUBLE_AS_FLOAT_P (XEXP (rtl
, 0))
16057 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
16059 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
16064 if (!const_ok_for_output (rtl
))
16068 if (is_a
<scalar_int_mode
> (mode
, &int_mode
)
16069 && GET_MODE_SIZE (int_mode
) == DWARF2_ADDR_SIZE
16070 && (dwarf_version
>= 4 || !dwarf_strict
))
16072 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
16073 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16074 vec_safe_push (used_rtx_array
, rtl
);
16078 case DEBUG_IMPLICIT_PTR
:
16079 loc_result
= implicit_ptr_descriptor (rtl
, 0);
16083 if (GET_CODE (XEXP (rtl
, 0)) == DEBUG_IMPLICIT_PTR
16084 && CONST_INT_P (XEXP (rtl
, 1)))
16087 = implicit_ptr_descriptor (XEXP (rtl
, 0), INTVAL (XEXP (rtl
, 1)));
16093 if ((is_a
<scalar_int_mode
> (mode
, &int_mode
)
16094 && GET_MODE (rtl
) == int_mode
16095 && GET_MODE_SIZE (int_mode
) <= DWARF2_ADDR_SIZE
16096 && dwarf_version
>= 4)
16097 || (!dwarf_strict
&& mode
!= VOIDmode
&& mode
!= BLKmode
))
16099 /* Value expression. */
16100 loc_result
= mem_loc_descriptor (rtl
, mode
, VOIDmode
, initialized
);
16102 add_loc_descr (&loc_result
,
16103 new_loc_descr (DW_OP_stack_value
, 0, 0));
16111 /* We need to figure out what section we should use as the base for the
16112 address ranges where a given location is valid.
16113 1. If this particular DECL has a section associated with it, use that.
16114 2. If this function has a section associated with it, use that.
16115 3. Otherwise, use the text section.
16116 XXX: If you split a variable across multiple sections, we won't notice. */
16118 static const char *
16119 secname_for_decl (const_tree decl
)
16121 const char *secname
;
16123 if (VAR_OR_FUNCTION_DECL_P (decl
)
16124 && (DECL_EXTERNAL (decl
) || TREE_PUBLIC (decl
) || TREE_STATIC (decl
))
16125 && DECL_SECTION_NAME (decl
))
16126 secname
= DECL_SECTION_NAME (decl
);
16127 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
16128 secname
= DECL_SECTION_NAME (current_function_decl
);
16129 else if (cfun
&& in_cold_section_p
)
16130 secname
= crtl
->subsections
.cold_section_label
;
16132 secname
= text_section_label
;
16137 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
16140 decl_by_reference_p (tree decl
)
16142 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
16144 && DECL_BY_REFERENCE (decl
));
16147 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
16150 static dw_loc_descr_ref
16151 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
16152 enum var_init_status initialized
)
16154 int have_address
= 0;
16155 dw_loc_descr_ref descr
;
16158 if (want_address
!= 2)
16160 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
16162 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
16164 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
16165 if (GET_CODE (varloc
) == EXPR_LIST
)
16166 varloc
= XEXP (varloc
, 0);
16167 mode
= GET_MODE (varloc
);
16168 if (MEM_P (varloc
))
16170 rtx addr
= XEXP (varloc
, 0);
16171 descr
= mem_loc_descriptor (addr
, get_address_mode (varloc
),
16172 mode
, initialized
);
16177 rtx x
= avoid_constant_pool_reference (varloc
);
16179 descr
= mem_loc_descriptor (x
, mode
, VOIDmode
,
16184 descr
= mem_loc_descriptor (varloc
, mode
, VOIDmode
, initialized
);
16191 if (GET_CODE (varloc
) == VAR_LOCATION
)
16192 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
16194 mode
= DECL_MODE (loc
);
16195 descr
= loc_descriptor (varloc
, mode
, initialized
);
16202 if (want_address
== 2 && !have_address
16203 && (dwarf_version
>= 4 || !dwarf_strict
))
16205 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
16207 expansion_failed (loc
, NULL_RTX
,
16208 "DWARF address size mismatch");
16211 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16214 /* Show if we can't fill the request for an address. */
16215 if (want_address
&& !have_address
)
16217 expansion_failed (loc
, NULL_RTX
,
16218 "Want address and only have value");
16222 /* If we've got an address and don't want one, dereference. */
16223 if (!want_address
&& have_address
)
16225 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
16226 enum dwarf_location_atom op
;
16228 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
16230 expansion_failed (loc
, NULL_RTX
,
16231 "DWARF address size mismatch");
16234 else if (size
== DWARF2_ADDR_SIZE
)
16237 op
= DW_OP_deref_size
;
16239 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
16245 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
16246 if it is not possible. */
16248 static dw_loc_descr_ref
16249 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
16251 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
16252 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
16253 else if (dwarf_version
>= 3 || !dwarf_strict
)
16254 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
16259 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
16260 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
16262 static dw_loc_descr_ref
16263 dw_sra_loc_expr (tree decl
, rtx loc
)
16266 unsigned HOST_WIDE_INT padsize
= 0;
16267 dw_loc_descr_ref descr
, *descr_tail
;
16268 unsigned HOST_WIDE_INT decl_size
;
16270 enum var_init_status initialized
;
16272 if (DECL_SIZE (decl
) == NULL
16273 || !tree_fits_uhwi_p (DECL_SIZE (decl
)))
16276 decl_size
= tree_to_uhwi (DECL_SIZE (decl
));
16278 descr_tail
= &descr
;
16280 for (p
= loc
; p
; p
= XEXP (p
, 1))
16282 unsigned HOST_WIDE_INT bitsize
= decl_piece_bitsize (p
);
16283 rtx loc_note
= *decl_piece_varloc_ptr (p
);
16284 dw_loc_descr_ref cur_descr
;
16285 dw_loc_descr_ref
*tail
, last
= NULL
;
16286 unsigned HOST_WIDE_INT opsize
= 0;
16288 if (loc_note
== NULL_RTX
16289 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
16291 padsize
+= bitsize
;
16294 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
16295 varloc
= NOTE_VAR_LOCATION (loc_note
);
16296 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
16297 if (cur_descr
== NULL
)
16299 padsize
+= bitsize
;
16303 /* Check that cur_descr either doesn't use
16304 DW_OP_*piece operations, or their sum is equal
16305 to bitsize. Otherwise we can't embed it. */
16306 for (tail
= &cur_descr
; *tail
!= NULL
;
16307 tail
= &(*tail
)->dw_loc_next
)
16308 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
16310 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
16314 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
16316 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
16320 if (last
!= NULL
&& opsize
!= bitsize
)
16322 padsize
+= bitsize
;
16323 /* Discard the current piece of the descriptor and release any
16324 addr_table entries it uses. */
16325 remove_loc_list_addr_table_entries (cur_descr
);
16329 /* If there is a hole, add DW_OP_*piece after empty DWARF
16330 expression, which means that those bits are optimized out. */
16333 if (padsize
> decl_size
)
16335 remove_loc_list_addr_table_entries (cur_descr
);
16336 goto discard_descr
;
16338 decl_size
-= padsize
;
16339 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
16340 if (*descr_tail
== NULL
)
16342 remove_loc_list_addr_table_entries (cur_descr
);
16343 goto discard_descr
;
16345 descr_tail
= &(*descr_tail
)->dw_loc_next
;
16348 *descr_tail
= cur_descr
;
16350 if (bitsize
> decl_size
)
16351 goto discard_descr
;
16352 decl_size
-= bitsize
;
16355 HOST_WIDE_INT offset
= 0;
16356 if (GET_CODE (varloc
) == VAR_LOCATION
16357 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
16359 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
16360 if (GET_CODE (varloc
) == EXPR_LIST
)
16361 varloc
= XEXP (varloc
, 0);
16365 if (GET_CODE (varloc
) == CONST
16366 || GET_CODE (varloc
) == SIGN_EXTEND
16367 || GET_CODE (varloc
) == ZERO_EXTEND
)
16368 varloc
= XEXP (varloc
, 0);
16369 else if (GET_CODE (varloc
) == SUBREG
)
16370 varloc
= SUBREG_REG (varloc
);
16375 /* DW_OP_bit_size offset should be zero for register
16376 or implicit location descriptions and empty location
16377 descriptions, but for memory addresses needs big endian
16379 if (MEM_P (varloc
))
16381 unsigned HOST_WIDE_INT memsize
;
16382 if (!poly_uint64 (MEM_SIZE (varloc
)).is_constant (&memsize
))
16383 goto discard_descr
;
16384 memsize
*= BITS_PER_UNIT
;
16385 if (memsize
!= bitsize
)
16387 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
16388 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
16389 goto discard_descr
;
16390 if (memsize
< bitsize
)
16391 goto discard_descr
;
16392 if (BITS_BIG_ENDIAN
)
16393 offset
= memsize
- bitsize
;
16397 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
16398 if (*descr_tail
== NULL
)
16399 goto discard_descr
;
16400 descr_tail
= &(*descr_tail
)->dw_loc_next
;
16404 /* If there were any non-empty expressions, add padding till the end of
16406 if (descr
!= NULL
&& decl_size
!= 0)
16408 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
16409 if (*descr_tail
== NULL
)
16410 goto discard_descr
;
16415 /* Discard the descriptor and release any addr_table entries it uses. */
16416 remove_loc_list_addr_table_entries (descr
);
16420 /* Return the dwarf representation of the location list LOC_LIST of
16421 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
16424 static dw_loc_list_ref
16425 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
16427 const char *endname
, *secname
;
16429 enum var_init_status initialized
;
16430 struct var_loc_node
*node
;
16431 dw_loc_descr_ref descr
;
16432 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
16433 dw_loc_list_ref list
= NULL
;
16434 dw_loc_list_ref
*listp
= &list
;
16436 /* Now that we know what section we are using for a base,
16437 actually construct the list of locations.
16438 The first location information is what is passed to the
16439 function that creates the location list, and the remaining
16440 locations just get added on to that list.
16441 Note that we only know the start address for a location
16442 (IE location changes), so to build the range, we use
16443 the range [current location start, next location start].
16444 This means we have to special case the last node, and generate
16445 a range of [last location start, end of function label]. */
16447 if (cfun
&& crtl
->has_bb_partition
)
16449 bool save_in_cold_section_p
= in_cold_section_p
;
16450 in_cold_section_p
= first_function_block_is_cold
;
16451 if (loc_list
->last_before_switch
== NULL
)
16452 in_cold_section_p
= !in_cold_section_p
;
16453 secname
= secname_for_decl (decl
);
16454 in_cold_section_p
= save_in_cold_section_p
;
16457 secname
= secname_for_decl (decl
);
16459 for (node
= loc_list
->first
; node
; node
= node
->next
)
16461 bool range_across_switch
= false;
16462 if (GET_CODE (node
->loc
) == EXPR_LIST
16463 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
16465 if (GET_CODE (node
->loc
) == EXPR_LIST
)
16468 /* This requires DW_OP_{,bit_}piece, which is not usable
16469 inside DWARF expressions. */
16470 if (want_address
== 2)
16471 descr
= dw_sra_loc_expr (decl
, node
->loc
);
16475 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
16476 varloc
= NOTE_VAR_LOCATION (node
->loc
);
16477 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
16481 /* If section switch happens in between node->label
16482 and node->next->label (or end of function) and
16483 we can't emit it as a single entry list,
16484 emit two ranges, first one ending at the end
16485 of first partition and second one starting at the
16486 beginning of second partition. */
16487 if (node
== loc_list
->last_before_switch
16488 && (node
!= loc_list
->first
|| loc_list
->first
->next
)
16489 && current_function_decl
)
16491 endname
= cfun
->fde
->dw_fde_end
;
16492 range_across_switch
= true;
16494 /* The variable has a location between NODE->LABEL and
16495 NODE->NEXT->LABEL. */
16496 else if (node
->next
)
16497 endname
= node
->next
->label
;
16498 /* If the variable has a location at the last label
16499 it keeps its location until the end of function. */
16500 else if (!current_function_decl
)
16501 endname
= text_end_label
;
16504 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
16505 current_function_funcdef_no
);
16506 endname
= ggc_strdup (label_id
);
16509 *listp
= new_loc_list (descr
, node
->label
, endname
, secname
);
16510 if (TREE_CODE (decl
) == PARM_DECL
16511 && node
== loc_list
->first
16512 && NOTE_P (node
->loc
)
16513 && strcmp (node
->label
, endname
) == 0)
16514 (*listp
)->force
= true;
16515 listp
= &(*listp
)->dw_loc_next
;
16520 && crtl
->has_bb_partition
16521 && node
== loc_list
->last_before_switch
)
16523 bool save_in_cold_section_p
= in_cold_section_p
;
16524 in_cold_section_p
= !first_function_block_is_cold
;
16525 secname
= secname_for_decl (decl
);
16526 in_cold_section_p
= save_in_cold_section_p
;
16529 if (range_across_switch
)
16531 if (GET_CODE (node
->loc
) == EXPR_LIST
)
16532 descr
= dw_sra_loc_expr (decl
, node
->loc
);
16535 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
16536 varloc
= NOTE_VAR_LOCATION (node
->loc
);
16537 descr
= dw_loc_list_1 (decl
, varloc
, want_address
,
16540 gcc_assert (descr
);
16541 /* The variable has a location between NODE->LABEL and
16542 NODE->NEXT->LABEL. */
16544 endname
= node
->next
->label
;
16546 endname
= cfun
->fde
->dw_fde_second_end
;
16547 *listp
= new_loc_list (descr
, cfun
->fde
->dw_fde_second_begin
,
16549 listp
= &(*listp
)->dw_loc_next
;
16553 /* Try to avoid the overhead of a location list emitting a location
16554 expression instead, but only if we didn't have more than one
16555 location entry in the first place. If some entries were not
16556 representable, we don't want to pretend a single entry that was
16557 applies to the entire scope in which the variable is
16559 if (list
&& loc_list
->first
->next
)
16565 /* Return if the loc_list has only single element and thus can be represented
16566 as location description. */
16569 single_element_loc_list_p (dw_loc_list_ref list
)
16571 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
16572 return !list
->ll_symbol
;
16575 /* Duplicate a single element of location list. */
16577 static inline dw_loc_descr_ref
16578 copy_loc_descr (dw_loc_descr_ref ref
)
16580 dw_loc_descr_ref copy
= ggc_alloc
<dw_loc_descr_node
> ();
16581 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
16585 /* To each location in list LIST append loc descr REF. */
16588 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
16590 dw_loc_descr_ref copy
;
16591 add_loc_descr (&list
->expr
, ref
);
16592 list
= list
->dw_loc_next
;
16595 copy
= copy_loc_descr (ref
);
16596 add_loc_descr (&list
->expr
, copy
);
16597 while (copy
->dw_loc_next
)
16598 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
16599 list
= list
->dw_loc_next
;
16603 /* To each location in list LIST prepend loc descr REF. */
16606 prepend_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
16608 dw_loc_descr_ref copy
;
16609 dw_loc_descr_ref ref_end
= list
->expr
;
16610 add_loc_descr (&ref
, list
->expr
);
16612 list
= list
->dw_loc_next
;
16615 dw_loc_descr_ref end
= list
->expr
;
16616 list
->expr
= copy
= copy_loc_descr (ref
);
16617 while (copy
->dw_loc_next
!= ref_end
)
16618 copy
= copy
->dw_loc_next
= copy_loc_descr (copy
->dw_loc_next
);
16619 copy
->dw_loc_next
= end
;
16620 list
= list
->dw_loc_next
;
16624 /* Given two lists RET and LIST
16625 produce location list that is result of adding expression in LIST
16626 to expression in RET on each position in program.
16627 Might be destructive on both RET and LIST.
16629 TODO: We handle only simple cases of RET or LIST having at most one
16630 element. General case would involve sorting the lists in program order
16631 and merging them that will need some additional work.
16632 Adding that will improve quality of debug info especially for SRA-ed
16636 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
16645 if (!list
->dw_loc_next
)
16647 add_loc_descr_to_each (*ret
, list
->expr
);
16650 if (!(*ret
)->dw_loc_next
)
16652 prepend_loc_descr_to_each (list
, (*ret
)->expr
);
16656 expansion_failed (NULL_TREE
, NULL_RTX
,
16657 "Don't know how to merge two non-trivial"
16658 " location lists.\n");
16663 /* LOC is constant expression. Try a luck, look it up in constant
16664 pool and return its loc_descr of its address. */
16666 static dw_loc_descr_ref
16667 cst_pool_loc_descr (tree loc
)
16669 /* Get an RTL for this, if something has been emitted. */
16670 rtx rtl
= lookup_constant_def (loc
);
16672 if (!rtl
|| !MEM_P (rtl
))
16677 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
16679 /* TODO: We might get more coverage if we was actually delaying expansion
16680 of all expressions till end of compilation when constant pools are fully
16682 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
16684 expansion_failed (loc
, NULL_RTX
,
16685 "CST value in contant pool but not marked.");
16688 return mem_loc_descriptor (XEXP (rtl
, 0), get_address_mode (rtl
),
16689 GET_MODE (rtl
), VAR_INIT_STATUS_INITIALIZED
);
16692 /* Return dw_loc_list representing address of addr_expr LOC
16693 by looking for inner INDIRECT_REF expression and turning
16694 it into simple arithmetics.
16696 See loc_list_from_tree for the meaning of CONTEXT. */
16698 static dw_loc_list_ref
16699 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
,
16700 loc_descr_context
*context
)
16703 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
16705 int unsignedp
, reversep
, volatilep
= 0;
16706 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
16708 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
16709 &bitsize
, &bitpos
, &offset
, &mode
,
16710 &unsignedp
, &reversep
, &volatilep
);
16712 if (bitpos
% BITS_PER_UNIT
)
16714 expansion_failed (loc
, NULL_RTX
, "bitfield access");
16717 if (!INDIRECT_REF_P (obj
))
16719 expansion_failed (obj
,
16720 NULL_RTX
, "no indirect ref in inner refrence");
16723 if (!offset
&& !bitpos
)
16724 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1,
16727 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
16728 && (dwarf_version
>= 4 || !dwarf_strict
))
16730 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0, context
);
16735 /* Variable offset. */
16736 list_ret1
= loc_list_from_tree (offset
, 0, context
);
16737 if (list_ret1
== 0)
16739 add_loc_list (&list_ret
, list_ret1
);
16742 add_loc_descr_to_each (list_ret
,
16743 new_loc_descr (DW_OP_plus
, 0, 0));
16745 bytepos
= bitpos
/ BITS_PER_UNIT
;
16747 add_loc_descr_to_each (list_ret
,
16748 new_loc_descr (DW_OP_plus_uconst
,
16750 else if (bytepos
< 0)
16751 loc_list_plus_const (list_ret
, bytepos
);
16752 add_loc_descr_to_each (list_ret
,
16753 new_loc_descr (DW_OP_stack_value
, 0, 0));
16758 /* Set LOC to the next operation that is not a DW_OP_nop operation. In the case
16759 all operations from LOC are nops, move to the last one. Insert in NOPS all
16760 operations that are skipped. */
16763 loc_descr_to_next_no_nop (dw_loc_descr_ref
&loc
,
16764 hash_set
<dw_loc_descr_ref
> &nops
)
16766 while (loc
->dw_loc_next
!= NULL
&& loc
->dw_loc_opc
== DW_OP_nop
)
16769 loc
= loc
->dw_loc_next
;
16773 /* Helper for loc_descr_without_nops: free the location description operation
16777 free_loc_descr (const dw_loc_descr_ref
&loc
, void *data ATTRIBUTE_UNUSED
)
16783 /* Remove all DW_OP_nop operations from LOC except, if it exists, the one that
16787 loc_descr_without_nops (dw_loc_descr_ref
&loc
)
16789 if (loc
->dw_loc_opc
== DW_OP_nop
&& loc
->dw_loc_next
== NULL
)
16792 /* Set of all DW_OP_nop operations we remove. */
16793 hash_set
<dw_loc_descr_ref
> nops
;
16795 /* First, strip all prefix NOP operations in order to keep the head of the
16796 operations list. */
16797 loc_descr_to_next_no_nop (loc
, nops
);
16799 for (dw_loc_descr_ref cur
= loc
; cur
!= NULL
;)
16801 /* For control flow operations: strip "prefix" nops in destination
16803 if (cur
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
)
16804 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd1
.v
.val_loc
, nops
);
16805 if (cur
->dw_loc_oprnd2
.val_class
== dw_val_class_loc
)
16806 loc_descr_to_next_no_nop (cur
->dw_loc_oprnd2
.v
.val_loc
, nops
);
16808 /* Do the same for the operations that follow, then move to the next
16810 if (cur
->dw_loc_next
!= NULL
)
16811 loc_descr_to_next_no_nop (cur
->dw_loc_next
, nops
);
16812 cur
= cur
->dw_loc_next
;
16815 nops
.traverse
<void *, free_loc_descr
> (NULL
);
16819 struct dwarf_procedure_info
;
16821 /* Helper structure for location descriptions generation. */
16822 struct loc_descr_context
16824 /* The type that is implicitly referenced by DW_OP_push_object_address, or
16825 NULL_TREE if DW_OP_push_object_address in invalid for this location
16826 description. This is used when processing PLACEHOLDER_EXPR nodes. */
16828 /* The ..._DECL node that should be translated as a
16829 DW_OP_push_object_address operation. */
16831 /* Information about the DWARF procedure we are currently generating. NULL if
16832 we are not generating a DWARF procedure. */
16833 struct dwarf_procedure_info
*dpi
;
16834 /* True if integral PLACEHOLDER_EXPR stands for the first argument passed
16835 by consumer. Used for DW_TAG_generic_subrange attributes. */
16836 bool placeholder_arg
;
16837 /* True if PLACEHOLDER_EXPR has been seen. */
16838 bool placeholder_seen
;
16841 /* DWARF procedures generation
16843 DWARF expressions (aka. location descriptions) are used to encode variable
16844 things such as sizes or offsets. Such computations can have redundant parts
16845 that can be factorized in order to reduce the size of the output debug
16846 information. This is the whole point of DWARF procedures.
16848 Thanks to stor-layout.c, size and offset expressions in GENERIC trees are
16849 already factorized into functions ("size functions") in order to handle very
16850 big and complex types. Such functions are quite simple: they have integral
16851 arguments, they return an integral result and their body contains only a
16852 return statement with arithmetic expressions. This is the only kind of
16853 function we are interested in translating into DWARF procedures, here.
16855 DWARF expressions and DWARF procedure are executed using a stack, so we have
16856 to define some calling convention for them to interact. Let's say that:
16858 - Before calling a DWARF procedure, DWARF expressions must push on the stack
16859 all arguments in reverse order (right-to-left) so that when the DWARF
16860 procedure execution starts, the first argument is the top of the stack.
16862 - Then, when returning, the DWARF procedure must have consumed all arguments
16863 on the stack, must have pushed the result and touched nothing else.
16865 - Each integral argument and the result are integral types can be hold in a
16868 - We call "frame offset" the number of stack slots that are "under DWARF
16869 procedure control": it includes the arguments slots, the temporaries and
16870 the result slot. Thus, it is equal to the number of arguments when the
16871 procedure execution starts and must be equal to one (the result) when it
16874 /* Helper structure used when generating operations for a DWARF procedure. */
16875 struct dwarf_procedure_info
16877 /* The FUNCTION_DECL node corresponding to the DWARF procedure that is
16878 currently translated. */
16880 /* The number of arguments FNDECL takes. */
16881 unsigned args_count
;
16884 /* Return a pointer to a newly created DIE node for a DWARF procedure. Add
16885 LOCATION as its DW_AT_location attribute. If FNDECL is not NULL_TREE,
16886 equate it to this DIE. */
16889 new_dwarf_proc_die (dw_loc_descr_ref location
, tree fndecl
,
16890 dw_die_ref parent_die
)
16892 dw_die_ref dwarf_proc_die
;
16894 if ((dwarf_version
< 3 && dwarf_strict
)
16895 || location
== NULL
)
16898 dwarf_proc_die
= new_die (DW_TAG_dwarf_procedure
, parent_die
, fndecl
);
16900 equate_decl_number_to_die (fndecl
, dwarf_proc_die
);
16901 add_AT_loc (dwarf_proc_die
, DW_AT_location
, location
);
16902 return dwarf_proc_die
;
16905 /* Return whether TYPE is a supported type as a DWARF procedure argument
16906 type or return type (we handle only scalar types and pointer types that
16907 aren't wider than the DWARF expression evaluation stack. */
16910 is_handled_procedure_type (tree type
)
16912 return ((INTEGRAL_TYPE_P (type
)
16913 || TREE_CODE (type
) == OFFSET_TYPE
16914 || TREE_CODE (type
) == POINTER_TYPE
)
16915 && int_size_in_bytes (type
) <= DWARF2_ADDR_SIZE
);
16918 /* Helper for resolve_args_picking: do the same but stop when coming across
16919 visited nodes. For each node we visit, register in FRAME_OFFSETS the frame
16920 offset *before* evaluating the corresponding operation. */
16923 resolve_args_picking_1 (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
16924 struct dwarf_procedure_info
*dpi
,
16925 hash_map
<dw_loc_descr_ref
, unsigned> &frame_offsets
)
16927 /* The "frame_offset" identifier is already used to name a macro... */
16928 unsigned frame_offset_
= initial_frame_offset
;
16929 dw_loc_descr_ref l
;
16931 for (l
= loc
; l
!= NULL
;)
16934 unsigned &l_frame_offset
= frame_offsets
.get_or_insert (l
, &existed
);
16936 /* If we already met this node, there is nothing to compute anymore. */
16939 /* Make sure that the stack size is consistent wherever the execution
16940 flow comes from. */
16941 gcc_assert ((unsigned) l_frame_offset
== frame_offset_
);
16944 l_frame_offset
= frame_offset_
;
16946 /* If needed, relocate the picking offset with respect to the frame
16948 if (l
->frame_offset_rel
)
16950 unsigned HOST_WIDE_INT off
;
16951 switch (l
->dw_loc_opc
)
16954 off
= l
->dw_loc_oprnd1
.v
.val_unsigned
;
16963 gcc_unreachable ();
16965 /* frame_offset_ is the size of the current stack frame, including
16966 incoming arguments. Besides, the arguments are pushed
16967 right-to-left. Thus, in order to access the Nth argument from
16968 this operation node, the picking has to skip temporaries *plus*
16969 one stack slot per argument (0 for the first one, 1 for the second
16972 The targetted argument number (N) is already set as the operand,
16973 and the number of temporaries can be computed with:
16974 frame_offsets_ - dpi->args_count */
16975 off
+= frame_offset_
- dpi
->args_count
;
16977 /* DW_OP_pick handles only offsets from 0 to 255 (inclusive)... */
16983 l
->dw_loc_opc
= DW_OP_dup
;
16984 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
16988 l
->dw_loc_opc
= DW_OP_over
;
16989 l
->dw_loc_oprnd1
.v
.val_unsigned
= 0;
16993 l
->dw_loc_opc
= DW_OP_pick
;
16994 l
->dw_loc_oprnd1
.v
.val_unsigned
= off
;
16998 /* Update frame_offset according to the effect the current operation has
17000 switch (l
->dw_loc_opc
)
17008 case DW_OP_plus_uconst
:
17044 case DW_OP_deref_size
:
17046 case DW_OP_bit_piece
:
17047 case DW_OP_implicit_value
:
17048 case DW_OP_stack_value
:
17052 case DW_OP_const1u
:
17053 case DW_OP_const1s
:
17054 case DW_OP_const2u
:
17055 case DW_OP_const2s
:
17056 case DW_OP_const4u
:
17057 case DW_OP_const4s
:
17058 case DW_OP_const8u
:
17059 case DW_OP_const8s
:
17130 case DW_OP_push_object_address
:
17131 case DW_OP_call_frame_cfa
:
17132 case DW_OP_GNU_variable_value
:
17157 case DW_OP_xderef_size
:
17163 case DW_OP_call_ref
:
17165 dw_die_ref dwarf_proc
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
17166 int *stack_usage
= dwarf_proc_stack_usage_map
->get (dwarf_proc
);
17168 if (stack_usage
== NULL
)
17170 frame_offset_
+= *stack_usage
;
17174 case DW_OP_implicit_pointer
:
17175 case DW_OP_entry_value
:
17176 case DW_OP_const_type
:
17177 case DW_OP_regval_type
:
17178 case DW_OP_deref_type
:
17179 case DW_OP_convert
:
17180 case DW_OP_reinterpret
:
17181 case DW_OP_form_tls_address
:
17182 case DW_OP_GNU_push_tls_address
:
17183 case DW_OP_GNU_uninit
:
17184 case DW_OP_GNU_encoded_addr
:
17185 case DW_OP_GNU_implicit_pointer
:
17186 case DW_OP_GNU_entry_value
:
17187 case DW_OP_GNU_const_type
:
17188 case DW_OP_GNU_regval_type
:
17189 case DW_OP_GNU_deref_type
:
17190 case DW_OP_GNU_convert
:
17191 case DW_OP_GNU_reinterpret
:
17192 case DW_OP_GNU_parameter_ref
:
17193 /* loc_list_from_tree will probably not output these operations for
17194 size functions, so assume they will not appear here. */
17195 /* Fall through... */
17198 gcc_unreachable ();
17201 /* Now, follow the control flow (except subroutine calls). */
17202 switch (l
->dw_loc_opc
)
17205 if (!resolve_args_picking_1 (l
->dw_loc_next
, frame_offset_
, dpi
,
17208 /* Fall through. */
17211 l
= l
->dw_loc_oprnd1
.v
.val_loc
;
17214 case DW_OP_stack_value
:
17218 l
= l
->dw_loc_next
;
17226 /* Make a DFS over operations reachable through LOC (i.e. follow branch
17227 operations) in order to resolve the operand of DW_OP_pick operations that
17228 target DWARF procedure arguments (DPI). INITIAL_FRAME_OFFSET is the frame
17229 offset *before* LOC is executed. Return if all relocations were
17233 resolve_args_picking (dw_loc_descr_ref loc
, unsigned initial_frame_offset
,
17234 struct dwarf_procedure_info
*dpi
)
17236 /* Associate to all visited operations the frame offset *before* evaluating
17238 hash_map
<dw_loc_descr_ref
, unsigned> frame_offsets
;
17240 return resolve_args_picking_1 (loc
, initial_frame_offset
, dpi
,
17244 /* Try to generate a DWARF procedure that computes the same result as FNDECL.
17245 Return NULL if it is not possible. */
17248 function_to_dwarf_procedure (tree fndecl
)
17250 struct loc_descr_context ctx
;
17251 struct dwarf_procedure_info dpi
;
17252 dw_die_ref dwarf_proc_die
;
17253 tree tree_body
= DECL_SAVED_TREE (fndecl
);
17254 dw_loc_descr_ref loc_body
, epilogue
;
17259 /* Do not generate multiple DWARF procedures for the same function
17261 dwarf_proc_die
= lookup_decl_die (fndecl
);
17262 if (dwarf_proc_die
!= NULL
)
17263 return dwarf_proc_die
;
17265 /* DWARF procedures are available starting with the DWARFv3 standard. */
17266 if (dwarf_version
< 3 && dwarf_strict
)
17269 /* We handle only functions for which we still have a body, that return a
17270 supported type and that takes arguments with supported types. Note that
17271 there is no point translating functions that return nothing. */
17272 if (tree_body
== NULL_TREE
17273 || DECL_RESULT (fndecl
) == NULL_TREE
17274 || !is_handled_procedure_type (TREE_TYPE (DECL_RESULT (fndecl
))))
17277 for (cursor
= DECL_ARGUMENTS (fndecl
);
17278 cursor
!= NULL_TREE
;
17279 cursor
= TREE_CHAIN (cursor
))
17280 if (!is_handled_procedure_type (TREE_TYPE (cursor
)))
17283 /* Match only "expr" in: RETURN_EXPR (MODIFY_EXPR (RESULT_DECL, expr)). */
17284 if (TREE_CODE (tree_body
) != RETURN_EXPR
)
17286 tree_body
= TREE_OPERAND (tree_body
, 0);
17287 if (TREE_CODE (tree_body
) != MODIFY_EXPR
17288 || TREE_OPERAND (tree_body
, 0) != DECL_RESULT (fndecl
))
17290 tree_body
= TREE_OPERAND (tree_body
, 1);
17292 /* Try to translate the body expression itself. Note that this will probably
17293 cause an infinite recursion if its call graph has a cycle. This is very
17294 unlikely for size functions, however, so don't bother with such things at
17296 ctx
.context_type
= NULL_TREE
;
17297 ctx
.base_decl
= NULL_TREE
;
17299 ctx
.placeholder_arg
= false;
17300 ctx
.placeholder_seen
= false;
17301 dpi
.fndecl
= fndecl
;
17302 dpi
.args_count
= list_length (DECL_ARGUMENTS (fndecl
));
17303 loc_body
= loc_descriptor_from_tree (tree_body
, 0, &ctx
);
17307 /* After evaluating all operands in "loc_body", we should still have on the
17308 stack all arguments plus the desired function result (top of the stack).
17309 Generate code in order to keep only the result in our stack frame. */
17311 for (i
= 0; i
< dpi
.args_count
; ++i
)
17313 dw_loc_descr_ref op_couple
= new_loc_descr (DW_OP_swap
, 0, 0);
17314 op_couple
->dw_loc_next
= new_loc_descr (DW_OP_drop
, 0, 0);
17315 op_couple
->dw_loc_next
->dw_loc_next
= epilogue
;
17316 epilogue
= op_couple
;
17318 add_loc_descr (&loc_body
, epilogue
);
17319 if (!resolve_args_picking (loc_body
, dpi
.args_count
, &dpi
))
17322 /* Trailing nops from loc_descriptor_from_tree (if any) cannot be removed
17323 because they are considered useful. Now there is an epilogue, they are
17324 not anymore, so give it another try. */
17325 loc_descr_without_nops (loc_body
);
17327 /* fndecl may be used both as a regular DW_TAG_subprogram DIE and as
17328 a DW_TAG_dwarf_procedure, so we may have a conflict, here. It's unlikely,
17329 though, given that size functions do not come from source, so they should
17330 not have a dedicated DW_TAG_subprogram DIE. */
17332 = new_dwarf_proc_die (loc_body
, fndecl
,
17333 get_context_die (DECL_CONTEXT (fndecl
)));
17335 /* The called DWARF procedure consumes one stack slot per argument and
17336 returns one stack slot. */
17337 dwarf_proc_stack_usage_map
->put (dwarf_proc_die
, 1 - dpi
.args_count
);
17339 return dwarf_proc_die
;
17343 /* Generate Dwarf location list representing LOC.
17344 If WANT_ADDRESS is false, expression computing LOC will be computed
17345 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
17346 if WANT_ADDRESS is 2, expression computing address useable in location
17347 will be returned (i.e. DW_OP_reg can be used
17348 to refer to register values).
17350 CONTEXT provides information to customize the location descriptions
17351 generation. Its context_type field specifies what type is implicitly
17352 referenced by DW_OP_push_object_address. If it is NULL_TREE, this operation
17353 will not be generated.
17355 Its DPI field determines whether we are generating a DWARF expression for a
17356 DWARF procedure, so PARM_DECL references are processed specifically.
17358 If CONTEXT is NULL, the behavior is the same as if context_type, base_decl
17359 and dpi fields were null. */
17361 static dw_loc_list_ref
17362 loc_list_from_tree_1 (tree loc
, int want_address
,
17363 struct loc_descr_context
*context
)
17365 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
17366 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
17367 int have_address
= 0;
17368 enum dwarf_location_atom op
;
17370 /* ??? Most of the time we do not take proper care for sign/zero
17371 extending the values properly. Hopefully this won't be a real
17374 if (context
!= NULL
17375 && context
->base_decl
== loc
17376 && want_address
== 0)
17378 if (dwarf_version
>= 3 || !dwarf_strict
)
17379 return new_loc_list (new_loc_descr (DW_OP_push_object_address
, 0, 0),
17385 switch (TREE_CODE (loc
))
17388 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
17391 case PLACEHOLDER_EXPR
:
17392 /* This case involves extracting fields from an object to determine the
17393 position of other fields. It is supposed to appear only as the first
17394 operand of COMPONENT_REF nodes and to reference precisely the type
17395 that the context allows. */
17396 if (context
!= NULL
17397 && TREE_TYPE (loc
) == context
->context_type
17398 && want_address
>= 1)
17400 if (dwarf_version
>= 3 || !dwarf_strict
)
17402 ret
= new_loc_descr (DW_OP_push_object_address
, 0, 0);
17409 /* For DW_TAG_generic_subrange attributes, PLACEHOLDER_EXPR stands for
17410 the single argument passed by consumer. */
17411 else if (context
!= NULL
17412 && context
->placeholder_arg
17413 && INTEGRAL_TYPE_P (TREE_TYPE (loc
))
17414 && want_address
== 0)
17416 ret
= new_loc_descr (DW_OP_pick
, 0, 0);
17417 ret
->frame_offset_rel
= 1;
17418 context
->placeholder_seen
= true;
17422 expansion_failed (loc
, NULL_RTX
,
17423 "PLACEHOLDER_EXPR for an unexpected type");
17428 const int nargs
= call_expr_nargs (loc
);
17429 tree callee
= get_callee_fndecl (loc
);
17431 dw_die_ref dwarf_proc
;
17433 if (callee
== NULL_TREE
)
17434 goto call_expansion_failed
;
17436 /* We handle only functions that return an integer. */
17437 if (!is_handled_procedure_type (TREE_TYPE (TREE_TYPE (callee
))))
17438 goto call_expansion_failed
;
17440 dwarf_proc
= function_to_dwarf_procedure (callee
);
17441 if (dwarf_proc
== NULL
)
17442 goto call_expansion_failed
;
17444 /* Evaluate arguments right-to-left so that the first argument will
17445 be the top-most one on the stack. */
17446 for (i
= nargs
- 1; i
>= 0; --i
)
17448 dw_loc_descr_ref loc_descr
17449 = loc_descriptor_from_tree (CALL_EXPR_ARG (loc
, i
), 0,
17452 if (loc_descr
== NULL
)
17453 goto call_expansion_failed
;
17455 add_loc_descr (&ret
, loc_descr
);
17458 ret1
= new_loc_descr (DW_OP_call4
, 0, 0);
17459 ret1
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
17460 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.die
= dwarf_proc
;
17461 ret1
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
17462 add_loc_descr (&ret
, ret1
);
17465 call_expansion_failed
:
17466 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
17467 /* There are no opcodes for these operations. */
17471 case PREINCREMENT_EXPR
:
17472 case PREDECREMENT_EXPR
:
17473 case POSTINCREMENT_EXPR
:
17474 case POSTDECREMENT_EXPR
:
17475 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
17476 /* There are no opcodes for these operations. */
17480 /* If we already want an address, see if there is INDIRECT_REF inside
17481 e.g. for &this->field. */
17484 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
17485 (loc
, want_address
== 2, context
);
17488 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
17489 && (ret
= cst_pool_loc_descr (loc
)))
17492 /* Otherwise, process the argument and look for the address. */
17493 if (!list_ret
&& !ret
)
17494 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 1, context
);
17498 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
17504 if (DECL_THREAD_LOCAL_P (loc
))
17507 enum dwarf_location_atom tls_op
;
17508 enum dtprel_bool dtprel
= dtprel_false
;
17510 if (targetm
.have_tls
)
17512 /* If this is not defined, we have no way to emit the
17514 if (!targetm
.asm_out
.output_dwarf_dtprel
)
17517 /* The way DW_OP_GNU_push_tls_address is specified, we
17518 can only look up addresses of objects in the current
17519 module. We used DW_OP_addr as first op, but that's
17520 wrong, because DW_OP_addr is relocated by the debug
17521 info consumer, while DW_OP_GNU_push_tls_address
17522 operand shouldn't be. */
17523 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
17525 dtprel
= dtprel_true
;
17526 /* We check for DWARF 5 here because gdb did not implement
17527 DW_OP_form_tls_address until after 7.12. */
17528 tls_op
= (dwarf_version
>= 5 ? DW_OP_form_tls_address
17529 : DW_OP_GNU_push_tls_address
);
17533 if (!targetm
.emutls
.debug_form_tls_address
17534 || !(dwarf_version
>= 3 || !dwarf_strict
))
17536 /* We stuffed the control variable into the DECL_VALUE_EXPR
17537 to signal (via DECL_HAS_VALUE_EXPR_P) that the decl should
17538 no longer appear in gimple code. We used the control
17539 variable in specific so that we could pick it up here. */
17540 loc
= DECL_VALUE_EXPR (loc
);
17541 tls_op
= DW_OP_form_tls_address
;
17544 rtl
= rtl_for_decl_location (loc
);
17545 if (rtl
== NULL_RTX
)
17550 rtl
= XEXP (rtl
, 0);
17551 if (! CONSTANT_P (rtl
))
17554 ret
= new_addr_loc_descr (rtl
, dtprel
);
17555 ret1
= new_loc_descr (tls_op
, 0, 0);
17556 add_loc_descr (&ret
, ret1
);
17564 if (context
!= NULL
&& context
->dpi
!= NULL
17565 && DECL_CONTEXT (loc
) == context
->dpi
->fndecl
)
17567 /* We are generating code for a DWARF procedure and we want to access
17568 one of its arguments: find the appropriate argument offset and let
17569 the resolve_args_picking pass compute the offset that complies
17570 with the stack frame size. */
17574 for (cursor
= DECL_ARGUMENTS (context
->dpi
->fndecl
);
17575 cursor
!= NULL_TREE
&& cursor
!= loc
;
17576 cursor
= TREE_CHAIN (cursor
), ++i
)
17578 /* If we are translating a DWARF procedure, all referenced parameters
17579 must belong to the current function. */
17580 gcc_assert (cursor
!= NULL_TREE
);
17582 ret
= new_loc_descr (DW_OP_pick
, i
, 0);
17583 ret
->frame_offset_rel
= 1;
17589 if (DECL_HAS_VALUE_EXPR_P (loc
))
17590 return loc_list_from_tree_1 (DECL_VALUE_EXPR (loc
),
17591 want_address
, context
);
17594 case FUNCTION_DECL
:
17597 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
17599 if (loc_list
&& loc_list
->first
)
17601 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
17602 have_address
= want_address
!= 0;
17605 rtl
= rtl_for_decl_location (loc
);
17606 if (rtl
== NULL_RTX
)
17608 if (TREE_CODE (loc
) != FUNCTION_DECL
17610 && current_function_decl
17611 && want_address
!= 1
17612 && ! DECL_IGNORED_P (loc
)
17613 && (INTEGRAL_TYPE_P (TREE_TYPE (loc
))
17614 || POINTER_TYPE_P (TREE_TYPE (loc
)))
17615 && DECL_CONTEXT (loc
) == current_function_decl
17616 && (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (TREE_TYPE (loc
)))
17617 <= DWARF2_ADDR_SIZE
))
17619 dw_die_ref ref
= lookup_decl_die (loc
);
17620 ret
= new_loc_descr (DW_OP_GNU_variable_value
, 0, 0);
17623 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
17624 ret
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
17625 ret
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
17629 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_decl_ref
;
17630 ret
->dw_loc_oprnd1
.v
.val_decl_ref
= loc
;
17634 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
17637 else if (CONST_INT_P (rtl
))
17639 HOST_WIDE_INT val
= INTVAL (rtl
);
17640 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
17641 val
&= GET_MODE_MASK (DECL_MODE (loc
));
17642 ret
= int_loc_descriptor (val
);
17644 else if (GET_CODE (rtl
) == CONST_STRING
)
17646 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
17649 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
17650 ret
= new_addr_loc_descr (rtl
, dtprel_false
);
17653 machine_mode mode
, mem_mode
;
17655 /* Certain constructs can only be represented at top-level. */
17656 if (want_address
== 2)
17658 ret
= loc_descriptor (rtl
, VOIDmode
,
17659 VAR_INIT_STATUS_INITIALIZED
);
17664 mode
= GET_MODE (rtl
);
17665 mem_mode
= VOIDmode
;
17669 mode
= get_address_mode (rtl
);
17670 rtl
= XEXP (rtl
, 0);
17673 ret
= mem_loc_descriptor (rtl
, mode
, mem_mode
,
17674 VAR_INIT_STATUS_INITIALIZED
);
17677 expansion_failed (loc
, rtl
,
17678 "failed to produce loc descriptor for rtl");
17684 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
17691 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
17695 case TARGET_MEM_REF
:
17697 case DEBUG_EXPR_DECL
:
17700 case COMPOUND_EXPR
:
17701 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), want_address
,
17705 case VIEW_CONVERT_EXPR
:
17708 case NON_LVALUE_EXPR
:
17709 return loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), want_address
,
17712 case COMPONENT_REF
:
17713 case BIT_FIELD_REF
:
17715 case ARRAY_RANGE_REF
:
17716 case REALPART_EXPR
:
17717 case IMAGPART_EXPR
:
17720 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
17722 int unsignedp
, reversep
, volatilep
= 0;
17724 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
17725 &unsignedp
, &reversep
, &volatilep
);
17727 gcc_assert (obj
!= loc
);
17729 list_ret
= loc_list_from_tree_1 (obj
,
17731 && !bitpos
&& !offset
? 2 : 1,
17733 /* TODO: We can extract value of the small expression via shifting even
17734 for nonzero bitpos. */
17737 if (bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
17739 expansion_failed (loc
, NULL_RTX
,
17740 "bitfield access");
17744 if (offset
!= NULL_TREE
)
17746 /* Variable offset. */
17747 list_ret1
= loc_list_from_tree_1 (offset
, 0, context
);
17748 if (list_ret1
== 0)
17750 add_loc_list (&list_ret
, list_ret1
);
17753 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
17756 bytepos
= bitpos
/ BITS_PER_UNIT
;
17758 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
17759 else if (bytepos
< 0)
17760 loc_list_plus_const (list_ret
, bytepos
);
17767 if ((want_address
|| !tree_fits_shwi_p (loc
))
17768 && (ret
= cst_pool_loc_descr (loc
)))
17770 else if (want_address
== 2
17771 && tree_fits_shwi_p (loc
)
17772 && (ret
= address_of_int_loc_descriptor
17773 (int_size_in_bytes (TREE_TYPE (loc
)),
17774 tree_to_shwi (loc
))))
17776 else if (tree_fits_shwi_p (loc
))
17777 ret
= int_loc_descriptor (tree_to_shwi (loc
));
17778 else if (tree_fits_uhwi_p (loc
))
17779 ret
= uint_loc_descriptor (tree_to_uhwi (loc
));
17782 expansion_failed (loc
, NULL_RTX
,
17783 "Integer operand is not host integer");
17792 if ((ret
= cst_pool_loc_descr (loc
)))
17794 else if (TREE_CODE (loc
) == CONSTRUCTOR
)
17796 tree type
= TREE_TYPE (loc
);
17797 unsigned HOST_WIDE_INT size
= int_size_in_bytes (type
);
17798 unsigned HOST_WIDE_INT offset
= 0;
17799 unsigned HOST_WIDE_INT cnt
;
17800 constructor_elt
*ce
;
17802 if (TREE_CODE (type
) == RECORD_TYPE
)
17804 /* This is very limited, but it's enough to output
17805 pointers to member functions, as long as the
17806 referenced function is defined in the current
17807 translation unit. */
17808 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (loc
), cnt
, ce
)
17810 tree val
= ce
->value
;
17812 tree field
= ce
->index
;
17817 if (!field
|| DECL_BIT_FIELD (field
))
17819 expansion_failed (loc
, NULL_RTX
,
17820 "bitfield in record type constructor");
17821 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
17826 HOST_WIDE_INT fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
17827 unsigned HOST_WIDE_INT pos
= int_byte_position (field
);
17828 gcc_assert (pos
+ fieldsize
<= size
);
17831 expansion_failed (loc
, NULL_RTX
,
17832 "out-of-order fields in record constructor");
17833 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
17839 ret1
= new_loc_descr (DW_OP_piece
, pos
- offset
, 0);
17840 add_loc_descr (&ret
, ret1
);
17843 if (val
&& fieldsize
!= 0)
17845 ret1
= loc_descriptor_from_tree (val
, want_address
, context
);
17848 expansion_failed (loc
, NULL_RTX
,
17849 "unsupported expression in field");
17850 size
= offset
= (unsigned HOST_WIDE_INT
)-1;
17854 add_loc_descr (&ret
, ret1
);
17858 ret1
= new_loc_descr (DW_OP_piece
, fieldsize
, 0);
17859 add_loc_descr (&ret
, ret1
);
17860 offset
= pos
+ fieldsize
;
17864 if (offset
!= size
)
17866 ret1
= new_loc_descr (DW_OP_piece
, size
- offset
, 0);
17867 add_loc_descr (&ret
, ret1
);
17871 have_address
= !!want_address
;
17874 expansion_failed (loc
, NULL_RTX
,
17875 "constructor of non-record type");
17878 /* We can construct small constants here using int_loc_descriptor. */
17879 expansion_failed (loc
, NULL_RTX
,
17880 "constructor or constant not in constant pool");
17883 case TRUTH_AND_EXPR
:
17884 case TRUTH_ANDIF_EXPR
:
17889 case TRUTH_XOR_EXPR
:
17894 case TRUTH_OR_EXPR
:
17895 case TRUTH_ORIF_EXPR
:
17900 case FLOOR_DIV_EXPR
:
17901 case CEIL_DIV_EXPR
:
17902 case ROUND_DIV_EXPR
:
17903 case TRUNC_DIV_EXPR
:
17904 case EXACT_DIV_EXPR
:
17905 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
17914 case FLOOR_MOD_EXPR
:
17915 case CEIL_MOD_EXPR
:
17916 case ROUND_MOD_EXPR
:
17917 case TRUNC_MOD_EXPR
:
17918 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
17923 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
17924 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
17925 if (list_ret
== 0 || list_ret1
== 0)
17928 add_loc_list (&list_ret
, list_ret1
);
17931 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
17932 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
17933 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
17934 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
17935 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
17947 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
17950 case POINTER_PLUS_EXPR
:
17953 if (tree_fits_shwi_p (TREE_OPERAND (loc
, 1)))
17955 /* Big unsigned numbers can fit in HOST_WIDE_INT but it may be
17956 smarter to encode their opposite. The DW_OP_plus_uconst operation
17957 takes 1 + X bytes, X being the size of the ULEB128 addend. On the
17958 other hand, a "<push literal>; DW_OP_minus" pattern takes 1 + Y
17959 bytes, Y being the size of the operation that pushes the opposite
17960 of the addend. So let's choose the smallest representation. */
17961 const tree tree_addend
= TREE_OPERAND (loc
, 1);
17962 offset_int wi_addend
;
17963 HOST_WIDE_INT shwi_addend
;
17964 dw_loc_descr_ref loc_naddend
;
17966 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
17970 /* Try to get the literal to push. It is the opposite of the addend,
17971 so as we rely on wrapping during DWARF evaluation, first decode
17972 the literal as a "DWARF-sized" signed number. */
17973 wi_addend
= wi::to_offset (tree_addend
);
17974 wi_addend
= wi::sext (wi_addend
, DWARF2_ADDR_SIZE
* 8);
17975 shwi_addend
= wi_addend
.to_shwi ();
17976 loc_naddend
= (shwi_addend
!= INTTYPE_MINIMUM (HOST_WIDE_INT
))
17977 ? int_loc_descriptor (-shwi_addend
)
17980 if (loc_naddend
!= NULL
17981 && ((unsigned) size_of_uleb128 (shwi_addend
)
17982 > size_of_loc_descr (loc_naddend
)))
17984 add_loc_descr_to_each (list_ret
, loc_naddend
);
17985 add_loc_descr_to_each (list_ret
,
17986 new_loc_descr (DW_OP_minus
, 0, 0));
17990 for (dw_loc_descr_ref loc_cur
= loc_naddend
; loc_cur
!= NULL
; )
17992 loc_naddend
= loc_cur
;
17993 loc_cur
= loc_cur
->dw_loc_next
;
17994 ggc_free (loc_naddend
);
17996 loc_list_plus_const (list_ret
, wi_addend
.to_shwi ());
18006 goto do_comp_binop
;
18010 goto do_comp_binop
;
18014 goto do_comp_binop
;
18018 goto do_comp_binop
;
18021 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
18023 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0, context
);
18024 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
18025 list_ret
= loc_list_from_uint_comparison (list_ret
, list_ret1
,
18041 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18042 list_ret1
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 1), 0, context
);
18043 if (list_ret
== 0 || list_ret1
== 0)
18046 add_loc_list (&list_ret
, list_ret1
);
18049 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
18052 case TRUTH_NOT_EXPR
:
18066 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18070 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
18076 const enum tree_code code
=
18077 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
18079 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
18080 build2 (code
, integer_type_node
,
18081 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
18082 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
18089 dw_loc_descr_ref lhs
18090 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0, context
);
18091 dw_loc_list_ref rhs
18092 = loc_list_from_tree_1 (TREE_OPERAND (loc
, 2), 0, context
);
18093 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
18095 list_ret
= loc_list_from_tree_1 (TREE_OPERAND (loc
, 0), 0, context
);
18096 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
18099 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
18100 add_loc_descr_to_each (list_ret
, bra_node
);
18102 add_loc_list (&list_ret
, rhs
);
18103 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
18104 add_loc_descr_to_each (list_ret
, jump_node
);
18106 add_loc_descr_to_each (list_ret
, lhs
);
18107 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
18108 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
18110 /* ??? Need a node to point the skip at. Use a nop. */
18111 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
18112 add_loc_descr_to_each (list_ret
, tmp
);
18113 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
18114 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
18118 case FIX_TRUNC_EXPR
:
18122 /* Leave front-end specific codes as simply unknown. This comes
18123 up, for instance, with the C STMT_EXPR. */
18124 if ((unsigned int) TREE_CODE (loc
)
18125 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
18127 expansion_failed (loc
, NULL_RTX
,
18128 "language specific tree node");
18132 /* Otherwise this is a generic code; we should just lists all of
18133 these explicitly. We forgot one. */
18135 gcc_unreachable ();
18137 /* In a release build, we want to degrade gracefully: better to
18138 generate incomplete debugging information than to crash. */
18142 if (!ret
&& !list_ret
)
18145 if (want_address
== 2 && !have_address
18146 && (dwarf_version
>= 4 || !dwarf_strict
))
18148 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
18150 expansion_failed (loc
, NULL_RTX
,
18151 "DWARF address size mismatch");
18155 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
18157 add_loc_descr_to_each (list_ret
,
18158 new_loc_descr (DW_OP_stack_value
, 0, 0));
18161 /* Show if we can't fill the request for an address. */
18162 if (want_address
&& !have_address
)
18164 expansion_failed (loc
, NULL_RTX
,
18165 "Want address and only have value");
18169 gcc_assert (!ret
|| !list_ret
);
18171 /* If we've got an address and don't want one, dereference. */
18172 if (!want_address
&& have_address
)
18174 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
18176 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
18178 expansion_failed (loc
, NULL_RTX
,
18179 "DWARF address size mismatch");
18182 else if (size
== DWARF2_ADDR_SIZE
)
18185 op
= DW_OP_deref_size
;
18188 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
18190 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
18193 list_ret
= new_loc_list (ret
, NULL
, NULL
, NULL
);
18198 /* Likewise, but strip useless DW_OP_nop operations in the resulting
18201 static dw_loc_list_ref
18202 loc_list_from_tree (tree loc
, int want_address
,
18203 struct loc_descr_context
*context
)
18205 dw_loc_list_ref result
= loc_list_from_tree_1 (loc
, want_address
, context
);
18207 for (dw_loc_list_ref loc_cur
= result
;
18208 loc_cur
!= NULL
; loc_cur
= loc_cur
->dw_loc_next
)
18209 loc_descr_without_nops (loc_cur
->expr
);
18213 /* Same as above but return only single location expression. */
18214 static dw_loc_descr_ref
18215 loc_descriptor_from_tree (tree loc
, int want_address
,
18216 struct loc_descr_context
*context
)
18218 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
, context
);
18221 if (ret
->dw_loc_next
)
18223 expansion_failed (loc
, NULL_RTX
,
18224 "Location list where only loc descriptor needed");
18230 /* Given a value, round it up to the lowest multiple of `boundary'
18231 which is not less than the value itself. */
18233 static inline HOST_WIDE_INT
18234 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
18236 return (((value
+ boundary
- 1) / boundary
) * boundary
);
18239 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
18240 pointer to the declared type for the relevant field variable, or return
18241 `integer_type_node' if the given node turns out to be an
18242 ERROR_MARK node. */
18245 field_type (const_tree decl
)
18249 if (TREE_CODE (decl
) == ERROR_MARK
)
18250 return integer_type_node
;
18252 type
= DECL_BIT_FIELD_TYPE (decl
);
18253 if (type
== NULL_TREE
)
18254 type
= TREE_TYPE (decl
);
18259 /* Given a pointer to a tree node, return the alignment in bits for
18260 it, or else return BITS_PER_WORD if the node actually turns out to
18261 be an ERROR_MARK node. */
18263 static inline unsigned
18264 simple_type_align_in_bits (const_tree type
)
18266 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
18269 static inline unsigned
18270 simple_decl_align_in_bits (const_tree decl
)
18272 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
18275 /* Return the result of rounding T up to ALIGN. */
18277 static inline offset_int
18278 round_up_to_align (const offset_int
&t
, unsigned int align
)
18280 return wi::udiv_trunc (t
+ align
- 1, align
) * align
;
18283 /* Compute the size of TYPE in bytes. If possible, return NULL and store the
18284 size as an integer constant in CST_SIZE. Otherwise, if possible, return a
18285 DWARF expression that computes the size. Return NULL and set CST_SIZE to -1
18286 if we fail to return the size in one of these two forms. */
18288 static dw_loc_descr_ref
18289 type_byte_size (const_tree type
, HOST_WIDE_INT
*cst_size
)
18292 struct loc_descr_context ctx
;
18294 /* Return a constant integer in priority, if possible. */
18295 *cst_size
= int_size_in_bytes (type
);
18296 if (*cst_size
!= -1)
18299 ctx
.context_type
= const_cast<tree
> (type
);
18300 ctx
.base_decl
= NULL_TREE
;
18302 ctx
.placeholder_arg
= false;
18303 ctx
.placeholder_seen
= false;
18305 type
= TYPE_MAIN_VARIANT (type
);
18306 tree_size
= TYPE_SIZE_UNIT (type
);
18307 return ((tree_size
!= NULL_TREE
)
18308 ? loc_descriptor_from_tree (tree_size
, 0, &ctx
)
18312 /* Helper structure for RECORD_TYPE processing. */
18315 /* Root RECORD_TYPE. It is needed to generate data member location
18316 descriptions in variable-length records (VLR), but also to cope with
18317 variants, which are composed of nested structures multiplexed with
18318 QUAL_UNION_TYPE nodes. Each time such a structure is passed to a
18319 function processing a FIELD_DECL, it is required to be non null. */
18321 /* When generating a variant part in a RECORD_TYPE (i.e. a nested
18322 QUAL_UNION_TYPE), this holds an expression that computes the offset for
18323 this variant part as part of the root record (in storage units). For
18324 regular records, it must be NULL_TREE. */
18325 tree variant_part_offset
;
18328 /* Given a pointer to a FIELD_DECL, compute the byte offset of the lowest
18329 addressed byte of the "containing object" for the given FIELD_DECL. If
18330 possible, return a native constant through CST_OFFSET (in which case NULL is
18331 returned); otherwise return a DWARF expression that computes the offset.
18333 Set *CST_OFFSET to 0 and return NULL if we are unable to determine what
18334 that offset is, either because the argument turns out to be a pointer to an
18335 ERROR_MARK node, or because the offset expression is too complex for us.
18337 CTX is required: see the comment for VLR_CONTEXT. */
18339 static dw_loc_descr_ref
18340 field_byte_offset (const_tree decl
, struct vlr_context
*ctx
,
18341 HOST_WIDE_INT
*cst_offset
)
18344 dw_loc_list_ref loc_result
;
18348 if (TREE_CODE (decl
) == ERROR_MARK
)
18351 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
18353 /* We cannot handle variable bit offsets at the moment, so abort if it's the
18355 if (TREE_CODE (DECL_FIELD_BIT_OFFSET (decl
)) != INTEGER_CST
)
18358 #ifdef PCC_BITFIELD_TYPE_MATTERS
18359 /* We used to handle only constant offsets in all cases. Now, we handle
18360 properly dynamic byte offsets only when PCC bitfield type doesn't
18362 if (PCC_BITFIELD_TYPE_MATTERS
18363 && TREE_CODE (DECL_FIELD_OFFSET (decl
)) == INTEGER_CST
)
18365 offset_int object_offset_in_bits
;
18366 offset_int object_offset_in_bytes
;
18367 offset_int bitpos_int
;
18369 tree field_size_tree
;
18370 offset_int deepest_bitpos
;
18371 offset_int field_size_in_bits
;
18372 unsigned int type_align_in_bits
;
18373 unsigned int decl_align_in_bits
;
18374 offset_int type_size_in_bits
;
18376 bitpos_int
= wi::to_offset (bit_position (decl
));
18377 type
= field_type (decl
);
18378 type_size_in_bits
= offset_int_type_size_in_bits (type
);
18379 type_align_in_bits
= simple_type_align_in_bits (type
);
18381 field_size_tree
= DECL_SIZE (decl
);
18383 /* The size could be unspecified if there was an error, or for
18384 a flexible array member. */
18385 if (!field_size_tree
)
18386 field_size_tree
= bitsize_zero_node
;
18388 /* If the size of the field is not constant, use the type size. */
18389 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
18390 field_size_in_bits
= wi::to_offset (field_size_tree
);
18392 field_size_in_bits
= type_size_in_bits
;
18394 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
18396 /* The GCC front-end doesn't make any attempt to keep track of the
18397 starting bit offset (relative to the start of the containing
18398 structure type) of the hypothetical "containing object" for a
18399 bit-field. Thus, when computing the byte offset value for the
18400 start of the "containing object" of a bit-field, we must deduce
18401 this information on our own. This can be rather tricky to do in
18402 some cases. For example, handling the following structure type
18403 definition when compiling for an i386/i486 target (which only
18404 aligns long long's to 32-bit boundaries) can be very tricky:
18406 struct S { int field1; long long field2:31; };
18408 Fortunately, there is a simple rule-of-thumb which can be used
18409 in such cases. When compiling for an i386/i486, GCC will
18410 allocate 8 bytes for the structure shown above. It decides to
18411 do this based upon one simple rule for bit-field allocation.
18412 GCC allocates each "containing object" for each bit-field at
18413 the first (i.e. lowest addressed) legitimate alignment boundary
18414 (based upon the required minimum alignment for the declared
18415 type of the field) which it can possibly use, subject to the
18416 condition that there is still enough available space remaining
18417 in the containing object (when allocated at the selected point)
18418 to fully accommodate all of the bits of the bit-field itself.
18420 This simple rule makes it obvious why GCC allocates 8 bytes for
18421 each object of the structure type shown above. When looking
18422 for a place to allocate the "containing object" for `field2',
18423 the compiler simply tries to allocate a 64-bit "containing
18424 object" at each successive 32-bit boundary (starting at zero)
18425 until it finds a place to allocate that 64- bit field such that
18426 at least 31 contiguous (and previously unallocated) bits remain
18427 within that selected 64 bit field. (As it turns out, for the
18428 example above, the compiler finds it is OK to allocate the
18429 "containing object" 64-bit field at bit-offset zero within the
18432 Here we attempt to work backwards from the limited set of facts
18433 we're given, and we try to deduce from those facts, where GCC
18434 must have believed that the containing object started (within
18435 the structure type). The value we deduce is then used (by the
18436 callers of this routine) to generate DW_AT_location and
18437 DW_AT_bit_offset attributes for fields (both bit-fields and, in
18438 the case of DW_AT_location, regular fields as well). */
18440 /* Figure out the bit-distance from the start of the structure to
18441 the "deepest" bit of the bit-field. */
18442 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
18444 /* This is the tricky part. Use some fancy footwork to deduce
18445 where the lowest addressed bit of the containing object must
18447 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
18449 /* Round up to type_align by default. This works best for
18451 object_offset_in_bits
18452 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
18454 if (wi::gtu_p (object_offset_in_bits
, bitpos_int
))
18456 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
18458 /* Round up to decl_align instead. */
18459 object_offset_in_bits
18460 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
18463 object_offset_in_bytes
18464 = wi::lrshift (object_offset_in_bits
, LOG2_BITS_PER_UNIT
);
18465 if (ctx
->variant_part_offset
== NULL_TREE
)
18467 *cst_offset
= object_offset_in_bytes
.to_shwi ();
18470 tree_result
= wide_int_to_tree (sizetype
, object_offset_in_bytes
);
18473 #endif /* PCC_BITFIELD_TYPE_MATTERS */
18474 tree_result
= byte_position (decl
);
18476 if (ctx
->variant_part_offset
!= NULL_TREE
)
18477 tree_result
= fold_build2 (PLUS_EXPR
, TREE_TYPE (tree_result
),
18478 ctx
->variant_part_offset
, tree_result
);
18480 /* If the byte offset is a constant, it's simplier to handle a native
18481 constant rather than a DWARF expression. */
18482 if (TREE_CODE (tree_result
) == INTEGER_CST
)
18484 *cst_offset
= wi::to_offset (tree_result
).to_shwi ();
18487 struct loc_descr_context loc_ctx
= {
18488 ctx
->struct_type
, /* context_type */
18489 NULL_TREE
, /* base_decl */
18491 false, /* placeholder_arg */
18492 false /* placeholder_seen */
18494 loc_result
= loc_list_from_tree (tree_result
, 0, &loc_ctx
);
18496 /* We want a DWARF expression: abort if we only have a location list with
18497 multiple elements. */
18498 if (!loc_result
|| !single_element_loc_list_p (loc_result
))
18501 return loc_result
->expr
;
18504 /* The following routines define various Dwarf attributes and any data
18505 associated with them. */
18507 /* Add a location description attribute value to a DIE.
18509 This emits location attributes suitable for whole variables and
18510 whole parameters. Note that the location attributes for struct fields are
18511 generated by the routine `data_member_location_attribute' below. */
18514 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
18515 dw_loc_list_ref descr
)
18519 if (single_element_loc_list_p (descr
))
18520 add_AT_loc (die
, attr_kind
, descr
->expr
);
18522 add_AT_loc_list (die
, attr_kind
, descr
);
18525 /* Add DW_AT_accessibility attribute to DIE if needed. */
18528 add_accessibility_attribute (dw_die_ref die
, tree decl
)
18530 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
18531 children, otherwise the default is DW_ACCESS_public. In DWARF2
18532 the default has always been DW_ACCESS_public. */
18533 if (TREE_PROTECTED (decl
))
18534 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
18535 else if (TREE_PRIVATE (decl
))
18537 if (dwarf_version
== 2
18538 || die
->die_parent
== NULL
18539 || die
->die_parent
->die_tag
!= DW_TAG_class_type
)
18540 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
18542 else if (dwarf_version
> 2
18544 && die
->die_parent
->die_tag
== DW_TAG_class_type
)
18545 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
18548 /* Attach the specialized form of location attribute used for data members of
18549 struct and union types. In the special case of a FIELD_DECL node which
18550 represents a bit-field, the "offset" part of this special location
18551 descriptor must indicate the distance in bytes from the lowest-addressed
18552 byte of the containing struct or union type to the lowest-addressed byte of
18553 the "containing object" for the bit-field. (See the `field_byte_offset'
18556 For any given bit-field, the "containing object" is a hypothetical object
18557 (of some integral or enum type) within which the given bit-field lives. The
18558 type of this hypothetical "containing object" is always the same as the
18559 declared type of the individual bit-field itself (for GCC anyway... the
18560 DWARF spec doesn't actually mandate this). Note that it is the size (in
18561 bytes) of the hypothetical "containing object" which will be given in the
18562 DW_AT_byte_size attribute for this bit-field. (See the
18563 `byte_size_attribute' function below.) It is also used when calculating the
18564 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
18567 CTX is required: see the comment for VLR_CONTEXT. */
18570 add_data_member_location_attribute (dw_die_ref die
,
18572 struct vlr_context
*ctx
)
18574 HOST_WIDE_INT offset
;
18575 dw_loc_descr_ref loc_descr
= 0;
18577 if (TREE_CODE (decl
) == TREE_BINFO
)
18579 /* We're working on the TAG_inheritance for a base class. */
18580 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
18582 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
18583 aren't at a fixed offset from all (sub)objects of the same
18584 type. We need to extract the appropriate offset from our
18585 vtable. The following dwarf expression means
18587 BaseAddr = ObAddr + *((*ObAddr) - Offset)
18589 This is specific to the V3 ABI, of course. */
18591 dw_loc_descr_ref tmp
;
18593 /* Make a copy of the object address. */
18594 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
18595 add_loc_descr (&loc_descr
, tmp
);
18597 /* Extract the vtable address. */
18598 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
18599 add_loc_descr (&loc_descr
, tmp
);
18601 /* Calculate the address of the offset. */
18602 offset
= tree_to_shwi (BINFO_VPTR_FIELD (decl
));
18603 gcc_assert (offset
< 0);
18605 tmp
= int_loc_descriptor (-offset
);
18606 add_loc_descr (&loc_descr
, tmp
);
18607 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
18608 add_loc_descr (&loc_descr
, tmp
);
18610 /* Extract the offset. */
18611 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
18612 add_loc_descr (&loc_descr
, tmp
);
18614 /* Add it to the object address. */
18615 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
18616 add_loc_descr (&loc_descr
, tmp
);
18619 offset
= tree_to_shwi (BINFO_OFFSET (decl
));
18623 loc_descr
= field_byte_offset (decl
, ctx
, &offset
);
18625 /* If loc_descr is available then we know the field offset is dynamic.
18626 However, GDB does not handle dynamic field offsets very well at the
18628 if (loc_descr
!= NULL
&& gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
)
18634 /* Data member location evalutation starts with the base address on the
18635 stack. Compute the field offset and add it to this base address. */
18636 else if (loc_descr
!= NULL
)
18637 add_loc_descr (&loc_descr
, new_loc_descr (DW_OP_plus
, 0, 0));
18642 /* While DW_AT_data_bit_offset has been added already in DWARF4,
18643 e.g. GDB only added support to it in November 2016. For DWARF5
18644 we need newer debug info consumers anyway. We might change this
18645 to dwarf_version >= 4 once most consumers catched up. */
18646 if (dwarf_version
>= 5
18647 && TREE_CODE (decl
) == FIELD_DECL
18648 && DECL_BIT_FIELD_TYPE (decl
))
18650 tree off
= bit_position (decl
);
18651 if (tree_fits_uhwi_p (off
) && get_AT (die
, DW_AT_bit_size
))
18653 remove_AT (die
, DW_AT_byte_size
);
18654 remove_AT (die
, DW_AT_bit_offset
);
18655 add_AT_unsigned (die
, DW_AT_data_bit_offset
, tree_to_uhwi (off
));
18659 if (dwarf_version
> 2)
18661 /* Don't need to output a location expression, just the constant. */
18663 add_AT_int (die
, DW_AT_data_member_location
, offset
);
18665 add_AT_unsigned (die
, DW_AT_data_member_location
, offset
);
18670 enum dwarf_location_atom op
;
18672 /* The DWARF2 standard says that we should assume that the structure
18673 address is already on the stack, so we can specify a structure
18674 field address by using DW_OP_plus_uconst. */
18675 op
= DW_OP_plus_uconst
;
18676 loc_descr
= new_loc_descr (op
, offset
, 0);
18680 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
18683 /* Writes integer values to dw_vec_const array. */
18686 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
18690 *dest
++ = val
& 0xff;
18696 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
18698 static HOST_WIDE_INT
18699 extract_int (const unsigned char *src
, unsigned int size
)
18701 HOST_WIDE_INT val
= 0;
18707 val
|= *--src
& 0xff;
18713 /* Writes wide_int values to dw_vec_const array. */
18716 insert_wide_int (const wide_int
&val
, unsigned char *dest
, int elt_size
)
18720 if (elt_size
<= HOST_BITS_PER_WIDE_INT
/BITS_PER_UNIT
)
18722 insert_int ((HOST_WIDE_INT
) val
.elt (0), elt_size
, dest
);
18726 /* We'd have to extend this code to support odd sizes. */
18727 gcc_assert (elt_size
% (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
) == 0);
18729 int n
= elt_size
/ (HOST_BITS_PER_WIDE_INT
/ BITS_PER_UNIT
);
18731 if (WORDS_BIG_ENDIAN
)
18732 for (i
= n
- 1; i
>= 0; i
--)
18734 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
18735 dest
+= sizeof (HOST_WIDE_INT
);
18738 for (i
= 0; i
< n
; i
++)
18740 insert_int ((HOST_WIDE_INT
) val
.elt (i
), sizeof (HOST_WIDE_INT
), dest
);
18741 dest
+= sizeof (HOST_WIDE_INT
);
18745 /* Writes floating point values to dw_vec_const array. */
18748 insert_float (const_rtx rtl
, unsigned char *array
)
18752 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
18754 real_to_target (val
, CONST_DOUBLE_REAL_VALUE (rtl
), mode
);
18756 /* real_to_target puts 32-bit pieces in each long. Pack them. */
18757 for (i
= 0; i
< GET_MODE_SIZE (mode
) / 4; i
++)
18759 insert_int (val
[i
], 4, array
);
18764 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
18765 does not have a "location" either in memory or in a register. These
18766 things can arise in GNU C when a constant is passed as an actual parameter
18767 to an inlined function. They can also arise in C++ where declared
18768 constants do not necessarily get memory "homes". */
18771 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
18773 switch (GET_CODE (rtl
))
18777 HOST_WIDE_INT val
= INTVAL (rtl
);
18780 add_AT_int (die
, DW_AT_const_value
, val
);
18782 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
18786 case CONST_WIDE_INT
:
18788 wide_int w1
= rtx_mode_t (rtl
, MAX_MODE_INT
);
18789 unsigned int prec
= MIN (wi::min_precision (w1
, UNSIGNED
),
18790 (unsigned int)CONST_WIDE_INT_NUNITS (rtl
) * HOST_BITS_PER_WIDE_INT
);
18791 wide_int w
= wi::zext (w1
, prec
);
18792 add_AT_wide (die
, DW_AT_const_value
, w
);
18797 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
18798 floating-point constant. A CONST_DOUBLE is used whenever the
18799 constant requires more than one word in order to be adequately
18801 if (TARGET_SUPPORTS_WIDE_INT
== 0
18802 && !SCALAR_FLOAT_MODE_P (GET_MODE (rtl
)))
18803 add_AT_double (die
, DW_AT_const_value
,
18804 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
18807 scalar_float_mode mode
= as_a
<scalar_float_mode
> (GET_MODE (rtl
));
18808 unsigned int length
= GET_MODE_SIZE (mode
);
18809 unsigned char *array
= ggc_vec_alloc
<unsigned char> (length
);
18811 insert_float (rtl
, array
);
18812 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
18818 machine_mode mode
= GET_MODE (rtl
);
18819 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
18820 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
18821 unsigned char *array
18822 = ggc_vec_alloc
<unsigned char> (length
* elt_size
);
18825 machine_mode imode
= GET_MODE_INNER (mode
);
18827 switch (GET_MODE_CLASS (mode
))
18829 case MODE_VECTOR_INT
:
18830 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
18832 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
18833 insert_wide_int (rtx_mode_t (elt
, imode
), p
, elt_size
);
18837 case MODE_VECTOR_FLOAT
:
18838 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
18840 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
18841 insert_float (elt
, p
);
18846 gcc_unreachable ();
18849 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
18854 if (dwarf_version
>= 4 || !dwarf_strict
)
18856 dw_loc_descr_ref loc_result
;
18857 resolve_one_addr (&rtl
);
18859 loc_result
= new_addr_loc_descr (rtl
, dtprel_false
);
18860 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
18861 add_AT_loc (die
, DW_AT_location
, loc_result
);
18862 vec_safe_push (used_rtx_array
, rtl
);
18868 if (CONSTANT_P (XEXP (rtl
, 0)))
18869 return add_const_value_attribute (die
, XEXP (rtl
, 0));
18872 if (!const_ok_for_output (rtl
))
18876 if (dwarf_version
>= 4 || !dwarf_strict
)
18881 /* In cases where an inlined instance of an inline function is passed
18882 the address of an `auto' variable (which is local to the caller) we
18883 can get a situation where the DECL_RTL of the artificial local
18884 variable (for the inlining) which acts as a stand-in for the
18885 corresponding formal parameter (of the inline function) will look
18886 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
18887 exactly a compile-time constant expression, but it isn't the address
18888 of the (artificial) local variable either. Rather, it represents the
18889 *value* which the artificial local variable always has during its
18890 lifetime. We currently have no way to represent such quasi-constant
18891 values in Dwarf, so for now we just punt and generate nothing. */
18899 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
18900 && MEM_READONLY_P (rtl
)
18901 && GET_MODE (rtl
) == BLKmode
)
18903 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
18909 /* No other kinds of rtx should be possible here. */
18910 gcc_unreachable ();
18915 /* Determine whether the evaluation of EXPR references any variables
18916 or functions which aren't otherwise used (and therefore may not be
18919 reference_to_unused (tree
* tp
, int * walk_subtrees
,
18920 void * data ATTRIBUTE_UNUSED
)
18922 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
18923 *walk_subtrees
= 0;
18925 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
18926 && ! TREE_ASM_WRITTEN (*tp
))
18928 /* ??? The C++ FE emits debug information for using decls, so
18929 putting gcc_unreachable here falls over. See PR31899. For now
18930 be conservative. */
18931 else if (!symtab
->global_info_ready
&& VAR_OR_FUNCTION_DECL_P (*tp
))
18933 else if (VAR_P (*tp
))
18935 varpool_node
*node
= varpool_node::get (*tp
);
18936 if (!node
|| !node
->definition
)
18939 else if (TREE_CODE (*tp
) == FUNCTION_DECL
18940 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
18942 /* The call graph machinery must have finished analyzing,
18943 optimizing and gimplifying the CU by now.
18944 So if *TP has no call graph node associated
18945 to it, it means *TP will not be emitted. */
18946 if (!cgraph_node::get (*tp
))
18949 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
18955 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
18956 for use in a later add_const_value_attribute call. */
18959 rtl_for_decl_init (tree init
, tree type
)
18961 rtx rtl
= NULL_RTX
;
18965 /* If a variable is initialized with a string constant without embedded
18966 zeros, build CONST_STRING. */
18967 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
18969 tree enttype
= TREE_TYPE (type
);
18970 tree domain
= TYPE_DOMAIN (type
);
18971 scalar_int_mode mode
;
18973 if (is_int_mode (TYPE_MODE (enttype
), &mode
)
18974 && GET_MODE_SIZE (mode
) == 1
18976 && integer_zerop (TYPE_MIN_VALUE (domain
))
18977 && compare_tree_int (TYPE_MAX_VALUE (domain
),
18978 TREE_STRING_LENGTH (init
) - 1) == 0
18979 && ((size_t) TREE_STRING_LENGTH (init
)
18980 == strlen (TREE_STRING_POINTER (init
)) + 1))
18982 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
18983 ggc_strdup (TREE_STRING_POINTER (init
)));
18984 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
18985 MEM_READONLY_P (rtl
) = 1;
18988 /* Other aggregates, and complex values, could be represented using
18990 else if (AGGREGATE_TYPE_P (type
)
18991 || (TREE_CODE (init
) == VIEW_CONVERT_EXPR
18992 && AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (init
, 0))))
18993 || TREE_CODE (type
) == COMPLEX_TYPE
)
18995 /* Vectors only work if their mode is supported by the target.
18996 FIXME: generic vectors ought to work too. */
18997 else if (TREE_CODE (type
) == VECTOR_TYPE
18998 && !VECTOR_MODE_P (TYPE_MODE (type
)))
19000 /* If the initializer is something that we know will expand into an
19001 immediate RTL constant, expand it now. We must be careful not to
19002 reference variables which won't be output. */
19003 else if (initializer_constant_valid_p (init
, type
)
19004 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
19006 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
19008 if (TREE_CODE (type
) == VECTOR_TYPE
)
19009 switch (TREE_CODE (init
))
19014 if (TREE_CONSTANT (init
))
19016 vec
<constructor_elt
, va_gc
> *elts
= CONSTRUCTOR_ELTS (init
);
19017 bool constant_p
= true;
19019 unsigned HOST_WIDE_INT ix
;
19021 /* Even when ctor is constant, it might contain non-*_CST
19022 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
19023 belong into VECTOR_CST nodes. */
19024 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
19025 if (!CONSTANT_CLASS_P (value
))
19027 constant_p
= false;
19033 init
= build_vector_from_ctor (type
, elts
);
19043 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
19045 /* If expand_expr returns a MEM, it wasn't immediate. */
19046 gcc_assert (!rtl
|| !MEM_P (rtl
));
19052 /* Generate RTL for the variable DECL to represent its location. */
19055 rtl_for_decl_location (tree decl
)
19059 /* Here we have to decide where we are going to say the parameter "lives"
19060 (as far as the debugger is concerned). We only have a couple of
19061 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
19063 DECL_RTL normally indicates where the parameter lives during most of the
19064 activation of the function. If optimization is enabled however, this
19065 could be either NULL or else a pseudo-reg. Both of those cases indicate
19066 that the parameter doesn't really live anywhere (as far as the code
19067 generation parts of GCC are concerned) during most of the function's
19068 activation. That will happen (for example) if the parameter is never
19069 referenced within the function.
19071 We could just generate a location descriptor here for all non-NULL
19072 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
19073 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
19074 where DECL_RTL is NULL or is a pseudo-reg.
19076 Note however that we can only get away with using DECL_INCOMING_RTL as
19077 a backup substitute for DECL_RTL in certain limited cases. In cases
19078 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
19079 we can be sure that the parameter was passed using the same type as it is
19080 declared to have within the function, and that its DECL_INCOMING_RTL
19081 points us to a place where a value of that type is passed.
19083 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
19084 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
19085 because in these cases DECL_INCOMING_RTL points us to a value of some
19086 type which is *different* from the type of the parameter itself. Thus,
19087 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
19088 such cases, the debugger would end up (for example) trying to fetch a
19089 `float' from a place which actually contains the first part of a
19090 `double'. That would lead to really incorrect and confusing
19091 output at debug-time.
19093 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
19094 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
19095 are a couple of exceptions however. On little-endian machines we can
19096 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
19097 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
19098 an integral type that is smaller than TREE_TYPE (decl). These cases arise
19099 when (on a little-endian machine) a non-prototyped function has a
19100 parameter declared to be of type `short' or `char'. In such cases,
19101 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
19102 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
19103 passed `int' value. If the debugger then uses that address to fetch
19104 a `short' or a `char' (on a little-endian machine) the result will be
19105 the correct data, so we allow for such exceptional cases below.
19107 Note that our goal here is to describe the place where the given formal
19108 parameter lives during most of the function's activation (i.e. between the
19109 end of the prologue and the start of the epilogue). We'll do that as best
19110 as we can. Note however that if the given formal parameter is modified
19111 sometime during the execution of the function, then a stack backtrace (at
19112 debug-time) will show the function as having been called with the *new*
19113 value rather than the value which was originally passed in. This happens
19114 rarely enough that it is not a major problem, but it *is* a problem, and
19115 I'd like to fix it.
19117 A future version of dwarf2out.c may generate two additional attributes for
19118 any given DW_TAG_formal_parameter DIE which will describe the "passed
19119 type" and the "passed location" for the given formal parameter in addition
19120 to the attributes we now generate to indicate the "declared type" and the
19121 "active location" for each parameter. This additional set of attributes
19122 could be used by debuggers for stack backtraces. Separately, note that
19123 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
19124 This happens (for example) for inlined-instances of inline function formal
19125 parameters which are never referenced. This really shouldn't be
19126 happening. All PARM_DECL nodes should get valid non-NULL
19127 DECL_INCOMING_RTL values. FIXME. */
19129 /* Use DECL_RTL as the "location" unless we find something better. */
19130 rtl
= DECL_RTL_IF_SET (decl
);
19132 /* When generating abstract instances, ignore everything except
19133 constants, symbols living in memory, and symbols living in
19134 fixed registers. */
19135 if (! reload_completed
)
19138 && (CONSTANT_P (rtl
)
19140 && CONSTANT_P (XEXP (rtl
, 0)))
19143 && TREE_STATIC (decl
))))
19145 rtl
= targetm
.delegitimize_address (rtl
);
19150 else if (TREE_CODE (decl
) == PARM_DECL
)
19152 if (rtl
== NULL_RTX
19153 || is_pseudo_reg (rtl
)
19155 && is_pseudo_reg (XEXP (rtl
, 0))
19156 && DECL_INCOMING_RTL (decl
)
19157 && MEM_P (DECL_INCOMING_RTL (decl
))
19158 && GET_MODE (rtl
) == GET_MODE (DECL_INCOMING_RTL (decl
))))
19160 tree declared_type
= TREE_TYPE (decl
);
19161 tree passed_type
= DECL_ARG_TYPE (decl
);
19162 machine_mode dmode
= TYPE_MODE (declared_type
);
19163 machine_mode pmode
= TYPE_MODE (passed_type
);
19165 /* This decl represents a formal parameter which was optimized out.
19166 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
19167 all cases where (rtl == NULL_RTX) just below. */
19168 if (dmode
== pmode
)
19169 rtl
= DECL_INCOMING_RTL (decl
);
19170 else if ((rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
19171 && SCALAR_INT_MODE_P (dmode
)
19172 && GET_MODE_SIZE (dmode
) <= GET_MODE_SIZE (pmode
)
19173 && DECL_INCOMING_RTL (decl
))
19175 rtx inc
= DECL_INCOMING_RTL (decl
);
19178 else if (MEM_P (inc
))
19180 if (BYTES_BIG_ENDIAN
)
19181 rtl
= adjust_address_nv (inc
, dmode
,
19182 GET_MODE_SIZE (pmode
)
19183 - GET_MODE_SIZE (dmode
));
19190 /* If the parm was passed in registers, but lives on the stack, then
19191 make a big endian correction if the mode of the type of the
19192 parameter is not the same as the mode of the rtl. */
19193 /* ??? This is the same series of checks that are made in dbxout.c before
19194 we reach the big endian correction code there. It isn't clear if all
19195 of these checks are necessary here, but keeping them all is the safe
19197 else if (MEM_P (rtl
)
19198 && XEXP (rtl
, 0) != const0_rtx
19199 && ! CONSTANT_P (XEXP (rtl
, 0))
19200 /* Not passed in memory. */
19201 && !MEM_P (DECL_INCOMING_RTL (decl
))
19202 /* Not passed by invisible reference. */
19203 && (!REG_P (XEXP (rtl
, 0))
19204 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
19205 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
19206 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
19207 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
19210 /* Big endian correction check. */
19211 && BYTES_BIG_ENDIAN
19212 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
19213 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
19216 machine_mode addr_mode
= get_address_mode (rtl
);
19217 int offset
= (UNITS_PER_WORD
19218 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
19220 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
19221 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
19224 else if (VAR_P (decl
)
19227 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
)))
19229 machine_mode addr_mode
= get_address_mode (rtl
);
19230 poly_int64 offset
= byte_lowpart_offset (TYPE_MODE (TREE_TYPE (decl
)),
19233 /* If a variable is declared "register" yet is smaller than
19234 a register, then if we store the variable to memory, it
19235 looks like we're storing a register-sized value, when in
19236 fact we are not. We need to adjust the offset of the
19237 storage location to reflect the actual value's bytes,
19238 else gdb will not be able to display it. */
19239 if (maybe_ne (offset
, 0))
19240 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
19241 plus_constant (addr_mode
, XEXP (rtl
, 0), offset
));
19244 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
19245 and will have been substituted directly into all expressions that use it.
19246 C does not have such a concept, but C++ and other languages do. */
19247 if (!rtl
&& VAR_P (decl
) && DECL_INITIAL (decl
))
19248 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
19251 rtl
= targetm
.delegitimize_address (rtl
);
19253 /* If we don't look past the constant pool, we risk emitting a
19254 reference to a constant pool entry that isn't referenced from
19255 code, and thus is not emitted. */
19257 rtl
= avoid_constant_pool_reference (rtl
);
19259 /* Try harder to get a rtl. If this symbol ends up not being emitted
19260 in the current CU, resolve_addr will remove the expression referencing
19262 if (rtl
== NULL_RTX
19264 && !DECL_EXTERNAL (decl
)
19265 && TREE_STATIC (decl
)
19266 && DECL_NAME (decl
)
19267 && !DECL_HARD_REGISTER (decl
)
19268 && DECL_MODE (decl
) != VOIDmode
)
19270 rtl
= make_decl_rtl_for_debug (decl
);
19272 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
19273 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
19280 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
19281 returned. If so, the decl for the COMMON block is returned, and the
19282 value is the offset into the common block for the symbol. */
19285 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
19287 tree val_expr
, cvar
;
19289 HOST_WIDE_INT bitsize
, bitpos
;
19291 int unsignedp
, reversep
, volatilep
= 0;
19293 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
19294 it does not have a value (the offset into the common area), or if it
19295 is thread local (as opposed to global) then it isn't common, and shouldn't
19296 be handled as such. */
19298 || !TREE_STATIC (decl
)
19299 || !DECL_HAS_VALUE_EXPR_P (decl
)
19303 val_expr
= DECL_VALUE_EXPR (decl
);
19304 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
19307 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
, &mode
,
19308 &unsignedp
, &reversep
, &volatilep
);
19310 if (cvar
== NULL_TREE
19312 || DECL_ARTIFICIAL (cvar
)
19313 || !TREE_PUBLIC (cvar
))
19317 if (offset
!= NULL
)
19319 if (!tree_fits_shwi_p (offset
))
19321 *value
= tree_to_shwi (offset
);
19324 *value
+= bitpos
/ BITS_PER_UNIT
;
19329 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
19330 data attribute for a variable or a parameter. We generate the
19331 DW_AT_const_value attribute only in those cases where the given variable
19332 or parameter does not have a true "location" either in memory or in a
19333 register. This can happen (for example) when a constant is passed as an
19334 actual argument in a call to an inline function. (It's possible that
19335 these things can crop up in other ways also.) Note that one type of
19336 constant value which can be passed into an inlined function is a constant
19337 pointer. This can happen for example if an actual argument in an inlined
19338 function call evaluates to a compile-time constant address.
19340 CACHE_P is true if it is worth caching the location list for DECL,
19341 so that future calls can reuse it rather than regenerate it from scratch.
19342 This is true for BLOCK_NONLOCALIZED_VARS in inlined subroutines,
19343 since we will need to refer to them each time the function is inlined. */
19346 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
, bool cache_p
)
19349 dw_loc_list_ref list
;
19350 var_loc_list
*loc_list
;
19351 cached_dw_loc_list
*cache
;
19356 if (TREE_CODE (decl
) == ERROR_MARK
)
19359 if (get_AT (die
, DW_AT_location
)
19360 || get_AT (die
, DW_AT_const_value
))
19363 gcc_assert (VAR_P (decl
) || TREE_CODE (decl
) == PARM_DECL
19364 || TREE_CODE (decl
) == RESULT_DECL
);
19366 /* Try to get some constant RTL for this decl, and use that as the value of
19369 rtl
= rtl_for_decl_location (decl
);
19370 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
19371 && add_const_value_attribute (die
, rtl
))
19374 /* See if we have single element location list that is equivalent to
19375 a constant value. That way we are better to use add_const_value_attribute
19376 rather than expanding constant value equivalent. */
19377 loc_list
= lookup_decl_loc (decl
);
19380 && loc_list
->first
->next
== NULL
19381 && NOTE_P (loc_list
->first
->loc
)
19382 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
19383 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
19385 struct var_loc_node
*node
;
19387 node
= loc_list
->first
;
19388 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
19389 if (GET_CODE (rtl
) == EXPR_LIST
)
19390 rtl
= XEXP (rtl
, 0);
19391 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
19392 && add_const_value_attribute (die
, rtl
))
19395 /* If this decl is from BLOCK_NONLOCALIZED_VARS, we might need its
19396 list several times. See if we've already cached the contents. */
19398 if (loc_list
== NULL
|| cached_dw_loc_list_table
== NULL
)
19402 cache
= cached_dw_loc_list_table
->find_with_hash (decl
, DECL_UID (decl
));
19404 list
= cache
->loc_list
;
19408 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2,
19410 /* It is usually worth caching this result if the decl is from
19411 BLOCK_NONLOCALIZED_VARS and if the list has at least two elements. */
19412 if (cache_p
&& list
&& list
->dw_loc_next
)
19414 cached_dw_loc_list
**slot
19415 = cached_dw_loc_list_table
->find_slot_with_hash (decl
,
19418 cache
= ggc_cleared_alloc
<cached_dw_loc_list
> ();
19419 cache
->decl_id
= DECL_UID (decl
);
19420 cache
->loc_list
= list
;
19426 add_AT_location_description (die
, DW_AT_location
, list
);
19429 /* None of that worked, so it must not really have a location;
19430 try adding a constant value attribute from the DECL_INITIAL. */
19431 return tree_add_const_value_attribute_for_decl (die
, decl
);
19434 /* Helper function for tree_add_const_value_attribute. Natively encode
19435 initializer INIT into an array. Return true if successful. */
19438 native_encode_initializer (tree init
, unsigned char *array
, int size
)
19442 if (init
== NULL_TREE
)
19446 switch (TREE_CODE (init
))
19449 type
= TREE_TYPE (init
);
19450 if (TREE_CODE (type
) == ARRAY_TYPE
)
19452 tree enttype
= TREE_TYPE (type
);
19453 scalar_int_mode mode
;
19455 if (!is_int_mode (TYPE_MODE (enttype
), &mode
)
19456 || GET_MODE_SIZE (mode
) != 1)
19458 if (int_size_in_bytes (type
) != size
)
19460 if (size
> TREE_STRING_LENGTH (init
))
19462 memcpy (array
, TREE_STRING_POINTER (init
),
19463 TREE_STRING_LENGTH (init
));
19464 memset (array
+ TREE_STRING_LENGTH (init
),
19465 '\0', size
- TREE_STRING_LENGTH (init
));
19468 memcpy (array
, TREE_STRING_POINTER (init
), size
);
19473 type
= TREE_TYPE (init
);
19474 if (int_size_in_bytes (type
) != size
)
19476 if (TREE_CODE (type
) == ARRAY_TYPE
)
19478 HOST_WIDE_INT min_index
;
19479 unsigned HOST_WIDE_INT cnt
;
19480 int curpos
= 0, fieldsize
;
19481 constructor_elt
*ce
;
19483 if (TYPE_DOMAIN (type
) == NULL_TREE
19484 || !tree_fits_shwi_p (TYPE_MIN_VALUE (TYPE_DOMAIN (type
))))
19487 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
19488 if (fieldsize
<= 0)
19491 min_index
= tree_to_shwi (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)));
19492 memset (array
, '\0', size
);
19493 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
19495 tree val
= ce
->value
;
19496 tree index
= ce
->index
;
19498 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
19499 pos
= (tree_to_shwi (TREE_OPERAND (index
, 0)) - min_index
)
19502 pos
= (tree_to_shwi (index
) - min_index
) * fieldsize
;
19507 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
19510 curpos
= pos
+ fieldsize
;
19511 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
19513 int count
= tree_to_shwi (TREE_OPERAND (index
, 1))
19514 - tree_to_shwi (TREE_OPERAND (index
, 0));
19515 while (count
-- > 0)
19518 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
19519 curpos
+= fieldsize
;
19522 gcc_assert (curpos
<= size
);
19526 else if (TREE_CODE (type
) == RECORD_TYPE
19527 || TREE_CODE (type
) == UNION_TYPE
)
19529 tree field
= NULL_TREE
;
19530 unsigned HOST_WIDE_INT cnt
;
19531 constructor_elt
*ce
;
19533 if (int_size_in_bytes (type
) != size
)
19536 if (TREE_CODE (type
) == RECORD_TYPE
)
19537 field
= TYPE_FIELDS (type
);
19539 FOR_EACH_VEC_SAFE_ELT (CONSTRUCTOR_ELTS (init
), cnt
, ce
)
19541 tree val
= ce
->value
;
19542 int pos
, fieldsize
;
19544 if (ce
->index
!= 0)
19550 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
19553 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
19554 && TYPE_DOMAIN (TREE_TYPE (field
))
19555 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
19557 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
19558 || !tree_fits_shwi_p (DECL_SIZE_UNIT (field
)))
19560 fieldsize
= tree_to_shwi (DECL_SIZE_UNIT (field
));
19561 pos
= int_byte_position (field
);
19562 gcc_assert (pos
+ fieldsize
<= size
);
19563 if (val
&& fieldsize
!= 0
19564 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
19570 case VIEW_CONVERT_EXPR
:
19571 case NON_LVALUE_EXPR
:
19572 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
19574 return native_encode_expr (init
, array
, size
) == size
;
19578 /* Attach a DW_AT_const_value attribute to DIE. The value of the
19579 attribute is the const value T. */
19582 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
19585 tree type
= TREE_TYPE (t
);
19588 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
19592 gcc_assert (!DECL_P (init
));
19594 if (TREE_CODE (init
) == INTEGER_CST
)
19596 if (tree_fits_uhwi_p (init
))
19598 add_AT_unsigned (die
, DW_AT_const_value
, tree_to_uhwi (init
));
19601 if (tree_fits_shwi_p (init
))
19603 add_AT_int (die
, DW_AT_const_value
, tree_to_shwi (init
));
19609 rtl
= rtl_for_decl_init (init
, type
);
19611 return add_const_value_attribute (die
, rtl
);
19613 /* If the host and target are sane, try harder. */
19614 if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
19615 && initializer_constant_valid_p (init
, type
))
19617 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
19618 if (size
> 0 && (int) size
== size
)
19620 unsigned char *array
= ggc_cleared_vec_alloc
<unsigned char> (size
);
19622 if (native_encode_initializer (init
, array
, size
))
19624 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
19633 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
19634 attribute is the const value of T, where T is an integral constant
19635 variable with static storage duration
19636 (so it can't be a PARM_DECL or a RESULT_DECL). */
19639 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
19643 || (!VAR_P (decl
) && TREE_CODE (decl
) != CONST_DECL
)
19644 || (VAR_P (decl
) && !TREE_STATIC (decl
)))
19647 if (TREE_READONLY (decl
)
19648 && ! TREE_THIS_VOLATILE (decl
)
19649 && DECL_INITIAL (decl
))
19654 /* Don't add DW_AT_const_value if abstract origin already has one. */
19655 if (get_AT (var_die
, DW_AT_const_value
))
19658 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
19661 /* Convert the CFI instructions for the current function into a
19662 location list. This is used for DW_AT_frame_base when we targeting
19663 a dwarf2 consumer that does not support the dwarf3
19664 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
19667 static dw_loc_list_ref
19668 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
19672 dw_loc_list_ref list
, *list_tail
;
19674 dw_cfa_location last_cfa
, next_cfa
;
19675 const char *start_label
, *last_label
, *section
;
19676 dw_cfa_location remember
;
19679 gcc_assert (fde
!= NULL
);
19681 section
= secname_for_decl (current_function_decl
);
19685 memset (&next_cfa
, 0, sizeof (next_cfa
));
19686 next_cfa
.reg
= INVALID_REGNUM
;
19687 remember
= next_cfa
;
19689 start_label
= fde
->dw_fde_begin
;
19691 /* ??? Bald assumption that the CIE opcode list does not contain
19692 advance opcodes. */
19693 FOR_EACH_VEC_ELT (*cie_cfi_vec
, ix
, cfi
)
19694 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
19696 last_cfa
= next_cfa
;
19697 last_label
= start_label
;
19699 if (fde
->dw_fde_second_begin
&& fde
->dw_fde_switch_cfi_index
== 0)
19701 /* If the first partition contained no CFI adjustments, the
19702 CIE opcodes apply to the whole first partition. */
19703 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
19704 fde
->dw_fde_begin
, fde
->dw_fde_end
, section
);
19705 list_tail
=&(*list_tail
)->dw_loc_next
;
19706 start_label
= last_label
= fde
->dw_fde_second_begin
;
19709 FOR_EACH_VEC_SAFE_ELT (fde
->dw_fde_cfi
, ix
, cfi
)
19711 switch (cfi
->dw_cfi_opc
)
19713 case DW_CFA_set_loc
:
19714 case DW_CFA_advance_loc1
:
19715 case DW_CFA_advance_loc2
:
19716 case DW_CFA_advance_loc4
:
19717 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
19719 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
19720 start_label
, last_label
, section
);
19722 list_tail
= &(*list_tail
)->dw_loc_next
;
19723 last_cfa
= next_cfa
;
19724 start_label
= last_label
;
19726 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
19729 case DW_CFA_advance_loc
:
19730 /* The encoding is complex enough that we should never emit this. */
19731 gcc_unreachable ();
19734 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
19737 if (ix
+ 1 == fde
->dw_fde_switch_cfi_index
)
19739 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
19741 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
19742 start_label
, last_label
, section
);
19744 list_tail
= &(*list_tail
)->dw_loc_next
;
19745 last_cfa
= next_cfa
;
19746 start_label
= last_label
;
19748 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
19749 start_label
, fde
->dw_fde_end
, section
);
19750 list_tail
= &(*list_tail
)->dw_loc_next
;
19751 start_label
= last_label
= fde
->dw_fde_second_begin
;
19755 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
19757 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
19758 start_label
, last_label
, section
);
19759 list_tail
= &(*list_tail
)->dw_loc_next
;
19760 start_label
= last_label
;
19763 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
19765 fde
->dw_fde_second_begin
19766 ? fde
->dw_fde_second_end
: fde
->dw_fde_end
,
19769 if (list
&& list
->dw_loc_next
)
19775 /* Compute a displacement from the "steady-state frame pointer" to the
19776 frame base (often the same as the CFA), and store it in
19777 frame_pointer_fb_offset. OFFSET is added to the displacement
19778 before the latter is negated. */
19781 compute_frame_pointer_to_fb_displacement (poly_int64 offset
)
19785 #ifdef FRAME_POINTER_CFA_OFFSET
19786 reg
= frame_pointer_rtx
;
19787 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
19789 reg
= arg_pointer_rtx
;
19790 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
19793 elim
= (ira_use_lra_p
19794 ? lra_eliminate_regs (reg
, VOIDmode
, NULL_RTX
)
19795 : eliminate_regs (reg
, VOIDmode
, NULL_RTX
));
19796 elim
= strip_offset_and_add (elim
, &offset
);
19798 frame_pointer_fb_offset
= -offset
;
19800 /* ??? AVR doesn't set up valid eliminations when there is no stack frame
19801 in which to eliminate. This is because it's stack pointer isn't
19802 directly accessible as a register within the ISA. To work around
19803 this, assume that while we cannot provide a proper value for
19804 frame_pointer_fb_offset, we won't need one either. */
19805 frame_pointer_fb_offset_valid
19806 = ((SUPPORTS_STACK_ALIGNMENT
19807 && (elim
== hard_frame_pointer_rtx
19808 || elim
== stack_pointer_rtx
))
19809 || elim
== (frame_pointer_needed
19810 ? hard_frame_pointer_rtx
19811 : stack_pointer_rtx
));
19814 /* Generate a DW_AT_name attribute given some string value to be included as
19815 the value of the attribute. */
19818 add_name_attribute (dw_die_ref die
, const char *name_string
)
19820 if (name_string
!= NULL
&& *name_string
!= 0)
19822 if (demangle_name_func
)
19823 name_string
= (*demangle_name_func
) (name_string
);
19825 add_AT_string (die
, DW_AT_name
, name_string
);
19829 /* Retrieve the descriptive type of TYPE, if any, make sure it has a
19830 DIE and attach a DW_AT_GNAT_descriptive_type attribute to the DIE
19831 of TYPE accordingly.
19833 ??? This is a temporary measure until after we're able to generate
19834 regular DWARF for the complex Ada type system. */
19837 add_gnat_descriptive_type_attribute (dw_die_ref die
, tree type
,
19838 dw_die_ref context_die
)
19841 dw_die_ref dtype_die
;
19843 if (!lang_hooks
.types
.descriptive_type
)
19846 dtype
= lang_hooks
.types
.descriptive_type (type
);
19850 dtype_die
= lookup_type_die (dtype
);
19853 gen_type_die (dtype
, context_die
);
19854 dtype_die
= lookup_type_die (dtype
);
19855 gcc_assert (dtype_die
);
19858 add_AT_die_ref (die
, DW_AT_GNAT_descriptive_type
, dtype_die
);
19861 /* Retrieve the comp_dir string suitable for use with DW_AT_comp_dir. */
19863 static const char *
19864 comp_dir_string (void)
19868 static const char *cached_wd
= NULL
;
19870 if (cached_wd
!= NULL
)
19873 wd
= get_src_pwd ();
19877 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
19881 wdlen
= strlen (wd
);
19882 wd1
= ggc_vec_alloc
<char> (wdlen
+ 2);
19884 wd1
[wdlen
] = DIR_SEPARATOR
;
19885 wd1
[wdlen
+ 1] = 0;
19889 cached_wd
= remap_debug_filename (wd
);
19893 /* Generate a DW_AT_comp_dir attribute for DIE. */
19896 add_comp_dir_attribute (dw_die_ref die
)
19898 const char * wd
= comp_dir_string ();
19900 add_AT_string (die
, DW_AT_comp_dir
, wd
);
19903 /* Given a tree node VALUE describing a scalar attribute ATTR (i.e. a bound, a
19904 pointer computation, ...), output a representation for that bound according
19905 to the accepted FORMS (see enum dw_scalar_form) and add it to DIE. See
19906 loc_list_from_tree for the meaning of CONTEXT. */
19909 add_scalar_info (dw_die_ref die
, enum dwarf_attribute attr
, tree value
,
19910 int forms
, struct loc_descr_context
*context
)
19912 dw_die_ref context_die
, decl_die
;
19913 dw_loc_list_ref list
;
19914 bool strip_conversions
= true;
19915 bool placeholder_seen
= false;
19917 while (strip_conversions
)
19918 switch (TREE_CODE (value
))
19925 case VIEW_CONVERT_EXPR
:
19926 value
= TREE_OPERAND (value
, 0);
19930 strip_conversions
= false;
19934 /* If possible and permitted, output the attribute as a constant. */
19935 if ((forms
& dw_scalar_form_constant
) != 0
19936 && TREE_CODE (value
) == INTEGER_CST
)
19938 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (value
));
19940 /* If HOST_WIDE_INT is big enough then represent the bound as
19941 a constant value. We need to choose a form based on
19942 whether the type is signed or unsigned. We cannot just
19943 call add_AT_unsigned if the value itself is positive
19944 (add_AT_unsigned might add the unsigned value encoded as
19945 DW_FORM_data[1248]). Some DWARF consumers will lookup the
19946 bounds type and then sign extend any unsigned values found
19947 for signed types. This is needed only for
19948 DW_AT_{lower,upper}_bound, since for most other attributes,
19949 consumers will treat DW_FORM_data[1248] as unsigned values,
19950 regardless of the underlying type. */
19951 if (prec
<= HOST_BITS_PER_WIDE_INT
19952 || tree_fits_uhwi_p (value
))
19954 if (TYPE_UNSIGNED (TREE_TYPE (value
)))
19955 add_AT_unsigned (die
, attr
, TREE_INT_CST_LOW (value
));
19957 add_AT_int (die
, attr
, TREE_INT_CST_LOW (value
));
19960 /* Otherwise represent the bound as an unsigned value with
19961 the precision of its type. The precision and signedness
19962 of the type will be necessary to re-interpret it
19964 add_AT_wide (die
, attr
, wi::to_wide (value
));
19968 /* Otherwise, if it's possible and permitted too, output a reference to
19970 if ((forms
& dw_scalar_form_reference
) != 0)
19972 tree decl
= NULL_TREE
;
19974 /* Some type attributes reference an outer type. For instance, the upper
19975 bound of an array may reference an embedding record (this happens in
19977 if (TREE_CODE (value
) == COMPONENT_REF
19978 && TREE_CODE (TREE_OPERAND (value
, 0)) == PLACEHOLDER_EXPR
19979 && TREE_CODE (TREE_OPERAND (value
, 1)) == FIELD_DECL
)
19980 decl
= TREE_OPERAND (value
, 1);
19982 else if (VAR_P (value
)
19983 || TREE_CODE (value
) == PARM_DECL
19984 || TREE_CODE (value
) == RESULT_DECL
)
19987 if (decl
!= NULL_TREE
)
19989 dw_die_ref decl_die
= lookup_decl_die (decl
);
19991 /* ??? Can this happen, or should the variable have been bound
19992 first? Probably it can, since I imagine that we try to create
19993 the types of parameters in the order in which they exist in
19994 the list, and won't have created a forward reference to a
19995 later parameter. */
19996 if (decl_die
!= NULL
)
19998 add_AT_die_ref (die
, attr
, decl_die
);
20004 /* Last chance: try to create a stack operation procedure to evaluate the
20005 value. Do nothing if even that is not possible or permitted. */
20006 if ((forms
& dw_scalar_form_exprloc
) == 0)
20009 list
= loc_list_from_tree (value
, 2, context
);
20010 if (context
&& context
->placeholder_arg
)
20012 placeholder_seen
= context
->placeholder_seen
;
20013 context
->placeholder_seen
= false;
20015 if (list
== NULL
|| single_element_loc_list_p (list
))
20017 /* If this attribute is not a reference nor constant, it is
20018 a DWARF expression rather than location description. For that
20019 loc_list_from_tree (value, 0, &context) is needed. */
20020 dw_loc_list_ref list2
= loc_list_from_tree (value
, 0, context
);
20021 if (list2
&& single_element_loc_list_p (list2
))
20023 if (placeholder_seen
)
20025 struct dwarf_procedure_info dpi
;
20026 dpi
.fndecl
= NULL_TREE
;
20027 dpi
.args_count
= 1;
20028 if (!resolve_args_picking (list2
->expr
, 1, &dpi
))
20031 add_AT_loc (die
, attr
, list2
->expr
);
20036 /* If that failed to give a single element location list, fall back to
20037 outputting this as a reference... still if permitted. */
20039 || (forms
& dw_scalar_form_reference
) == 0
20040 || placeholder_seen
)
20043 if (current_function_decl
== 0)
20044 context_die
= comp_unit_die ();
20046 context_die
= lookup_decl_die (current_function_decl
);
20048 decl_die
= new_die (DW_TAG_variable
, context_die
, value
);
20049 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
20050 add_type_attribute (decl_die
, TREE_TYPE (value
), TYPE_QUAL_CONST
, false,
20052 add_AT_location_description (decl_die
, DW_AT_location
, list
);
20053 add_AT_die_ref (die
, attr
, decl_die
);
20056 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
20060 lower_bound_default (void)
20062 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
20068 case DW_LANG_C_plus_plus
:
20069 case DW_LANG_C_plus_plus_11
:
20070 case DW_LANG_C_plus_plus_14
:
20072 case DW_LANG_ObjC_plus_plus
:
20074 case DW_LANG_Fortran77
:
20075 case DW_LANG_Fortran90
:
20076 case DW_LANG_Fortran95
:
20077 case DW_LANG_Fortran03
:
20078 case DW_LANG_Fortran08
:
20082 case DW_LANG_Python
:
20083 return dwarf_version
>= 4 ? 0 : -1;
20084 case DW_LANG_Ada95
:
20085 case DW_LANG_Ada83
:
20086 case DW_LANG_Cobol74
:
20087 case DW_LANG_Cobol85
:
20088 case DW_LANG_Modula2
:
20090 return dwarf_version
>= 4 ? 1 : -1;
20096 /* Given a tree node describing an array bound (either lower or upper) output
20097 a representation for that bound. */
20100 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
,
20101 tree bound
, struct loc_descr_context
*context
)
20106 switch (TREE_CODE (bound
))
20108 /* Strip all conversions. */
20110 case VIEW_CONVERT_EXPR
:
20111 bound
= TREE_OPERAND (bound
, 0);
20114 /* All fixed-bounds are represented by INTEGER_CST nodes. Lower bounds
20115 are even omitted when they are the default. */
20117 /* If the value for this bound is the default one, we can even omit the
20119 if (bound_attr
== DW_AT_lower_bound
20120 && tree_fits_shwi_p (bound
)
20121 && (dflt
= lower_bound_default ()) != -1
20122 && tree_to_shwi (bound
) == dflt
)
20128 /* Because of the complex interaction there can be with other GNAT
20129 encodings, GDB isn't ready yet to handle proper DWARF description
20130 for self-referencial subrange bounds: let GNAT encodings do the
20131 magic in such a case. */
20133 && gnat_encodings
!= DWARF_GNAT_ENCODINGS_MINIMAL
20134 && contains_placeholder_p (bound
))
20137 add_scalar_info (subrange_die
, bound_attr
, bound
,
20138 dw_scalar_form_constant
20139 | dw_scalar_form_exprloc
20140 | dw_scalar_form_reference
,
20146 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
20147 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
20148 Note that the block of subscript information for an array type also
20149 includes information about the element type of the given array type.
20151 This function reuses previously set type and bound information if
20155 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
20157 unsigned dimension_number
;
20159 dw_die_ref child
= type_die
->die_child
;
20161 for (dimension_number
= 0;
20162 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
20163 type
= TREE_TYPE (type
), dimension_number
++)
20165 tree domain
= TYPE_DOMAIN (type
);
20167 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
20170 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
20171 and (in GNU C only) variable bounds. Handle all three forms
20174 /* Find and reuse a previously generated DW_TAG_subrange_type if
20177 For multi-dimensional arrays, as we iterate through the
20178 various dimensions in the enclosing for loop above, we also
20179 iterate through the DIE children and pick at each
20180 DW_TAG_subrange_type previously generated (if available).
20181 Each child DW_TAG_subrange_type DIE describes the range of
20182 the current dimension. At this point we should have as many
20183 DW_TAG_subrange_type's as we have dimensions in the
20185 dw_die_ref subrange_die
= NULL
;
20189 child
= child
->die_sib
;
20190 if (child
->die_tag
== DW_TAG_subrange_type
)
20191 subrange_die
= child
;
20192 if (child
== type_die
->die_child
)
20194 /* If we wrapped around, stop looking next time. */
20198 if (child
->die_tag
== DW_TAG_subrange_type
)
20202 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
20206 /* We have an array type with specified bounds. */
20207 lower
= TYPE_MIN_VALUE (domain
);
20208 upper
= TYPE_MAX_VALUE (domain
);
20210 /* Define the index type. */
20211 if (TREE_TYPE (domain
)
20212 && !get_AT (subrange_die
, DW_AT_type
))
20214 /* ??? This is probably an Ada unnamed subrange type. Ignore the
20215 TREE_TYPE field. We can't emit debug info for this
20216 because it is an unnamed integral type. */
20217 if (TREE_CODE (domain
) == INTEGER_TYPE
20218 && TYPE_NAME (domain
) == NULL_TREE
20219 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
20220 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
20223 add_type_attribute (subrange_die
, TREE_TYPE (domain
),
20224 TYPE_UNQUALIFIED
, false, type_die
);
20227 /* ??? If upper is NULL, the array has unspecified length,
20228 but it does have a lower bound. This happens with Fortran
20230 Since the debugger is definitely going to need to know N
20231 to produce useful results, go ahead and output the lower
20232 bound solo, and hope the debugger can cope. */
20234 if (!get_AT (subrange_die
, DW_AT_lower_bound
))
20235 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
, NULL
);
20236 if (upper
&& !get_AT (subrange_die
, DW_AT_upper_bound
))
20237 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
, NULL
);
20240 /* Otherwise we have an array type with an unspecified length. The
20241 DWARF-2 spec does not say how to handle this; let's just leave out the
20246 /* Add a DW_AT_byte_size attribute to DIE with TREE_NODE's size. */
20249 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
20251 dw_die_ref decl_die
;
20252 HOST_WIDE_INT size
;
20253 dw_loc_descr_ref size_expr
= NULL
;
20255 switch (TREE_CODE (tree_node
))
20260 case ENUMERAL_TYPE
:
20263 case QUAL_UNION_TYPE
:
20264 if (TREE_CODE (TYPE_SIZE_UNIT (tree_node
)) == VAR_DECL
20265 && (decl_die
= lookup_decl_die (TYPE_SIZE_UNIT (tree_node
))))
20267 add_AT_die_ref (die
, DW_AT_byte_size
, decl_die
);
20270 size_expr
= type_byte_size (tree_node
, &size
);
20273 /* For a data member of a struct or union, the DW_AT_byte_size is
20274 generally given as the number of bytes normally allocated for an
20275 object of the *declared* type of the member itself. This is true
20276 even for bit-fields. */
20277 size
= int_size_in_bytes (field_type (tree_node
));
20280 gcc_unreachable ();
20283 /* Support for dynamically-sized objects was introduced by DWARFv3.
20284 At the moment, GDB does not handle variable byte sizes very well,
20286 if ((dwarf_version
>= 3 || !dwarf_strict
)
20287 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
20288 && size_expr
!= NULL
)
20289 add_AT_loc (die
, DW_AT_byte_size
, size_expr
);
20291 /* Note that `size' might be -1 when we get to this point. If it is, that
20292 indicates that the byte size of the entity in question is variable and
20293 that we could not generate a DWARF expression that computes it. */
20295 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
20298 /* Add a DW_AT_alignment attribute to DIE with TREE_NODE's non-default
20302 add_alignment_attribute (dw_die_ref die
, tree tree_node
)
20304 if (dwarf_version
< 5 && dwarf_strict
)
20309 if (DECL_P (tree_node
))
20311 if (!DECL_USER_ALIGN (tree_node
))
20314 align
= DECL_ALIGN_UNIT (tree_node
);
20316 else if (TYPE_P (tree_node
))
20318 if (!TYPE_USER_ALIGN (tree_node
))
20321 align
= TYPE_ALIGN_UNIT (tree_node
);
20324 gcc_unreachable ();
20326 add_AT_unsigned (die
, DW_AT_alignment
, align
);
20329 /* For a FIELD_DECL node which represents a bit-field, output an attribute
20330 which specifies the distance in bits from the highest order bit of the
20331 "containing object" for the bit-field to the highest order bit of the
20334 For any given bit-field, the "containing object" is a hypothetical object
20335 (of some integral or enum type) within which the given bit-field lives. The
20336 type of this hypothetical "containing object" is always the same as the
20337 declared type of the individual bit-field itself. The determination of the
20338 exact location of the "containing object" for a bit-field is rather
20339 complicated. It's handled by the `field_byte_offset' function (above).
20341 CTX is required: see the comment for VLR_CONTEXT.
20343 Note that it is the size (in bytes) of the hypothetical "containing object"
20344 which will be given in the DW_AT_byte_size attribute for this bit-field.
20345 (See `byte_size_attribute' above). */
20348 add_bit_offset_attribute (dw_die_ref die
, tree decl
, struct vlr_context
*ctx
)
20350 HOST_WIDE_INT object_offset_in_bytes
;
20351 tree original_type
= DECL_BIT_FIELD_TYPE (decl
);
20352 HOST_WIDE_INT bitpos_int
;
20353 HOST_WIDE_INT highest_order_object_bit_offset
;
20354 HOST_WIDE_INT highest_order_field_bit_offset
;
20355 HOST_WIDE_INT bit_offset
;
20357 field_byte_offset (decl
, ctx
, &object_offset_in_bytes
);
20359 /* Must be a field and a bit field. */
20360 gcc_assert (original_type
&& TREE_CODE (decl
) == FIELD_DECL
);
20362 /* We can't yet handle bit-fields whose offsets are variable, so if we
20363 encounter such things, just return without generating any attribute
20364 whatsoever. Likewise for variable or too large size. */
20365 if (! tree_fits_shwi_p (bit_position (decl
))
20366 || ! tree_fits_uhwi_p (DECL_SIZE (decl
)))
20369 bitpos_int
= int_bit_position (decl
);
20371 /* Note that the bit offset is always the distance (in bits) from the
20372 highest-order bit of the "containing object" to the highest-order bit of
20373 the bit-field itself. Since the "high-order end" of any object or field
20374 is different on big-endian and little-endian machines, the computation
20375 below must take account of these differences. */
20376 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
20377 highest_order_field_bit_offset
= bitpos_int
;
20379 if (! BYTES_BIG_ENDIAN
)
20381 highest_order_field_bit_offset
+= tree_to_shwi (DECL_SIZE (decl
));
20382 highest_order_object_bit_offset
+=
20383 simple_type_size_in_bits (original_type
);
20387 = (! BYTES_BIG_ENDIAN
20388 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
20389 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
20391 if (bit_offset
< 0)
20392 add_AT_int (die
, DW_AT_bit_offset
, bit_offset
);
20394 add_AT_unsigned (die
, DW_AT_bit_offset
, (unsigned HOST_WIDE_INT
) bit_offset
);
20397 /* For a FIELD_DECL node which represents a bit field, output an attribute
20398 which specifies the length in bits of the given field. */
20401 add_bit_size_attribute (dw_die_ref die
, tree decl
)
20403 /* Must be a field and a bit field. */
20404 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
20405 && DECL_BIT_FIELD_TYPE (decl
));
20407 if (tree_fits_uhwi_p (DECL_SIZE (decl
)))
20408 add_AT_unsigned (die
, DW_AT_bit_size
, tree_to_uhwi (DECL_SIZE (decl
)));
20411 /* If the compiled language is ANSI C, then add a 'prototyped'
20412 attribute, if arg types are given for the parameters of a function. */
20415 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
20417 switch (get_AT_unsigned (comp_unit_die (), DW_AT_language
))
20424 if (prototype_p (func_type
))
20425 add_AT_flag (die
, DW_AT_prototyped
, 1);
20432 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
20433 by looking in the type declaration, the object declaration equate table or
20434 the block mapping. */
20436 static inline dw_die_ref
20437 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
20439 dw_die_ref origin_die
= NULL
;
20441 if (DECL_P (origin
))
20444 origin_die
= lookup_decl_die (origin
);
20445 /* "Unwrap" the decls DIE which we put in the imported unit context.
20446 We are looking for the abstract copy here. */
20449 && (c
= get_AT_ref (origin_die
, DW_AT_abstract_origin
))
20450 /* ??? Identify this better. */
20454 else if (TYPE_P (origin
))
20455 origin_die
= lookup_type_die (origin
);
20456 else if (TREE_CODE (origin
) == BLOCK
)
20457 origin_die
= BLOCK_DIE (origin
);
20459 /* XXX: Functions that are never lowered don't always have correct block
20460 trees (in the case of java, they simply have no block tree, in some other
20461 languages). For these functions, there is nothing we can really do to
20462 output correct debug info for inlined functions in all cases. Rather
20463 than die, we'll just produce deficient debug info now, in that we will
20464 have variables without a proper abstract origin. In the future, when all
20465 functions are lowered, we should re-add a gcc_assert (origin_die)
20469 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
20473 /* We do not currently support the pure_virtual attribute. */
20476 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
20478 if (DECL_VINDEX (func_decl
))
20480 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
20482 if (tree_fits_shwi_p (DECL_VINDEX (func_decl
)))
20483 add_AT_loc (die
, DW_AT_vtable_elem_location
,
20484 new_loc_descr (DW_OP_constu
,
20485 tree_to_shwi (DECL_VINDEX (func_decl
)),
20488 /* GNU extension: Record what type this method came from originally. */
20489 if (debug_info_level
> DINFO_LEVEL_TERSE
20490 && DECL_CONTEXT (func_decl
))
20491 add_AT_die_ref (die
, DW_AT_containing_type
,
20492 lookup_type_die (DECL_CONTEXT (func_decl
)));
20496 /* Add a DW_AT_linkage_name or DW_AT_MIPS_linkage_name attribute for the
20497 given decl. This used to be a vendor extension until after DWARF 4
20498 standardized it. */
20501 add_linkage_attr (dw_die_ref die
, tree decl
)
20503 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
20505 /* Mimic what assemble_name_raw does with a leading '*'. */
20506 if (name
[0] == '*')
20509 if (dwarf_version
>= 4)
20510 add_AT_string (die
, DW_AT_linkage_name
, name
);
20512 add_AT_string (die
, DW_AT_MIPS_linkage_name
, name
);
20515 /* Add source coordinate attributes for the given decl. */
20518 add_src_coords_attributes (dw_die_ref die
, tree decl
)
20520 expanded_location s
;
20522 if (LOCATION_LOCUS (DECL_SOURCE_LOCATION (decl
)) == UNKNOWN_LOCATION
)
20524 s
= expand_location (DECL_SOURCE_LOCATION (decl
));
20525 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
20526 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
20527 if (debug_column_info
&& s
.column
)
20528 add_AT_unsigned (die
, DW_AT_decl_column
, s
.column
);
20531 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
20534 add_linkage_name_raw (dw_die_ref die
, tree decl
)
20536 /* Defer until we have an assembler name set. */
20537 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
20539 limbo_die_node
*asm_name
;
20541 asm_name
= ggc_cleared_alloc
<limbo_die_node
> ();
20542 asm_name
->die
= die
;
20543 asm_name
->created_for
= decl
;
20544 asm_name
->next
= deferred_asm_name
;
20545 deferred_asm_name
= asm_name
;
20547 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
20548 add_linkage_attr (die
, decl
);
20551 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl if desired. */
20554 add_linkage_name (dw_die_ref die
, tree decl
)
20556 if (debug_info_level
> DINFO_LEVEL_NONE
20557 && VAR_OR_FUNCTION_DECL_P (decl
)
20558 && TREE_PUBLIC (decl
)
20559 && !(VAR_P (decl
) && DECL_REGISTER (decl
))
20560 && die
->die_tag
!= DW_TAG_member
)
20561 add_linkage_name_raw (die
, decl
);
20564 /* Add a DW_AT_name attribute and source coordinate attribute for the
20565 given decl, but only if it actually has a name. */
20568 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
,
20569 bool no_linkage_name
)
20573 decl_name
= DECL_NAME (decl
);
20574 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
20576 const char *name
= dwarf2_name (decl
, 0);
20578 add_name_attribute (die
, name
);
20579 if (! DECL_ARTIFICIAL (decl
))
20580 add_src_coords_attributes (die
, decl
);
20582 if (!no_linkage_name
)
20583 add_linkage_name (die
, decl
);
20586 #ifdef VMS_DEBUGGING_INFO
20587 /* Get the function's name, as described by its RTL. This may be different
20588 from the DECL_NAME name used in the source file. */
20589 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
20591 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
20592 XEXP (DECL_RTL (decl
), 0), false);
20593 vec_safe_push (used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
20595 #endif /* VMS_DEBUGGING_INFO */
20598 /* Add VALUE as a DW_AT_discr_value attribute to DIE. */
20601 add_discr_value (dw_die_ref die
, dw_discr_value
*value
)
20605 attr
.dw_attr
= DW_AT_discr_value
;
20606 attr
.dw_attr_val
.val_class
= dw_val_class_discr_value
;
20607 attr
.dw_attr_val
.val_entry
= NULL
;
20608 attr
.dw_attr_val
.v
.val_discr_value
.pos
= value
->pos
;
20610 attr
.dw_attr_val
.v
.val_discr_value
.v
.uval
= value
->v
.uval
;
20612 attr
.dw_attr_val
.v
.val_discr_value
.v
.sval
= value
->v
.sval
;
20613 add_dwarf_attr (die
, &attr
);
20616 /* Add DISCR_LIST as a DW_AT_discr_list to DIE. */
20619 add_discr_list (dw_die_ref die
, dw_discr_list_ref discr_list
)
20623 attr
.dw_attr
= DW_AT_discr_list
;
20624 attr
.dw_attr_val
.val_class
= dw_val_class_discr_list
;
20625 attr
.dw_attr_val
.val_entry
= NULL
;
20626 attr
.dw_attr_val
.v
.val_discr_list
= discr_list
;
20627 add_dwarf_attr (die
, &attr
);
20630 static inline dw_discr_list_ref
20631 AT_discr_list (dw_attr_node
*attr
)
20633 return attr
->dw_attr_val
.v
.val_discr_list
;
20636 #ifdef VMS_DEBUGGING_INFO
20637 /* Output the debug main pointer die for VMS */
20640 dwarf2out_vms_debug_main_pointer (void)
20642 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
20645 /* Allocate the VMS debug main subprogram die. */
20646 die
= new_die_raw (DW_TAG_subprogram
);
20647 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
20648 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
20649 current_function_funcdef_no
);
20650 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
20652 /* Make it the first child of comp_unit_die (). */
20653 die
->die_parent
= comp_unit_die ();
20654 if (comp_unit_die ()->die_child
)
20656 die
->die_sib
= comp_unit_die ()->die_child
->die_sib
;
20657 comp_unit_die ()->die_child
->die_sib
= die
;
20661 die
->die_sib
= die
;
20662 comp_unit_die ()->die_child
= die
;
20665 #endif /* VMS_DEBUGGING_INFO */
20667 /* Push a new declaration scope. */
20670 push_decl_scope (tree scope
)
20672 vec_safe_push (decl_scope_table
, scope
);
20675 /* Pop a declaration scope. */
20678 pop_decl_scope (void)
20680 decl_scope_table
->pop ();
20683 /* walk_tree helper function for uses_local_type, below. */
20686 uses_local_type_r (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
20689 *walk_subtrees
= 0;
20692 tree name
= TYPE_NAME (*tp
);
20693 if (name
&& DECL_P (name
) && decl_function_context (name
))
20699 /* If TYPE involves a function-local type (including a local typedef to a
20700 non-local type), returns that type; otherwise returns NULL_TREE. */
20703 uses_local_type (tree type
)
20705 tree used
= walk_tree_without_duplicates (&type
, uses_local_type_r
, NULL
);
20709 /* Return the DIE for the scope that immediately contains this type.
20710 Non-named types that do not involve a function-local type get global
20711 scope. Named types nested in namespaces or other types get their
20712 containing scope. All other types (i.e. function-local named types) get
20713 the current active scope. */
20716 scope_die_for (tree t
, dw_die_ref context_die
)
20718 dw_die_ref scope_die
= NULL
;
20719 tree containing_scope
;
20721 /* Non-types always go in the current scope. */
20722 gcc_assert (TYPE_P (t
));
20724 /* Use the scope of the typedef, rather than the scope of the type
20726 if (TYPE_NAME (t
) && DECL_P (TYPE_NAME (t
)))
20727 containing_scope
= DECL_CONTEXT (TYPE_NAME (t
));
20729 containing_scope
= TYPE_CONTEXT (t
);
20731 /* Use the containing namespace if there is one. */
20732 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
20734 if (context_die
== lookup_decl_die (containing_scope
))
20736 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
20737 context_die
= get_context_die (containing_scope
);
20739 containing_scope
= NULL_TREE
;
20742 /* Ignore function type "scopes" from the C frontend. They mean that
20743 a tagged type is local to a parmlist of a function declarator, but
20744 that isn't useful to DWARF. */
20745 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
20746 containing_scope
= NULL_TREE
;
20748 if (SCOPE_FILE_SCOPE_P (containing_scope
))
20750 /* If T uses a local type keep it local as well, to avoid references
20751 to function-local DIEs from outside the function. */
20752 if (current_function_decl
&& uses_local_type (t
))
20753 scope_die
= context_die
;
20755 scope_die
= comp_unit_die ();
20757 else if (TYPE_P (containing_scope
))
20759 /* For types, we can just look up the appropriate DIE. */
20760 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20761 scope_die
= get_context_die (containing_scope
);
20764 scope_die
= lookup_type_die_strip_naming_typedef (containing_scope
);
20765 if (scope_die
== NULL
)
20766 scope_die
= comp_unit_die ();
20770 scope_die
= context_die
;
20775 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
20778 local_scope_p (dw_die_ref context_die
)
20780 for (; context_die
; context_die
= context_die
->die_parent
)
20781 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
20782 || context_die
->die_tag
== DW_TAG_subprogram
)
20788 /* Returns nonzero if CONTEXT_DIE is a class. */
20791 class_scope_p (dw_die_ref context_die
)
20793 return (context_die
20794 && (context_die
->die_tag
== DW_TAG_structure_type
20795 || context_die
->die_tag
== DW_TAG_class_type
20796 || context_die
->die_tag
== DW_TAG_interface_type
20797 || context_die
->die_tag
== DW_TAG_union_type
));
20800 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
20801 whether or not to treat a DIE in this context as a declaration. */
20804 class_or_namespace_scope_p (dw_die_ref context_die
)
20806 return (class_scope_p (context_die
)
20807 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
20810 /* Many forms of DIEs require a "type description" attribute. This
20811 routine locates the proper "type descriptor" die for the type given
20812 by 'type' plus any additional qualifiers given by 'cv_quals', and
20813 adds a DW_AT_type attribute below the given die. */
20816 add_type_attribute (dw_die_ref object_die
, tree type
, int cv_quals
,
20817 bool reverse
, dw_die_ref context_die
)
20819 enum tree_code code
= TREE_CODE (type
);
20820 dw_die_ref type_die
= NULL
;
20822 /* ??? If this type is an unnamed subrange type of an integral, floating-point
20823 or fixed-point type, use the inner type. This is because we have no
20824 support for unnamed types in base_type_die. This can happen if this is
20825 an Ada subrange type. Correct solution is emit a subrange type die. */
20826 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
20827 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
20828 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
20830 if (code
== ERROR_MARK
20831 /* Handle a special case. For functions whose return type is void, we
20832 generate *no* type attribute. (Note that no object may have type
20833 `void', so this only applies to function return types). */
20834 || code
== VOID_TYPE
)
20837 type_die
= modified_type_die (type
,
20838 cv_quals
| TYPE_QUALS (type
),
20842 if (type_die
!= NULL
)
20843 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
20846 /* Given an object die, add the calling convention attribute for the
20847 function call type. */
20849 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
20851 enum dwarf_calling_convention value
= DW_CC_normal
;
20853 value
= ((enum dwarf_calling_convention
)
20854 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
20857 && id_equal (DECL_ASSEMBLER_NAME (decl
), "MAIN__"))
20859 /* DWARF 2 doesn't provide a way to identify a program's source-level
20860 entry point. DW_AT_calling_convention attributes are only meant
20861 to describe functions' calling conventions. However, lacking a
20862 better way to signal the Fortran main program, we used this for
20863 a long time, following existing custom. Now, DWARF 4 has
20864 DW_AT_main_subprogram, which we add below, but some tools still
20865 rely on the old way, which we thus keep. */
20866 value
= DW_CC_program
;
20868 if (dwarf_version
>= 4 || !dwarf_strict
)
20869 add_AT_flag (subr_die
, DW_AT_main_subprogram
, 1);
20872 /* Only add the attribute if the backend requests it, and
20873 is not DW_CC_normal. */
20874 if (value
&& (value
!= DW_CC_normal
))
20875 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
20878 /* Given a tree pointer to a struct, class, union, or enum type node, return
20879 a pointer to the (string) tag name for the given type, or zero if the type
20880 was declared without a tag. */
20882 static const char *
20883 type_tag (const_tree type
)
20885 const char *name
= 0;
20887 if (TYPE_NAME (type
) != 0)
20891 /* Find the IDENTIFIER_NODE for the type name. */
20892 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
20893 && !TYPE_NAMELESS (type
))
20894 t
= TYPE_NAME (type
);
20896 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
20897 a TYPE_DECL node, regardless of whether or not a `typedef' was
20899 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
20900 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
20902 /* We want to be extra verbose. Don't call dwarf_name if
20903 DECL_NAME isn't set. The default hook for decl_printable_name
20904 doesn't like that, and in this context it's correct to return
20905 0, instead of "<anonymous>" or the like. */
20906 if (DECL_NAME (TYPE_NAME (type
))
20907 && !DECL_NAMELESS (TYPE_NAME (type
)))
20908 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
20911 /* Now get the name as a string, or invent one. */
20912 if (!name
&& t
!= 0)
20913 name
= IDENTIFIER_POINTER (t
);
20916 return (name
== 0 || *name
== '\0') ? 0 : name
;
20919 /* Return the type associated with a data member, make a special check
20920 for bit field types. */
20923 member_declared_type (const_tree member
)
20925 return (DECL_BIT_FIELD_TYPE (member
)
20926 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
20929 /* Get the decl's label, as described by its RTL. This may be different
20930 from the DECL_NAME name used in the source file. */
20933 static const char *
20934 decl_start_label (tree decl
)
20937 const char *fnname
;
20939 x
= DECL_RTL (decl
);
20940 gcc_assert (MEM_P (x
));
20943 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
20945 fnname
= XSTR (x
, 0);
20950 /* For variable-length arrays that have been previously generated, but
20951 may be incomplete due to missing subscript info, fill the subscript
20952 info. Return TRUE if this is one of those cases. */
20954 fill_variable_array_bounds (tree type
)
20956 if (TREE_ASM_WRITTEN (type
)
20957 && TREE_CODE (type
) == ARRAY_TYPE
20958 && variably_modified_type_p (type
, NULL
))
20960 dw_die_ref array_die
= lookup_type_die (type
);
20963 add_subscript_info (array_die
, type
, !is_ada ());
20969 /* These routines generate the internal representation of the DIE's for
20970 the compilation unit. Debugging information is collected by walking
20971 the declaration trees passed in from dwarf2out_decl(). */
20974 gen_array_type_die (tree type
, dw_die_ref context_die
)
20976 dw_die_ref array_die
;
20978 /* GNU compilers represent multidimensional array types as sequences of one
20979 dimensional array types whose element types are themselves array types.
20980 We sometimes squish that down to a single array_type DIE with multiple
20981 subscripts in the Dwarf debugging info. The draft Dwarf specification
20982 say that we are allowed to do this kind of compression in C, because
20983 there is no difference between an array of arrays and a multidimensional
20984 array. We don't do this for Ada to remain as close as possible to the
20985 actual representation, which is especially important against the language
20986 flexibilty wrt arrays of variable size. */
20988 bool collapse_nested_arrays
= !is_ada ();
20990 if (fill_variable_array_bounds (type
))
20993 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
20996 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
20997 DW_TAG_string_type doesn't have DW_AT_type attribute). */
20998 if (TYPE_STRING_FLAG (type
)
20999 && TREE_CODE (type
) == ARRAY_TYPE
21001 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
21003 HOST_WIDE_INT size
;
21005 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
21006 add_name_attribute (array_die
, type_tag (type
));
21007 equate_type_number_to_die (type
, array_die
);
21008 size
= int_size_in_bytes (type
);
21010 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
21011 /* ??? We can't annotate types late, but for LTO we may not
21012 generate a location early either (gfortran.dg/save_6.f90). */
21013 else if (! (early_dwarf
&& (flag_generate_lto
|| flag_generate_offload
))
21014 && TYPE_DOMAIN (type
) != NULL_TREE
21015 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
)
21017 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
21018 tree rszdecl
= szdecl
;
21020 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
21021 if (!DECL_P (szdecl
))
21023 if (TREE_CODE (szdecl
) == INDIRECT_REF
21024 && DECL_P (TREE_OPERAND (szdecl
, 0)))
21026 rszdecl
= TREE_OPERAND (szdecl
, 0);
21027 if (int_size_in_bytes (TREE_TYPE (rszdecl
))
21028 != DWARF2_ADDR_SIZE
)
21036 dw_loc_list_ref loc
21037 = loc_list_from_tree (rszdecl
, szdecl
== rszdecl
? 2 : 0,
21041 add_AT_location_description (array_die
, DW_AT_string_length
,
21043 if (size
!= DWARF2_ADDR_SIZE
)
21044 add_AT_unsigned (array_die
, dwarf_version
>= 5
21045 ? DW_AT_string_length_byte_size
21046 : DW_AT_byte_size
, size
);
21053 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
21054 add_name_attribute (array_die
, type_tag (type
));
21055 equate_type_number_to_die (type
, array_die
);
21057 if (TREE_CODE (type
) == VECTOR_TYPE
)
21058 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
21060 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
21062 && TREE_CODE (type
) == ARRAY_TYPE
21063 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
21064 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
21065 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
21068 /* We default the array ordering. Debuggers will probably do the right
21069 things even if DW_AT_ordering is not present. It's not even an issue
21070 until we start to get into multidimensional arrays anyway. If a debugger
21071 is ever caught doing the Wrong Thing for multi-dimensional arrays,
21072 then we'll have to put the DW_AT_ordering attribute back in. (But if
21073 and when we find out that we need to put these in, we will only do so
21074 for multidimensional arrays. */
21075 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
21078 if (TREE_CODE (type
) == VECTOR_TYPE
)
21080 /* For VECTOR_TYPEs we use an array die with appropriate bounds. */
21081 dw_die_ref subrange_die
= new_die (DW_TAG_subrange_type
, array_die
, NULL
);
21082 add_bound_info (subrange_die
, DW_AT_lower_bound
, size_zero_node
, NULL
);
21083 add_bound_info (subrange_die
, DW_AT_upper_bound
,
21084 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1), NULL
);
21087 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
21089 /* Add representation of the type of the elements of this array type and
21090 emit the corresponding DIE if we haven't done it already. */
21091 element_type
= TREE_TYPE (type
);
21092 if (collapse_nested_arrays
)
21093 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
21095 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
21097 element_type
= TREE_TYPE (element_type
);
21100 add_type_attribute (array_die
, element_type
, TYPE_UNQUALIFIED
,
21101 TREE_CODE (type
) == ARRAY_TYPE
21102 && TYPE_REVERSE_STORAGE_ORDER (type
),
21105 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
21106 if (TYPE_ARTIFICIAL (type
))
21107 add_AT_flag (array_die
, DW_AT_artificial
, 1);
21109 if (get_AT (array_die
, DW_AT_name
))
21110 add_pubtype (type
, array_die
);
21112 add_alignment_attribute (array_die
, type
);
21115 /* This routine generates DIE for array with hidden descriptor, details
21116 are filled into *info by a langhook. */
21119 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
21120 dw_die_ref context_die
)
21122 const dw_die_ref scope_die
= scope_die_for (type
, context_die
);
21123 const dw_die_ref array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
21124 struct loc_descr_context context
= { type
, info
->base_decl
, NULL
,
21126 enum dwarf_tag subrange_tag
= DW_TAG_subrange_type
;
21129 add_name_attribute (array_die
, type_tag (type
));
21130 equate_type_number_to_die (type
, array_die
);
21132 if (info
->ndimensions
> 1)
21133 switch (info
->ordering
)
21135 case array_descr_ordering_row_major
:
21136 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
21138 case array_descr_ordering_column_major
:
21139 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
21145 if (dwarf_version
>= 3 || !dwarf_strict
)
21147 if (info
->data_location
)
21148 add_scalar_info (array_die
, DW_AT_data_location
, info
->data_location
,
21149 dw_scalar_form_exprloc
, &context
);
21150 if (info
->associated
)
21151 add_scalar_info (array_die
, DW_AT_associated
, info
->associated
,
21152 dw_scalar_form_constant
21153 | dw_scalar_form_exprloc
21154 | dw_scalar_form_reference
, &context
);
21155 if (info
->allocated
)
21156 add_scalar_info (array_die
, DW_AT_allocated
, info
->allocated
,
21157 dw_scalar_form_constant
21158 | dw_scalar_form_exprloc
21159 | dw_scalar_form_reference
, &context
);
21162 const enum dwarf_attribute attr
21163 = (info
->stride_in_bits
) ? DW_AT_bit_stride
: DW_AT_byte_stride
;
21165 = (info
->stride_in_bits
)
21166 ? dw_scalar_form_constant
21167 : (dw_scalar_form_constant
21168 | dw_scalar_form_exprloc
21169 | dw_scalar_form_reference
);
21171 add_scalar_info (array_die
, attr
, info
->stride
, forms
, &context
);
21174 if (dwarf_version
>= 5)
21178 add_scalar_info (array_die
, DW_AT_rank
, info
->rank
,
21179 dw_scalar_form_constant
21180 | dw_scalar_form_exprloc
, &context
);
21181 subrange_tag
= DW_TAG_generic_subrange
;
21182 context
.placeholder_arg
= true;
21186 add_gnat_descriptive_type_attribute (array_die
, type
, context_die
);
21188 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
21190 dw_die_ref subrange_die
= new_die (subrange_tag
, array_die
, NULL
);
21192 if (info
->dimen
[dim
].bounds_type
)
21193 add_type_attribute (subrange_die
,
21194 info
->dimen
[dim
].bounds_type
, TYPE_UNQUALIFIED
,
21195 false, context_die
);
21196 if (info
->dimen
[dim
].lower_bound
)
21197 add_bound_info (subrange_die
, DW_AT_lower_bound
,
21198 info
->dimen
[dim
].lower_bound
, &context
);
21199 if (info
->dimen
[dim
].upper_bound
)
21200 add_bound_info (subrange_die
, DW_AT_upper_bound
,
21201 info
->dimen
[dim
].upper_bound
, &context
);
21202 if ((dwarf_version
>= 3 || !dwarf_strict
) && info
->dimen
[dim
].stride
)
21203 add_scalar_info (subrange_die
, DW_AT_byte_stride
,
21204 info
->dimen
[dim
].stride
,
21205 dw_scalar_form_constant
21206 | dw_scalar_form_exprloc
21207 | dw_scalar_form_reference
,
21211 gen_type_die (info
->element_type
, context_die
);
21212 add_type_attribute (array_die
, info
->element_type
, TYPE_UNQUALIFIED
,
21213 TREE_CODE (type
) == ARRAY_TYPE
21214 && TYPE_REVERSE_STORAGE_ORDER (type
),
21217 if (get_AT (array_die
, DW_AT_name
))
21218 add_pubtype (type
, array_die
);
21220 add_alignment_attribute (array_die
, type
);
21225 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
21227 tree origin
= decl_ultimate_origin (decl
);
21228 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
21230 if (origin
!= NULL
)
21231 add_abstract_origin_attribute (decl_die
, origin
);
21234 add_name_and_src_coords_attributes (decl_die
, decl
);
21235 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
21236 TYPE_UNQUALIFIED
, false, context_die
);
21239 if (DECL_ABSTRACT_P (decl
))
21240 equate_decl_number_to_die (decl
, decl_die
);
21242 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
21246 /* Walk through the list of incomplete types again, trying once more to
21247 emit full debugging info for them. */
21250 retry_incomplete_types (void)
21255 for (i
= vec_safe_length (incomplete_types
) - 1; i
>= 0; i
--)
21256 if (should_emit_struct_debug ((*incomplete_types
)[i
], DINFO_USAGE_DIR_USE
))
21257 gen_type_die ((*incomplete_types
)[i
], comp_unit_die ());
21258 vec_safe_truncate (incomplete_types
, 0);
21261 /* Determine what tag to use for a record type. */
21263 static enum dwarf_tag
21264 record_type_tag (tree type
)
21266 if (! lang_hooks
.types
.classify_record
)
21267 return DW_TAG_structure_type
;
21269 switch (lang_hooks
.types
.classify_record (type
))
21271 case RECORD_IS_STRUCT
:
21272 return DW_TAG_structure_type
;
21274 case RECORD_IS_CLASS
:
21275 return DW_TAG_class_type
;
21277 case RECORD_IS_INTERFACE
:
21278 if (dwarf_version
>= 3 || !dwarf_strict
)
21279 return DW_TAG_interface_type
;
21280 return DW_TAG_structure_type
;
21283 gcc_unreachable ();
21287 /* Generate a DIE to represent an enumeration type. Note that these DIEs
21288 include all of the information about the enumeration values also. Each
21289 enumerated type name/value is listed as a child of the enumerated type
21293 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
21295 dw_die_ref type_die
= lookup_type_die (type
);
21297 if (type_die
== NULL
)
21299 type_die
= new_die (DW_TAG_enumeration_type
,
21300 scope_die_for (type
, context_die
), type
);
21301 equate_type_number_to_die (type
, type_die
);
21302 add_name_attribute (type_die
, type_tag (type
));
21303 if (dwarf_version
>= 4 || !dwarf_strict
)
21305 if (ENUM_IS_SCOPED (type
))
21306 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
21307 if (ENUM_IS_OPAQUE (type
))
21308 add_AT_flag (type_die
, DW_AT_declaration
, 1);
21311 add_AT_unsigned (type_die
, DW_AT_encoding
,
21312 TYPE_UNSIGNED (type
)
21316 else if (! TYPE_SIZE (type
))
21319 remove_AT (type_die
, DW_AT_declaration
);
21321 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
21322 given enum type is incomplete, do not generate the DW_AT_byte_size
21323 attribute or the DW_AT_element_list attribute. */
21324 if (TYPE_SIZE (type
))
21328 TREE_ASM_WRITTEN (type
) = 1;
21329 add_byte_size_attribute (type_die
, type
);
21330 add_alignment_attribute (type_die
, type
);
21331 if (dwarf_version
>= 3 || !dwarf_strict
)
21333 tree underlying
= lang_hooks
.types
.enum_underlying_base_type (type
);
21334 add_type_attribute (type_die
, underlying
, TYPE_UNQUALIFIED
, false,
21337 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
21339 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
21340 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
21343 /* If the first reference to this type was as the return type of an
21344 inline function, then it may not have a parent. Fix this now. */
21345 if (type_die
->die_parent
== NULL
)
21346 add_child_die (scope_die_for (type
, context_die
), type_die
);
21348 for (link
= TYPE_VALUES (type
);
21349 link
!= NULL
; link
= TREE_CHAIN (link
))
21351 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
21352 tree value
= TREE_VALUE (link
);
21354 add_name_attribute (enum_die
,
21355 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
21357 if (TREE_CODE (value
) == CONST_DECL
)
21358 value
= DECL_INITIAL (value
);
21360 if (simple_type_size_in_bits (TREE_TYPE (value
))
21361 <= HOST_BITS_PER_WIDE_INT
|| tree_fits_shwi_p (value
))
21363 /* For constant forms created by add_AT_unsigned DWARF
21364 consumers (GDB, elfutils, etc.) always zero extend
21365 the value. Only when the actual value is negative
21366 do we need to use add_AT_int to generate a constant
21367 form that can represent negative values. */
21368 HOST_WIDE_INT val
= TREE_INT_CST_LOW (value
);
21369 if (TYPE_UNSIGNED (TREE_TYPE (value
)) || val
>= 0)
21370 add_AT_unsigned (enum_die
, DW_AT_const_value
,
21371 (unsigned HOST_WIDE_INT
) val
);
21373 add_AT_int (enum_die
, DW_AT_const_value
, val
);
21376 /* Enumeration constants may be wider than HOST_WIDE_INT. Handle
21377 that here. TODO: This should be re-worked to use correct
21378 signed/unsigned double tags for all cases. */
21379 add_AT_wide (enum_die
, DW_AT_const_value
, wi::to_wide (value
));
21382 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
21383 if (TYPE_ARTIFICIAL (type
))
21384 add_AT_flag (type_die
, DW_AT_artificial
, 1);
21387 add_AT_flag (type_die
, DW_AT_declaration
, 1);
21389 add_pubtype (type
, type_die
);
21394 /* Generate a DIE to represent either a real live formal parameter decl or to
21395 represent just the type of some formal parameter position in some function
21398 Note that this routine is a bit unusual because its argument may be a
21399 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
21400 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
21401 node. If it's the former then this function is being called to output a
21402 DIE to represent a formal parameter object (or some inlining thereof). If
21403 it's the latter, then this function is only being called to output a
21404 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
21405 argument type of some subprogram type.
21406 If EMIT_NAME_P is true, name and source coordinate attributes
21410 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
21411 dw_die_ref context_die
)
21413 tree node_or_origin
= node
? node
: origin
;
21414 tree ultimate_origin
;
21415 dw_die_ref parm_die
= NULL
;
21417 if (DECL_P (node_or_origin
))
21419 parm_die
= lookup_decl_die (node
);
21421 /* If the contexts differ, we may not be talking about the same
21423 ??? When in LTO the DIE parent is the "abstract" copy and the
21424 context_die is the specification "copy". But this whole block
21425 should eventually be no longer needed. */
21426 if (parm_die
&& parm_die
->die_parent
!= context_die
&& !in_lto_p
)
21428 if (!DECL_ABSTRACT_P (node
))
21430 /* This can happen when creating an inlined instance, in
21431 which case we need to create a new DIE that will get
21432 annotated with DW_AT_abstract_origin. */
21436 gcc_unreachable ();
21439 if (parm_die
&& parm_die
->die_parent
== NULL
)
21441 /* Check that parm_die already has the right attributes that
21442 we would have added below. If any attributes are
21443 missing, fall through to add them. */
21444 if (! DECL_ABSTRACT_P (node_or_origin
)
21445 && !get_AT (parm_die
, DW_AT_location
)
21446 && !get_AT (parm_die
, DW_AT_const_value
))
21447 /* We are missing location info, and are about to add it. */
21451 add_child_die (context_die
, parm_die
);
21457 /* If we have a previously generated DIE, use it, unless this is an
21458 concrete instance (origin != NULL), in which case we need a new
21459 DIE with a corresponding DW_AT_abstract_origin. */
21461 if (parm_die
&& origin
== NULL
)
21462 reusing_die
= true;
21465 parm_die
= new_die (DW_TAG_formal_parameter
, context_die
, node
);
21466 reusing_die
= false;
21469 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
21471 case tcc_declaration
:
21472 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
21473 if (node
|| ultimate_origin
)
21474 origin
= ultimate_origin
;
21479 if (origin
!= NULL
)
21480 add_abstract_origin_attribute (parm_die
, origin
);
21481 else if (emit_name_p
)
21482 add_name_and_src_coords_attributes (parm_die
, node
);
21484 || (! DECL_ABSTRACT_P (node_or_origin
)
21485 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
21486 decl_function_context
21487 (node_or_origin
))))
21489 tree type
= TREE_TYPE (node_or_origin
);
21490 if (decl_by_reference_p (node_or_origin
))
21491 add_type_attribute (parm_die
, TREE_TYPE (type
),
21493 false, context_die
);
21495 add_type_attribute (parm_die
, type
,
21496 decl_quals (node_or_origin
),
21497 false, context_die
);
21499 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
21500 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
21502 if (node
&& node
!= origin
)
21503 equate_decl_number_to_die (node
, parm_die
);
21504 if (! DECL_ABSTRACT_P (node_or_origin
))
21505 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
21511 /* We were called with some kind of a ..._TYPE node. */
21512 add_type_attribute (parm_die
, node_or_origin
, TYPE_UNQUALIFIED
, false,
21517 gcc_unreachable ();
21523 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
21524 children DW_TAG_formal_parameter DIEs representing the arguments of the
21527 PARM_PACK must be a function parameter pack.
21528 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
21529 must point to the subsequent arguments of the function PACK_ARG belongs to.
21530 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
21531 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
21532 following the last one for which a DIE was generated. */
21535 gen_formal_parameter_pack_die (tree parm_pack
,
21537 dw_die_ref subr_die
,
21541 dw_die_ref parm_pack_die
;
21543 gcc_assert (parm_pack
21544 && lang_hooks
.function_parameter_pack_p (parm_pack
)
21547 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
21548 add_src_coords_attributes (parm_pack_die
, parm_pack
);
21550 for (arg
= pack_arg
; arg
; arg
= DECL_CHAIN (arg
))
21552 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
21555 gen_formal_parameter_die (arg
, NULL
,
21556 false /* Don't emit name attribute. */,
21561 return parm_pack_die
;
21564 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
21565 at the end of an (ANSI prototyped) formal parameters list. */
21568 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
21570 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
21573 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
21574 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
21575 parameters as specified in some function type specification (except for
21576 those which appear as part of a function *definition*). */
21579 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
21582 tree formal_type
= NULL
;
21583 tree first_parm_type
;
21586 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
21588 arg
= DECL_ARGUMENTS (function_or_method_type
);
21589 function_or_method_type
= TREE_TYPE (function_or_method_type
);
21594 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
21596 /* Make our first pass over the list of formal parameter types and output a
21597 DW_TAG_formal_parameter DIE for each one. */
21598 for (link
= first_parm_type
; link
; )
21600 dw_die_ref parm_die
;
21602 formal_type
= TREE_VALUE (link
);
21603 if (formal_type
== void_type_node
)
21606 /* Output a (nameless) DIE to represent the formal parameter itself. */
21607 if (!POINTER_BOUNDS_TYPE_P (formal_type
))
21609 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
21610 true /* Emit name attribute. */,
21612 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
21613 && link
== first_parm_type
)
21615 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
21616 if (dwarf_version
>= 3 || !dwarf_strict
)
21617 add_AT_die_ref (context_die
, DW_AT_object_pointer
, parm_die
);
21619 else if (arg
&& DECL_ARTIFICIAL (arg
))
21620 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
21623 link
= TREE_CHAIN (link
);
21625 arg
= DECL_CHAIN (arg
);
21628 /* If this function type has an ellipsis, add a
21629 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
21630 if (formal_type
!= void_type_node
)
21631 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
21633 /* Make our second (and final) pass over the list of formal parameter types
21634 and output DIEs to represent those types (as necessary). */
21635 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
21636 link
&& TREE_VALUE (link
);
21637 link
= TREE_CHAIN (link
))
21638 gen_type_die (TREE_VALUE (link
), context_die
);
21641 /* We want to generate the DIE for TYPE so that we can generate the
21642 die for MEMBER, which has been defined; we will need to refer back
21643 to the member declaration nested within TYPE. If we're trying to
21644 generate minimal debug info for TYPE, processing TYPE won't do the
21645 trick; we need to attach the member declaration by hand. */
21648 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
21650 gen_type_die (type
, context_die
);
21652 /* If we're trying to avoid duplicate debug info, we may not have
21653 emitted the member decl for this function. Emit it now. */
21654 if (TYPE_STUB_DECL (type
)
21655 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
21656 && ! lookup_decl_die (member
))
21658 dw_die_ref type_die
;
21659 gcc_assert (!decl_ultimate_origin (member
));
21661 push_decl_scope (type
);
21662 type_die
= lookup_type_die_strip_naming_typedef (type
);
21663 if (TREE_CODE (member
) == FUNCTION_DECL
)
21664 gen_subprogram_die (member
, type_die
);
21665 else if (TREE_CODE (member
) == FIELD_DECL
)
21667 /* Ignore the nameless fields that are used to skip bits but handle
21668 C++ anonymous unions and structs. */
21669 if (DECL_NAME (member
) != NULL_TREE
21670 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
21671 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
21673 struct vlr_context vlr_ctx
= {
21674 DECL_CONTEXT (member
), /* struct_type */
21675 NULL_TREE
/* variant_part_offset */
21677 gen_type_die (member_declared_type (member
), type_die
);
21678 gen_field_die (member
, &vlr_ctx
, type_die
);
21682 gen_variable_die (member
, NULL_TREE
, type_die
);
21688 /* Forward declare these functions, because they are mutually recursive
21689 with their set_block_* pairing functions. */
21690 static void set_decl_origin_self (tree
);
21692 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
21693 given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
21694 that it points to the node itself, thus indicating that the node is its
21695 own (abstract) origin. Additionally, if the BLOCK_ABSTRACT_ORIGIN for
21696 the given node is NULL, recursively descend the decl/block tree which
21697 it is the root of, and for each other ..._DECL or BLOCK node contained
21698 therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
21699 still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
21700 values to point to themselves. */
21703 set_block_origin_self (tree stmt
)
21705 if (BLOCK_ABSTRACT_ORIGIN (stmt
) == NULL_TREE
)
21707 BLOCK_ABSTRACT_ORIGIN (stmt
) = stmt
;
21712 for (local_decl
= BLOCK_VARS (stmt
);
21713 local_decl
!= NULL_TREE
;
21714 local_decl
= DECL_CHAIN (local_decl
))
21715 /* Do not recurse on nested functions since the inlining status
21716 of parent and child can be different as per the DWARF spec. */
21717 if (TREE_CODE (local_decl
) != FUNCTION_DECL
21718 && !DECL_EXTERNAL (local_decl
))
21719 set_decl_origin_self (local_decl
);
21725 for (subblock
= BLOCK_SUBBLOCKS (stmt
);
21726 subblock
!= NULL_TREE
;
21727 subblock
= BLOCK_CHAIN (subblock
))
21728 set_block_origin_self (subblock
); /* Recurse. */
21733 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
21734 the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
21735 node to so that it points to the node itself, thus indicating that the
21736 node represents its own (abstract) origin. Additionally, if the
21737 DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
21738 the decl/block tree of which the given node is the root of, and for
21739 each other ..._DECL or BLOCK node contained therein whose
21740 DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
21741 set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
21742 point to themselves. */
21745 set_decl_origin_self (tree decl
)
21747 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL_TREE
)
21749 DECL_ABSTRACT_ORIGIN (decl
) = decl
;
21750 if (TREE_CODE (decl
) == FUNCTION_DECL
)
21754 for (arg
= DECL_ARGUMENTS (decl
); arg
; arg
= DECL_CHAIN (arg
))
21755 DECL_ABSTRACT_ORIGIN (arg
) = arg
;
21756 if (DECL_INITIAL (decl
) != NULL_TREE
21757 && DECL_INITIAL (decl
) != error_mark_node
)
21758 set_block_origin_self (DECL_INITIAL (decl
));
21763 /* Mark the early DIE for DECL as the abstract instance. */
21766 dwarf2out_abstract_function (tree decl
)
21768 dw_die_ref old_die
;
21770 /* Make sure we have the actual abstract inline, not a clone. */
21771 decl
= DECL_ORIGIN (decl
);
21773 if (DECL_IGNORED_P (decl
))
21776 old_die
= lookup_decl_die (decl
);
21777 /* With early debug we always have an old DIE unless we are in LTO
21778 and the user did not compile but only link with debug. */
21779 if (in_lto_p
&& ! old_die
)
21781 gcc_assert (old_die
!= NULL
);
21782 if (get_AT (old_die
, DW_AT_inline
)
21783 || get_AT (old_die
, DW_AT_abstract_origin
))
21784 /* We've already generated the abstract instance. */
21787 /* Go ahead and put DW_AT_inline on the DIE. */
21788 if (DECL_DECLARED_INLINE_P (decl
))
21790 if (cgraph_function_possibly_inlined_p (decl
))
21791 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_inlined
);
21793 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
21797 if (cgraph_function_possibly_inlined_p (decl
))
21798 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_inlined
);
21800 add_AT_unsigned (old_die
, DW_AT_inline
, DW_INL_not_inlined
);
21803 if (DECL_DECLARED_INLINE_P (decl
)
21804 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
21805 add_AT_flag (old_die
, DW_AT_artificial
, 1);
21807 set_decl_origin_self (decl
);
21810 /* Helper function of premark_used_types() which gets called through
21813 Marks the DIE of a given type in *SLOT as perennial, so it never gets
21814 marked as unused by prune_unused_types. */
21817 premark_used_types_helper (tree
const &type
, void *)
21821 die
= lookup_type_die (type
);
21823 die
->die_perennial_p
= 1;
21827 /* Helper function of premark_types_used_by_global_vars which gets called
21828 through htab_traverse.
21830 Marks the DIE of a given type in *SLOT as perennial, so it never gets
21831 marked as unused by prune_unused_types. The DIE of the type is marked
21832 only if the global variable using the type will actually be emitted. */
21835 premark_types_used_by_global_vars_helper (types_used_by_vars_entry
**slot
,
21838 struct types_used_by_vars_entry
*entry
;
21841 entry
= (struct types_used_by_vars_entry
*) *slot
;
21842 gcc_assert (entry
->type
!= NULL
21843 && entry
->var_decl
!= NULL
);
21844 die
= lookup_type_die (entry
->type
);
21847 /* Ask cgraph if the global variable really is to be emitted.
21848 If yes, then we'll keep the DIE of ENTRY->TYPE. */
21849 varpool_node
*node
= varpool_node::get (entry
->var_decl
);
21850 if (node
&& node
->definition
)
21852 die
->die_perennial_p
= 1;
21853 /* Keep the parent DIEs as well. */
21854 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
21855 die
->die_perennial_p
= 1;
21861 /* Mark all members of used_types_hash as perennial. */
21864 premark_used_types (struct function
*fun
)
21866 if (fun
&& fun
->used_types_hash
)
21867 fun
->used_types_hash
->traverse
<void *, premark_used_types_helper
> (NULL
);
21870 /* Mark all members of types_used_by_vars_entry as perennial. */
21873 premark_types_used_by_global_vars (void)
21875 if (types_used_by_vars_hash
)
21876 types_used_by_vars_hash
21877 ->traverse
<void *, premark_types_used_by_global_vars_helper
> (NULL
);
21880 /* Generate a DW_TAG_call_site DIE in function DECL under SUBR_DIE
21881 for CA_LOC call arg loc node. */
21884 gen_call_site_die (tree decl
, dw_die_ref subr_die
,
21885 struct call_arg_loc_node
*ca_loc
)
21887 dw_die_ref stmt_die
= NULL
, die
;
21888 tree block
= ca_loc
->block
;
21891 && block
!= DECL_INITIAL (decl
)
21892 && TREE_CODE (block
) == BLOCK
)
21894 stmt_die
= BLOCK_DIE (block
);
21897 block
= BLOCK_SUPERCONTEXT (block
);
21899 if (stmt_die
== NULL
)
21900 stmt_die
= subr_die
;
21901 die
= new_die (dwarf_TAG (DW_TAG_call_site
), stmt_die
, NULL_TREE
);
21902 add_AT_lbl_id (die
, dwarf_AT (DW_AT_call_return_pc
), ca_loc
->label
);
21903 if (ca_loc
->tail_call_p
)
21904 add_AT_flag (die
, dwarf_AT (DW_AT_call_tail_call
), 1);
21905 if (ca_loc
->symbol_ref
)
21907 dw_die_ref tdie
= lookup_decl_die (SYMBOL_REF_DECL (ca_loc
->symbol_ref
));
21909 add_AT_die_ref (die
, dwarf_AT (DW_AT_call_origin
), tdie
);
21911 add_AT_addr (die
, dwarf_AT (DW_AT_call_origin
), ca_loc
->symbol_ref
,
21917 /* Generate a DIE to represent a declared function (either file-scope or
21921 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
21923 tree origin
= decl_ultimate_origin (decl
);
21924 dw_die_ref subr_die
;
21925 dw_die_ref old_die
= lookup_decl_die (decl
);
21927 /* This function gets called multiple times for different stages of
21928 the debug process. For example, for func() in this code:
21932 void func() { ... }
21935 ...we get called 4 times. Twice in early debug and twice in
21941 1. Once while generating func() within the namespace. This is
21942 the declaration. The declaration bit below is set, as the
21943 context is the namespace.
21945 A new DIE will be generated with DW_AT_declaration set.
21947 2. Once for func() itself. This is the specification. The
21948 declaration bit below is clear as the context is the CU.
21950 We will use the cached DIE from (1) to create a new DIE with
21951 DW_AT_specification pointing to the declaration in (1).
21953 Late debug via rest_of_handle_final()
21954 -------------------------------------
21956 3. Once generating func() within the namespace. This is also the
21957 declaration, as in (1), but this time we will early exit below
21958 as we have a cached DIE and a declaration needs no additional
21959 annotations (no locations), as the source declaration line
21962 4. Once for func() itself. As in (2), this is the specification,
21963 but this time we will re-use the cached DIE, and just annotate
21964 it with the location information that should now be available.
21966 For something without namespaces, but with abstract instances, we
21967 are also called a multiple times:
21972 Base (); // constructor declaration (1)
21975 Base::Base () { } // constructor specification (2)
21980 1. Once for the Base() constructor by virtue of it being a
21981 member of the Base class. This is done via
21982 rest_of_type_compilation.
21984 This is a declaration, so a new DIE will be created with
21987 2. Once for the Base() constructor definition, but this time
21988 while generating the abstract instance of the base
21989 constructor (__base_ctor) which is being generated via early
21990 debug of reachable functions.
21992 Even though we have a cached version of the declaration (1),
21993 we will create a DW_AT_specification of the declaration DIE
21996 3. Once for the __base_ctor itself, but this time, we generate
21997 an DW_AT_abstract_origin version of the DW_AT_specification in
22000 Late debug via rest_of_handle_final
22001 -----------------------------------
22003 4. One final time for the __base_ctor (which will have a cached
22004 DIE with DW_AT_abstract_origin created in (3). This time,
22005 we will just annotate the location information now
22008 int declaration
= (current_function_decl
!= decl
22009 || class_or_namespace_scope_p (context_die
));
22011 /* Now that the C++ front end lazily declares artificial member fns, we
22012 might need to retrofit the declaration into its class. */
22013 if (!declaration
&& !origin
&& !old_die
22014 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
22015 && !class_or_namespace_scope_p (context_die
)
22016 && debug_info_level
> DINFO_LEVEL_TERSE
)
22017 old_die
= force_decl_die (decl
);
22019 /* A concrete instance, tag a new DIE with DW_AT_abstract_origin. */
22020 if (origin
!= NULL
)
22022 gcc_assert (!declaration
|| local_scope_p (context_die
));
22024 /* Fixup die_parent for the abstract instance of a nested
22025 inline function. */
22026 if (old_die
&& old_die
->die_parent
== NULL
)
22027 add_child_die (context_die
, old_die
);
22029 if (old_die
&& get_AT_ref (old_die
, DW_AT_abstract_origin
))
22031 /* If we have a DW_AT_abstract_origin we have a working
22033 subr_die
= old_die
;
22037 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22038 add_abstract_origin_attribute (subr_die
, origin
);
22039 /* This is where the actual code for a cloned function is.
22040 Let's emit linkage name attribute for it. This helps
22041 debuggers to e.g, set breakpoints into
22042 constructors/destructors when the user asks "break
22044 add_linkage_name (subr_die
, decl
);
22047 /* A cached copy, possibly from early dwarf generation. Reuse as
22048 much as possible. */
22051 /* A declaration that has been previously dumped needs no
22052 additional information. */
22056 if (!get_AT_flag (old_die
, DW_AT_declaration
)
22057 /* We can have a normal definition following an inline one in the
22058 case of redefinition of GNU C extern inlines.
22059 It seems reasonable to use AT_specification in this case. */
22060 && !get_AT (old_die
, DW_AT_inline
))
22062 /* Detect and ignore this case, where we are trying to output
22063 something we have already output. */
22064 if (get_AT (old_die
, DW_AT_low_pc
)
22065 || get_AT (old_die
, DW_AT_ranges
))
22068 /* If we have no location information, this must be a
22069 partially generated DIE from early dwarf generation.
22070 Fall through and generate it. */
22073 /* If the definition comes from the same place as the declaration,
22074 maybe use the old DIE. We always want the DIE for this function
22075 that has the *_pc attributes to be under comp_unit_die so the
22076 debugger can find it. We also need to do this for abstract
22077 instances of inlines, since the spec requires the out-of-line copy
22078 to have the same parent. For local class methods, this doesn't
22079 apply; we just use the old DIE. */
22080 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
22081 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
22082 if ((is_cu_die (old_die
->die_parent
)
22083 /* This condition fixes the inconsistency/ICE with the
22084 following Fortran test (or some derivative thereof) while
22085 building libgfortran:
22089 logical function funky (FLAG)
22094 || (old_die
->die_parent
22095 && old_die
->die_parent
->die_tag
== DW_TAG_module
)
22096 || context_die
== NULL
)
22097 && (DECL_ARTIFICIAL (decl
)
22098 /* The location attributes may be in the abstract origin
22099 which in the case of LTO might be not available to
22101 || get_AT (old_die
, DW_AT_abstract_origin
)
22102 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
22103 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
22104 == (unsigned) s
.line
)
22105 && (!debug_column_info
22107 || (get_AT_unsigned (old_die
, DW_AT_decl_column
)
22108 == (unsigned) s
.column
)))))
22110 subr_die
= old_die
;
22112 /* Clear out the declaration attribute, but leave the
22113 parameters so they can be augmented with location
22114 information later. Unless this was a declaration, in
22115 which case, wipe out the nameless parameters and recreate
22116 them further down. */
22117 if (remove_AT (subr_die
, DW_AT_declaration
))
22120 remove_AT (subr_die
, DW_AT_object_pointer
);
22121 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
22124 /* Make a specification pointing to the previously built
22128 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22129 add_AT_specification (subr_die
, old_die
);
22130 add_pubname (decl
, subr_die
);
22131 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
22132 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
22133 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
22134 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
22135 if (debug_column_info
22137 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
22138 != (unsigned) s
.column
))
22139 add_AT_unsigned (subr_die
, DW_AT_decl_column
, s
.column
);
22141 /* If the prototype had an 'auto' or 'decltype(auto)' return type,
22142 emit the real type on the definition die. */
22143 if (is_cxx () && debug_info_level
> DINFO_LEVEL_TERSE
)
22145 dw_die_ref die
= get_AT_ref (old_die
, DW_AT_type
);
22146 if (die
== auto_die
|| die
== decltype_auto_die
)
22147 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
22148 TYPE_UNQUALIFIED
, false, context_die
);
22151 /* When we process the method declaration, we haven't seen
22152 the out-of-class defaulted definition yet, so we have to
22154 if ((dwarf_version
>= 5 || ! dwarf_strict
)
22155 && !get_AT (subr_die
, DW_AT_defaulted
))
22158 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22160 if (defaulted
!= -1)
22162 /* Other values must have been handled before. */
22163 gcc_assert (defaulted
== DW_DEFAULTED_out_of_class
);
22164 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
22169 /* Create a fresh DIE for anything else. */
22172 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
22174 if (TREE_PUBLIC (decl
))
22175 add_AT_flag (subr_die
, DW_AT_external
, 1);
22177 add_name_and_src_coords_attributes (subr_die
, decl
);
22178 add_pubname (decl
, subr_die
);
22179 if (debug_info_level
> DINFO_LEVEL_TERSE
)
22181 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
22182 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
22183 TYPE_UNQUALIFIED
, false, context_die
);
22186 add_pure_or_virtual_attribute (subr_die
, decl
);
22187 if (DECL_ARTIFICIAL (decl
))
22188 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
22190 if (TREE_THIS_VOLATILE (decl
) && (dwarf_version
>= 5 || !dwarf_strict
))
22191 add_AT_flag (subr_die
, DW_AT_noreturn
, 1);
22193 add_alignment_attribute (subr_die
, decl
);
22195 add_accessibility_attribute (subr_die
, decl
);
22198 /* Unless we have an existing non-declaration DIE, equate the new
22200 if (!old_die
|| is_declaration_die (old_die
))
22201 equate_decl_number_to_die (decl
, subr_die
);
22205 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
22207 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
22209 /* If this is an explicit function declaration then generate
22210 a DW_AT_explicit attribute. */
22211 if ((dwarf_version
>= 3 || !dwarf_strict
)
22212 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22213 DW_AT_explicit
) == 1)
22214 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
22216 /* If this is a C++11 deleted special function member then generate
22217 a DW_AT_deleted attribute. */
22218 if ((dwarf_version
>= 5 || !dwarf_strict
)
22219 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22220 DW_AT_deleted
) == 1)
22221 add_AT_flag (subr_die
, DW_AT_deleted
, 1);
22223 /* If this is a C++11 defaulted special function member then
22224 generate a DW_AT_defaulted attribute. */
22225 if (dwarf_version
>= 5 || !dwarf_strict
)
22228 = lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22230 if (defaulted
!= -1)
22231 add_AT_unsigned (subr_die
, DW_AT_defaulted
, defaulted
);
22234 /* If this is a C++11 non-static member function with & ref-qualifier
22235 then generate a DW_AT_reference attribute. */
22236 if ((dwarf_version
>= 5 || !dwarf_strict
)
22237 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22238 DW_AT_reference
) == 1)
22239 add_AT_flag (subr_die
, DW_AT_reference
, 1);
22241 /* If this is a C++11 non-static member function with &&
22242 ref-qualifier then generate a DW_AT_reference attribute. */
22243 if ((dwarf_version
>= 5 || !dwarf_strict
)
22244 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
22245 DW_AT_rvalue_reference
)
22247 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
22250 /* For non DECL_EXTERNALs, if range information is available, fill
22251 the DIE with it. */
22252 else if (!DECL_EXTERNAL (decl
) && !early_dwarf
)
22254 HOST_WIDE_INT cfa_fb_offset
;
22256 struct function
*fun
= DECL_STRUCT_FUNCTION (decl
);
22258 if (!crtl
->has_bb_partition
)
22260 dw_fde_ref fde
= fun
->fde
;
22261 if (fde
->dw_fde_begin
)
22263 /* We have already generated the labels. */
22264 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
22265 fde
->dw_fde_end
, false);
22269 /* Create start/end labels and add the range. */
22270 char label_id_low
[MAX_ARTIFICIAL_LABEL_BYTES
];
22271 char label_id_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
22272 ASM_GENERATE_INTERNAL_LABEL (label_id_low
, FUNC_BEGIN_LABEL
,
22273 current_function_funcdef_no
);
22274 ASM_GENERATE_INTERNAL_LABEL (label_id_high
, FUNC_END_LABEL
,
22275 current_function_funcdef_no
);
22276 add_AT_low_high_pc (subr_die
, label_id_low
, label_id_high
,
22280 #if VMS_DEBUGGING_INFO
22281 /* HP OpenVMS Industry Standard 64: DWARF Extensions
22282 Section 2.3 Prologue and Epilogue Attributes:
22283 When a breakpoint is set on entry to a function, it is generally
22284 desirable for execution to be suspended, not on the very first
22285 instruction of the function, but rather at a point after the
22286 function's frame has been set up, after any language defined local
22287 declaration processing has been completed, and before execution of
22288 the first statement of the function begins. Debuggers generally
22289 cannot properly determine where this point is. Similarly for a
22290 breakpoint set on exit from a function. The prologue and epilogue
22291 attributes allow a compiler to communicate the location(s) to use. */
22294 if (fde
->dw_fde_vms_end_prologue
)
22295 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
22296 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
22298 if (fde
->dw_fde_vms_begin_epilogue
)
22299 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
22300 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
22307 /* Generate pubnames entries for the split function code ranges. */
22308 dw_fde_ref fde
= fun
->fde
;
22310 if (fde
->dw_fde_second_begin
)
22312 if (dwarf_version
>= 3 || !dwarf_strict
)
22314 /* We should use ranges for non-contiguous code section
22315 addresses. Use the actual code range for the initial
22316 section, since the HOT/COLD labels might precede an
22317 alignment offset. */
22318 bool range_list_added
= false;
22319 add_ranges_by_labels (subr_die
, fde
->dw_fde_begin
,
22320 fde
->dw_fde_end
, &range_list_added
,
22322 add_ranges_by_labels (subr_die
, fde
->dw_fde_second_begin
,
22323 fde
->dw_fde_second_end
,
22324 &range_list_added
, false);
22325 if (range_list_added
)
22330 /* There is no real support in DW2 for this .. so we make
22331 a work-around. First, emit the pub name for the segment
22332 containing the function label. Then make and emit a
22333 simplified subprogram DIE for the second segment with the
22334 name pre-fixed by __hot/cold_sect_of_. We use the same
22335 linkage name for the second die so that gdb will find both
22336 sections when given "b foo". */
22337 const char *name
= NULL
;
22338 tree decl_name
= DECL_NAME (decl
);
22339 dw_die_ref seg_die
;
22341 /* Do the 'primary' section. */
22342 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
,
22343 fde
->dw_fde_end
, false);
22345 /* Build a minimal DIE for the secondary section. */
22346 seg_die
= new_die (DW_TAG_subprogram
,
22347 subr_die
->die_parent
, decl
);
22349 if (TREE_PUBLIC (decl
))
22350 add_AT_flag (seg_die
, DW_AT_external
, 1);
22352 if (decl_name
!= NULL
22353 && IDENTIFIER_POINTER (decl_name
) != NULL
)
22355 name
= dwarf2_name (decl
, 1);
22356 if (! DECL_ARTIFICIAL (decl
))
22357 add_src_coords_attributes (seg_die
, decl
);
22359 add_linkage_name (seg_die
, decl
);
22361 gcc_assert (name
!= NULL
);
22362 add_pure_or_virtual_attribute (seg_die
, decl
);
22363 if (DECL_ARTIFICIAL (decl
))
22364 add_AT_flag (seg_die
, DW_AT_artificial
, 1);
22366 name
= concat ("__second_sect_of_", name
, NULL
);
22367 add_AT_low_high_pc (seg_die
, fde
->dw_fde_second_begin
,
22368 fde
->dw_fde_second_end
, false);
22369 add_name_attribute (seg_die
, name
);
22370 if (want_pubnames ())
22371 add_pubname_string (name
, seg_die
);
22375 add_AT_low_high_pc (subr_die
, fde
->dw_fde_begin
, fde
->dw_fde_end
,
22379 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
22381 /* We define the "frame base" as the function's CFA. This is more
22382 convenient for several reasons: (1) It's stable across the prologue
22383 and epilogue, which makes it better than just a frame pointer,
22384 (2) With dwarf3, there exists a one-byte encoding that allows us
22385 to reference the .debug_frame data by proxy, but failing that,
22386 (3) We can at least reuse the code inspection and interpretation
22387 code that determines the CFA position at various points in the
22389 if (dwarf_version
>= 3 && targetm
.debug_unwind_info () == UI_DWARF2
)
22391 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
22392 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
22396 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
22397 if (list
->dw_loc_next
)
22398 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
22400 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
22403 /* Compute a displacement from the "steady-state frame pointer" to
22404 the CFA. The former is what all stack slots and argument slots
22405 will reference in the rtl; the latter is what we've told the
22406 debugger about. We'll need to adjust all frame_base references
22407 by this displacement. */
22408 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
22410 if (fun
->static_chain_decl
)
22412 /* DWARF requires here a location expression that computes the
22413 address of the enclosing subprogram's frame base. The machinery
22414 in tree-nested.c is supposed to store this specific address in the
22415 last field of the FRAME record. */
22416 const tree frame_type
22417 = TREE_TYPE (TREE_TYPE (fun
->static_chain_decl
));
22418 const tree fb_decl
= tree_last (TYPE_FIELDS (frame_type
));
22421 = build1 (INDIRECT_REF
, frame_type
, fun
->static_chain_decl
);
22422 fb_expr
= build3 (COMPONENT_REF
, TREE_TYPE (fb_decl
),
22423 fb_expr
, fb_decl
, NULL_TREE
);
22425 add_AT_location_description (subr_die
, DW_AT_static_link
,
22426 loc_list_from_tree (fb_expr
, 0, NULL
));
22429 resolve_variable_values ();
22432 /* Generate child dies for template paramaters. */
22433 if (early_dwarf
&& debug_info_level
> DINFO_LEVEL_TERSE
)
22434 gen_generic_params_dies (decl
);
22436 /* Now output descriptions of the arguments for this function. This gets
22437 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
22438 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
22439 `...' at the end of the formal parameter list. In order to find out if
22440 there was a trailing ellipsis or not, we must instead look at the type
22441 associated with the FUNCTION_DECL. This will be a node of type
22442 FUNCTION_TYPE. If the chain of type nodes hanging off of this
22443 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
22444 an ellipsis at the end. */
22446 /* In the case where we are describing a mere function declaration, all we
22447 need to do here (and all we *can* do here) is to describe the *types* of
22448 its formal parameters. */
22449 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
22451 else if (declaration
)
22452 gen_formal_types_die (decl
, subr_die
);
22455 /* Generate DIEs to represent all known formal parameters. */
22456 tree parm
= DECL_ARGUMENTS (decl
);
22457 tree generic_decl
= early_dwarf
22458 ? lang_hooks
.decls
.get_generic_function_decl (decl
) : NULL
;
22459 tree generic_decl_parm
= generic_decl
22460 ? DECL_ARGUMENTS (generic_decl
)
22463 /* Now we want to walk the list of parameters of the function and
22464 emit their relevant DIEs.
22466 We consider the case of DECL being an instance of a generic function
22467 as well as it being a normal function.
22469 If DECL is an instance of a generic function we walk the
22470 parameters of the generic function declaration _and_ the parameters of
22471 DECL itself. This is useful because we want to emit specific DIEs for
22472 function parameter packs and those are declared as part of the
22473 generic function declaration. In that particular case,
22474 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
22475 That DIE has children DIEs representing the set of arguments
22476 of the pack. Note that the set of pack arguments can be empty.
22477 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
22480 Otherwise, we just consider the parameters of DECL. */
22481 while (generic_decl_parm
|| parm
)
22483 if (generic_decl_parm
22484 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
22485 gen_formal_parameter_pack_die (generic_decl_parm
,
22488 else if (parm
&& !POINTER_BOUNDS_P (parm
))
22490 dw_die_ref parm_die
= gen_decl_die (parm
, NULL
, NULL
, subr_die
);
22493 && parm
== DECL_ARGUMENTS (decl
)
22494 && TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
22496 && (dwarf_version
>= 3 || !dwarf_strict
))
22497 add_AT_die_ref (subr_die
, DW_AT_object_pointer
, parm_die
);
22499 parm
= DECL_CHAIN (parm
);
22502 parm
= DECL_CHAIN (parm
);
22504 if (generic_decl_parm
)
22505 generic_decl_parm
= DECL_CHAIN (generic_decl_parm
);
22508 /* Decide whether we need an unspecified_parameters DIE at the end.
22509 There are 2 more cases to do this for: 1) the ansi ... declaration -
22510 this is detectable when the end of the arg list is not a
22511 void_type_node 2) an unprototyped function declaration (not a
22512 definition). This just means that we have no info about the
22513 parameters at all. */
22516 if (prototype_p (TREE_TYPE (decl
)))
22518 /* This is the prototyped case, check for.... */
22519 if (stdarg_p (TREE_TYPE (decl
)))
22520 gen_unspecified_parameters_die (decl
, subr_die
);
22522 else if (DECL_INITIAL (decl
) == NULL_TREE
)
22523 gen_unspecified_parameters_die (decl
, subr_die
);
22527 if (subr_die
!= old_die
)
22528 /* Add the calling convention attribute if requested. */
22529 add_calling_convention_attribute (subr_die
, decl
);
22531 /* Output Dwarf info for all of the stuff within the body of the function
22532 (if it has one - it may be just a declaration).
22534 OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
22535 a function. This BLOCK actually represents the outermost binding contour
22536 for the function, i.e. the contour in which the function's formal
22537 parameters and labels get declared. Curiously, it appears that the front
22538 end doesn't actually put the PARM_DECL nodes for the current function onto
22539 the BLOCK_VARS list for this outer scope, but are strung off of the
22540 DECL_ARGUMENTS list for the function instead.
22542 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
22543 the LABEL_DECL nodes for the function however, and we output DWARF info
22544 for those in decls_for_scope. Just within the `outer_scope' there will be
22545 a BLOCK node representing the function's outermost pair of curly braces,
22546 and any blocks used for the base and member initializers of a C++
22547 constructor function. */
22548 tree outer_scope
= DECL_INITIAL (decl
);
22549 if (! declaration
&& outer_scope
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
22551 int call_site_note_count
= 0;
22552 int tail_call_site_note_count
= 0;
22554 /* Emit a DW_TAG_variable DIE for a named return value. */
22555 if (DECL_NAME (DECL_RESULT (decl
)))
22556 gen_decl_die (DECL_RESULT (decl
), NULL
, NULL
, subr_die
);
22558 /* The first time through decls_for_scope we will generate the
22559 DIEs for the locals. The second time, we fill in the
22561 decls_for_scope (outer_scope
, subr_die
);
22563 if (call_arg_locations
&& (!dwarf_strict
|| dwarf_version
>= 5))
22565 struct call_arg_loc_node
*ca_loc
;
22566 for (ca_loc
= call_arg_locations
; ca_loc
; ca_loc
= ca_loc
->next
)
22568 dw_die_ref die
= NULL
;
22569 rtx tloc
= NULL_RTX
, tlocc
= NULL_RTX
;
22572 for (arg
= (ca_loc
->call_arg_loc_note
!= NULL_RTX
22573 ? NOTE_VAR_LOCATION (ca_loc
->call_arg_loc_note
)
22575 arg
; arg
= next_arg
)
22577 dw_loc_descr_ref reg
, val
;
22578 machine_mode mode
= GET_MODE (XEXP (XEXP (arg
, 0), 1));
22579 dw_die_ref cdie
, tdie
= NULL
;
22581 next_arg
= XEXP (arg
, 1);
22582 if (REG_P (XEXP (XEXP (arg
, 0), 0))
22584 && MEM_P (XEXP (XEXP (next_arg
, 0), 0))
22585 && REG_P (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0))
22586 && REGNO (XEXP (XEXP (arg
, 0), 0))
22587 == REGNO (XEXP (XEXP (XEXP (next_arg
, 0), 0), 0)))
22588 next_arg
= XEXP (next_arg
, 1);
22589 if (mode
== VOIDmode
)
22591 mode
= GET_MODE (XEXP (XEXP (arg
, 0), 0));
22592 if (mode
== VOIDmode
)
22593 mode
= GET_MODE (XEXP (arg
, 0));
22595 if (mode
== VOIDmode
|| mode
== BLKmode
)
22597 /* Get dynamic information about call target only if we
22598 have no static information: we cannot generate both
22599 DW_AT_call_origin and DW_AT_call_target
22601 if (ca_loc
->symbol_ref
== NULL_RTX
)
22603 if (XEXP (XEXP (arg
, 0), 0) == pc_rtx
)
22605 tloc
= XEXP (XEXP (arg
, 0), 1);
22608 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0)) == CLOBBER
22609 && XEXP (XEXP (XEXP (arg
, 0), 0), 0) == pc_rtx
)
22611 tlocc
= XEXP (XEXP (arg
, 0), 1);
22616 if (REG_P (XEXP (XEXP (arg
, 0), 0)))
22617 reg
= reg_loc_descriptor (XEXP (XEXP (arg
, 0), 0),
22618 VAR_INIT_STATUS_INITIALIZED
);
22619 else if (MEM_P (XEXP (XEXP (arg
, 0), 0)))
22621 rtx mem
= XEXP (XEXP (arg
, 0), 0);
22622 reg
= mem_loc_descriptor (XEXP (mem
, 0),
22623 get_address_mode (mem
),
22625 VAR_INIT_STATUS_INITIALIZED
);
22627 else if (GET_CODE (XEXP (XEXP (arg
, 0), 0))
22628 == DEBUG_PARAMETER_REF
)
22631 = DEBUG_PARAMETER_REF_DECL (XEXP (XEXP (arg
, 0), 0));
22632 tdie
= lookup_decl_die (tdecl
);
22639 && GET_CODE (XEXP (XEXP (arg
, 0), 0))
22640 != DEBUG_PARAMETER_REF
)
22642 val
= mem_loc_descriptor (XEXP (XEXP (arg
, 0), 1), mode
,
22644 VAR_INIT_STATUS_INITIALIZED
);
22648 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
22649 cdie
= new_die (dwarf_TAG (DW_TAG_call_site_parameter
), die
,
22652 add_AT_loc (cdie
, DW_AT_location
, reg
);
22653 else if (tdie
!= NULL
)
22654 add_AT_die_ref (cdie
, dwarf_AT (DW_AT_call_parameter
),
22656 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_value
), val
);
22657 if (next_arg
!= XEXP (arg
, 1))
22659 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 1));
22660 if (mode
== VOIDmode
)
22661 mode
= GET_MODE (XEXP (XEXP (XEXP (arg
, 1), 0), 0));
22662 val
= mem_loc_descriptor (XEXP (XEXP (XEXP (arg
, 1),
22665 VAR_INIT_STATUS_INITIALIZED
);
22667 add_AT_loc (cdie
, dwarf_AT (DW_AT_call_data_value
),
22672 && (ca_loc
->symbol_ref
|| tloc
))
22673 die
= gen_call_site_die (decl
, subr_die
, ca_loc
);
22674 if (die
!= NULL
&& (tloc
!= NULL_RTX
|| tlocc
!= NULL_RTX
))
22676 dw_loc_descr_ref tval
= NULL
;
22678 if (tloc
!= NULL_RTX
)
22679 tval
= mem_loc_descriptor (tloc
,
22680 GET_MODE (tloc
) == VOIDmode
22681 ? Pmode
: GET_MODE (tloc
),
22683 VAR_INIT_STATUS_INITIALIZED
);
22685 add_AT_loc (die
, dwarf_AT (DW_AT_call_target
), tval
);
22686 else if (tlocc
!= NULL_RTX
)
22688 tval
= mem_loc_descriptor (tlocc
,
22689 GET_MODE (tlocc
) == VOIDmode
22690 ? Pmode
: GET_MODE (tlocc
),
22692 VAR_INIT_STATUS_INITIALIZED
);
22695 dwarf_AT (DW_AT_call_target_clobbered
),
22701 call_site_note_count
++;
22702 if (ca_loc
->tail_call_p
)
22703 tail_call_site_note_count
++;
22707 call_arg_locations
= NULL
;
22708 call_arg_loc_last
= NULL
;
22709 if (tail_call_site_count
>= 0
22710 && tail_call_site_count
== tail_call_site_note_count
22711 && (!dwarf_strict
|| dwarf_version
>= 5))
22713 if (call_site_count
>= 0
22714 && call_site_count
== call_site_note_count
)
22715 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_calls
), 1);
22717 add_AT_flag (subr_die
, dwarf_AT (DW_AT_call_all_tail_calls
), 1);
22719 call_site_count
= -1;
22720 tail_call_site_count
= -1;
22723 /* Mark used types after we have created DIEs for the functions scopes. */
22724 premark_used_types (DECL_STRUCT_FUNCTION (decl
));
22727 /* Returns a hash value for X (which really is a die_struct). */
22730 block_die_hasher::hash (die_struct
*d
)
22732 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
22735 /* Return nonzero if decl_id and die_parent of die_struct X is the same
22736 as decl_id and die_parent of die_struct Y. */
22739 block_die_hasher::equal (die_struct
*x
, die_struct
*y
)
22741 return x
->decl_id
== y
->decl_id
&& x
->die_parent
== y
->die_parent
;
22744 /* Return TRUE if DECL, which may have been previously generated as
22745 OLD_DIE, is a candidate for a DW_AT_specification. DECLARATION is
22746 true if decl (or its origin) is either an extern declaration or a
22747 class/namespace scoped declaration.
22749 The declare_in_namespace support causes us to get two DIEs for one
22750 variable, both of which are declarations. We want to avoid
22751 considering one to be a specification, so we must test for
22752 DECLARATION and DW_AT_declaration. */
22754 decl_will_get_specification_p (dw_die_ref old_die
, tree decl
, bool declaration
)
22756 return (old_die
&& TREE_STATIC (decl
) && !declaration
22757 && get_AT_flag (old_die
, DW_AT_declaration
) == 1);
22760 /* Return true if DECL is a local static. */
22763 local_function_static (tree decl
)
22765 gcc_assert (VAR_P (decl
));
22766 return TREE_STATIC (decl
)
22767 && DECL_CONTEXT (decl
)
22768 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
;
22771 /* Generate a DIE to represent a declared data object.
22772 Either DECL or ORIGIN must be non-null. */
22775 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
22777 HOST_WIDE_INT off
= 0;
22779 tree decl_or_origin
= decl
? decl
: origin
;
22780 tree ultimate_origin
;
22781 dw_die_ref var_die
;
22782 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
22783 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
22784 || class_or_namespace_scope_p (context_die
));
22785 bool specialization_p
= false;
22786 bool no_linkage_name
= false;
22788 /* While C++ inline static data members have definitions inside of the
22789 class, force the first DIE to be a declaration, then let gen_member_die
22790 reparent it to the class context and call gen_variable_die again
22791 to create the outside of the class DIE for the definition. */
22795 && DECL_CONTEXT (decl
)
22796 && TYPE_P (DECL_CONTEXT (decl
))
22797 && lang_hooks
.decls
.decl_dwarf_attribute (decl
, DW_AT_inline
) != -1)
22799 declaration
= true;
22800 if (dwarf_version
< 5)
22801 no_linkage_name
= true;
22804 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
22805 if (decl
|| ultimate_origin
)
22806 origin
= ultimate_origin
;
22807 com_decl
= fortran_common (decl_or_origin
, &off
);
22809 /* Symbol in common gets emitted as a child of the common block, in the form
22810 of a data member. */
22813 dw_die_ref com_die
;
22814 dw_loc_list_ref loc
= NULL
;
22815 die_node com_die_arg
;
22817 var_die
= lookup_decl_die (decl_or_origin
);
22820 if (! early_dwarf
&& get_AT (var_die
, DW_AT_location
) == NULL
)
22822 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2, NULL
);
22827 /* Optimize the common case. */
22828 if (single_element_loc_list_p (loc
)
22829 && loc
->expr
->dw_loc_opc
== DW_OP_addr
22830 && loc
->expr
->dw_loc_next
== NULL
22831 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
22834 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
22835 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
22836 = plus_constant (GET_MODE (x
), x
, off
);
22839 loc_list_plus_const (loc
, off
);
22841 add_AT_location_description (var_die
, DW_AT_location
, loc
);
22842 remove_AT (var_die
, DW_AT_declaration
);
22848 if (common_block_die_table
== NULL
)
22849 common_block_die_table
= hash_table
<block_die_hasher
>::create_ggc (10);
22851 com_die_arg
.decl_id
= DECL_UID (com_decl
);
22852 com_die_arg
.die_parent
= context_die
;
22853 com_die
= common_block_die_table
->find (&com_die_arg
);
22855 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
22856 if (com_die
== NULL
)
22859 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
22862 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
22863 add_name_and_src_coords_attributes (com_die
, com_decl
);
22866 add_AT_location_description (com_die
, DW_AT_location
, loc
);
22867 /* Avoid sharing the same loc descriptor between
22868 DW_TAG_common_block and DW_TAG_variable. */
22869 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
22871 else if (DECL_EXTERNAL (decl_or_origin
))
22872 add_AT_flag (com_die
, DW_AT_declaration
, 1);
22873 if (want_pubnames ())
22874 add_pubname_string (cnam
, com_die
); /* ??? needed? */
22875 com_die
->decl_id
= DECL_UID (com_decl
);
22876 slot
= common_block_die_table
->find_slot (com_die
, INSERT
);
22879 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
22881 add_AT_location_description (com_die
, DW_AT_location
, loc
);
22882 loc
= loc_list_from_tree (com_decl
, 2, NULL
);
22883 remove_AT (com_die
, DW_AT_declaration
);
22885 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
22886 add_name_and_src_coords_attributes (var_die
, decl_or_origin
);
22887 add_type_attribute (var_die
, TREE_TYPE (decl_or_origin
),
22888 decl_quals (decl_or_origin
), false,
22890 add_alignment_attribute (var_die
, decl
);
22891 add_AT_flag (var_die
, DW_AT_external
, 1);
22896 /* Optimize the common case. */
22897 if (single_element_loc_list_p (loc
)
22898 && loc
->expr
->dw_loc_opc
== DW_OP_addr
22899 && loc
->expr
->dw_loc_next
== NULL
22900 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
22902 rtx x
= loc
->expr
->dw_loc_oprnd1
.v
.val_addr
;
22903 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
22904 = plus_constant (GET_MODE (x
), x
, off
);
22907 loc_list_plus_const (loc
, off
);
22909 add_AT_location_description (var_die
, DW_AT_location
, loc
);
22911 else if (DECL_EXTERNAL (decl_or_origin
))
22912 add_AT_flag (var_die
, DW_AT_declaration
, 1);
22914 equate_decl_number_to_die (decl
, var_die
);
22922 /* A declaration that has been previously dumped, needs no
22923 further annotations, since it doesn't need location on
22924 the second pass. */
22927 else if (decl_will_get_specification_p (old_die
, decl
, declaration
)
22928 && !get_AT (old_die
, DW_AT_specification
))
22930 /* Fall-thru so we can make a new variable die along with a
22931 DW_AT_specification. */
22933 else if (origin
&& old_die
->die_parent
!= context_die
)
22935 /* If we will be creating an inlined instance, we need a
22936 new DIE that will get annotated with
22937 DW_AT_abstract_origin. Clear things so we can get a
22939 gcc_assert (!DECL_ABSTRACT_P (decl
));
22944 /* If a DIE was dumped early, it still needs location info.
22945 Skip to where we fill the location bits. */
22948 /* ??? In LTRANS we cannot annotate early created variably
22949 modified type DIEs without copying them and adjusting all
22950 references to them. Thus we dumped them again, also add a
22951 reference to them. */
22952 tree type
= TREE_TYPE (decl_or_origin
);
22954 && variably_modified_type_p
22955 (type
, decl_function_context (decl_or_origin
)))
22957 if (decl_by_reference_p (decl_or_origin
))
22958 add_type_attribute (var_die
, TREE_TYPE (type
),
22959 TYPE_UNQUALIFIED
, false, context_die
);
22961 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
),
22962 false, context_die
);
22965 goto gen_variable_die_location
;
22969 /* For static data members, the declaration in the class is supposed
22970 to have DW_TAG_member tag in DWARF{3,4} and we emit it for compatibility
22971 also in DWARF2; the specification should still be DW_TAG_variable
22972 referencing the DW_TAG_member DIE. */
22973 if (declaration
&& class_scope_p (context_die
) && dwarf_version
< 5)
22974 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
22976 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
22978 if (origin
!= NULL
)
22979 add_abstract_origin_attribute (var_die
, origin
);
22981 /* Loop unrolling can create multiple blocks that refer to the same
22982 static variable, so we must test for the DW_AT_declaration flag.
22984 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
22985 copy decls and set the DECL_ABSTRACT_P flag on them instead of
22988 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
22989 else if (decl_will_get_specification_p (old_die
, decl
, declaration
))
22991 /* This is a definition of a C++ class level static. */
22992 add_AT_specification (var_die
, old_die
);
22993 specialization_p
= true;
22994 if (DECL_NAME (decl
))
22996 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
22997 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
22999 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
23000 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
23002 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
23003 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
23005 if (debug_column_info
23007 && (get_AT_unsigned (old_die
, DW_AT_decl_column
)
23008 != (unsigned) s
.column
))
23009 add_AT_unsigned (var_die
, DW_AT_decl_column
, s
.column
);
23011 if (old_die
->die_tag
== DW_TAG_member
)
23012 add_linkage_name (var_die
, decl
);
23016 add_name_and_src_coords_attributes (var_die
, decl
, no_linkage_name
);
23018 if ((origin
== NULL
&& !specialization_p
)
23020 && !DECL_ABSTRACT_P (decl_or_origin
)
23021 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
23022 decl_function_context
23023 (decl_or_origin
))))
23025 tree type
= TREE_TYPE (decl_or_origin
);
23027 if (decl_by_reference_p (decl_or_origin
))
23028 add_type_attribute (var_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
23031 add_type_attribute (var_die
, type
, decl_quals (decl_or_origin
), false,
23035 if (origin
== NULL
&& !specialization_p
)
23037 if (TREE_PUBLIC (decl
))
23038 add_AT_flag (var_die
, DW_AT_external
, 1);
23040 if (DECL_ARTIFICIAL (decl
))
23041 add_AT_flag (var_die
, DW_AT_artificial
, 1);
23043 add_alignment_attribute (var_die
, decl
);
23045 add_accessibility_attribute (var_die
, decl
);
23049 add_AT_flag (var_die
, DW_AT_declaration
, 1);
23051 if (decl
&& (DECL_ABSTRACT_P (decl
)
23052 || !old_die
|| is_declaration_die (old_die
)))
23053 equate_decl_number_to_die (decl
, var_die
);
23055 gen_variable_die_location
:
23057 && (! DECL_ABSTRACT_P (decl_or_origin
)
23058 /* Local static vars are shared between all clones/inlines,
23059 so emit DW_AT_location on the abstract DIE if DECL_RTL is
23061 || (VAR_P (decl_or_origin
)
23062 && TREE_STATIC (decl_or_origin
)
23063 && DECL_RTL_SET_P (decl_or_origin
))))
23066 add_pubname (decl_or_origin
, var_die
);
23068 add_location_or_const_value_attribute (var_die
, decl_or_origin
,
23072 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
23074 if ((dwarf_version
>= 4 || !dwarf_strict
)
23075 && lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
23076 DW_AT_const_expr
) == 1
23077 && !get_AT (var_die
, DW_AT_const_expr
)
23078 && !specialization_p
)
23079 add_AT_flag (var_die
, DW_AT_const_expr
, 1);
23083 int inl
= lang_hooks
.decls
.decl_dwarf_attribute (decl_or_origin
,
23086 && !get_AT (var_die
, DW_AT_inline
)
23087 && !specialization_p
)
23088 add_AT_unsigned (var_die
, DW_AT_inline
, inl
);
23092 /* Generate a DIE to represent a named constant. */
23095 gen_const_die (tree decl
, dw_die_ref context_die
)
23097 dw_die_ref const_die
;
23098 tree type
= TREE_TYPE (decl
);
23100 const_die
= lookup_decl_die (decl
);
23104 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
23105 equate_decl_number_to_die (decl
, const_die
);
23106 add_name_and_src_coords_attributes (const_die
, decl
);
23107 add_type_attribute (const_die
, type
, TYPE_QUAL_CONST
, false, context_die
);
23108 if (TREE_PUBLIC (decl
))
23109 add_AT_flag (const_die
, DW_AT_external
, 1);
23110 if (DECL_ARTIFICIAL (decl
))
23111 add_AT_flag (const_die
, DW_AT_artificial
, 1);
23112 tree_add_const_value_attribute_for_decl (const_die
, decl
);
23115 /* Generate a DIE to represent a label identifier. */
23118 gen_label_die (tree decl
, dw_die_ref context_die
)
23120 tree origin
= decl_ultimate_origin (decl
);
23121 dw_die_ref lbl_die
= lookup_decl_die (decl
);
23123 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
23127 lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
23128 equate_decl_number_to_die (decl
, lbl_die
);
23130 if (origin
!= NULL
)
23131 add_abstract_origin_attribute (lbl_die
, origin
);
23133 add_name_and_src_coords_attributes (lbl_die
, decl
);
23136 if (DECL_ABSTRACT_P (decl
))
23137 equate_decl_number_to_die (decl
, lbl_die
);
23138 else if (! early_dwarf
)
23140 insn
= DECL_RTL_IF_SET (decl
);
23142 /* Deleted labels are programmer specified labels which have been
23143 eliminated because of various optimizations. We still emit them
23144 here so that it is possible to put breakpoints on them. */
23148 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
23150 /* When optimization is enabled (via -O) some parts of the compiler
23151 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
23152 represent source-level labels which were explicitly declared by
23153 the user. This really shouldn't be happening though, so catch
23154 it if it ever does happen. */
23155 gcc_assert (!as_a
<rtx_insn
*> (insn
)->deleted ());
23157 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
23158 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
23162 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_DEBUG_LABEL
23163 && CODE_LABEL_NUMBER (insn
) != -1)
23165 ASM_GENERATE_INTERNAL_LABEL (label
, "LDL", CODE_LABEL_NUMBER (insn
));
23166 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
23171 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
23172 attributes to the DIE for a block STMT, to describe where the inlined
23173 function was called from. This is similar to add_src_coords_attributes. */
23176 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
23178 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
23180 if (dwarf_version
>= 3 || !dwarf_strict
)
23182 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
23183 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
23184 if (debug_column_info
&& s
.column
)
23185 add_AT_unsigned (die
, DW_AT_call_column
, s
.column
);
23190 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
23191 Add low_pc and high_pc attributes to the DIE for a block STMT. */
23194 add_high_low_attributes (tree stmt
, dw_die_ref die
)
23196 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
23198 if (BLOCK_FRAGMENT_CHAIN (stmt
)
23199 && (dwarf_version
>= 3 || !dwarf_strict
))
23201 tree chain
, superblock
= NULL_TREE
;
23203 dw_attr_node
*attr
= NULL
;
23205 if (inlined_function_outer_scope_p (stmt
))
23207 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
23208 BLOCK_NUMBER (stmt
));
23209 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
23212 /* Optimize duplicate .debug_ranges lists or even tails of
23213 lists. If this BLOCK has same ranges as its supercontext,
23214 lookup DW_AT_ranges attribute in the supercontext (and
23215 recursively so), verify that the ranges_table contains the
23216 right values and use it instead of adding a new .debug_range. */
23217 for (chain
= stmt
, pdie
= die
;
23218 BLOCK_SAME_RANGE (chain
);
23219 chain
= BLOCK_SUPERCONTEXT (chain
))
23221 dw_attr_node
*new_attr
;
23223 pdie
= pdie
->die_parent
;
23226 if (BLOCK_SUPERCONTEXT (chain
) == NULL_TREE
)
23228 new_attr
= get_AT (pdie
, DW_AT_ranges
);
23229 if (new_attr
== NULL
23230 || new_attr
->dw_attr_val
.val_class
!= dw_val_class_range_list
)
23233 superblock
= BLOCK_SUPERCONTEXT (chain
);
23236 && ((*ranges_table
)[attr
->dw_attr_val
.v
.val_offset
].num
23237 == BLOCK_NUMBER (superblock
))
23238 && BLOCK_FRAGMENT_CHAIN (superblock
))
23240 unsigned long off
= attr
->dw_attr_val
.v
.val_offset
;
23241 unsigned long supercnt
= 0, thiscnt
= 0;
23242 for (chain
= BLOCK_FRAGMENT_CHAIN (superblock
);
23243 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
23246 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
].num
23247 == BLOCK_NUMBER (chain
));
23249 gcc_checking_assert ((*ranges_table
)[off
+ supercnt
+ 1].num
== 0);
23250 for (chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
23251 chain
; chain
= BLOCK_FRAGMENT_CHAIN (chain
))
23253 gcc_assert (supercnt
>= thiscnt
);
23254 add_AT_range_list (die
, DW_AT_ranges
, off
+ supercnt
- thiscnt
,
23256 note_rnglist_head (off
+ supercnt
- thiscnt
);
23260 unsigned int offset
= add_ranges (stmt
, true);
23261 add_AT_range_list (die
, DW_AT_ranges
, offset
, false);
23262 note_rnglist_head (offset
);
23264 bool prev_in_cold
= BLOCK_IN_COLD_SECTION_P (stmt
);
23265 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
23268 add_ranges (chain
, prev_in_cold
!= BLOCK_IN_COLD_SECTION_P (chain
));
23269 prev_in_cold
= BLOCK_IN_COLD_SECTION_P (chain
);
23270 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
23277 char label_high
[MAX_ARTIFICIAL_LABEL_BYTES
];
23278 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
23279 BLOCK_NUMBER (stmt
));
23280 ASM_GENERATE_INTERNAL_LABEL (label_high
, BLOCK_END_LABEL
,
23281 BLOCK_NUMBER (stmt
));
23282 add_AT_low_high_pc (die
, label
, label_high
, false);
23286 /* Generate a DIE for a lexical block. */
23289 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
)
23291 dw_die_ref old_die
= BLOCK_DIE (stmt
);
23292 dw_die_ref stmt_die
= NULL
;
23295 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
23296 BLOCK_DIE (stmt
) = stmt_die
;
23299 if (BLOCK_ABSTRACT (stmt
))
23303 /* This must have been generated early and it won't even
23304 need location information since it's a DW_AT_inline
23307 for (dw_die_ref c
= context_die
; c
; c
= c
->die_parent
)
23308 if (c
->die_tag
== DW_TAG_inlined_subroutine
23309 || c
->die_tag
== DW_TAG_subprogram
)
23311 gcc_assert (get_AT (c
, DW_AT_inline
));
23317 else if (BLOCK_ABSTRACT_ORIGIN (stmt
))
23319 /* If this is an inlined instance, create a new lexical die for
23320 anything below to attach DW_AT_abstract_origin to. */
23323 stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
23324 BLOCK_DIE (stmt
) = stmt_die
;
23328 tree origin
= block_ultimate_origin (stmt
);
23329 if (origin
!= NULL_TREE
&& origin
!= stmt
)
23330 add_abstract_origin_attribute (stmt_die
, origin
);
23334 stmt_die
= old_die
;
23336 /* A non abstract block whose blocks have already been reordered
23337 should have the instruction range for this block. If so, set the
23338 high/low attributes. */
23339 if (!early_dwarf
&& !BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
23341 gcc_assert (stmt_die
);
23342 add_high_low_attributes (stmt
, stmt_die
);
23345 decls_for_scope (stmt
, stmt_die
);
23348 /* Generate a DIE for an inlined subprogram. */
23351 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
)
23355 /* The instance of function that is effectively being inlined shall not
23357 gcc_assert (! BLOCK_ABSTRACT (stmt
));
23359 decl
= block_ultimate_origin (stmt
);
23361 /* Make sure any inlined functions are known to be inlineable. */
23362 gcc_checking_assert (DECL_ABSTRACT_P (decl
)
23363 || cgraph_function_possibly_inlined_p (decl
));
23365 if (! BLOCK_ABSTRACT (stmt
))
23367 dw_die_ref subr_die
23368 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
23370 if (call_arg_locations
)
23371 BLOCK_DIE (stmt
) = subr_die
;
23372 add_abstract_origin_attribute (subr_die
, decl
);
23373 if (TREE_ASM_WRITTEN (stmt
))
23374 add_high_low_attributes (stmt
, subr_die
);
23375 add_call_src_coords_attributes (stmt
, subr_die
);
23377 decls_for_scope (stmt
, subr_die
);
23381 /* Generate a DIE for a field in a record, or structure. CTX is required: see
23382 the comment for VLR_CONTEXT. */
23385 gen_field_die (tree decl
, struct vlr_context
*ctx
, dw_die_ref context_die
)
23387 dw_die_ref decl_die
;
23389 if (TREE_TYPE (decl
) == error_mark_node
)
23392 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
23393 add_name_and_src_coords_attributes (decl_die
, decl
);
23394 add_type_attribute (decl_die
, member_declared_type (decl
), decl_quals (decl
),
23395 TYPE_REVERSE_STORAGE_ORDER (DECL_FIELD_CONTEXT (decl
)),
23398 if (DECL_BIT_FIELD_TYPE (decl
))
23400 add_byte_size_attribute (decl_die
, decl
);
23401 add_bit_size_attribute (decl_die
, decl
);
23402 add_bit_offset_attribute (decl_die
, decl
, ctx
);
23405 add_alignment_attribute (decl_die
, decl
);
23407 /* If we have a variant part offset, then we are supposed to process a member
23408 of a QUAL_UNION_TYPE, which is how we represent variant parts in
23410 gcc_assert (ctx
->variant_part_offset
== NULL_TREE
23411 || TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != QUAL_UNION_TYPE
);
23412 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
23413 add_data_member_location_attribute (decl_die
, decl
, ctx
);
23415 if (DECL_ARTIFICIAL (decl
))
23416 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
23418 add_accessibility_attribute (decl_die
, decl
);
23420 /* Equate decl number to die, so that we can look up this decl later on. */
23421 equate_decl_number_to_die (decl
, decl_die
);
23424 /* Generate a DIE for a pointer to a member type. TYPE can be an
23425 OFFSET_TYPE, for a pointer to data member, or a RECORD_TYPE, for a
23426 pointer to member function. */
23429 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
23431 if (lookup_type_die (type
))
23434 dw_die_ref ptr_die
= new_die (DW_TAG_ptr_to_member_type
,
23435 scope_die_for (type
, context_die
), type
);
23437 equate_type_number_to_die (type
, ptr_die
);
23438 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
23439 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
23440 add_type_attribute (ptr_die
, TREE_TYPE (type
), TYPE_UNQUALIFIED
, false,
23442 add_alignment_attribute (ptr_die
, type
);
23444 if (TREE_CODE (TREE_TYPE (type
)) != FUNCTION_TYPE
23445 && TREE_CODE (TREE_TYPE (type
)) != METHOD_TYPE
)
23447 dw_loc_descr_ref op
= new_loc_descr (DW_OP_plus
, 0, 0);
23448 add_AT_loc (ptr_die
, DW_AT_use_location
, op
);
23452 static char *producer_string
;
23454 /* Return a heap allocated producer string including command line options
23455 if -grecord-gcc-switches. */
23458 gen_producer_string (void)
23461 auto_vec
<const char *> switches
;
23462 const char *language_string
= lang_hooks
.name
;
23463 char *producer
, *tail
;
23465 size_t len
= dwarf_record_gcc_switches
? 0 : 3;
23466 size_t plen
= strlen (language_string
) + 1 + strlen (version_string
);
23468 for (j
= 1; dwarf_record_gcc_switches
&& j
< save_decoded_options_count
; j
++)
23469 switch (save_decoded_options
[j
].opt_index
)
23476 case OPT_auxbase_strip
:
23485 case OPT_SPECIAL_unknown
:
23486 case OPT_SPECIAL_ignore
:
23487 case OPT_SPECIAL_program_name
:
23488 case OPT_SPECIAL_input_file
:
23489 case OPT_grecord_gcc_switches
:
23490 case OPT__output_pch_
:
23491 case OPT_fdiagnostics_show_location_
:
23492 case OPT_fdiagnostics_show_option
:
23493 case OPT_fdiagnostics_show_caret
:
23494 case OPT_fdiagnostics_color_
:
23495 case OPT_fverbose_asm
:
23497 case OPT__sysroot_
:
23499 case OPT_nostdinc__
:
23500 case OPT_fpreprocessed
:
23501 case OPT_fltrans_output_list_
:
23502 case OPT_fresolution_
:
23503 case OPT_fdebug_prefix_map_
:
23504 case OPT_fcompare_debug
:
23505 /* Ignore these. */
23508 if (cl_options
[save_decoded_options
[j
].opt_index
].flags
23509 & CL_NO_DWARF_RECORD
)
23511 gcc_checking_assert (save_decoded_options
[j
].canonical_option
[0][0]
23513 switch (save_decoded_options
[j
].canonical_option
[0][1])
23520 if (strncmp (save_decoded_options
[j
].canonical_option
[0] + 2,
23527 switches
.safe_push (save_decoded_options
[j
].orig_option_with_args_text
);
23528 len
+= strlen (save_decoded_options
[j
].orig_option_with_args_text
) + 1;
23532 producer
= XNEWVEC (char, plen
+ 1 + len
+ 1);
23534 sprintf (tail
, "%s %s", language_string
, version_string
);
23537 FOR_EACH_VEC_ELT (switches
, j
, p
)
23541 memcpy (tail
+ 1, p
, len
);
23549 /* Given a C and/or C++ language/version string return the "highest".
23550 C++ is assumed to be "higher" than C in this case. Used for merging
23551 LTO translation unit languages. */
23552 static const char *
23553 highest_c_language (const char *lang1
, const char *lang2
)
23555 if (strcmp ("GNU C++17", lang1
) == 0 || strcmp ("GNU C++17", lang2
) == 0)
23556 return "GNU C++17";
23557 if (strcmp ("GNU C++14", lang1
) == 0 || strcmp ("GNU C++14", lang2
) == 0)
23558 return "GNU C++14";
23559 if (strcmp ("GNU C++11", lang1
) == 0 || strcmp ("GNU C++11", lang2
) == 0)
23560 return "GNU C++11";
23561 if (strcmp ("GNU C++98", lang1
) == 0 || strcmp ("GNU C++98", lang2
) == 0)
23562 return "GNU C++98";
23564 if (strcmp ("GNU C17", lang1
) == 0 || strcmp ("GNU C17", lang2
) == 0)
23566 if (strcmp ("GNU C11", lang1
) == 0 || strcmp ("GNU C11", lang2
) == 0)
23568 if (strcmp ("GNU C99", lang1
) == 0 || strcmp ("GNU C99", lang2
) == 0)
23570 if (strcmp ("GNU C89", lang1
) == 0 || strcmp ("GNU C89", lang2
) == 0)
23573 gcc_unreachable ();
23577 /* Generate the DIE for the compilation unit. */
23580 gen_compile_unit_die (const char *filename
)
23583 const char *language_string
= lang_hooks
.name
;
23586 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
23590 add_name_attribute (die
, filename
);
23591 /* Don't add cwd for <built-in>. */
23592 if (filename
[0] != '<')
23593 add_comp_dir_attribute (die
);
23596 add_AT_string (die
, DW_AT_producer
, producer_string
? producer_string
: "");
23598 /* If our producer is LTO try to figure out a common language to use
23599 from the global list of translation units. */
23600 if (strcmp (language_string
, "GNU GIMPLE") == 0)
23604 const char *common_lang
= NULL
;
23606 FOR_EACH_VEC_SAFE_ELT (all_translation_units
, i
, t
)
23608 if (!TRANSLATION_UNIT_LANGUAGE (t
))
23611 common_lang
= TRANSLATION_UNIT_LANGUAGE (t
);
23612 else if (strcmp (common_lang
, TRANSLATION_UNIT_LANGUAGE (t
)) == 0)
23614 else if (strncmp (common_lang
, "GNU C", 5) == 0
23615 && strncmp (TRANSLATION_UNIT_LANGUAGE (t
), "GNU C", 5) == 0)
23616 /* Mixing C and C++ is ok, use C++ in that case. */
23617 common_lang
= highest_c_language (common_lang
,
23618 TRANSLATION_UNIT_LANGUAGE (t
));
23621 /* Fall back to C. */
23622 common_lang
= NULL
;
23628 language_string
= common_lang
;
23631 language
= DW_LANG_C
;
23632 if (strncmp (language_string
, "GNU C", 5) == 0
23633 && ISDIGIT (language_string
[5]))
23635 language
= DW_LANG_C89
;
23636 if (dwarf_version
>= 3 || !dwarf_strict
)
23638 if (strcmp (language_string
, "GNU C89") != 0)
23639 language
= DW_LANG_C99
;
23641 if (dwarf_version
>= 5 /* || !dwarf_strict */)
23642 if (strcmp (language_string
, "GNU C11") == 0
23643 || strcmp (language_string
, "GNU C17") == 0)
23644 language
= DW_LANG_C11
;
23647 else if (strncmp (language_string
, "GNU C++", 7) == 0)
23649 language
= DW_LANG_C_plus_plus
;
23650 if (dwarf_version
>= 5 /* || !dwarf_strict */)
23652 if (strcmp (language_string
, "GNU C++11") == 0)
23653 language
= DW_LANG_C_plus_plus_11
;
23654 else if (strcmp (language_string
, "GNU C++14") == 0)
23655 language
= DW_LANG_C_plus_plus_14
;
23656 else if (strcmp (language_string
, "GNU C++17") == 0)
23658 language
= DW_LANG_C_plus_plus_14
;
23661 else if (strcmp (language_string
, "GNU F77") == 0)
23662 language
= DW_LANG_Fortran77
;
23663 else if (dwarf_version
>= 3 || !dwarf_strict
)
23665 if (strcmp (language_string
, "GNU Ada") == 0)
23666 language
= DW_LANG_Ada95
;
23667 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
23669 language
= DW_LANG_Fortran95
;
23670 if (dwarf_version
>= 5 /* || !dwarf_strict */)
23672 if (strcmp (language_string
, "GNU Fortran2003") == 0)
23673 language
= DW_LANG_Fortran03
;
23674 else if (strcmp (language_string
, "GNU Fortran2008") == 0)
23675 language
= DW_LANG_Fortran08
;
23678 else if (strcmp (language_string
, "GNU Objective-C") == 0)
23679 language
= DW_LANG_ObjC
;
23680 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
23681 language
= DW_LANG_ObjC_plus_plus
;
23682 else if (dwarf_version
>= 5 || !dwarf_strict
)
23684 if (strcmp (language_string
, "GNU Go") == 0)
23685 language
= DW_LANG_Go
;
23688 /* Use a degraded Fortran setting in strict DWARF2 so is_fortran works. */
23689 else if (strncmp (language_string
, "GNU Fortran", 11) == 0)
23690 language
= DW_LANG_Fortran90
;
23692 add_AT_unsigned (die
, DW_AT_language
, language
);
23696 case DW_LANG_Fortran77
:
23697 case DW_LANG_Fortran90
:
23698 case DW_LANG_Fortran95
:
23699 case DW_LANG_Fortran03
:
23700 case DW_LANG_Fortran08
:
23701 /* Fortran has case insensitive identifiers and the front-end
23702 lowercases everything. */
23703 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
23706 /* The default DW_ID_case_sensitive doesn't need to be specified. */
23712 /* Generate the DIE for a base class. */
23715 gen_inheritance_die (tree binfo
, tree access
, tree type
,
23716 dw_die_ref context_die
)
23718 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
23719 struct vlr_context ctx
= { type
, NULL
};
23721 add_type_attribute (die
, BINFO_TYPE (binfo
), TYPE_UNQUALIFIED
, false,
23723 add_data_member_location_attribute (die
, binfo
, &ctx
);
23725 if (BINFO_VIRTUAL_P (binfo
))
23726 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
23728 /* In DWARF3+ the default is DW_ACCESS_private only in DW_TAG_class_type
23729 children, otherwise the default is DW_ACCESS_public. In DWARF2
23730 the default has always been DW_ACCESS_private. */
23731 if (access
== access_public_node
)
23733 if (dwarf_version
== 2
23734 || context_die
->die_tag
== DW_TAG_class_type
)
23735 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
23737 else if (access
== access_protected_node
)
23738 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
23739 else if (dwarf_version
> 2
23740 && context_die
->die_tag
!= DW_TAG_class_type
)
23741 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
23744 /* Return whether DECL is a FIELD_DECL that represents the variant part of a
23747 is_variant_part (tree decl
)
23749 return (TREE_CODE (decl
) == FIELD_DECL
23750 && TREE_CODE (TREE_TYPE (decl
)) == QUAL_UNION_TYPE
);
23753 /* Check that OPERAND is a reference to a field in STRUCT_TYPE. If it is,
23754 return the FIELD_DECL. Return NULL_TREE otherwise. */
23757 analyze_discr_in_predicate (tree operand
, tree struct_type
)
23759 bool continue_stripping
= true;
23760 while (continue_stripping
)
23761 switch (TREE_CODE (operand
))
23764 operand
= TREE_OPERAND (operand
, 0);
23767 continue_stripping
= false;
23771 /* Match field access to members of struct_type only. */
23772 if (TREE_CODE (operand
) == COMPONENT_REF
23773 && TREE_CODE (TREE_OPERAND (operand
, 0)) == PLACEHOLDER_EXPR
23774 && TREE_TYPE (TREE_OPERAND (operand
, 0)) == struct_type
23775 && TREE_CODE (TREE_OPERAND (operand
, 1)) == FIELD_DECL
)
23776 return TREE_OPERAND (operand
, 1);
23781 /* Check that SRC is a constant integer that can be represented as a native
23782 integer constant (either signed or unsigned). If so, store it into DEST and
23783 return true. Return false otherwise. */
23786 get_discr_value (tree src
, dw_discr_value
*dest
)
23788 tree discr_type
= TREE_TYPE (src
);
23790 if (lang_hooks
.types
.get_debug_type
)
23792 tree debug_type
= lang_hooks
.types
.get_debug_type (discr_type
);
23793 if (debug_type
!= NULL
)
23794 discr_type
= debug_type
;
23797 if (TREE_CODE (src
) != INTEGER_CST
|| !INTEGRAL_TYPE_P (discr_type
))
23800 /* Signedness can vary between the original type and the debug type. This
23801 can happen for character types in Ada for instance: the character type
23802 used for code generation can be signed, to be compatible with the C one,
23803 but from a debugger point of view, it must be unsigned. */
23804 bool is_orig_unsigned
= TYPE_UNSIGNED (TREE_TYPE (src
));
23805 bool is_debug_unsigned
= TYPE_UNSIGNED (discr_type
);
23807 if (is_orig_unsigned
!= is_debug_unsigned
)
23808 src
= fold_convert (discr_type
, src
);
23810 if (!(is_debug_unsigned
? tree_fits_uhwi_p (src
) : tree_fits_shwi_p (src
)))
23813 dest
->pos
= is_debug_unsigned
;
23814 if (is_debug_unsigned
)
23815 dest
->v
.uval
= tree_to_uhwi (src
);
23817 dest
->v
.sval
= tree_to_shwi (src
);
23822 /* Try to extract synthetic properties out of VARIANT_PART_DECL, which is a
23823 FIELD_DECL in STRUCT_TYPE that represents a variant part. If unsuccessful,
23824 store NULL_TREE in DISCR_DECL. Otherwise:
23826 - store the discriminant field in STRUCT_TYPE that controls the variant
23827 part to *DISCR_DECL
23829 - put in *DISCR_LISTS_P an array where for each variant, the item
23830 represents the corresponding matching list of discriminant values.
23832 - put in *DISCR_LISTS_LENGTH the number of variants, which is the size of
23835 Note that when the array is allocated (i.e. when the analysis is
23836 successful), it is up to the caller to free the array. */
23839 analyze_variants_discr (tree variant_part_decl
,
23842 dw_discr_list_ref
**discr_lists_p
,
23843 unsigned *discr_lists_length
)
23845 tree variant_part_type
= TREE_TYPE (variant_part_decl
);
23847 dw_discr_list_ref
*discr_lists
;
23850 /* Compute how many variants there are in this variant part. */
23851 *discr_lists_length
= 0;
23852 for (variant
= TYPE_FIELDS (variant_part_type
);
23853 variant
!= NULL_TREE
;
23854 variant
= DECL_CHAIN (variant
))
23855 ++*discr_lists_length
;
23857 *discr_decl
= NULL_TREE
;
23859 = (dw_discr_list_ref
*) xcalloc (*discr_lists_length
,
23860 sizeof (**discr_lists_p
));
23861 discr_lists
= *discr_lists_p
;
23863 /* And then analyze all variants to extract discriminant information for all
23864 of them. This analysis is conservative: as soon as we detect something we
23865 do not support, abort everything and pretend we found nothing. */
23866 for (variant
= TYPE_FIELDS (variant_part_type
), i
= 0;
23867 variant
!= NULL_TREE
;
23868 variant
= DECL_CHAIN (variant
), ++i
)
23870 tree match_expr
= DECL_QUALIFIER (variant
);
23872 /* Now, try to analyze the predicate and deduce a discriminant for
23874 if (match_expr
== boolean_true_node
)
23875 /* Typically happens for the default variant: it matches all cases that
23876 previous variants rejected. Don't output any matching value for
23880 /* The following loop tries to iterate over each discriminant
23881 possibility: single values or ranges. */
23882 while (match_expr
!= NULL_TREE
)
23884 tree next_round_match_expr
;
23885 tree candidate_discr
= NULL_TREE
;
23886 dw_discr_list_ref new_node
= NULL
;
23888 /* Possibilities are matched one after the other by nested
23889 TRUTH_ORIF_EXPR expressions. Process the current possibility and
23890 continue with the rest at next iteration. */
23891 if (TREE_CODE (match_expr
) == TRUTH_ORIF_EXPR
)
23893 next_round_match_expr
= TREE_OPERAND (match_expr
, 0);
23894 match_expr
= TREE_OPERAND (match_expr
, 1);
23897 next_round_match_expr
= NULL_TREE
;
23899 if (match_expr
== boolean_false_node
)
23900 /* This sub-expression matches nothing: just wait for the next
23904 else if (TREE_CODE (match_expr
) == EQ_EXPR
)
23906 /* We are matching: <discr_field> == <integer_cst>
23907 This sub-expression matches a single value. */
23908 tree integer_cst
= TREE_OPERAND (match_expr
, 1);
23911 = analyze_discr_in_predicate (TREE_OPERAND (match_expr
, 0),
23914 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
23915 if (!get_discr_value (integer_cst
,
23916 &new_node
->dw_discr_lower_bound
))
23918 new_node
->dw_discr_range
= false;
23921 else if (TREE_CODE (match_expr
) == TRUTH_ANDIF_EXPR
)
23923 /* We are matching:
23924 <discr_field> > <integer_cst>
23925 && <discr_field> < <integer_cst>.
23926 This sub-expression matches the range of values between the
23927 two matched integer constants. Note that comparisons can be
23928 inclusive or exclusive. */
23929 tree candidate_discr_1
, candidate_discr_2
;
23930 tree lower_cst
, upper_cst
;
23931 bool lower_cst_included
, upper_cst_included
;
23932 tree lower_op
= TREE_OPERAND (match_expr
, 0);
23933 tree upper_op
= TREE_OPERAND (match_expr
, 1);
23935 /* When the comparison is exclusive, the integer constant is not
23936 the discriminant range bound we are looking for: we will have
23937 to increment or decrement it. */
23938 if (TREE_CODE (lower_op
) == GE_EXPR
)
23939 lower_cst_included
= true;
23940 else if (TREE_CODE (lower_op
) == GT_EXPR
)
23941 lower_cst_included
= false;
23945 if (TREE_CODE (upper_op
) == LE_EXPR
)
23946 upper_cst_included
= true;
23947 else if (TREE_CODE (upper_op
) == LT_EXPR
)
23948 upper_cst_included
= false;
23952 /* Extract the discriminant from the first operand and check it
23953 is consistant with the same analysis in the second
23956 = analyze_discr_in_predicate (TREE_OPERAND (lower_op
, 0),
23959 = analyze_discr_in_predicate (TREE_OPERAND (upper_op
, 0),
23961 if (candidate_discr_1
== candidate_discr_2
)
23962 candidate_discr
= candidate_discr_1
;
23966 /* Extract bounds from both. */
23967 new_node
= ggc_cleared_alloc
<dw_discr_list_node
> ();
23968 lower_cst
= TREE_OPERAND (lower_op
, 1);
23969 upper_cst
= TREE_OPERAND (upper_op
, 1);
23971 if (!lower_cst_included
)
23973 = fold_build2 (PLUS_EXPR
, TREE_TYPE (lower_cst
), lower_cst
,
23974 build_int_cst (TREE_TYPE (lower_cst
), 1));
23975 if (!upper_cst_included
)
23977 = fold_build2 (MINUS_EXPR
, TREE_TYPE (upper_cst
), upper_cst
,
23978 build_int_cst (TREE_TYPE (upper_cst
), 1));
23980 if (!get_discr_value (lower_cst
,
23981 &new_node
->dw_discr_lower_bound
)
23982 || !get_discr_value (upper_cst
,
23983 &new_node
->dw_discr_upper_bound
))
23986 new_node
->dw_discr_range
= true;
23990 /* Unsupported sub-expression: we cannot determine the set of
23991 matching discriminant values. Abort everything. */
23994 /* If the discriminant info is not consistant with what we saw so
23995 far, consider the analysis failed and abort everything. */
23996 if (candidate_discr
== NULL_TREE
23997 || (*discr_decl
!= NULL_TREE
&& candidate_discr
!= *discr_decl
))
24000 *discr_decl
= candidate_discr
;
24002 if (new_node
!= NULL
)
24004 new_node
->dw_discr_next
= discr_lists
[i
];
24005 discr_lists
[i
] = new_node
;
24007 match_expr
= next_round_match_expr
;
24011 /* If we reach this point, we could match everything we were interested
24016 /* Clean all data structure and return no result. */
24017 free (*discr_lists_p
);
24018 *discr_lists_p
= NULL
;
24019 *discr_decl
= NULL_TREE
;
24022 /* Generate a DIE to represent VARIANT_PART_DECL, a variant part that is part
24023 of STRUCT_TYPE, a record type. This new DIE is emitted as the next child
24026 Variant parts are supposed to be implemented as a FIELD_DECL whose type is a
24027 QUAL_UNION_TYPE: this is the VARIANT_PART_DECL parameter. The members for
24028 this type, which are record types, represent the available variants and each
24029 has a DECL_QUALIFIER attribute. The discriminant and the discriminant
24030 values are inferred from these attributes.
24032 In trees, the offsets for the fields inside these sub-records are relative
24033 to the variant part itself, whereas the corresponding DIEs should have
24034 offset attributes that are relative to the embedding record base address.
24035 This is why the caller must provide a VARIANT_PART_OFFSET expression: it
24036 must be an expression that computes the offset of the variant part to
24037 describe in DWARF. */
24040 gen_variant_part (tree variant_part_decl
, struct vlr_context
*vlr_ctx
,
24041 dw_die_ref context_die
)
24043 const tree variant_part_type
= TREE_TYPE (variant_part_decl
);
24044 tree variant_part_offset
= vlr_ctx
->variant_part_offset
;
24045 struct loc_descr_context ctx
= {
24046 vlr_ctx
->struct_type
, /* context_type */
24047 NULL_TREE
, /* base_decl */
24049 false, /* placeholder_arg */
24050 false /* placeholder_seen */
24053 /* The FIELD_DECL node in STRUCT_TYPE that acts as the discriminant, or
24054 NULL_TREE if there is no such field. */
24055 tree discr_decl
= NULL_TREE
;
24056 dw_discr_list_ref
*discr_lists
;
24057 unsigned discr_lists_length
= 0;
24060 dw_die_ref dwarf_proc_die
= NULL
;
24061 dw_die_ref variant_part_die
24062 = new_die (DW_TAG_variant_part
, context_die
, variant_part_type
);
24064 equate_decl_number_to_die (variant_part_decl
, variant_part_die
);
24066 analyze_variants_discr (variant_part_decl
, vlr_ctx
->struct_type
,
24067 &discr_decl
, &discr_lists
, &discr_lists_length
);
24069 if (discr_decl
!= NULL_TREE
)
24071 dw_die_ref discr_die
= lookup_decl_die (discr_decl
);
24074 add_AT_die_ref (variant_part_die
, DW_AT_discr
, discr_die
);
24076 /* We have no DIE for the discriminant, so just discard all
24077 discrimimant information in the output. */
24078 discr_decl
= NULL_TREE
;
24081 /* If the offset for this variant part is more complex than a constant,
24082 create a DWARF procedure for it so that we will not have to generate DWARF
24083 expressions for it for each member. */
24084 if (TREE_CODE (variant_part_offset
) != INTEGER_CST
24085 && (dwarf_version
>= 3 || !dwarf_strict
))
24087 const tree dwarf_proc_fndecl
24088 = build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
24089 build_function_type (TREE_TYPE (variant_part_offset
),
24091 const tree dwarf_proc_call
= build_call_expr (dwarf_proc_fndecl
, 0);
24092 const dw_loc_descr_ref dwarf_proc_body
24093 = loc_descriptor_from_tree (variant_part_offset
, 0, &ctx
);
24095 dwarf_proc_die
= new_dwarf_proc_die (dwarf_proc_body
,
24096 dwarf_proc_fndecl
, context_die
);
24097 if (dwarf_proc_die
!= NULL
)
24098 variant_part_offset
= dwarf_proc_call
;
24101 /* Output DIEs for all variants. */
24103 for (tree variant
= TYPE_FIELDS (variant_part_type
);
24104 variant
!= NULL_TREE
;
24105 variant
= DECL_CHAIN (variant
), ++i
)
24107 tree variant_type
= TREE_TYPE (variant
);
24108 dw_die_ref variant_die
;
24110 /* All variants (i.e. members of a variant part) are supposed to be
24111 encoded as structures. Sub-variant parts are QUAL_UNION_TYPE fields
24112 under these records. */
24113 gcc_assert (TREE_CODE (variant_type
) == RECORD_TYPE
);
24115 variant_die
= new_die (DW_TAG_variant
, variant_part_die
, variant_type
);
24116 equate_decl_number_to_die (variant
, variant_die
);
24118 /* Output discriminant values this variant matches, if any. */
24119 if (discr_decl
== NULL
|| discr_lists
[i
] == NULL
)
24120 /* In the case we have discriminant information at all, this is
24121 probably the default variant: as the standard says, don't
24122 output any discriminant value/list attribute. */
24124 else if (discr_lists
[i
]->dw_discr_next
== NULL
24125 && !discr_lists
[i
]->dw_discr_range
)
24126 /* If there is only one accepted value, don't bother outputting a
24128 add_discr_value (variant_die
, &discr_lists
[i
]->dw_discr_lower_bound
);
24130 add_discr_list (variant_die
, discr_lists
[i
]);
24132 for (tree member
= TYPE_FIELDS (variant_type
);
24133 member
!= NULL_TREE
;
24134 member
= DECL_CHAIN (member
))
24136 struct vlr_context vlr_sub_ctx
= {
24137 vlr_ctx
->struct_type
, /* struct_type */
24138 NULL
/* variant_part_offset */
24140 if (is_variant_part (member
))
24142 /* All offsets for fields inside variant parts are relative to
24143 the top-level embedding RECORD_TYPE's base address. On the
24144 other hand, offsets in GCC's types are relative to the
24145 nested-most variant part. So we have to sum offsets each time
24148 vlr_sub_ctx
.variant_part_offset
24149 = fold_build2 (PLUS_EXPR
, TREE_TYPE (variant_part_offset
),
24150 variant_part_offset
, byte_position (member
));
24151 gen_variant_part (member
, &vlr_sub_ctx
, variant_die
);
24155 vlr_sub_ctx
.variant_part_offset
= variant_part_offset
;
24156 gen_decl_die (member
, NULL
, &vlr_sub_ctx
, variant_die
);
24161 free (discr_lists
);
24164 /* Generate a DIE for a class member. */
24167 gen_member_die (tree type
, dw_die_ref context_die
)
24170 tree binfo
= TYPE_BINFO (type
);
24172 gcc_assert (TYPE_MAIN_VARIANT (type
) == type
);
24174 /* If this is not an incomplete type, output descriptions of each of its
24175 members. Note that as we output the DIEs necessary to represent the
24176 members of this record or union type, we will also be trying to output
24177 DIEs to represent the *types* of those members. However the `type'
24178 function (above) will specifically avoid generating type DIEs for member
24179 types *within* the list of member DIEs for this (containing) type except
24180 for those types (of members) which are explicitly marked as also being
24181 members of this (containing) type themselves. The g++ front- end can
24182 force any given type to be treated as a member of some other (containing)
24183 type by setting the TYPE_CONTEXT of the given (member) type to point to
24184 the TREE node representing the appropriate (containing) type. */
24186 /* First output info about the base classes. */
24189 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
24193 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
24194 gen_inheritance_die (base
,
24195 (accesses
? (*accesses
)[i
] : access_public_node
),
24200 /* Now output info about the data members and type members. */
24201 for (member
= TYPE_FIELDS (type
); member
; member
= DECL_CHAIN (member
))
24203 struct vlr_context vlr_ctx
= { type
, NULL_TREE
};
24204 bool static_inline_p
24205 = (TREE_STATIC (member
)
24206 && (lang_hooks
.decls
.decl_dwarf_attribute (member
, DW_AT_inline
)
24209 /* Ignore clones. */
24210 if (DECL_ABSTRACT_ORIGIN (member
))
24213 /* If we thought we were generating minimal debug info for TYPE
24214 and then changed our minds, some of the member declarations
24215 may have already been defined. Don't define them again, but
24216 do put them in the right order. */
24218 if (dw_die_ref child
= lookup_decl_die (member
))
24220 /* Handle inline static data members, which only have in-class
24222 dw_die_ref ref
= NULL
;
24223 if (child
->die_tag
== DW_TAG_variable
24224 && child
->die_parent
== comp_unit_die ())
24226 ref
= get_AT_ref (child
, DW_AT_specification
);
24227 /* For C++17 inline static data members followed by redundant
24228 out of class redeclaration, we might get here with
24229 child being the DIE created for the out of class
24230 redeclaration and with its DW_AT_specification being
24231 the DIE created for in-class definition. We want to
24232 reparent the latter, and don't want to create another
24233 DIE with DW_AT_specification in that case, because
24234 we already have one. */
24237 && ref
->die_tag
== DW_TAG_variable
24238 && ref
->die_parent
== comp_unit_die ()
24239 && get_AT (ref
, DW_AT_specification
) == NULL
)
24243 static_inline_p
= false;
24247 if (child
->die_tag
== DW_TAG_variable
24248 && child
->die_parent
== comp_unit_die ()
24251 reparent_child (child
, context_die
);
24252 if (dwarf_version
< 5)
24253 child
->die_tag
= DW_TAG_member
;
24256 splice_child_die (context_die
, child
);
24259 /* Do not generate standard DWARF for variant parts if we are generating
24260 the corresponding GNAT encodings: DIEs generated for both would
24261 conflict in our mappings. */
24262 else if (is_variant_part (member
)
24263 && gnat_encodings
== DWARF_GNAT_ENCODINGS_MINIMAL
)
24265 vlr_ctx
.variant_part_offset
= byte_position (member
);
24266 gen_variant_part (member
, &vlr_ctx
, context_die
);
24270 vlr_ctx
.variant_part_offset
= NULL_TREE
;
24271 gen_decl_die (member
, NULL
, &vlr_ctx
, context_die
);
24274 /* For C++ inline static data members emit immediately a DW_TAG_variable
24275 DIE that will refer to that DW_TAG_member/DW_TAG_variable through
24276 DW_AT_specification. */
24277 if (static_inline_p
)
24279 int old_extern
= DECL_EXTERNAL (member
);
24280 DECL_EXTERNAL (member
) = 0;
24281 gen_decl_die (member
, NULL
, NULL
, comp_unit_die ());
24282 DECL_EXTERNAL (member
) = old_extern
;
24287 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
24288 is set, we pretend that the type was never defined, so we only get the
24289 member DIEs needed by later specification DIEs. */
24292 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
24293 enum debug_info_usage usage
)
24295 if (TREE_ASM_WRITTEN (type
))
24297 /* Fill in the bound of variable-length fields in late dwarf if
24298 still incomplete. */
24299 if (!early_dwarf
&& variably_modified_type_p (type
, NULL
))
24300 for (tree member
= TYPE_FIELDS (type
);
24302 member
= DECL_CHAIN (member
))
24303 fill_variable_array_bounds (TREE_TYPE (member
));
24307 dw_die_ref type_die
= lookup_type_die (type
);
24308 dw_die_ref scope_die
= 0;
24310 int complete
= (TYPE_SIZE (type
)
24311 && (! TYPE_STUB_DECL (type
)
24312 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
24313 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
24314 complete
= complete
&& should_emit_struct_debug (type
, usage
);
24316 if (type_die
&& ! complete
)
24319 if (TYPE_CONTEXT (type
) != NULL_TREE
24320 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
24321 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
24324 scope_die
= scope_die_for (type
, context_die
);
24326 /* Generate child dies for template paramaters. */
24327 if (!type_die
&& debug_info_level
> DINFO_LEVEL_TERSE
)
24328 schedule_generic_params_dies_gen (type
);
24330 if (! type_die
|| (nested
&& is_cu_die (scope_die
)))
24331 /* First occurrence of type or toplevel definition of nested class. */
24333 dw_die_ref old_die
= type_die
;
24335 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
24336 ? record_type_tag (type
) : DW_TAG_union_type
,
24338 equate_type_number_to_die (type
, type_die
);
24340 add_AT_specification (type_die
, old_die
);
24342 add_name_attribute (type_die
, type_tag (type
));
24345 remove_AT (type_die
, DW_AT_declaration
);
24347 /* If this type has been completed, then give it a byte_size attribute and
24348 then give a list of members. */
24349 if (complete
&& !ns_decl
)
24351 /* Prevent infinite recursion in cases where the type of some member of
24352 this type is expressed in terms of this type itself. */
24353 TREE_ASM_WRITTEN (type
) = 1;
24354 add_byte_size_attribute (type_die
, type
);
24355 add_alignment_attribute (type_die
, type
);
24356 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
24358 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
24359 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
24362 /* If the first reference to this type was as the return type of an
24363 inline function, then it may not have a parent. Fix this now. */
24364 if (type_die
->die_parent
== NULL
)
24365 add_child_die (scope_die
, type_die
);
24367 push_decl_scope (type
);
24368 gen_member_die (type
, type_die
);
24371 add_gnat_descriptive_type_attribute (type_die
, type
, context_die
);
24372 if (TYPE_ARTIFICIAL (type
))
24373 add_AT_flag (type_die
, DW_AT_artificial
, 1);
24375 /* GNU extension: Record what type our vtable lives in. */
24376 if (TYPE_VFIELD (type
))
24378 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
24380 gen_type_die (vtype
, context_die
);
24381 add_AT_die_ref (type_die
, DW_AT_containing_type
,
24382 lookup_type_die (vtype
));
24387 add_AT_flag (type_die
, DW_AT_declaration
, 1);
24389 /* We don't need to do this for function-local types. */
24390 if (TYPE_STUB_DECL (type
)
24391 && ! decl_function_context (TYPE_STUB_DECL (type
)))
24392 vec_safe_push (incomplete_types
, type
);
24395 if (get_AT (type_die
, DW_AT_name
))
24396 add_pubtype (type
, type_die
);
24399 /* Generate a DIE for a subroutine _type_. */
24402 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
24404 tree return_type
= TREE_TYPE (type
);
24405 dw_die_ref subr_die
24406 = new_die (DW_TAG_subroutine_type
,
24407 scope_die_for (type
, context_die
), type
);
24409 equate_type_number_to_die (type
, subr_die
);
24410 add_prototyped_attribute (subr_die
, type
);
24411 add_type_attribute (subr_die
, return_type
, TYPE_UNQUALIFIED
, false,
24413 add_alignment_attribute (subr_die
, type
);
24414 gen_formal_types_die (type
, subr_die
);
24416 if (get_AT (subr_die
, DW_AT_name
))
24417 add_pubtype (type
, subr_die
);
24418 if ((dwarf_version
>= 5 || !dwarf_strict
)
24419 && lang_hooks
.types
.type_dwarf_attribute (type
, DW_AT_reference
) != -1)
24420 add_AT_flag (subr_die
, DW_AT_reference
, 1);
24421 if ((dwarf_version
>= 5 || !dwarf_strict
)
24422 && lang_hooks
.types
.type_dwarf_attribute (type
,
24423 DW_AT_rvalue_reference
) != -1)
24424 add_AT_flag (subr_die
, DW_AT_rvalue_reference
, 1);
24427 /* Generate a DIE for a type definition. */
24430 gen_typedef_die (tree decl
, dw_die_ref context_die
)
24432 dw_die_ref type_die
;
24435 if (TREE_ASM_WRITTEN (decl
))
24437 if (DECL_ORIGINAL_TYPE (decl
))
24438 fill_variable_array_bounds (DECL_ORIGINAL_TYPE (decl
));
24442 /* As we avoid creating DIEs for local typedefs (see decl_ultimate_origin
24443 checks in process_scope_var and modified_type_die), this should be called
24444 only for original types. */
24445 gcc_assert (decl_ultimate_origin (decl
) == NULL
24446 || decl_ultimate_origin (decl
) == decl
);
24448 TREE_ASM_WRITTEN (decl
) = 1;
24449 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
24451 add_name_and_src_coords_attributes (type_die
, decl
);
24452 if (DECL_ORIGINAL_TYPE (decl
))
24454 type
= DECL_ORIGINAL_TYPE (decl
);
24455 if (type
== error_mark_node
)
24458 gcc_assert (type
!= TREE_TYPE (decl
));
24459 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
24463 type
= TREE_TYPE (decl
);
24464 if (type
== error_mark_node
)
24467 if (is_naming_typedef_decl (TYPE_NAME (type
)))
24469 /* Here, we are in the case of decl being a typedef naming
24470 an anonymous type, e.g:
24471 typedef struct {...} foo;
24472 In that case TREE_TYPE (decl) is not a typedef variant
24473 type and TYPE_NAME of the anonymous type is set to the
24474 TYPE_DECL of the typedef. This construct is emitted by
24477 TYPE is the anonymous struct named by the typedef
24478 DECL. As we need the DW_AT_type attribute of the
24479 DW_TAG_typedef to point to the DIE of TYPE, let's
24480 generate that DIE right away. add_type_attribute
24481 called below will then pick (via lookup_type_die) that
24482 anonymous struct DIE. */
24483 if (!TREE_ASM_WRITTEN (type
))
24484 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
24486 /* This is a GNU Extension. We are adding a
24487 DW_AT_linkage_name attribute to the DIE of the
24488 anonymous struct TYPE. The value of that attribute
24489 is the name of the typedef decl naming the anonymous
24490 struct. This greatly eases the work of consumers of
24491 this debug info. */
24492 add_linkage_name_raw (lookup_type_die (type
), decl
);
24496 add_type_attribute (type_die
, type
, decl_quals (decl
), false,
24499 if (is_naming_typedef_decl (decl
))
24500 /* We want that all subsequent calls to lookup_type_die with
24501 TYPE in argument yield the DW_TAG_typedef we have just
24503 equate_type_number_to_die (type
, type_die
);
24505 add_alignment_attribute (type_die
, TREE_TYPE (decl
));
24507 add_accessibility_attribute (type_die
, decl
);
24509 if (DECL_ABSTRACT_P (decl
))
24510 equate_decl_number_to_die (decl
, type_die
);
24512 if (get_AT (type_die
, DW_AT_name
))
24513 add_pubtype (decl
, type_die
);
24516 /* Generate a DIE for a struct, class, enum or union type. */
24519 gen_tagged_type_die (tree type
,
24520 dw_die_ref context_die
,
24521 enum debug_info_usage usage
)
24525 if (type
== NULL_TREE
24526 || !is_tagged_type (type
))
24529 if (TREE_ASM_WRITTEN (type
))
24531 /* If this is a nested type whose containing class hasn't been written
24532 out yet, writing it out will cover this one, too. This does not apply
24533 to instantiations of member class templates; they need to be added to
24534 the containing class as they are generated. FIXME: This hurts the
24535 idea of combining type decls from multiple TUs, since we can't predict
24536 what set of template instantiations we'll get. */
24537 else if (TYPE_CONTEXT (type
)
24538 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
24539 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
24541 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
24543 if (TREE_ASM_WRITTEN (type
))
24546 /* If that failed, attach ourselves to the stub. */
24547 push_decl_scope (TYPE_CONTEXT (type
));
24548 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
24551 else if (TYPE_CONTEXT (type
) != NULL_TREE
24552 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
24554 /* If this type is local to a function that hasn't been written
24555 out yet, use a NULL context for now; it will be fixed up in
24556 decls_for_scope. */
24557 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
24558 /* A declaration DIE doesn't count; nested types need to go in the
24560 if (context_die
&& is_declaration_die (context_die
))
24561 context_die
= NULL
;
24566 context_die
= declare_in_namespace (type
, context_die
);
24570 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
24572 /* This might have been written out by the call to
24573 declare_in_namespace. */
24574 if (!TREE_ASM_WRITTEN (type
))
24575 gen_enumeration_type_die (type
, context_die
);
24578 gen_struct_or_union_type_die (type
, context_die
, usage
);
24583 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
24584 it up if it is ever completed. gen_*_type_die will set it for us
24585 when appropriate. */
24588 /* Generate a type description DIE. */
24591 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
24592 enum debug_info_usage usage
)
24594 struct array_descr_info info
;
24596 if (type
== NULL_TREE
|| type
== error_mark_node
)
24599 if (flag_checking
&& type
)
24600 verify_type (type
);
24602 if (TYPE_NAME (type
) != NULL_TREE
24603 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
24604 && is_redundant_typedef (TYPE_NAME (type
))
24605 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
24606 /* The DECL of this type is a typedef we don't want to emit debug
24607 info for but we want debug info for its underlying typedef.
24608 This can happen for e.g, the injected-class-name of a C++
24610 type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
24612 /* If TYPE is a typedef type variant, let's generate debug info
24613 for the parent typedef which TYPE is a type of. */
24614 if (typedef_variant_p (type
))
24616 if (TREE_ASM_WRITTEN (type
))
24619 tree name
= TYPE_NAME (type
);
24620 tree origin
= decl_ultimate_origin (name
);
24621 if (origin
!= NULL
&& origin
!= name
)
24623 gen_decl_die (origin
, NULL
, NULL
, context_die
);
24627 /* Prevent broken recursion; we can't hand off to the same type. */
24628 gcc_assert (DECL_ORIGINAL_TYPE (name
) != type
);
24630 /* Give typedefs the right scope. */
24631 context_die
= scope_die_for (type
, context_die
);
24633 TREE_ASM_WRITTEN (type
) = 1;
24635 gen_decl_die (name
, NULL
, NULL
, context_die
);
24639 /* If type is an anonymous tagged type named by a typedef, let's
24640 generate debug info for the typedef. */
24641 if (is_naming_typedef_decl (TYPE_NAME (type
)))
24643 /* Use the DIE of the containing namespace as the parent DIE of
24644 the type description DIE we want to generate. */
24645 if (DECL_CONTEXT (TYPE_NAME (type
))
24646 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type
))) == NAMESPACE_DECL
)
24647 context_die
= get_context_die (DECL_CONTEXT (TYPE_NAME (type
)));
24649 gen_decl_die (TYPE_NAME (type
), NULL
, NULL
, context_die
);
24653 if (lang_hooks
.types
.get_debug_type
)
24655 tree debug_type
= lang_hooks
.types
.get_debug_type (type
);
24657 if (debug_type
!= NULL_TREE
&& debug_type
!= type
)
24659 gen_type_die_with_usage (debug_type
, context_die
, usage
);
24664 /* We are going to output a DIE to represent the unqualified version
24665 of this type (i.e. without any const or volatile qualifiers) so
24666 get the main variant (i.e. the unqualified version) of this type
24667 now. (Vectors and arrays are special because the debugging info is in the
24668 cloned type itself. Similarly function/method types can contain extra
24669 ref-qualification). */
24670 if (TREE_CODE (type
) == FUNCTION_TYPE
24671 || TREE_CODE (type
) == METHOD_TYPE
)
24673 /* For function/method types, can't use type_main_variant here,
24674 because that can have different ref-qualifiers for C++,
24675 but try to canonicalize. */
24676 tree main
= TYPE_MAIN_VARIANT (type
);
24677 for (tree t
= main
; t
; t
= TYPE_NEXT_VARIANT (t
))
24678 if (TYPE_QUALS_NO_ADDR_SPACE (t
) == 0
24679 && check_base_type (t
, main
)
24680 && check_lang_type (t
, type
))
24686 else if (TREE_CODE (type
) != VECTOR_TYPE
24687 && TREE_CODE (type
) != ARRAY_TYPE
)
24688 type
= type_main_variant (type
);
24690 /* If this is an array type with hidden descriptor, handle it first. */
24691 if (!TREE_ASM_WRITTEN (type
)
24692 && lang_hooks
.types
.get_array_descr_info
)
24694 memset (&info
, 0, sizeof (info
));
24695 if (lang_hooks
.types
.get_array_descr_info (type
, &info
))
24697 /* Fortran sometimes emits array types with no dimension. */
24698 gcc_assert (info
.ndimensions
>= 0
24699 && (info
.ndimensions
24700 <= DWARF2OUT_ARRAY_DESCR_INFO_MAX_DIMEN
));
24701 gen_descr_array_type_die (type
, &info
, context_die
);
24702 TREE_ASM_WRITTEN (type
) = 1;
24707 if (TREE_ASM_WRITTEN (type
))
24709 /* Variable-length types may be incomplete even if
24710 TREE_ASM_WRITTEN. For such types, fall through to
24711 gen_array_type_die() and possibly fill in
24712 DW_AT_{upper,lower}_bound attributes. */
24713 if ((TREE_CODE (type
) != ARRAY_TYPE
24714 && TREE_CODE (type
) != RECORD_TYPE
24715 && TREE_CODE (type
) != UNION_TYPE
24716 && TREE_CODE (type
) != QUAL_UNION_TYPE
)
24717 || !variably_modified_type_p (type
, NULL
))
24721 switch (TREE_CODE (type
))
24727 case REFERENCE_TYPE
:
24728 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
24729 ensures that the gen_type_die recursion will terminate even if the
24730 type is recursive. Recursive types are possible in Ada. */
24731 /* ??? We could perhaps do this for all types before the switch
24733 TREE_ASM_WRITTEN (type
) = 1;
24735 /* For these types, all that is required is that we output a DIE (or a
24736 set of DIEs) to represent the "basis" type. */
24737 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
24738 DINFO_USAGE_IND_USE
);
24742 /* This code is used for C++ pointer-to-data-member types.
24743 Output a description of the relevant class type. */
24744 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
24745 DINFO_USAGE_IND_USE
);
24747 /* Output a description of the type of the object pointed to. */
24748 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
24749 DINFO_USAGE_IND_USE
);
24751 /* Now output a DIE to represent this pointer-to-data-member type
24753 gen_ptr_to_mbr_type_die (type
, context_die
);
24756 case FUNCTION_TYPE
:
24757 /* Force out return type (in case it wasn't forced out already). */
24758 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
24759 DINFO_USAGE_DIR_USE
);
24760 gen_subroutine_type_die (type
, context_die
);
24764 /* Force out return type (in case it wasn't forced out already). */
24765 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
24766 DINFO_USAGE_DIR_USE
);
24767 gen_subroutine_type_die (type
, context_die
);
24772 gen_array_type_die (type
, context_die
);
24775 case ENUMERAL_TYPE
:
24778 case QUAL_UNION_TYPE
:
24779 gen_tagged_type_die (type
, context_die
, usage
);
24785 case FIXED_POINT_TYPE
:
24788 case POINTER_BOUNDS_TYPE
:
24789 /* No DIEs needed for fundamental types. */
24794 /* Just use DW_TAG_unspecified_type. */
24796 dw_die_ref type_die
= lookup_type_die (type
);
24797 if (type_die
== NULL
)
24799 tree name
= TYPE_IDENTIFIER (type
);
24800 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die (),
24802 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
24803 equate_type_number_to_die (type
, type_die
);
24809 if (is_cxx_auto (type
))
24811 tree name
= TYPE_IDENTIFIER (type
);
24812 dw_die_ref
*die
= (name
== get_identifier ("auto")
24813 ? &auto_die
: &decltype_auto_die
);
24816 *die
= new_die (DW_TAG_unspecified_type
,
24817 comp_unit_die (), NULL_TREE
);
24818 add_name_attribute (*die
, IDENTIFIER_POINTER (name
));
24820 equate_type_number_to_die (type
, *die
);
24823 gcc_unreachable ();
24826 TREE_ASM_WRITTEN (type
) = 1;
24830 gen_type_die (tree type
, dw_die_ref context_die
)
24832 if (type
!= error_mark_node
)
24834 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
24837 dw_die_ref die
= lookup_type_die (type
);
24844 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
24845 things which are local to the given block. */
24848 gen_block_die (tree stmt
, dw_die_ref context_die
)
24850 int must_output_die
= 0;
24853 /* Ignore blocks that are NULL. */
24854 if (stmt
== NULL_TREE
)
24857 inlined_func
= inlined_function_outer_scope_p (stmt
);
24859 /* If the block is one fragment of a non-contiguous block, do not
24860 process the variables, since they will have been done by the
24861 origin block. Do process subblocks. */
24862 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
24866 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
24867 gen_block_die (sub
, context_die
);
24872 /* Determine if we need to output any Dwarf DIEs at all to represent this
24875 /* The outer scopes for inlinings *must* always be represented. We
24876 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
24877 must_output_die
= 1;
24880 /* Determine if this block directly contains any "significant"
24881 local declarations which we will need to output DIEs for. */
24882 if (debug_info_level
> DINFO_LEVEL_TERSE
)
24883 /* We are not in terse mode so *any* local declaration counts
24884 as being a "significant" one. */
24885 must_output_die
= ((BLOCK_VARS (stmt
) != NULL
24886 || BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
24887 && (TREE_USED (stmt
)
24888 || TREE_ASM_WRITTEN (stmt
)
24889 || BLOCK_ABSTRACT (stmt
)));
24890 else if ((TREE_USED (stmt
)
24891 || TREE_ASM_WRITTEN (stmt
)
24892 || BLOCK_ABSTRACT (stmt
))
24893 && !dwarf2out_ignore_block (stmt
))
24894 must_output_die
= 1;
24897 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
24898 DIE for any block which contains no significant local declarations at
24899 all. Rather, in such cases we just call `decls_for_scope' so that any
24900 needed Dwarf info for any sub-blocks will get properly generated. Note
24901 that in terse mode, our definition of what constitutes a "significant"
24902 local declaration gets restricted to include only inlined function
24903 instances and local (nested) function definitions. */
24904 if (must_output_die
)
24908 /* If STMT block is abstract, that means we have been called
24909 indirectly from dwarf2out_abstract_function.
24910 That function rightfully marks the descendent blocks (of
24911 the abstract function it is dealing with) as being abstract,
24912 precisely to prevent us from emitting any
24913 DW_TAG_inlined_subroutine DIE as a descendent
24914 of an abstract function instance. So in that case, we should
24915 not call gen_inlined_subroutine_die.
24917 Later though, when cgraph asks dwarf2out to emit info
24918 for the concrete instance of the function decl into which
24919 the concrete instance of STMT got inlined, the later will lead
24920 to the generation of a DW_TAG_inlined_subroutine DIE. */
24921 if (! BLOCK_ABSTRACT (stmt
))
24922 gen_inlined_subroutine_die (stmt
, context_die
);
24925 gen_lexical_block_die (stmt
, context_die
);
24928 decls_for_scope (stmt
, context_die
);
24931 /* Process variable DECL (or variable with origin ORIGIN) within
24932 block STMT and add it to CONTEXT_DIE. */
24934 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
24937 tree decl_or_origin
= decl
? decl
: origin
;
24939 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
24940 die
= lookup_decl_die (decl_or_origin
);
24941 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
)
24943 if (TYPE_DECL_IS_STUB (decl_or_origin
))
24944 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
24946 die
= lookup_decl_die (decl_or_origin
);
24947 /* Avoid re-creating the DIE late if it was optimized as unused early. */
24948 if (! die
&& ! early_dwarf
)
24954 /* Avoid creating DIEs for local typedefs and concrete static variables that
24955 will only be pruned later. */
24956 if ((origin
|| decl_ultimate_origin (decl
))
24957 && (TREE_CODE (decl_or_origin
) == TYPE_DECL
24958 || (VAR_P (decl_or_origin
) && TREE_STATIC (decl_or_origin
))))
24960 origin
= decl_ultimate_origin (decl_or_origin
);
24961 if (decl
&& VAR_P (decl
) && die
!= NULL
)
24963 die
= lookup_decl_die (origin
);
24965 equate_decl_number_to_die (decl
, die
);
24970 if (die
!= NULL
&& die
->die_parent
== NULL
)
24971 add_child_die (context_die
, die
);
24972 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
24975 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
24976 stmt
, context_die
);
24980 if (decl
&& DECL_P (decl
))
24982 die
= lookup_decl_die (decl
);
24984 /* Early created DIEs do not have a parent as the decls refer
24985 to the function as DECL_CONTEXT rather than the BLOCK. */
24986 if (die
&& die
->die_parent
== NULL
)
24988 gcc_assert (in_lto_p
);
24989 add_child_die (context_die
, die
);
24993 gen_decl_die (decl
, origin
, NULL
, context_die
);
24997 /* Generate all of the decls declared within a given scope and (recursively)
24998 all of its sub-blocks. */
25001 decls_for_scope (tree stmt
, dw_die_ref context_die
)
25007 /* Ignore NULL blocks. */
25008 if (stmt
== NULL_TREE
)
25011 /* Output the DIEs to represent all of the data objects and typedefs
25012 declared directly within this block but not within any nested
25013 sub-blocks. Also, nested function and tag DIEs have been
25014 generated with a parent of NULL; fix that up now. We don't
25015 have to do this if we're at -g1. */
25016 if (debug_info_level
> DINFO_LEVEL_TERSE
)
25018 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= DECL_CHAIN (decl
))
25019 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
25020 /* BLOCK_NONLOCALIZED_VARs simply generate DIE stubs with abstract
25021 origin - avoid doing this twice as we have no good way to see
25022 if we've done it once already. */
25024 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
25026 decl
= BLOCK_NONLOCALIZED_VAR (stmt
, i
);
25027 if (decl
== current_function_decl
)
25028 /* Ignore declarations of the current function, while they
25029 are declarations, gen_subprogram_die would treat them
25030 as definitions again, because they are equal to
25031 current_function_decl and endlessly recurse. */;
25032 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
25033 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
25035 process_scope_var (stmt
, NULL_TREE
, decl
, context_die
);
25039 /* Even if we're at -g1, we need to process the subblocks in order to get
25040 inlined call information. */
25042 /* Output the DIEs to represent all sub-blocks (and the items declared
25043 therein) of this block. */
25044 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
25046 subblocks
= BLOCK_CHAIN (subblocks
))
25047 gen_block_die (subblocks
, context_die
);
25050 /* Is this a typedef we can avoid emitting? */
25053 is_redundant_typedef (const_tree decl
)
25055 if (TYPE_DECL_IS_STUB (decl
))
25058 if (DECL_ARTIFICIAL (decl
)
25059 && DECL_CONTEXT (decl
)
25060 && is_tagged_type (DECL_CONTEXT (decl
))
25061 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
25062 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
25063 /* Also ignore the artificial member typedef for the class name. */
25069 /* Return TRUE if TYPE is a typedef that names a type for linkage
25070 purposes. This kind of typedefs is produced by the C++ FE for
25073 typedef struct {...} foo;
25075 In that case, there is no typedef variant type produced for foo.
25076 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
25080 is_naming_typedef_decl (const_tree decl
)
25082 if (decl
== NULL_TREE
25083 || TREE_CODE (decl
) != TYPE_DECL
25084 || DECL_NAMELESS (decl
)
25085 || !is_tagged_type (TREE_TYPE (decl
))
25086 || DECL_IS_BUILTIN (decl
)
25087 || is_redundant_typedef (decl
)
25088 /* It looks like Ada produces TYPE_DECLs that are very similar
25089 to C++ naming typedefs but that have different
25090 semantics. Let's be specific to c++ for now. */
25094 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
25095 && TYPE_NAME (TREE_TYPE (decl
)) == decl
25096 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
25097 != TYPE_NAME (TREE_TYPE (decl
))));
25100 /* Looks up the DIE for a context. */
25102 static inline dw_die_ref
25103 lookup_context_die (tree context
)
25107 /* Find die that represents this context. */
25108 if (TYPE_P (context
))
25110 context
= TYPE_MAIN_VARIANT (context
);
25111 dw_die_ref ctx
= lookup_type_die (context
);
25114 return strip_naming_typedef (context
, ctx
);
25117 return lookup_decl_die (context
);
25119 return comp_unit_die ();
25122 /* Returns the DIE for a context. */
25124 static inline dw_die_ref
25125 get_context_die (tree context
)
25129 /* Find die that represents this context. */
25130 if (TYPE_P (context
))
25132 context
= TYPE_MAIN_VARIANT (context
);
25133 return strip_naming_typedef (context
, force_type_die (context
));
25136 return force_decl_die (context
);
25138 return comp_unit_die ();
25141 /* Returns the DIE for decl. A DIE will always be returned. */
25144 force_decl_die (tree decl
)
25146 dw_die_ref decl_die
;
25147 unsigned saved_external_flag
;
25148 tree save_fn
= NULL_TREE
;
25149 decl_die
= lookup_decl_die (decl
);
25152 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
25154 decl_die
= lookup_decl_die (decl
);
25158 switch (TREE_CODE (decl
))
25160 case FUNCTION_DECL
:
25161 /* Clear current_function_decl, so that gen_subprogram_die thinks
25162 that this is a declaration. At this point, we just want to force
25163 declaration die. */
25164 save_fn
= current_function_decl
;
25165 current_function_decl
= NULL_TREE
;
25166 gen_subprogram_die (decl
, context_die
);
25167 current_function_decl
= save_fn
;
25171 /* Set external flag to force declaration die. Restore it after
25172 gen_decl_die() call. */
25173 saved_external_flag
= DECL_EXTERNAL (decl
);
25174 DECL_EXTERNAL (decl
) = 1;
25175 gen_decl_die (decl
, NULL
, NULL
, context_die
);
25176 DECL_EXTERNAL (decl
) = saved_external_flag
;
25179 case NAMESPACE_DECL
:
25180 if (dwarf_version
>= 3 || !dwarf_strict
)
25181 dwarf2out_decl (decl
);
25183 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
25184 decl_die
= comp_unit_die ();
25187 case TRANSLATION_UNIT_DECL
:
25188 decl_die
= comp_unit_die ();
25192 gcc_unreachable ();
25195 /* We should be able to find the DIE now. */
25197 decl_die
= lookup_decl_die (decl
);
25198 gcc_assert (decl_die
);
25204 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
25205 always returned. */
25208 force_type_die (tree type
)
25210 dw_die_ref type_die
;
25212 type_die
= lookup_type_die (type
);
25215 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
25217 type_die
= modified_type_die (type
, TYPE_QUALS_NO_ADDR_SPACE (type
),
25218 false, context_die
);
25219 gcc_assert (type_die
);
25224 /* Force out any required namespaces to be able to output DECL,
25225 and return the new context_die for it, if it's changed. */
25228 setup_namespace_context (tree thing
, dw_die_ref context_die
)
25230 tree context
= (DECL_P (thing
)
25231 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
25232 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
25233 /* Force out the namespace. */
25234 context_die
= force_decl_die (context
);
25236 return context_die
;
25239 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
25240 type) within its namespace, if appropriate.
25242 For compatibility with older debuggers, namespace DIEs only contain
25243 declarations; all definitions are emitted at CU scope, with
25244 DW_AT_specification pointing to the declaration (like with class
25248 declare_in_namespace (tree thing
, dw_die_ref context_die
)
25250 dw_die_ref ns_context
;
25252 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25253 return context_die
;
25255 /* External declarations in the local scope only need to be emitted
25256 once, not once in the namespace and once in the scope.
25258 This avoids declaring the `extern' below in the
25259 namespace DIE as well as in the innermost scope:
25272 if (DECL_P (thing
) && DECL_EXTERNAL (thing
) && local_scope_p (context_die
))
25273 return context_die
;
25275 /* If this decl is from an inlined function, then don't try to emit it in its
25276 namespace, as we will get confused. It would have already been emitted
25277 when the abstract instance of the inline function was emitted anyways. */
25278 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
25279 return context_die
;
25281 ns_context
= setup_namespace_context (thing
, context_die
);
25283 if (ns_context
!= context_die
)
25287 if (DECL_P (thing
))
25288 gen_decl_die (thing
, NULL
, NULL
, ns_context
);
25290 gen_type_die (thing
, ns_context
);
25292 return context_die
;
25295 /* Generate a DIE for a namespace or namespace alias. */
25298 gen_namespace_die (tree decl
, dw_die_ref context_die
)
25300 dw_die_ref namespace_die
;
25302 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
25303 they are an alias of. */
25304 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
25306 /* Output a real namespace or module. */
25307 context_die
= setup_namespace_context (decl
, comp_unit_die ());
25308 namespace_die
= new_die (is_fortran ()
25309 ? DW_TAG_module
: DW_TAG_namespace
,
25310 context_die
, decl
);
25311 /* For Fortran modules defined in different CU don't add src coords. */
25312 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
25314 const char *name
= dwarf2_name (decl
, 0);
25316 add_name_attribute (namespace_die
, name
);
25319 add_name_and_src_coords_attributes (namespace_die
, decl
);
25320 if (DECL_EXTERNAL (decl
))
25321 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
25322 equate_decl_number_to_die (decl
, namespace_die
);
25326 /* Output a namespace alias. */
25328 /* Force out the namespace we are an alias of, if necessary. */
25329 dw_die_ref origin_die
25330 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
25332 if (DECL_FILE_SCOPE_P (decl
)
25333 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
25334 context_die
= setup_namespace_context (decl
, comp_unit_die ());
25335 /* Now create the namespace alias DIE. */
25336 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
25337 add_name_and_src_coords_attributes (namespace_die
, decl
);
25338 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
25339 equate_decl_number_to_die (decl
, namespace_die
);
25341 if ((dwarf_version
>= 5 || !dwarf_strict
)
25342 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
25343 DW_AT_export_symbols
) == 1)
25344 add_AT_flag (namespace_die
, DW_AT_export_symbols
, 1);
25346 /* Bypass dwarf2_name's check for DECL_NAMELESS. */
25347 if (want_pubnames ())
25348 add_pubname_string (lang_hooks
.dwarf_name (decl
, 1), namespace_die
);
25351 /* Generate Dwarf debug information for a decl described by DECL.
25352 The return value is currently only meaningful for PARM_DECLs,
25353 for all other decls it returns NULL.
25355 If DECL is a FIELD_DECL, CTX is required: see the comment for VLR_CONTEXT.
25356 It can be NULL otherwise. */
25359 gen_decl_die (tree decl
, tree origin
, struct vlr_context
*ctx
,
25360 dw_die_ref context_die
)
25362 tree decl_or_origin
= decl
? decl
: origin
;
25363 tree class_origin
= NULL
, ultimate_origin
;
25365 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
25368 /* Ignore pointer bounds decls. */
25369 if (DECL_P (decl_or_origin
)
25370 && TREE_TYPE (decl_or_origin
)
25371 && POINTER_BOUNDS_P (decl_or_origin
))
25374 switch (TREE_CODE (decl_or_origin
))
25380 if (!is_fortran () && !is_ada ())
25382 /* The individual enumerators of an enum type get output when we output
25383 the Dwarf representation of the relevant enum type itself. */
25387 /* Emit its type. */
25388 gen_type_die (TREE_TYPE (decl
), context_die
);
25390 /* And its containing namespace. */
25391 context_die
= declare_in_namespace (decl
, context_die
);
25393 gen_const_die (decl
, context_die
);
25396 case FUNCTION_DECL
:
25399 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
25400 on local redeclarations of global functions. That seems broken. */
25401 if (current_function_decl
!= decl
)
25402 /* This is only a declaration. */;
25405 /* We should have abstract copies already and should not generate
25406 stray type DIEs in late LTO dumping. */
25410 /* If we're emitting a clone, emit info for the abstract instance. */
25411 else if (origin
|| DECL_ORIGIN (decl
) != decl
)
25412 dwarf2out_abstract_function (origin
25413 ? DECL_ORIGIN (origin
)
25414 : DECL_ABSTRACT_ORIGIN (decl
));
25416 /* If we're emitting a possibly inlined function emit it as
25417 abstract instance. */
25418 else if (cgraph_function_possibly_inlined_p (decl
)
25419 && ! DECL_ABSTRACT_P (decl
)
25420 && ! class_or_namespace_scope_p (context_die
)
25421 /* dwarf2out_abstract_function won't emit a die if this is just
25422 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
25423 that case, because that works only if we have a die. */
25424 && DECL_INITIAL (decl
) != NULL_TREE
)
25425 dwarf2out_abstract_function (decl
);
25427 /* Otherwise we're emitting the primary DIE for this decl. */
25428 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
25430 /* Before we describe the FUNCTION_DECL itself, make sure that we
25431 have its containing type. */
25433 origin
= decl_class_context (decl
);
25434 if (origin
!= NULL_TREE
)
25435 gen_type_die (origin
, context_die
);
25437 /* And its return type. */
25438 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
25440 /* And its virtual context. */
25441 if (DECL_VINDEX (decl
) != NULL_TREE
)
25442 gen_type_die (DECL_CONTEXT (decl
), context_die
);
25444 /* Make sure we have a member DIE for decl. */
25445 if (origin
!= NULL_TREE
)
25446 gen_type_die_for_member (origin
, decl
, context_die
);
25448 /* And its containing namespace. */
25449 context_die
= declare_in_namespace (decl
, context_die
);
25452 /* Now output a DIE to represent the function itself. */
25454 gen_subprogram_die (decl
, context_die
);
25458 /* If we are in terse mode, don't generate any DIEs to represent any
25459 actual typedefs. */
25460 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25463 /* In the special case of a TYPE_DECL node representing the declaration
25464 of some type tag, if the given TYPE_DECL is marked as having been
25465 instantiated from some other (original) TYPE_DECL node (e.g. one which
25466 was generated within the original definition of an inline function) we
25467 used to generate a special (abbreviated) DW_TAG_structure_type,
25468 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
25469 should be actually referencing those DIEs, as variable DIEs with that
25470 type would be emitted already in the abstract origin, so it was always
25471 removed during unused type prunning. Don't add anything in this
25473 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
25476 if (is_redundant_typedef (decl
))
25477 gen_type_die (TREE_TYPE (decl
), context_die
);
25479 /* Output a DIE to represent the typedef itself. */
25480 gen_typedef_die (decl
, context_die
);
25484 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
25485 gen_label_die (decl
, context_die
);
25490 /* If we are in terse mode, don't generate any DIEs to represent any
25491 variable declarations or definitions. */
25492 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25495 /* Avoid generating stray type DIEs during late dwarf dumping.
25496 All types have been dumped early. */
25498 /* ??? But in LTRANS we cannot annotate early created variably
25499 modified type DIEs without copying them and adjusting all
25500 references to them. Dump them again as happens for inlining
25501 which copies both the decl and the types. */
25502 /* ??? And even non-LTO needs to re-visit type DIEs to fill
25503 in VLA bound information for example. */
25504 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
25505 current_function_decl
)))
25507 /* Output any DIEs that are needed to specify the type of this data
25509 if (decl_by_reference_p (decl_or_origin
))
25510 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
25512 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
25517 /* And its containing type. */
25518 class_origin
= decl_class_context (decl_or_origin
);
25519 if (class_origin
!= NULL_TREE
)
25520 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
25522 /* And its containing namespace. */
25523 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
25526 /* Now output the DIE to represent the data object itself. This gets
25527 complicated because of the possibility that the VAR_DECL really
25528 represents an inlined instance of a formal parameter for an inline
25530 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
25531 if (ultimate_origin
!= NULL_TREE
25532 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
25533 gen_formal_parameter_die (decl
, origin
,
25534 true /* Emit name attribute. */,
25537 gen_variable_die (decl
, origin
, context_die
);
25541 gcc_assert (ctx
!= NULL
&& ctx
->struct_type
!= NULL
);
25542 /* Ignore the nameless fields that are used to skip bits but handle C++
25543 anonymous unions and structs. */
25544 if (DECL_NAME (decl
) != NULL_TREE
25545 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
25546 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
25548 gen_type_die (member_declared_type (decl
), context_die
);
25549 gen_field_die (decl
, ctx
, context_die
);
25554 /* Avoid generating stray type DIEs during late dwarf dumping.
25555 All types have been dumped early. */
25557 /* ??? But in LTRANS we cannot annotate early created variably
25558 modified type DIEs without copying them and adjusting all
25559 references to them. Dump them again as happens for inlining
25560 which copies both the decl and the types. */
25561 /* ??? And even non-LTO needs to re-visit type DIEs to fill
25562 in VLA bound information for example. */
25563 || (decl
&& variably_modified_type_p (TREE_TYPE (decl
),
25564 current_function_decl
)))
25566 if (DECL_BY_REFERENCE (decl_or_origin
))
25567 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
25569 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
25571 return gen_formal_parameter_die (decl
, origin
,
25572 true /* Emit name attribute. */,
25575 case NAMESPACE_DECL
:
25576 if (dwarf_version
>= 3 || !dwarf_strict
)
25577 gen_namespace_die (decl
, context_die
);
25580 case IMPORTED_DECL
:
25581 dwarf2out_imported_module_or_decl_1 (decl
, DECL_NAME (decl
),
25582 DECL_CONTEXT (decl
), context_die
);
25585 case NAMELIST_DECL
:
25586 gen_namelist_decl (DECL_NAME (decl
), context_die
,
25587 NAMELIST_DECL_ASSOCIATED_DECL (decl
));
25591 /* Probably some frontend-internal decl. Assume we don't care. */
25592 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
25599 /* Output initial debug information for global DECL. Called at the
25600 end of the parsing process.
25602 This is the initial debug generation process. As such, the DIEs
25603 generated may be incomplete. A later debug generation pass
25604 (dwarf2out_late_global_decl) will augment the information generated
25605 in this pass (e.g., with complete location info). */
25608 dwarf2out_early_global_decl (tree decl
)
25612 /* gen_decl_die() will set DECL_ABSTRACT because
25613 cgraph_function_possibly_inlined_p() returns true. This is in
25614 turn will cause DW_AT_inline attributes to be set.
25616 This happens because at early dwarf generation, there is no
25617 cgraph information, causing cgraph_function_possibly_inlined_p()
25618 to return true. Trick cgraph_function_possibly_inlined_p()
25619 while we generate dwarf early. */
25620 bool save
= symtab
->global_info_ready
;
25621 symtab
->global_info_ready
= true;
25623 /* We don't handle TYPE_DECLs. If required, they'll be reached via
25624 other DECLs and they can point to template types or other things
25625 that dwarf2out can't handle when done via dwarf2out_decl. */
25626 if (TREE_CODE (decl
) != TYPE_DECL
25627 && TREE_CODE (decl
) != PARM_DECL
)
25629 if (TREE_CODE (decl
) == FUNCTION_DECL
)
25631 tree save_fndecl
= current_function_decl
;
25633 /* For nested functions, make sure we have DIEs for the parents first
25634 so that all nested DIEs are generated at the proper scope in the
25636 tree context
= decl_function_context (decl
);
25637 if (context
!= NULL
)
25639 dw_die_ref context_die
= lookup_decl_die (context
);
25640 current_function_decl
= context
;
25642 /* Avoid emitting DIEs multiple times, but still process CONTEXT
25643 enough so that it lands in its own context. This avoids type
25644 pruning issues later on. */
25645 if (context_die
== NULL
|| is_declaration_die (context_die
))
25646 dwarf2out_decl (context
);
25649 /* Emit an abstract origin of a function first. This happens
25650 with C++ constructor clones for example and makes
25651 dwarf2out_abstract_function happy which requires the early
25652 DIE of the abstract instance to be present. */
25653 tree origin
= DECL_ABSTRACT_ORIGIN (decl
);
25654 dw_die_ref origin_die
;
25656 /* Do not emit the DIE multiple times but make sure to
25657 process it fully here in case we just saw a declaration. */
25658 && ((origin_die
= lookup_decl_die (origin
)) == NULL
25659 || is_declaration_die (origin_die
)))
25661 current_function_decl
= origin
;
25662 dwarf2out_decl (origin
);
25665 /* Emit the DIE for decl but avoid doing that multiple times. */
25666 dw_die_ref old_die
;
25667 if ((old_die
= lookup_decl_die (decl
)) == NULL
25668 || is_declaration_die (old_die
))
25670 current_function_decl
= decl
;
25671 dwarf2out_decl (decl
);
25674 current_function_decl
= save_fndecl
;
25677 dwarf2out_decl (decl
);
25679 symtab
->global_info_ready
= save
;
25682 /* Output debug information for global decl DECL. Called from
25683 toplev.c after compilation proper has finished. */
25686 dwarf2out_late_global_decl (tree decl
)
25688 /* Fill-in any location information we were unable to determine
25689 on the first pass. */
25690 if (VAR_P (decl
) && !POINTER_BOUNDS_P (decl
))
25692 dw_die_ref die
= lookup_decl_die (decl
);
25694 /* We may have to generate early debug late for LTO in case debug
25695 was not enabled at compile-time or the target doesn't support
25696 the LTO early debug scheme. */
25697 if (! die
&& in_lto_p
)
25699 dwarf2out_decl (decl
);
25700 die
= lookup_decl_die (decl
);
25705 /* We get called via the symtab code invoking late_global_decl
25706 for symbols that are optimized out. Do not add locations
25707 for those, except if they have a DECL_VALUE_EXPR, in which case
25708 they are relevant for debuggers. */
25709 varpool_node
*node
= varpool_node::get (decl
);
25710 if ((! node
|| ! node
->definition
) && ! DECL_HAS_VALUE_EXPR_P (decl
))
25711 tree_add_const_value_attribute_for_decl (die
, decl
);
25713 add_location_or_const_value_attribute (die
, decl
, false);
25718 /* Output debug information for type decl DECL. Called from toplev.c
25719 and from language front ends (to record built-in types). */
25721 dwarf2out_type_decl (tree decl
, int local
)
25726 dwarf2out_decl (decl
);
25730 /* Output debug information for imported module or decl DECL.
25731 NAME is non-NULL name in the lexical block if the decl has been renamed.
25732 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
25733 that DECL belongs to.
25734 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
25736 dwarf2out_imported_module_or_decl_1 (tree decl
,
25738 tree lexical_block
,
25739 dw_die_ref lexical_block_die
)
25741 expanded_location xloc
;
25742 dw_die_ref imported_die
= NULL
;
25743 dw_die_ref at_import_die
;
25745 if (TREE_CODE (decl
) == IMPORTED_DECL
)
25747 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
25748 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
25752 xloc
= expand_location (input_location
);
25754 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
25756 at_import_die
= force_type_die (TREE_TYPE (decl
));
25757 /* For namespace N { typedef void T; } using N::T; base_type_die
25758 returns NULL, but DW_TAG_imported_declaration requires
25759 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
25760 if (!at_import_die
)
25762 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
25763 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
25764 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
25765 gcc_assert (at_import_die
);
25770 at_import_die
= lookup_decl_die (decl
);
25771 if (!at_import_die
)
25773 /* If we're trying to avoid duplicate debug info, we may not have
25774 emitted the member decl for this field. Emit it now. */
25775 if (TREE_CODE (decl
) == FIELD_DECL
)
25777 tree type
= DECL_CONTEXT (decl
);
25779 if (TYPE_CONTEXT (type
)
25780 && TYPE_P (TYPE_CONTEXT (type
))
25781 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
25782 DINFO_USAGE_DIR_USE
))
25784 gen_type_die_for_member (type
, decl
,
25785 get_context_die (TYPE_CONTEXT (type
)));
25787 if (TREE_CODE (decl
) == NAMELIST_DECL
)
25788 at_import_die
= gen_namelist_decl (DECL_NAME (decl
),
25789 get_context_die (DECL_CONTEXT (decl
)),
25792 at_import_die
= force_decl_die (decl
);
25796 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
25798 if (dwarf_version
>= 3 || !dwarf_strict
)
25799 imported_die
= new_die (DW_TAG_imported_module
,
25806 imported_die
= new_die (DW_TAG_imported_declaration
,
25810 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
25811 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
25812 if (debug_column_info
&& xloc
.column
)
25813 add_AT_unsigned (imported_die
, DW_AT_decl_column
, xloc
.column
);
25815 add_AT_string (imported_die
, DW_AT_name
,
25816 IDENTIFIER_POINTER (name
));
25817 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
25820 /* Output debug information for imported module or decl DECL.
25821 NAME is non-NULL name in context if the decl has been renamed.
25822 CHILD is true if decl is one of the renamed decls as part of
25823 importing whole module.
25824 IMPLICIT is set if this hook is called for an implicit import
25825 such as inline namespace. */
25828 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
25829 bool child
, bool implicit
)
25831 /* dw_die_ref at_import_die; */
25832 dw_die_ref scope_die
;
25834 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25839 /* For DWARF5, just DW_AT_export_symbols on the DW_TAG_namespace
25840 should be enough, for DWARF4 and older even if we emit as extension
25841 DW_AT_export_symbols add the implicit DW_TAG_imported_module anyway
25842 for the benefit of consumers unaware of DW_AT_export_symbols. */
25844 && dwarf_version
>= 5
25845 && lang_hooks
.decls
.decl_dwarf_attribute (decl
,
25846 DW_AT_export_symbols
) == 1)
25851 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
25852 We need decl DIE for reference and scope die. First, get DIE for the decl
25855 /* Get the scope die for decl context. Use comp_unit_die for global module
25856 or decl. If die is not found for non globals, force new die. */
25858 && TYPE_P (context
)
25859 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
25862 scope_die
= get_context_die (context
);
25866 /* DW_TAG_imported_module was introduced in the DWARFv3 specification, so
25867 there is nothing we can do, here. */
25868 if (dwarf_version
< 3 && dwarf_strict
)
25871 gcc_assert (scope_die
->die_child
);
25872 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
25873 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
25874 scope_die
= scope_die
->die_child
;
25877 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
25878 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
25881 /* Output debug information for namelists. */
25884 gen_namelist_decl (tree name
, dw_die_ref scope_die
, tree item_decls
)
25886 dw_die_ref nml_die
, nml_item_die
, nml_item_ref_die
;
25890 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25893 gcc_assert (scope_die
!= NULL
);
25894 nml_die
= new_die (DW_TAG_namelist
, scope_die
, NULL
);
25895 add_AT_string (nml_die
, DW_AT_name
, IDENTIFIER_POINTER (name
));
25897 /* If there are no item_decls, we have a nondefining namelist, e.g.
25898 with USE association; hence, set DW_AT_declaration. */
25899 if (item_decls
== NULL_TREE
)
25901 add_AT_flag (nml_die
, DW_AT_declaration
, 1);
25905 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (item_decls
), i
, value
)
25907 nml_item_ref_die
= lookup_decl_die (value
);
25908 if (!nml_item_ref_die
)
25909 nml_item_ref_die
= force_decl_die (value
);
25911 nml_item_die
= new_die (DW_TAG_namelist_item
, nml_die
, NULL
);
25912 add_AT_die_ref (nml_item_die
, DW_AT_namelist_items
, nml_item_ref_die
);
25918 /* Write the debugging output for DECL and return the DIE. */
25921 dwarf2out_decl (tree decl
)
25923 dw_die_ref context_die
= comp_unit_die ();
25925 switch (TREE_CODE (decl
))
25930 case FUNCTION_DECL
:
25931 /* If we're a nested function, initially use a parent of NULL; if we're
25932 a plain function, this will be fixed up in decls_for_scope. If
25933 we're a method, it will be ignored, since we already have a DIE. */
25934 if (decl_function_context (decl
)
25935 /* But if we're in terse mode, we don't care about scope. */
25936 && debug_info_level
> DINFO_LEVEL_TERSE
)
25937 context_die
= NULL
;
25941 /* For local statics lookup proper context die. */
25942 if (local_function_static (decl
))
25943 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
25945 /* If we are in terse mode, don't generate any DIEs to represent any
25946 variable declarations or definitions. */
25947 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25952 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25954 if (!is_fortran () && !is_ada ())
25956 if (TREE_STATIC (decl
) && decl_function_context (decl
))
25957 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
25960 case NAMESPACE_DECL
:
25961 case IMPORTED_DECL
:
25962 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25964 if (lookup_decl_die (decl
) != NULL
)
25969 /* Don't emit stubs for types unless they are needed by other DIEs. */
25970 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
25973 /* Don't bother trying to generate any DIEs to represent any of the
25974 normal built-in types for the language we are compiling. */
25975 if (DECL_IS_BUILTIN (decl
))
25978 /* If we are in terse mode, don't generate any DIEs for types. */
25979 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
25982 /* If we're a function-scope tag, initially use a parent of NULL;
25983 this will be fixed up in decls_for_scope. */
25984 if (decl_function_context (decl
))
25985 context_die
= NULL
;
25989 case NAMELIST_DECL
:
25996 gen_decl_die (decl
, NULL
, NULL
, context_die
);
26000 dw_die_ref die
= lookup_decl_die (decl
);
26006 /* Write the debugging output for DECL. */
26009 dwarf2out_function_decl (tree decl
)
26011 dwarf2out_decl (decl
);
26012 call_arg_locations
= NULL
;
26013 call_arg_loc_last
= NULL
;
26014 call_site_count
= -1;
26015 tail_call_site_count
= -1;
26016 decl_loc_table
->empty ();
26017 cached_dw_loc_list_table
->empty ();
26020 /* Output a marker (i.e. a label) for the beginning of the generated code for
26021 a lexical block. */
26024 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
26025 unsigned int blocknum
)
26027 switch_to_section (current_function_section ());
26028 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
26031 /* Output a marker (i.e. a label) for the end of the generated code for a
26035 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
26037 switch_to_section (current_function_section ());
26038 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
26041 /* Returns nonzero if it is appropriate not to emit any debugging
26042 information for BLOCK, because it doesn't contain any instructions.
26044 Don't allow this for blocks with nested functions or local classes
26045 as we would end up with orphans, and in the presence of scheduling
26046 we may end up calling them anyway. */
26049 dwarf2out_ignore_block (const_tree block
)
26054 for (decl
= BLOCK_VARS (block
); decl
; decl
= DECL_CHAIN (decl
))
26055 if (TREE_CODE (decl
) == FUNCTION_DECL
26056 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
26058 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
26060 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
26061 if (TREE_CODE (decl
) == FUNCTION_DECL
26062 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
26069 /* Hash table routines for file_hash. */
26072 dwarf_file_hasher::equal (dwarf_file_data
*p1
, const char *p2
)
26074 return filename_cmp (p1
->filename
, p2
) == 0;
26078 dwarf_file_hasher::hash (dwarf_file_data
*p
)
26080 return htab_hash_string (p
->filename
);
26083 /* Lookup FILE_NAME (in the list of filenames that we know about here in
26084 dwarf2out.c) and return its "index". The index of each (known) filename is
26085 just a unique number which is associated with only that one filename. We
26086 need such numbers for the sake of generating labels (in the .debug_sfnames
26087 section) and references to those files numbers (in the .debug_srcinfo
26088 and .debug_macinfo sections). If the filename given as an argument is not
26089 found in our current list, add it to the list and assign it the next
26090 available unique index number. */
26092 static struct dwarf_file_data
*
26093 lookup_filename (const char *file_name
)
26095 struct dwarf_file_data
* created
;
26100 dwarf_file_data
**slot
26101 = file_table
->find_slot_with_hash (file_name
, htab_hash_string (file_name
),
26106 created
= ggc_alloc
<dwarf_file_data
> ();
26107 created
->filename
= file_name
;
26108 created
->emitted_number
= 0;
26113 /* If the assembler will construct the file table, then translate the compiler
26114 internal file table number into the assembler file table number, and emit
26115 a .file directive if we haven't already emitted one yet. The file table
26116 numbers are different because we prune debug info for unused variables and
26117 types, which may include filenames. */
26120 maybe_emit_file (struct dwarf_file_data
* fd
)
26122 if (! fd
->emitted_number
)
26124 if (last_emitted_file
)
26125 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
26127 fd
->emitted_number
= 1;
26128 last_emitted_file
= fd
;
26130 if (DWARF2_ASM_LINE_DEBUG_INFO
)
26132 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
26133 output_quoted_string (asm_out_file
,
26134 remap_debug_filename (fd
->filename
));
26135 fputc ('\n', asm_out_file
);
26139 return fd
->emitted_number
;
26142 /* Schedule generation of a DW_AT_const_value attribute to DIE.
26143 That generation should happen after function debug info has been
26144 generated. The value of the attribute is the constant value of ARG. */
26147 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
26149 die_arg_entry entry
;
26154 gcc_assert (early_dwarf
);
26156 if (!tmpl_value_parm_die_table
)
26157 vec_alloc (tmpl_value_parm_die_table
, 32);
26161 vec_safe_push (tmpl_value_parm_die_table
, entry
);
26164 /* Return TRUE if T is an instance of generic type, FALSE
26168 generic_type_p (tree t
)
26170 if (t
== NULL_TREE
|| !TYPE_P (t
))
26172 return lang_hooks
.get_innermost_generic_parms (t
) != NULL_TREE
;
26175 /* Schedule the generation of the generic parameter dies for the
26176 instance of generic type T. The proper generation itself is later
26177 done by gen_scheduled_generic_parms_dies. */
26180 schedule_generic_params_dies_gen (tree t
)
26182 if (!generic_type_p (t
))
26185 gcc_assert (early_dwarf
);
26187 if (!generic_type_instances
)
26188 vec_alloc (generic_type_instances
, 256);
26190 vec_safe_push (generic_type_instances
, t
);
26193 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
26194 by append_entry_to_tmpl_value_parm_die_table. This function must
26195 be called after function DIEs have been generated. */
26198 gen_remaining_tmpl_value_param_die_attribute (void)
26200 if (tmpl_value_parm_die_table
)
26205 /* We do this in two phases - first get the cases we can
26206 handle during early-finish, preserving those we cannot
26207 (containing symbolic constants where we don't yet know
26208 whether we are going to output the referenced symbols).
26209 For those we try again at late-finish. */
26211 FOR_EACH_VEC_ELT (*tmpl_value_parm_die_table
, i
, e
)
26213 if (!e
->die
->removed
26214 && !tree_add_const_value_attribute (e
->die
, e
->arg
))
26216 dw_loc_descr_ref loc
= NULL
;
26218 && (dwarf_version
>= 5 || !dwarf_strict
))
26219 loc
= loc_descriptor_from_tree (e
->arg
, 2, NULL
);
26221 add_AT_loc (e
->die
, DW_AT_location
, loc
);
26223 (*tmpl_value_parm_die_table
)[j
++] = *e
;
26226 tmpl_value_parm_die_table
->truncate (j
);
26230 /* Generate generic parameters DIEs for instances of generic types
26231 that have been previously scheduled by
26232 schedule_generic_params_dies_gen. This function must be called
26233 after all the types of the CU have been laid out. */
26236 gen_scheduled_generic_parms_dies (void)
26241 if (!generic_type_instances
)
26244 FOR_EACH_VEC_ELT (*generic_type_instances
, i
, t
)
26245 if (COMPLETE_TYPE_P (t
))
26246 gen_generic_params_dies (t
);
26248 generic_type_instances
= NULL
;
26252 /* Replace DW_AT_name for the decl with name. */
26255 dwarf2out_set_name (tree decl
, tree name
)
26258 dw_attr_node
*attr
;
26261 die
= TYPE_SYMTAB_DIE (decl
);
26265 dname
= dwarf2_name (name
, 0);
26269 attr
= get_AT (die
, DW_AT_name
);
26272 struct indirect_string_node
*node
;
26274 node
= find_AT_string (dname
);
26275 /* replace the string. */
26276 attr
->dw_attr_val
.v
.val_str
= node
;
26280 add_name_attribute (die
, dname
);
26283 /* True if before or during processing of the first function being emitted. */
26284 static bool in_first_function_p
= true;
26285 /* True if loc_note during dwarf2out_var_location call might still be
26286 before first real instruction at address equal to .Ltext0. */
26287 static bool maybe_at_text_label_p
= true;
26288 /* One above highest N where .LVLN label might be equal to .Ltext0 label. */
26289 static unsigned int first_loclabel_num_not_at_text_label
;
26291 /* Look ahead for a real insn, or for a begin stmt marker. */
26294 dwarf2out_next_real_insn (rtx_insn
*loc_note
)
26296 rtx_insn
*next_real
= NEXT_INSN (loc_note
);
26299 if (INSN_P (next_real
))
26302 next_real
= NEXT_INSN (next_real
);
26307 /* Called by the final INSN scan whenever we see a var location. We
26308 use it to drop labels in the right places, and throw the location in
26309 our lookup table. */
26312 dwarf2out_var_location (rtx_insn
*loc_note
)
26314 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
26315 struct var_loc_node
*newloc
;
26316 rtx_insn
*next_real
, *next_note
;
26317 rtx_insn
*call_insn
= NULL
;
26318 static const char *last_label
;
26319 static const char *last_postcall_label
;
26320 static bool last_in_cold_section_p
;
26321 static rtx_insn
*expected_next_loc_note
;
26325 if (!NOTE_P (loc_note
))
26327 if (CALL_P (loc_note
))
26330 if (SIBLING_CALL_P (loc_note
))
26331 tail_call_site_count
++;
26332 if (optimize
== 0 && !flag_var_tracking
)
26334 /* When the var-tracking pass is not running, there is no note
26335 for indirect calls whose target is compile-time known. In this
26336 case, process such calls specifically so that we generate call
26337 sites for them anyway. */
26338 rtx x
= PATTERN (loc_note
);
26339 if (GET_CODE (x
) == PARALLEL
)
26340 x
= XVECEXP (x
, 0, 0);
26341 if (GET_CODE (x
) == SET
)
26343 if (GET_CODE (x
) == CALL
)
26346 || GET_CODE (XEXP (x
, 0)) != SYMBOL_REF
26347 || !SYMBOL_REF_DECL (XEXP (x
, 0))
26348 || (TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0)))
26351 call_insn
= loc_note
;
26355 next_real
= dwarf2out_next_real_insn (call_insn
);
26357 cached_next_real_insn
= NULL
;
26365 var_loc_p
= NOTE_KIND (loc_note
) == NOTE_INSN_VAR_LOCATION
;
26366 if (var_loc_p
&& !DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
26369 /* Optimize processing a large consecutive sequence of location
26370 notes so we don't spend too much time in next_real_insn. If the
26371 next insn is another location note, remember the next_real_insn
26372 calculation for next time. */
26373 next_real
= cached_next_real_insn
;
26376 if (expected_next_loc_note
!= loc_note
)
26380 next_note
= NEXT_INSN (loc_note
);
26382 || next_note
->deleted ()
26383 || ! NOTE_P (next_note
)
26384 || (NOTE_KIND (next_note
) != NOTE_INSN_VAR_LOCATION
26385 && NOTE_KIND (next_note
) != NOTE_INSN_BEGIN_STMT
26386 && NOTE_KIND (next_note
) != NOTE_INSN_CALL_ARG_LOCATION
))
26390 next_real
= dwarf2out_next_real_insn (loc_note
);
26394 expected_next_loc_note
= next_note
;
26395 cached_next_real_insn
= next_real
;
26398 cached_next_real_insn
= NULL
;
26400 /* If there are no instructions which would be affected by this note,
26401 don't do anything. */
26403 && next_real
== NULL_RTX
26404 && !NOTE_DURING_CALL_P (loc_note
))
26409 if (next_real
== NULL_RTX
)
26410 next_real
= get_last_insn ();
26412 /* If there were any real insns between note we processed last time
26413 and this note (or if it is the first note), clear
26414 last_{,postcall_}label so that they are not reused this time. */
26415 if (last_var_location_insn
== NULL_RTX
26416 || last_var_location_insn
!= next_real
26417 || last_in_cold_section_p
!= in_cold_section_p
)
26420 last_postcall_label
= NULL
;
26425 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
26426 newloc
= add_var_loc_to_decl (decl
, loc_note
,
26427 NOTE_DURING_CALL_P (loc_note
)
26428 ? last_postcall_label
: last_label
);
26429 if (newloc
== NULL
)
26438 /* If there were no real insns between note we processed last time
26439 and this note, use the label we emitted last time. Otherwise
26440 create a new label and emit it. */
26441 if (last_label
== NULL
)
26443 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
26444 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
26446 last_label
= ggc_strdup (loclabel
);
26447 /* See if loclabel might be equal to .Ltext0. If yes,
26448 bump first_loclabel_num_not_at_text_label. */
26449 if (!have_multiple_function_sections
26450 && in_first_function_p
26451 && maybe_at_text_label_p
)
26453 static rtx_insn
*last_start
;
26455 for (insn
= loc_note
; insn
; insn
= previous_insn (insn
))
26456 if (insn
== last_start
)
26458 else if (!NONDEBUG_INSN_P (insn
))
26462 rtx body
= PATTERN (insn
);
26463 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
26465 /* Inline asm could occupy zero bytes. */
26466 else if (GET_CODE (body
) == ASM_INPUT
26467 || asm_noperands (body
) >= 0)
26469 #ifdef HAVE_attr_length
26470 else if (get_attr_min_length (insn
) == 0)
26475 /* Assume insn has non-zero length. */
26476 maybe_at_text_label_p
= false;
26480 if (maybe_at_text_label_p
)
26482 last_start
= loc_note
;
26483 first_loclabel_num_not_at_text_label
= loclabel_num
;
26488 gcc_assert ((loc_note
== NULL_RTX
&& call_insn
!= NULL_RTX
)
26489 || (loc_note
!= NULL_RTX
&& call_insn
== NULL_RTX
));
26493 struct call_arg_loc_node
*ca_loc
26494 = ggc_cleared_alloc
<call_arg_loc_node
> ();
26496 = loc_note
!= NULL_RTX
? prev_real_insn (loc_note
) : call_insn
;
26498 ca_loc
->call_arg_loc_note
= loc_note
;
26499 ca_loc
->next
= NULL
;
26500 ca_loc
->label
= last_label
;
26503 || (NONJUMP_INSN_P (prev
)
26504 && GET_CODE (PATTERN (prev
)) == SEQUENCE
26505 && CALL_P (XVECEXP (PATTERN (prev
), 0, 0)))));
26506 if (!CALL_P (prev
))
26507 prev
= as_a
<rtx_sequence
*> (PATTERN (prev
))->insn (0);
26508 ca_loc
->tail_call_p
= SIBLING_CALL_P (prev
);
26510 /* Look for a SYMBOL_REF in the "prev" instruction. */
26511 rtx x
= get_call_rtx_from (PATTERN (prev
));
26514 /* Try to get the call symbol, if any. */
26515 if (MEM_P (XEXP (x
, 0)))
26517 /* First, look for a memory access to a symbol_ref. */
26518 if (GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
26519 && SYMBOL_REF_DECL (XEXP (x
, 0))
26520 && TREE_CODE (SYMBOL_REF_DECL (XEXP (x
, 0))) == FUNCTION_DECL
)
26521 ca_loc
->symbol_ref
= XEXP (x
, 0);
26522 /* Otherwise, look at a compile-time known user-level function
26526 && TREE_CODE (MEM_EXPR (x
)) == FUNCTION_DECL
)
26527 ca_loc
->symbol_ref
= XEXP (DECL_RTL (MEM_EXPR (x
)), 0);
26530 ca_loc
->block
= insn_scope (prev
);
26531 if (call_arg_locations
)
26532 call_arg_loc_last
->next
= ca_loc
;
26534 call_arg_locations
= ca_loc
;
26535 call_arg_loc_last
= ca_loc
;
26537 else if (loc_note
!= NULL_RTX
&& !NOTE_DURING_CALL_P (loc_note
))
26538 newloc
->label
= last_label
;
26541 if (!last_postcall_label
)
26543 sprintf (loclabel
, "%s-1", last_label
);
26544 last_postcall_label
= ggc_strdup (loclabel
);
26546 newloc
->label
= last_postcall_label
;
26549 if (var_loc_p
&& flag_debug_asm
)
26551 const char *name
= NULL
, *sep
= " => ", *patstr
= NULL
;
26552 if (decl
&& DECL_NAME (decl
))
26553 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
26554 if (NOTE_VAR_LOCATION_LOC (loc_note
))
26555 patstr
= str_pattern_slim (NOTE_VAR_LOCATION_LOC (loc_note
));
26561 fprintf (asm_out_file
, "\t%s DEBUG %s%s%s\n", ASM_COMMENT_START
,
26562 name
, sep
, patstr
);
26565 last_var_location_insn
= next_real
;
26566 last_in_cold_section_p
= in_cold_section_p
;
26569 /* Called from finalize_size_functions for size functions so that their body
26570 can be encoded in the debug info to describe the layout of variable-length
26574 dwarf2out_size_function (tree decl
)
26576 function_to_dwarf_procedure (decl
);
26579 /* Note in one location list that text section has changed. */
26582 var_location_switch_text_section_1 (var_loc_list
**slot
, void *)
26584 var_loc_list
*list
= *slot
;
26586 list
->last_before_switch
26587 = list
->last
->next
? list
->last
->next
: list
->last
;
26591 /* Note in all location lists that text section has changed. */
26594 var_location_switch_text_section (void)
26596 if (decl_loc_table
== NULL
)
26599 decl_loc_table
->traverse
<void *, var_location_switch_text_section_1
> (NULL
);
26602 /* Create a new line number table. */
26604 static dw_line_info_table
*
26605 new_line_info_table (void)
26607 dw_line_info_table
*table
;
26609 table
= ggc_cleared_alloc
<dw_line_info_table
> ();
26610 table
->file_num
= 1;
26611 table
->line_num
= 1;
26612 table
->is_stmt
= DWARF_LINE_DEFAULT_IS_STMT_START
;
26617 /* Lookup the "current" table into which we emit line info, so
26618 that we don't have to do it for every source line. */
26621 set_cur_line_info_table (section
*sec
)
26623 dw_line_info_table
*table
;
26625 if (sec
== text_section
)
26626 table
= text_section_line_info
;
26627 else if (sec
== cold_text_section
)
26629 table
= cold_text_section_line_info
;
26632 cold_text_section_line_info
= table
= new_line_info_table ();
26633 table
->end_label
= cold_end_label
;
26638 const char *end_label
;
26640 if (crtl
->has_bb_partition
)
26642 if (in_cold_section_p
)
26643 end_label
= crtl
->subsections
.cold_section_end_label
;
26645 end_label
= crtl
->subsections
.hot_section_end_label
;
26649 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
26650 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
26651 current_function_funcdef_no
);
26652 end_label
= ggc_strdup (label
);
26655 table
= new_line_info_table ();
26656 table
->end_label
= end_label
;
26658 vec_safe_push (separate_line_info
, table
);
26661 if (DWARF2_ASM_LINE_DEBUG_INFO
)
26662 table
->is_stmt
= (cur_line_info_table
26663 ? cur_line_info_table
->is_stmt
26664 : DWARF_LINE_DEFAULT_IS_STMT_START
);
26665 cur_line_info_table
= table
;
26669 /* We need to reset the locations at the beginning of each
26670 function. We can't do this in the end_function hook, because the
26671 declarations that use the locations won't have been output when
26672 that hook is called. Also compute have_multiple_function_sections here. */
26675 dwarf2out_begin_function (tree fun
)
26677 section
*sec
= function_section (fun
);
26679 if (sec
!= text_section
)
26680 have_multiple_function_sections
= true;
26682 if (crtl
->has_bb_partition
&& !cold_text_section
)
26684 gcc_assert (current_function_decl
== fun
);
26685 cold_text_section
= unlikely_text_section ();
26686 switch_to_section (cold_text_section
);
26687 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
26688 switch_to_section (sec
);
26691 dwarf2out_note_section_used ();
26692 call_site_count
= 0;
26693 tail_call_site_count
= 0;
26695 set_cur_line_info_table (sec
);
26698 /* Helper function of dwarf2out_end_function, called only after emitting
26699 the very first function into assembly. Check if some .debug_loc range
26700 might end with a .LVL* label that could be equal to .Ltext0.
26701 In that case we must force using absolute addresses in .debug_loc ranges,
26702 because this range could be .LVLN-.Ltext0 .. .LVLM-.Ltext0 for
26703 .LVLN == .LVLM == .Ltext0, thus 0 .. 0, which is a .debug_loc
26705 Set have_multiple_function_sections to true in that case and
26706 terminate htab traversal. */
26709 find_empty_loc_ranges_at_text_label (var_loc_list
**slot
, int)
26711 var_loc_list
*entry
= *slot
;
26712 struct var_loc_node
*node
;
26714 node
= entry
->first
;
26715 if (node
&& node
->next
&& node
->next
->label
)
26718 const char *label
= node
->next
->label
;
26719 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
26721 for (i
= 0; i
< first_loclabel_num_not_at_text_label
; i
++)
26723 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", i
);
26724 if (strcmp (label
, loclabel
) == 0)
26726 have_multiple_function_sections
= true;
26734 /* Hook called after emitting a function into assembly.
26735 This does something only for the very first function emitted. */
26738 dwarf2out_end_function (unsigned int)
26740 if (in_first_function_p
26741 && !have_multiple_function_sections
26742 && first_loclabel_num_not_at_text_label
26744 decl_loc_table
->traverse
<int, find_empty_loc_ranges_at_text_label
> (0);
26745 in_first_function_p
= false;
26746 maybe_at_text_label_p
= false;
26749 /* Temporary holder for dwarf2out_register_main_translation_unit. Used to let
26750 front-ends register a translation unit even before dwarf2out_init is
26752 static tree main_translation_unit
= NULL_TREE
;
26754 /* Hook called by front-ends after they built their main translation unit.
26755 Associate comp_unit_die to UNIT. */
26758 dwarf2out_register_main_translation_unit (tree unit
)
26760 gcc_assert (TREE_CODE (unit
) == TRANSLATION_UNIT_DECL
26761 && main_translation_unit
== NULL_TREE
);
26762 main_translation_unit
= unit
;
26763 /* If dwarf2out_init has not been called yet, it will perform the association
26764 itself looking at main_translation_unit. */
26765 if (decl_die_table
!= NULL
)
26766 equate_decl_number_to_die (unit
, comp_unit_die ());
26769 /* Add OPCODE+VAL as an entry at the end of the opcode array in TABLE. */
26772 push_dw_line_info_entry (dw_line_info_table
*table
,
26773 enum dw_line_info_opcode opcode
, unsigned int val
)
26775 dw_line_info_entry e
;
26778 vec_safe_push (table
->entries
, e
);
26781 /* Output a label to mark the beginning of a source code line entry
26782 and record information relating to this source line, in
26783 'line_info_table' for later output of the .debug_line section. */
26784 /* ??? The discriminator parameter ought to be unsigned. */
26787 dwarf2out_source_line (unsigned int line
, unsigned int column
,
26788 const char *filename
,
26789 int discriminator
, bool is_stmt
)
26791 unsigned int file_num
;
26792 dw_line_info_table
*table
;
26794 if (debug_info_level
< DINFO_LEVEL_TERSE
|| line
== 0)
26797 /* The discriminator column was added in dwarf4. Simplify the below
26798 by simply removing it if we're not supposed to output it. */
26799 if (dwarf_version
< 4 && dwarf_strict
)
26802 if (!debug_column_info
)
26805 table
= cur_line_info_table
;
26806 file_num
= maybe_emit_file (lookup_filename (filename
));
26808 /* ??? TODO: Elide duplicate line number entries. Traditionally,
26809 the debugger has used the second (possibly duplicate) line number
26810 at the beginning of the function to mark the end of the prologue.
26811 We could eliminate any other duplicates within the function. For
26812 Dwarf3, we ought to include the DW_LNS_set_prologue_end mark in
26813 that second line number entry. */
26814 /* Recall that this end-of-prologue indication is *not* the same thing
26815 as the end_prologue debug hook. The NOTE_INSN_PROLOGUE_END note,
26816 to which the hook corresponds, follows the last insn that was
26817 emitted by gen_prologue. What we need is to precede the first insn
26818 that had been emitted after NOTE_INSN_FUNCTION_BEG, i.e. the first
26819 insn that corresponds to something the user wrote. These may be
26820 very different locations once scheduling is enabled. */
26822 if (0 && file_num
== table
->file_num
26823 && line
== table
->line_num
26824 && column
== table
->column_num
26825 && discriminator
== table
->discrim_num
26826 && is_stmt
== table
->is_stmt
)
26829 switch_to_section (current_function_section ());
26831 /* If requested, emit something human-readable. */
26832 if (flag_debug_asm
)
26834 if (debug_column_info
)
26835 fprintf (asm_out_file
, "\t%s %s:%d:%d\n", ASM_COMMENT_START
,
26836 filename
, line
, column
);
26838 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
26842 if (DWARF2_ASM_LINE_DEBUG_INFO
)
26844 /* Emit the .loc directive understood by GNU as. */
26845 /* "\t.loc %u %u 0 is_stmt %u discriminator %u",
26846 file_num, line, is_stmt, discriminator */
26847 fputs ("\t.loc ", asm_out_file
);
26848 fprint_ul (asm_out_file
, file_num
);
26849 putc (' ', asm_out_file
);
26850 fprint_ul (asm_out_file
, line
);
26851 putc (' ', asm_out_file
);
26852 fprint_ul (asm_out_file
, column
);
26854 if (is_stmt
!= table
->is_stmt
)
26856 fputs (" is_stmt ", asm_out_file
);
26857 putc (is_stmt
? '1' : '0', asm_out_file
);
26859 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
26861 gcc_assert (discriminator
> 0);
26862 fputs (" discriminator ", asm_out_file
);
26863 fprint_ul (asm_out_file
, (unsigned long) discriminator
);
26865 putc ('\n', asm_out_file
);
26869 unsigned int label_num
= ++line_info_label_num
;
26871 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
, label_num
);
26873 push_dw_line_info_entry (table
, LI_set_address
, label_num
);
26874 if (file_num
!= table
->file_num
)
26875 push_dw_line_info_entry (table
, LI_set_file
, file_num
);
26876 if (discriminator
!= table
->discrim_num
)
26877 push_dw_line_info_entry (table
, LI_set_discriminator
, discriminator
);
26878 if (is_stmt
!= table
->is_stmt
)
26879 push_dw_line_info_entry (table
, LI_negate_stmt
, 0);
26880 push_dw_line_info_entry (table
, LI_set_line
, line
);
26881 if (debug_column_info
)
26882 push_dw_line_info_entry (table
, LI_set_column
, column
);
26885 table
->file_num
= file_num
;
26886 table
->line_num
= line
;
26887 table
->column_num
= column
;
26888 table
->discrim_num
= discriminator
;
26889 table
->is_stmt
= is_stmt
;
26890 table
->in_use
= true;
26893 /* Record the beginning of a new source file. */
26896 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
26898 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
26901 e
.code
= DW_MACINFO_start_file
;
26903 e
.info
= ggc_strdup (filename
);
26904 vec_safe_push (macinfo_table
, e
);
26908 /* Record the end of a source file. */
26911 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
26913 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
26916 e
.code
= DW_MACINFO_end_file
;
26919 vec_safe_push (macinfo_table
, e
);
26923 /* Called from debug_define in toplev.c. The `buffer' parameter contains
26924 the tail part of the directive line, i.e. the part which is past the
26925 initial whitespace, #, whitespace, directive-name, whitespace part. */
26928 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
26929 const char *buffer ATTRIBUTE_UNUSED
)
26931 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
26934 /* Insert a dummy first entry to be able to optimize the whole
26935 predefined macro block using DW_MACRO_import. */
26936 if (macinfo_table
->is_empty () && lineno
<= 1)
26941 vec_safe_push (macinfo_table
, e
);
26943 e
.code
= DW_MACINFO_define
;
26945 e
.info
= ggc_strdup (buffer
);
26946 vec_safe_push (macinfo_table
, e
);
26950 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
26951 the tail part of the directive line, i.e. the part which is past the
26952 initial whitespace, #, whitespace, directive-name, whitespace part. */
26955 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
26956 const char *buffer ATTRIBUTE_UNUSED
)
26958 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
26961 /* Insert a dummy first entry to be able to optimize the whole
26962 predefined macro block using DW_MACRO_import. */
26963 if (macinfo_table
->is_empty () && lineno
<= 1)
26968 vec_safe_push (macinfo_table
, e
);
26970 e
.code
= DW_MACINFO_undef
;
26972 e
.info
= ggc_strdup (buffer
);
26973 vec_safe_push (macinfo_table
, e
);
26977 /* Helpers to manipulate hash table of CUs. */
26979 struct macinfo_entry_hasher
: nofree_ptr_hash
<macinfo_entry
>
26981 static inline hashval_t
hash (const macinfo_entry
*);
26982 static inline bool equal (const macinfo_entry
*, const macinfo_entry
*);
26986 macinfo_entry_hasher::hash (const macinfo_entry
*entry
)
26988 return htab_hash_string (entry
->info
);
26992 macinfo_entry_hasher::equal (const macinfo_entry
*entry1
,
26993 const macinfo_entry
*entry2
)
26995 return !strcmp (entry1
->info
, entry2
->info
);
26998 typedef hash_table
<macinfo_entry_hasher
> macinfo_hash_type
;
27000 /* Output a single .debug_macinfo entry. */
27003 output_macinfo_op (macinfo_entry
*ref
)
27007 struct indirect_string_node
*node
;
27008 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27009 struct dwarf_file_data
*fd
;
27013 case DW_MACINFO_start_file
:
27014 fd
= lookup_filename (ref
->info
);
27015 file_num
= maybe_emit_file (fd
);
27016 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
27017 dw2_asm_output_data_uleb128 (ref
->lineno
,
27018 "Included from line number %lu",
27019 (unsigned long) ref
->lineno
);
27020 dw2_asm_output_data_uleb128 (file_num
, "file %s", ref
->info
);
27022 case DW_MACINFO_end_file
:
27023 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
27025 case DW_MACINFO_define
:
27026 case DW_MACINFO_undef
:
27027 len
= strlen (ref
->info
) + 1;
27029 && len
> DWARF_OFFSET_SIZE
27030 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
27031 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
27033 ref
->code
= ref
->code
== DW_MACINFO_define
27034 ? DW_MACRO_define_strp
: DW_MACRO_undef_strp
;
27035 output_macinfo_op (ref
);
27038 dw2_asm_output_data (1, ref
->code
,
27039 ref
->code
== DW_MACINFO_define
27040 ? "Define macro" : "Undefine macro");
27041 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
27042 (unsigned long) ref
->lineno
);
27043 dw2_asm_output_nstring (ref
->info
, -1, "The macro");
27045 case DW_MACRO_define_strp
:
27046 case DW_MACRO_undef_strp
:
27047 node
= find_AT_string (ref
->info
);
27049 && (node
->form
== DW_FORM_strp
27050 || node
->form
== DW_FORM_GNU_str_index
));
27051 dw2_asm_output_data (1, ref
->code
,
27052 ref
->code
== DW_MACRO_define_strp
27053 ? "Define macro strp"
27054 : "Undefine macro strp");
27055 dw2_asm_output_data_uleb128 (ref
->lineno
, "At line number %lu",
27056 (unsigned long) ref
->lineno
);
27057 if (node
->form
== DW_FORM_strp
)
27058 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, node
->label
,
27059 debug_str_section
, "The macro: \"%s\"",
27062 dw2_asm_output_data_uleb128 (node
->index
, "The macro: \"%s\"",
27065 case DW_MACRO_import
:
27066 dw2_asm_output_data (1, ref
->code
, "Import");
27067 ASM_GENERATE_INTERNAL_LABEL (label
,
27068 DEBUG_MACRO_SECTION_LABEL
,
27069 ref
->lineno
+ macinfo_label_base
);
27070 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, label
, NULL
, NULL
);
27073 fprintf (asm_out_file
, "%s unrecognized macinfo code %lu\n",
27074 ASM_COMMENT_START
, (unsigned long) ref
->code
);
27079 /* Attempt to make a sequence of define/undef macinfo ops shareable with
27080 other compilation unit .debug_macinfo sections. IDX is the first
27081 index of a define/undef, return the number of ops that should be
27082 emitted in a comdat .debug_macinfo section and emit
27083 a DW_MACRO_import entry referencing it.
27084 If the define/undef entry should be emitted normally, return 0. */
27087 optimize_macinfo_range (unsigned int idx
, vec
<macinfo_entry
, va_gc
> *files
,
27088 macinfo_hash_type
**macinfo_htab
)
27090 macinfo_entry
*first
, *second
, *cur
, *inc
;
27091 char linebuf
[sizeof (HOST_WIDE_INT
) * 3 + 1];
27092 unsigned char checksum
[16];
27093 struct md5_ctx ctx
;
27094 char *grp_name
, *tail
;
27096 unsigned int i
, count
, encoded_filename_len
, linebuf_len
;
27097 macinfo_entry
**slot
;
27099 first
= &(*macinfo_table
)[idx
];
27100 second
= &(*macinfo_table
)[idx
+ 1];
27102 /* Optimize only if there are at least two consecutive define/undef ops,
27103 and either all of them are before first DW_MACINFO_start_file
27104 with lineno {0,1} (i.e. predefined macro block), or all of them are
27105 in some included header file. */
27106 if (second
->code
!= DW_MACINFO_define
&& second
->code
!= DW_MACINFO_undef
)
27108 if (vec_safe_is_empty (files
))
27110 if (first
->lineno
> 1 || second
->lineno
> 1)
27113 else if (first
->lineno
== 0)
27116 /* Find the last define/undef entry that can be grouped together
27117 with first and at the same time compute md5 checksum of their
27118 codes, linenumbers and strings. */
27119 md5_init_ctx (&ctx
);
27120 for (i
= idx
; macinfo_table
->iterate (i
, &cur
); i
++)
27121 if (cur
->code
!= DW_MACINFO_define
&& cur
->code
!= DW_MACINFO_undef
)
27123 else if (vec_safe_is_empty (files
) && cur
->lineno
> 1)
27127 unsigned char code
= cur
->code
;
27128 md5_process_bytes (&code
, 1, &ctx
);
27129 checksum_uleb128 (cur
->lineno
, &ctx
);
27130 md5_process_bytes (cur
->info
, strlen (cur
->info
) + 1, &ctx
);
27132 md5_finish_ctx (&ctx
, checksum
);
27135 /* From the containing include filename (if any) pick up just
27136 usable characters from its basename. */
27137 if (vec_safe_is_empty (files
))
27140 base
= lbasename (files
->last ().info
);
27141 for (encoded_filename_len
= 0, i
= 0; base
[i
]; i
++)
27142 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
27143 encoded_filename_len
++;
27144 /* Count . at the end. */
27145 if (encoded_filename_len
)
27146 encoded_filename_len
++;
27148 sprintf (linebuf
, HOST_WIDE_INT_PRINT_UNSIGNED
, first
->lineno
);
27149 linebuf_len
= strlen (linebuf
);
27151 /* The group name format is: wmN.[<encoded filename>.]<lineno>.<md5sum> */
27152 grp_name
= XALLOCAVEC (char, 4 + encoded_filename_len
+ linebuf_len
+ 1
27154 memcpy (grp_name
, DWARF_OFFSET_SIZE
== 4 ? "wm4." : "wm8.", 4);
27155 tail
= grp_name
+ 4;
27156 if (encoded_filename_len
)
27158 for (i
= 0; base
[i
]; i
++)
27159 if (ISIDNUM (base
[i
]) || base
[i
] == '.')
27163 memcpy (tail
, linebuf
, linebuf_len
);
27164 tail
+= linebuf_len
;
27166 for (i
= 0; i
< 16; i
++)
27167 sprintf (tail
+ i
* 2, "%02x", checksum
[i
] & 0xff);
27169 /* Construct a macinfo_entry for DW_MACRO_import
27170 in the empty vector entry before the first define/undef. */
27171 inc
= &(*macinfo_table
)[idx
- 1];
27172 inc
->code
= DW_MACRO_import
;
27174 inc
->info
= ggc_strdup (grp_name
);
27175 if (!*macinfo_htab
)
27176 *macinfo_htab
= new macinfo_hash_type (10);
27177 /* Avoid emitting duplicates. */
27178 slot
= (*macinfo_htab
)->find_slot (inc
, INSERT
);
27183 /* If such an entry has been used before, just emit
27184 a DW_MACRO_import op. */
27186 output_macinfo_op (inc
);
27187 /* And clear all macinfo_entry in the range to avoid emitting them
27188 in the second pass. */
27189 for (i
= idx
; macinfo_table
->iterate (i
, &cur
) && i
< idx
+ count
; i
++)
27198 inc
->lineno
= (*macinfo_htab
)->elements ();
27199 output_macinfo_op (inc
);
27204 /* Save any strings needed by the macinfo table in the debug str
27205 table. All strings must be collected into the table by the time
27206 index_string is called. */
27209 save_macinfo_strings (void)
27213 macinfo_entry
*ref
;
27215 for (i
= 0; macinfo_table
&& macinfo_table
->iterate (i
, &ref
); i
++)
27219 /* Match the logic in output_macinfo_op to decide on
27220 indirect strings. */
27221 case DW_MACINFO_define
:
27222 case DW_MACINFO_undef
:
27223 len
= strlen (ref
->info
) + 1;
27225 && len
> DWARF_OFFSET_SIZE
27226 && !DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
27227 && (debug_str_section
->common
.flags
& SECTION_MERGE
) != 0)
27228 set_indirect_string (find_AT_string (ref
->info
));
27230 case DW_MACRO_define_strp
:
27231 case DW_MACRO_undef_strp
:
27232 set_indirect_string (find_AT_string (ref
->info
));
27240 /* Output macinfo section(s). */
27243 output_macinfo (const char *debug_line_label
, bool early_lto_debug
)
27246 unsigned long length
= vec_safe_length (macinfo_table
);
27247 macinfo_entry
*ref
;
27248 vec
<macinfo_entry
, va_gc
> *files
= NULL
;
27249 macinfo_hash_type
*macinfo_htab
= NULL
;
27250 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
27255 /* output_macinfo* uses these interchangeably. */
27256 gcc_assert ((int) DW_MACINFO_define
== (int) DW_MACRO_define
27257 && (int) DW_MACINFO_undef
== (int) DW_MACRO_undef
27258 && (int) DW_MACINFO_start_file
== (int) DW_MACRO_start_file
27259 && (int) DW_MACINFO_end_file
== (int) DW_MACRO_end_file
);
27261 /* AIX Assembler inserts the length, so adjust the reference to match the
27262 offset expected by debuggers. */
27263 strcpy (dl_section_ref
, debug_line_label
);
27264 if (XCOFF_DEBUGGING_INFO
)
27265 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
27267 /* For .debug_macro emit the section header. */
27268 if (!dwarf_strict
|| dwarf_version
>= 5)
27270 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
27271 "DWARF macro version number");
27272 if (DWARF_OFFSET_SIZE
== 8)
27273 dw2_asm_output_data (1, 3, "Flags: 64-bit, lineptr present");
27275 dw2_asm_output_data (1, 2, "Flags: 32-bit, lineptr present");
27276 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_line_label
,
27277 debug_line_section
, NULL
);
27280 /* In the first loop, it emits the primary .debug_macinfo section
27281 and after each emitted op the macinfo_entry is cleared.
27282 If a longer range of define/undef ops can be optimized using
27283 DW_MACRO_import, the DW_MACRO_import op is emitted and kept in
27284 the vector before the first define/undef in the range and the
27285 whole range of define/undef ops is not emitted and kept. */
27286 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
27290 case DW_MACINFO_start_file
:
27291 vec_safe_push (files
, *ref
);
27293 case DW_MACINFO_end_file
:
27294 if (!vec_safe_is_empty (files
))
27297 case DW_MACINFO_define
:
27298 case DW_MACINFO_undef
:
27299 if ((!dwarf_strict
|| dwarf_version
>= 5)
27300 && HAVE_COMDAT_GROUP
27301 && vec_safe_length (files
) != 1
27304 && (*macinfo_table
)[i
- 1].code
== 0)
27306 unsigned count
= optimize_macinfo_range (i
, files
, &macinfo_htab
);
27315 /* A dummy entry may be inserted at the beginning to be able
27316 to optimize the whole block of predefined macros. */
27322 output_macinfo_op (ref
);
27330 /* Save the number of transparent includes so we can adjust the
27331 label number for the fat LTO object DWARF. */
27332 unsigned macinfo_label_base_adj
= macinfo_htab
->elements ();
27334 delete macinfo_htab
;
27335 macinfo_htab
= NULL
;
27337 /* If any DW_MACRO_import were used, on those DW_MACRO_import entries
27338 terminate the current chain and switch to a new comdat .debug_macinfo
27339 section and emit the define/undef entries within it. */
27340 for (i
= 0; macinfo_table
->iterate (i
, &ref
); i
++)
27345 case DW_MACRO_import
:
27347 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
27348 tree comdat_key
= get_identifier (ref
->info
);
27349 /* Terminate the previous .debug_macinfo section. */
27350 dw2_asm_output_data (1, 0, "End compilation unit");
27351 targetm
.asm_out
.named_section (debug_macinfo_section_name
,
27355 ? SECTION_EXCLUDE
: 0),
27357 ASM_GENERATE_INTERNAL_LABEL (label
,
27358 DEBUG_MACRO_SECTION_LABEL
,
27359 ref
->lineno
+ macinfo_label_base
);
27360 ASM_OUTPUT_LABEL (asm_out_file
, label
);
27363 dw2_asm_output_data (2, dwarf_version
>= 5 ? 5 : 4,
27364 "DWARF macro version number");
27365 if (DWARF_OFFSET_SIZE
== 8)
27366 dw2_asm_output_data (1, 1, "Flags: 64-bit");
27368 dw2_asm_output_data (1, 0, "Flags: 32-bit");
27371 case DW_MACINFO_define
:
27372 case DW_MACINFO_undef
:
27373 output_macinfo_op (ref
);
27378 gcc_unreachable ();
27381 macinfo_label_base
+= macinfo_label_base_adj
;
27384 /* Initialize the various sections and labels for dwarf output and prefix
27385 them with PREFIX if non-NULL. Returns the generation (zero based
27386 number of times function was called). */
27389 init_sections_and_labels (bool early_lto_debug
)
27391 /* As we may get called multiple times have a generation count for
27393 static unsigned generation
= 0;
27395 if (early_lto_debug
)
27397 if (!dwarf_split_debug_info
)
27399 debug_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
27400 SECTION_DEBUG
| SECTION_EXCLUDE
,
27402 debug_abbrev_section
= get_section (DEBUG_LTO_ABBREV_SECTION
,
27403 SECTION_DEBUG
| SECTION_EXCLUDE
,
27405 debug_macinfo_section_name
27406 = ((dwarf_strict
&& dwarf_version
< 5)
27407 ? DEBUG_LTO_MACINFO_SECTION
: DEBUG_LTO_MACRO_SECTION
);
27408 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
27410 | SECTION_EXCLUDE
, NULL
);
27411 /* For macro info we have to refer to a debug_line section, so
27412 similar to split-dwarf emit a skeleton one for early debug. */
27413 debug_skeleton_line_section
27414 = get_section (DEBUG_LTO_LINE_SECTION
,
27415 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
27416 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
27417 DEBUG_SKELETON_LINE_SECTION_LABEL
,
27422 /* ??? Which of the following do we need early? */
27423 debug_info_section
= get_section (DEBUG_LTO_DWO_INFO_SECTION
,
27424 SECTION_DEBUG
| SECTION_EXCLUDE
,
27426 debug_abbrev_section
= get_section (DEBUG_LTO_DWO_ABBREV_SECTION
,
27427 SECTION_DEBUG
| SECTION_EXCLUDE
,
27429 debug_skeleton_info_section
= get_section (DEBUG_LTO_INFO_SECTION
,
27431 | SECTION_EXCLUDE
, NULL
);
27432 debug_skeleton_abbrev_section
27433 = get_section (DEBUG_LTO_ABBREV_SECTION
,
27434 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
27435 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
27436 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
27439 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
27440 stay in the main .o, but the skeleton_line goes into the split
27442 debug_skeleton_line_section
27443 = get_section (DEBUG_LTO_LINE_SECTION
,
27444 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
27445 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
27446 DEBUG_SKELETON_LINE_SECTION_LABEL
,
27448 debug_str_offsets_section
27449 = get_section (DEBUG_LTO_DWO_STR_OFFSETS_SECTION
,
27450 SECTION_DEBUG
| SECTION_EXCLUDE
,
27452 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
27453 DEBUG_SKELETON_INFO_SECTION_LABEL
,
27455 debug_str_dwo_section
= get_section (DEBUG_LTO_STR_DWO_SECTION
,
27456 DEBUG_STR_DWO_SECTION_FLAGS
,
27458 debug_macinfo_section_name
27459 = ((dwarf_strict
&& dwarf_version
< 5)
27460 ? DEBUG_LTO_DWO_MACINFO_SECTION
: DEBUG_LTO_DWO_MACRO_SECTION
);
27461 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
27462 SECTION_DEBUG
| SECTION_EXCLUDE
,
27465 debug_str_section
= get_section (DEBUG_LTO_STR_SECTION
,
27466 DEBUG_STR_SECTION_FLAGS
27467 | SECTION_EXCLUDE
, NULL
);
27468 if (!dwarf_split_debug_info
&& !DWARF2_ASM_LINE_DEBUG_INFO
)
27469 debug_line_str_section
27470 = get_section (DEBUG_LTO_LINE_STR_SECTION
,
27471 DEBUG_STR_SECTION_FLAGS
| SECTION_EXCLUDE
, NULL
);
27475 if (!dwarf_split_debug_info
)
27477 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
27478 SECTION_DEBUG
, NULL
);
27479 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
27480 SECTION_DEBUG
, NULL
);
27481 debug_loc_section
= get_section (dwarf_version
>= 5
27482 ? DEBUG_LOCLISTS_SECTION
27483 : DEBUG_LOC_SECTION
,
27484 SECTION_DEBUG
, NULL
);
27485 debug_macinfo_section_name
27486 = ((dwarf_strict
&& dwarf_version
< 5)
27487 ? DEBUG_MACINFO_SECTION
: DEBUG_MACRO_SECTION
);
27488 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
27489 SECTION_DEBUG
, NULL
);
27493 debug_info_section
= get_section (DEBUG_DWO_INFO_SECTION
,
27494 SECTION_DEBUG
| SECTION_EXCLUDE
,
27496 debug_abbrev_section
= get_section (DEBUG_DWO_ABBREV_SECTION
,
27497 SECTION_DEBUG
| SECTION_EXCLUDE
,
27499 debug_addr_section
= get_section (DEBUG_ADDR_SECTION
,
27500 SECTION_DEBUG
, NULL
);
27501 debug_skeleton_info_section
= get_section (DEBUG_INFO_SECTION
,
27502 SECTION_DEBUG
, NULL
);
27503 debug_skeleton_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
27504 SECTION_DEBUG
, NULL
);
27505 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_abbrev_section_label
,
27506 DEBUG_SKELETON_ABBREV_SECTION_LABEL
,
27509 /* Somewhat confusing detail: The skeleton_[abbrev|info] sections
27510 stay in the main .o, but the skeleton_line goes into the
27512 debug_skeleton_line_section
27513 = get_section (DEBUG_DWO_LINE_SECTION
,
27514 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
27515 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_line_section_label
,
27516 DEBUG_SKELETON_LINE_SECTION_LABEL
,
27518 debug_str_offsets_section
27519 = get_section (DEBUG_DWO_STR_OFFSETS_SECTION
,
27520 SECTION_DEBUG
| SECTION_EXCLUDE
, NULL
);
27521 ASM_GENERATE_INTERNAL_LABEL (debug_skeleton_info_section_label
,
27522 DEBUG_SKELETON_INFO_SECTION_LABEL
,
27524 debug_loc_section
= get_section (dwarf_version
>= 5
27525 ? DEBUG_DWO_LOCLISTS_SECTION
27526 : DEBUG_DWO_LOC_SECTION
,
27527 SECTION_DEBUG
| SECTION_EXCLUDE
,
27529 debug_str_dwo_section
= get_section (DEBUG_STR_DWO_SECTION
,
27530 DEBUG_STR_DWO_SECTION_FLAGS
,
27532 debug_macinfo_section_name
27533 = ((dwarf_strict
&& dwarf_version
< 5)
27534 ? DEBUG_DWO_MACINFO_SECTION
: DEBUG_DWO_MACRO_SECTION
);
27535 debug_macinfo_section
= get_section (debug_macinfo_section_name
,
27536 SECTION_DEBUG
| SECTION_EXCLUDE
,
27539 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
27540 SECTION_DEBUG
, NULL
);
27541 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
27542 SECTION_DEBUG
, NULL
);
27543 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
27544 SECTION_DEBUG
, NULL
);
27545 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
27546 SECTION_DEBUG
, NULL
);
27547 debug_str_section
= get_section (DEBUG_STR_SECTION
,
27548 DEBUG_STR_SECTION_FLAGS
, NULL
);
27549 if (!dwarf_split_debug_info
&& !DWARF2_ASM_LINE_DEBUG_INFO
)
27550 debug_line_str_section
= get_section (DEBUG_LINE_STR_SECTION
,
27551 DEBUG_STR_SECTION_FLAGS
, NULL
);
27552 debug_ranges_section
= get_section (dwarf_version
>= 5
27553 ? DEBUG_RNGLISTS_SECTION
27554 : DEBUG_RANGES_SECTION
,
27555 SECTION_DEBUG
, NULL
);
27556 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
27557 SECTION_DEBUG
, NULL
);
27560 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
27561 DEBUG_ABBREV_SECTION_LABEL
, generation
);
27562 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
27563 DEBUG_INFO_SECTION_LABEL
, generation
);
27564 info_section_emitted
= false;
27565 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
27566 DEBUG_LINE_SECTION_LABEL
, generation
);
27567 /* There are up to 4 unique ranges labels per generation.
27568 See also output_rnglists. */
27569 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
27570 DEBUG_RANGES_SECTION_LABEL
, generation
* 4);
27571 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
27572 ASM_GENERATE_INTERNAL_LABEL (ranges_base_label
,
27573 DEBUG_RANGES_SECTION_LABEL
,
27574 1 + generation
* 4);
27575 ASM_GENERATE_INTERNAL_LABEL (debug_addr_section_label
,
27576 DEBUG_ADDR_SECTION_LABEL
, generation
);
27577 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
27578 (dwarf_strict
&& dwarf_version
< 5)
27579 ? DEBUG_MACINFO_SECTION_LABEL
27580 : DEBUG_MACRO_SECTION_LABEL
, generation
);
27581 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
, DEBUG_LOC_SECTION_LABEL
,
27585 return generation
- 1;
27588 /* Set up for Dwarf output at the start of compilation. */
27591 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
27593 /* Allocate the file_table. */
27594 file_table
= hash_table
<dwarf_file_hasher
>::create_ggc (50);
27596 #ifndef DWARF2_LINENO_DEBUGGING_INFO
27597 /* Allocate the decl_die_table. */
27598 decl_die_table
= hash_table
<decl_die_hasher
>::create_ggc (10);
27600 /* Allocate the decl_loc_table. */
27601 decl_loc_table
= hash_table
<decl_loc_hasher
>::create_ggc (10);
27603 /* Allocate the cached_dw_loc_list_table. */
27604 cached_dw_loc_list_table
= hash_table
<dw_loc_list_hasher
>::create_ggc (10);
27606 /* Allocate the initial hunk of the decl_scope_table. */
27607 vec_alloc (decl_scope_table
, 256);
27609 /* Allocate the initial hunk of the abbrev_die_table. */
27610 vec_alloc (abbrev_die_table
, 256);
27611 /* Zero-th entry is allocated, but unused. */
27612 abbrev_die_table
->quick_push (NULL
);
27614 /* Allocate the dwarf_proc_stack_usage_map. */
27615 dwarf_proc_stack_usage_map
= new hash_map
<dw_die_ref
, int>;
27617 /* Allocate the pubtypes and pubnames vectors. */
27618 vec_alloc (pubname_table
, 32);
27619 vec_alloc (pubtype_table
, 32);
27621 vec_alloc (incomplete_types
, 64);
27623 vec_alloc (used_rtx_array
, 32);
27625 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
27626 vec_alloc (macinfo_table
, 64);
27629 /* If front-ends already registered a main translation unit but we were not
27630 ready to perform the association, do this now. */
27631 if (main_translation_unit
!= NULL_TREE
)
27632 equate_decl_number_to_die (main_translation_unit
, comp_unit_die ());
27635 /* Called before compile () starts outputtting functions, variables
27636 and toplevel asms into assembly. */
27639 dwarf2out_assembly_start (void)
27641 if (text_section_line_info
)
27644 #ifndef DWARF2_LINENO_DEBUGGING_INFO
27645 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
27646 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
27647 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
27648 COLD_TEXT_SECTION_LABEL
, 0);
27649 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
27651 switch_to_section (text_section
);
27652 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
27655 /* Make sure the line number table for .text always exists. */
27656 text_section_line_info
= new_line_info_table ();
27657 text_section_line_info
->end_label
= text_end_label
;
27659 #ifdef DWARF2_LINENO_DEBUGGING_INFO
27660 cur_line_info_table
= text_section_line_info
;
27663 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
27664 && dwarf2out_do_cfi_asm ()
27665 && !dwarf2out_do_eh_frame ())
27666 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
27669 /* A helper function for dwarf2out_finish called through
27670 htab_traverse. Assign a string its index. All strings must be
27671 collected into the table by the time index_string is called,
27672 because the indexing code relies on htab_traverse to traverse nodes
27673 in the same order for each run. */
27676 index_string (indirect_string_node
**h
, unsigned int *index
)
27678 indirect_string_node
*node
= *h
;
27680 find_string_form (node
);
27681 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
27683 gcc_assert (node
->index
== NO_INDEX_ASSIGNED
);
27684 node
->index
= *index
;
27690 /* A helper function for output_indirect_strings called through
27691 htab_traverse. Output the offset to a string and update the
27695 output_index_string_offset (indirect_string_node
**h
, unsigned int *offset
)
27697 indirect_string_node
*node
= *h
;
27699 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
27701 /* Assert that this node has been assigned an index. */
27702 gcc_assert (node
->index
!= NO_INDEX_ASSIGNED
27703 && node
->index
!= NOT_INDEXED
);
27704 dw2_asm_output_data (DWARF_OFFSET_SIZE
, *offset
,
27705 "indexed string 0x%x: %s", node
->index
, node
->str
);
27706 *offset
+= strlen (node
->str
) + 1;
27711 /* A helper function for dwarf2out_finish called through
27712 htab_traverse. Output the indexed string. */
27715 output_index_string (indirect_string_node
**h
, unsigned int *cur_idx
)
27717 struct indirect_string_node
*node
= *h
;
27719 if (node
->form
== DW_FORM_GNU_str_index
&& node
->refcount
> 0)
27721 /* Assert that the strings are output in the same order as their
27722 indexes were assigned. */
27723 gcc_assert (*cur_idx
== node
->index
);
27724 assemble_string (node
->str
, strlen (node
->str
) + 1);
27730 /* A helper function for dwarf2out_finish called through
27731 htab_traverse. Emit one queued .debug_str string. */
27734 output_indirect_string (indirect_string_node
**h
, enum dwarf_form form
)
27736 struct indirect_string_node
*node
= *h
;
27738 node
->form
= find_string_form (node
);
27739 if (node
->form
== form
&& node
->refcount
> 0)
27741 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
27742 assemble_string (node
->str
, strlen (node
->str
) + 1);
27748 /* Output the indexed string table. */
27751 output_indirect_strings (void)
27753 switch_to_section (debug_str_section
);
27754 if (!dwarf_split_debug_info
)
27755 debug_str_hash
->traverse
<enum dwarf_form
,
27756 output_indirect_string
> (DW_FORM_strp
);
27759 unsigned int offset
= 0;
27760 unsigned int cur_idx
= 0;
27762 skeleton_debug_str_hash
->traverse
<enum dwarf_form
,
27763 output_indirect_string
> (DW_FORM_strp
);
27765 switch_to_section (debug_str_offsets_section
);
27766 debug_str_hash
->traverse_noresize
27767 <unsigned int *, output_index_string_offset
> (&offset
);
27768 switch_to_section (debug_str_dwo_section
);
27769 debug_str_hash
->traverse_noresize
<unsigned int *, output_index_string
>
27774 /* Callback for htab_traverse to assign an index to an entry in the
27775 table, and to write that entry to the .debug_addr section. */
27778 output_addr_table_entry (addr_table_entry
**slot
, unsigned int *cur_index
)
27780 addr_table_entry
*entry
= *slot
;
27782 if (entry
->refcount
== 0)
27784 gcc_assert (entry
->index
== NO_INDEX_ASSIGNED
27785 || entry
->index
== NOT_INDEXED
);
27789 gcc_assert (entry
->index
== *cur_index
);
27792 switch (entry
->kind
)
27795 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, entry
->addr
.rtl
,
27796 "0x%x", entry
->index
);
27798 case ate_kind_rtx_dtprel
:
27799 gcc_assert (targetm
.asm_out
.output_dwarf_dtprel
);
27800 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
27803 fputc ('\n', asm_out_file
);
27805 case ate_kind_label
:
27806 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, entry
->addr
.label
,
27807 "0x%x", entry
->index
);
27810 gcc_unreachable ();
27815 /* Produce the .debug_addr section. */
27818 output_addr_table (void)
27820 unsigned int index
= 0;
27821 if (addr_index_table
== NULL
|| addr_index_table
->size () == 0)
27824 switch_to_section (debug_addr_section
);
27826 ->traverse_noresize
<unsigned int *, output_addr_table_entry
> (&index
);
27829 #if ENABLE_ASSERT_CHECKING
27830 /* Verify that all marks are clear. */
27833 verify_marks_clear (dw_die_ref die
)
27837 gcc_assert (! die
->die_mark
);
27838 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
27840 #endif /* ENABLE_ASSERT_CHECKING */
27842 /* Clear the marks for a die and its children.
27843 Be cool if the mark isn't set. */
27846 prune_unmark_dies (dw_die_ref die
)
27852 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
27855 /* Given LOC that is referenced by a DIE we're marking as used, find all
27856 referenced DWARF procedures it references and mark them as used. */
27859 prune_unused_types_walk_loc_descr (dw_loc_descr_ref loc
)
27861 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
27862 switch (loc
->dw_loc_opc
)
27864 case DW_OP_implicit_pointer
:
27865 case DW_OP_convert
:
27866 case DW_OP_reinterpret
:
27867 case DW_OP_GNU_implicit_pointer
:
27868 case DW_OP_GNU_convert
:
27869 case DW_OP_GNU_reinterpret
:
27870 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
)
27871 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
27873 case DW_OP_GNU_variable_value
:
27874 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
27877 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
27880 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
27881 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
27882 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
27887 case DW_OP_call_ref
:
27888 case DW_OP_const_type
:
27889 case DW_OP_GNU_const_type
:
27890 case DW_OP_GNU_parameter_ref
:
27891 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_die_ref
);
27892 prune_unused_types_mark (loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
, 1);
27894 case DW_OP_regval_type
:
27895 case DW_OP_deref_type
:
27896 case DW_OP_GNU_regval_type
:
27897 case DW_OP_GNU_deref_type
:
27898 gcc_assert (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_die_ref
);
27899 prune_unused_types_mark (loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
, 1);
27901 case DW_OP_entry_value
:
27902 case DW_OP_GNU_entry_value
:
27903 gcc_assert (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_loc
);
27904 prune_unused_types_walk_loc_descr (loc
->dw_loc_oprnd1
.v
.val_loc
);
27911 /* Given DIE that we're marking as used, find any other dies
27912 it references as attributes and mark them as used. */
27915 prune_unused_types_walk_attribs (dw_die_ref die
)
27920 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
27922 switch (AT_class (a
))
27924 /* Make sure DWARF procedures referenced by location descriptions will
27926 case dw_val_class_loc
:
27927 prune_unused_types_walk_loc_descr (AT_loc (a
));
27929 case dw_val_class_loc_list
:
27930 for (dw_loc_list_ref list
= AT_loc_list (a
);
27932 list
= list
->dw_loc_next
)
27933 prune_unused_types_walk_loc_descr (list
->expr
);
27936 case dw_val_class_die_ref
:
27937 /* A reference to another DIE.
27938 Make sure that it will get emitted.
27939 If it was broken out into a comdat group, don't follow it. */
27940 if (! AT_ref (a
)->comdat_type_p
27941 || a
->dw_attr
== DW_AT_specification
)
27942 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
27945 case dw_val_class_str
:
27946 /* Set the string's refcount to 0 so that prune_unused_types_mark
27947 accounts properly for it. */
27948 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
27957 /* Mark the generic parameters and arguments children DIEs of DIE. */
27960 prune_unused_types_mark_generic_parms_dies (dw_die_ref die
)
27964 if (die
== NULL
|| die
->die_child
== NULL
)
27966 c
= die
->die_child
;
27969 if (is_template_parameter (c
))
27970 prune_unused_types_mark (c
, 1);
27972 } while (c
&& c
!= die
->die_child
);
27975 /* Mark DIE as being used. If DOKIDS is true, then walk down
27976 to DIE's children. */
27979 prune_unused_types_mark (dw_die_ref die
, int dokids
)
27983 if (die
->die_mark
== 0)
27985 /* We haven't done this node yet. Mark it as used. */
27987 /* If this is the DIE of a generic type instantiation,
27988 mark the children DIEs that describe its generic parms and
27990 prune_unused_types_mark_generic_parms_dies (die
);
27992 /* We also have to mark its parents as used.
27993 (But we don't want to mark our parent's kids due to this,
27994 unless it is a class.) */
27995 if (die
->die_parent
)
27996 prune_unused_types_mark (die
->die_parent
,
27997 class_scope_p (die
->die_parent
));
27999 /* Mark any referenced nodes. */
28000 prune_unused_types_walk_attribs (die
);
28002 /* If this node is a specification,
28003 also mark the definition, if it exists. */
28004 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
28005 prune_unused_types_mark (die
->die_definition
, 1);
28008 if (dokids
&& die
->die_mark
!= 2)
28010 /* We need to walk the children, but haven't done so yet.
28011 Remember that we've walked the kids. */
28014 /* If this is an array type, we need to make sure our
28015 kids get marked, even if they're types. If we're
28016 breaking out types into comdat sections, do this
28017 for all type definitions. */
28018 if (die
->die_tag
== DW_TAG_array_type
28019 || (use_debug_types
28020 && is_type_die (die
) && ! is_declaration_die (die
)))
28021 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
28023 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
28027 /* For local classes, look if any static member functions were emitted
28028 and if so, mark them. */
28031 prune_unused_types_walk_local_classes (dw_die_ref die
)
28035 if (die
->die_mark
== 2)
28038 switch (die
->die_tag
)
28040 case DW_TAG_structure_type
:
28041 case DW_TAG_union_type
:
28042 case DW_TAG_class_type
:
28045 case DW_TAG_subprogram
:
28046 if (!get_AT_flag (die
, DW_AT_declaration
)
28047 || die
->die_definition
!= NULL
)
28048 prune_unused_types_mark (die
, 1);
28055 /* Mark children. */
28056 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
28059 /* Walk the tree DIE and mark types that we actually use. */
28062 prune_unused_types_walk (dw_die_ref die
)
28066 /* Don't do anything if this node is already marked and
28067 children have been marked as well. */
28068 if (die
->die_mark
== 2)
28071 switch (die
->die_tag
)
28073 case DW_TAG_structure_type
:
28074 case DW_TAG_union_type
:
28075 case DW_TAG_class_type
:
28076 if (die
->die_perennial_p
)
28079 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
28080 if (c
->die_tag
== DW_TAG_subprogram
)
28083 /* Finding used static member functions inside of classes
28084 is needed just for local classes, because for other classes
28085 static member function DIEs with DW_AT_specification
28086 are emitted outside of the DW_TAG_*_type. If we ever change
28087 it, we'd need to call this even for non-local classes. */
28089 prune_unused_types_walk_local_classes (die
);
28091 /* It's a type node --- don't mark it. */
28094 case DW_TAG_const_type
:
28095 case DW_TAG_packed_type
:
28096 case DW_TAG_pointer_type
:
28097 case DW_TAG_reference_type
:
28098 case DW_TAG_rvalue_reference_type
:
28099 case DW_TAG_volatile_type
:
28100 case DW_TAG_typedef
:
28101 case DW_TAG_array_type
:
28102 case DW_TAG_interface_type
:
28103 case DW_TAG_friend
:
28104 case DW_TAG_enumeration_type
:
28105 case DW_TAG_subroutine_type
:
28106 case DW_TAG_string_type
:
28107 case DW_TAG_set_type
:
28108 case DW_TAG_subrange_type
:
28109 case DW_TAG_ptr_to_member_type
:
28110 case DW_TAG_file_type
:
28111 /* Type nodes are useful only when other DIEs reference them --- don't
28115 case DW_TAG_dwarf_procedure
:
28116 /* Likewise for DWARF procedures. */
28118 if (die
->die_perennial_p
)
28124 /* Mark everything else. */
28128 if (die
->die_mark
== 0)
28132 /* Now, mark any dies referenced from here. */
28133 prune_unused_types_walk_attribs (die
);
28138 /* Mark children. */
28139 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
28142 /* Increment the string counts on strings referred to from DIE's
28146 prune_unused_types_update_strings (dw_die_ref die
)
28151 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
28152 if (AT_class (a
) == dw_val_class_str
)
28154 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
28156 /* Avoid unnecessarily putting strings that are used less than
28157 twice in the hash table. */
28159 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
28161 indirect_string_node
**slot
28162 = debug_str_hash
->find_slot_with_hash (s
->str
,
28163 htab_hash_string (s
->str
),
28165 gcc_assert (*slot
== NULL
);
28171 /* Mark DIE and its children as removed. */
28174 mark_removed (dw_die_ref die
)
28177 die
->removed
= true;
28178 FOR_EACH_CHILD (die
, c
, mark_removed (c
));
28181 /* Remove from the tree DIE any dies that aren't marked. */
28184 prune_unused_types_prune (dw_die_ref die
)
28188 gcc_assert (die
->die_mark
);
28189 prune_unused_types_update_strings (die
);
28191 if (! die
->die_child
)
28194 c
= die
->die_child
;
28196 dw_die_ref prev
= c
, next
;
28197 for (c
= c
->die_sib
; ! c
->die_mark
; c
= next
)
28198 if (c
== die
->die_child
)
28200 /* No marked children between 'prev' and the end of the list. */
28202 /* No marked children at all. */
28203 die
->die_child
= NULL
;
28206 prev
->die_sib
= c
->die_sib
;
28207 die
->die_child
= prev
;
28220 if (c
!= prev
->die_sib
)
28222 prune_unused_types_prune (c
);
28223 } while (c
!= die
->die_child
);
28226 /* Remove dies representing declarations that we never use. */
28229 prune_unused_types (void)
28232 limbo_die_node
*node
;
28233 comdat_type_node
*ctnode
;
28234 pubname_entry
*pub
;
28235 dw_die_ref base_type
;
28237 #if ENABLE_ASSERT_CHECKING
28238 /* All the marks should already be clear. */
28239 verify_marks_clear (comp_unit_die ());
28240 for (node
= limbo_die_list
; node
; node
= node
->next
)
28241 verify_marks_clear (node
->die
);
28242 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
28243 verify_marks_clear (ctnode
->root_die
);
28244 #endif /* ENABLE_ASSERT_CHECKING */
28246 /* Mark types that are used in global variables. */
28247 premark_types_used_by_global_vars ();
28249 /* Set the mark on nodes that are actually used. */
28250 prune_unused_types_walk (comp_unit_die ());
28251 for (node
= limbo_die_list
; node
; node
= node
->next
)
28252 prune_unused_types_walk (node
->die
);
28253 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
28255 prune_unused_types_walk (ctnode
->root_die
);
28256 prune_unused_types_mark (ctnode
->type_die
, 1);
28259 /* Also set the mark on nodes referenced from the pubname_table. Enumerators
28260 are unusual in that they are pubnames that are the children of pubtypes.
28261 They should only be marked via their parent DW_TAG_enumeration_type die,
28262 not as roots in themselves. */
28263 FOR_EACH_VEC_ELT (*pubname_table
, i
, pub
)
28264 if (pub
->die
->die_tag
!= DW_TAG_enumerator
)
28265 prune_unused_types_mark (pub
->die
, 1);
28266 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
28267 prune_unused_types_mark (base_type
, 1);
28269 /* For -fvar-tracking-assignments, also set the mark on nodes that could be
28270 referenced by DW_TAG_call_site DW_AT_call_origin (i.e. direct call
28272 cgraph_node
*cnode
;
28273 FOR_EACH_FUNCTION (cnode
)
28274 if (cnode
->referred_to_p (false))
28276 dw_die_ref die
= lookup_decl_die (cnode
->decl
);
28277 if (die
== NULL
|| die
->die_mark
)
28279 for (cgraph_edge
*e
= cnode
->callers
; e
; e
= e
->next_caller
)
28280 if (e
->caller
!= cnode
28281 && opt_for_fn (e
->caller
->decl
, flag_var_tracking_assignments
))
28283 prune_unused_types_mark (die
, 1);
28288 if (debug_str_hash
)
28289 debug_str_hash
->empty ();
28290 if (skeleton_debug_str_hash
)
28291 skeleton_debug_str_hash
->empty ();
28292 prune_unused_types_prune (comp_unit_die ());
28293 for (limbo_die_node
**pnode
= &limbo_die_list
; *pnode
; )
28296 if (!node
->die
->die_mark
)
28297 *pnode
= node
->next
;
28300 prune_unused_types_prune (node
->die
);
28301 pnode
= &node
->next
;
28304 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
28305 prune_unused_types_prune (ctnode
->root_die
);
28307 /* Leave the marks clear. */
28308 prune_unmark_dies (comp_unit_die ());
28309 for (node
= limbo_die_list
; node
; node
= node
->next
)
28310 prune_unmark_dies (node
->die
);
28311 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
28312 prune_unmark_dies (ctnode
->root_die
);
28315 /* Helpers to manipulate hash table of comdat type units. */
28317 struct comdat_type_hasher
: nofree_ptr_hash
<comdat_type_node
>
28319 static inline hashval_t
hash (const comdat_type_node
*);
28320 static inline bool equal (const comdat_type_node
*, const comdat_type_node
*);
28324 comdat_type_hasher::hash (const comdat_type_node
*type_node
)
28327 memcpy (&h
, type_node
->signature
, sizeof (h
));
28332 comdat_type_hasher::equal (const comdat_type_node
*type_node_1
,
28333 const comdat_type_node
*type_node_2
)
28335 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
28336 DWARF_TYPE_SIGNATURE_SIZE
));
28339 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
28340 to the location it would have been added, should we know its
28341 DECL_ASSEMBLER_NAME when we added other attributes. This will
28342 probably improve compactness of debug info, removing equivalent
28343 abbrevs, and hide any differences caused by deferring the
28344 computation of the assembler name, triggered by e.g. PCH. */
28347 move_linkage_attr (dw_die_ref die
)
28349 unsigned ix
= vec_safe_length (die
->die_attr
);
28350 dw_attr_node linkage
= (*die
->die_attr
)[ix
- 1];
28352 gcc_assert (linkage
.dw_attr
== DW_AT_linkage_name
28353 || linkage
.dw_attr
== DW_AT_MIPS_linkage_name
);
28357 dw_attr_node
*prev
= &(*die
->die_attr
)[ix
- 1];
28359 if (prev
->dw_attr
== DW_AT_decl_line
28360 || prev
->dw_attr
== DW_AT_decl_column
28361 || prev
->dw_attr
== DW_AT_name
)
28365 if (ix
!= vec_safe_length (die
->die_attr
) - 1)
28367 die
->die_attr
->pop ();
28368 die
->die_attr
->quick_insert (ix
, linkage
);
28372 /* Helper function for resolve_addr, mark DW_TAG_base_type nodes
28373 referenced from typed stack ops and count how often they are used. */
28376 mark_base_types (dw_loc_descr_ref loc
)
28378 dw_die_ref base_type
= NULL
;
28380 for (; loc
; loc
= loc
->dw_loc_next
)
28382 switch (loc
->dw_loc_opc
)
28384 case DW_OP_regval_type
:
28385 case DW_OP_deref_type
:
28386 case DW_OP_GNU_regval_type
:
28387 case DW_OP_GNU_deref_type
:
28388 base_type
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
28390 case DW_OP_convert
:
28391 case DW_OP_reinterpret
:
28392 case DW_OP_GNU_convert
:
28393 case DW_OP_GNU_reinterpret
:
28394 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_unsigned_const
)
28397 case DW_OP_const_type
:
28398 case DW_OP_GNU_const_type
:
28399 base_type
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
28401 case DW_OP_entry_value
:
28402 case DW_OP_GNU_entry_value
:
28403 mark_base_types (loc
->dw_loc_oprnd1
.v
.val_loc
);
28408 gcc_assert (base_type
->die_parent
== comp_unit_die ());
28409 if (base_type
->die_mark
)
28410 base_type
->die_mark
++;
28413 base_types
.safe_push (base_type
);
28414 base_type
->die_mark
= 1;
28419 /* Comparison function for sorting marked base types. */
28422 base_type_cmp (const void *x
, const void *y
)
28424 dw_die_ref dx
= *(const dw_die_ref
*) x
;
28425 dw_die_ref dy
= *(const dw_die_ref
*) y
;
28426 unsigned int byte_size1
, byte_size2
;
28427 unsigned int encoding1
, encoding2
;
28428 unsigned int align1
, align2
;
28429 if (dx
->die_mark
> dy
->die_mark
)
28431 if (dx
->die_mark
< dy
->die_mark
)
28433 byte_size1
= get_AT_unsigned (dx
, DW_AT_byte_size
);
28434 byte_size2
= get_AT_unsigned (dy
, DW_AT_byte_size
);
28435 if (byte_size1
< byte_size2
)
28437 if (byte_size1
> byte_size2
)
28439 encoding1
= get_AT_unsigned (dx
, DW_AT_encoding
);
28440 encoding2
= get_AT_unsigned (dy
, DW_AT_encoding
);
28441 if (encoding1
< encoding2
)
28443 if (encoding1
> encoding2
)
28445 align1
= get_AT_unsigned (dx
, DW_AT_alignment
);
28446 align2
= get_AT_unsigned (dy
, DW_AT_alignment
);
28447 if (align1
< align2
)
28449 if (align1
> align2
)
28454 /* Move base types marked by mark_base_types as early as possible
28455 in the CU, sorted by decreasing usage count both to make the
28456 uleb128 references as small as possible and to make sure they
28457 will have die_offset already computed by calc_die_sizes when
28458 sizes of typed stack loc ops is computed. */
28461 move_marked_base_types (void)
28464 dw_die_ref base_type
, die
, c
;
28466 if (base_types
.is_empty ())
28469 /* Sort by decreasing usage count, they will be added again in that
28471 base_types
.qsort (base_type_cmp
);
28472 die
= comp_unit_die ();
28473 c
= die
->die_child
;
28476 dw_die_ref prev
= c
;
28478 while (c
->die_mark
)
28480 remove_child_with_prev (c
, prev
);
28481 /* As base types got marked, there must be at least
28482 one node other than DW_TAG_base_type. */
28483 gcc_assert (die
->die_child
!= NULL
);
28487 while (c
!= die
->die_child
);
28488 gcc_assert (die
->die_child
);
28489 c
= die
->die_child
;
28490 for (i
= 0; base_types
.iterate (i
, &base_type
); i
++)
28492 base_type
->die_mark
= 0;
28493 base_type
->die_sib
= c
->die_sib
;
28494 c
->die_sib
= base_type
;
28499 /* Helper function for resolve_addr, attempt to resolve
28500 one CONST_STRING, return true if successful. Similarly verify that
28501 SYMBOL_REFs refer to variables emitted in the current CU. */
28504 resolve_one_addr (rtx
*addr
)
28508 if (GET_CODE (rtl
) == CONST_STRING
)
28510 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
28511 tree t
= build_string (len
, XSTR (rtl
, 0));
28512 tree tlen
= size_int (len
- 1);
28514 = build_array_type (char_type_node
, build_index_type (tlen
));
28515 rtl
= lookup_constant_def (t
);
28516 if (!rtl
|| !MEM_P (rtl
))
28518 rtl
= XEXP (rtl
, 0);
28519 if (GET_CODE (rtl
) == SYMBOL_REF
28520 && SYMBOL_REF_DECL (rtl
)
28521 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
28523 vec_safe_push (used_rtx_array
, rtl
);
28528 if (GET_CODE (rtl
) == SYMBOL_REF
28529 && SYMBOL_REF_DECL (rtl
))
28531 if (TREE_CONSTANT_POOL_ADDRESS_P (rtl
))
28533 if (!TREE_ASM_WRITTEN (DECL_INITIAL (SYMBOL_REF_DECL (rtl
))))
28536 else if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
28540 if (GET_CODE (rtl
) == CONST
)
28542 subrtx_ptr_iterator::array_type array
;
28543 FOR_EACH_SUBRTX_PTR (iter
, array
, &XEXP (rtl
, 0), ALL
)
28544 if (!resolve_one_addr (*iter
))
28551 /* For STRING_CST, return SYMBOL_REF of its constant pool entry,
28552 if possible, and create DW_TAG_dwarf_procedure that can be referenced
28553 from DW_OP_implicit_pointer if the string hasn't been seen yet. */
28556 string_cst_pool_decl (tree t
)
28558 rtx rtl
= output_constant_def (t
, 1);
28559 unsigned char *array
;
28560 dw_loc_descr_ref l
;
28565 if (!rtl
|| !MEM_P (rtl
))
28567 rtl
= XEXP (rtl
, 0);
28568 if (GET_CODE (rtl
) != SYMBOL_REF
28569 || SYMBOL_REF_DECL (rtl
) == NULL_TREE
)
28572 decl
= SYMBOL_REF_DECL (rtl
);
28573 if (!lookup_decl_die (decl
))
28575 len
= TREE_STRING_LENGTH (t
);
28576 vec_safe_push (used_rtx_array
, rtl
);
28577 ref
= new_die (DW_TAG_dwarf_procedure
, comp_unit_die (), decl
);
28578 array
= ggc_vec_alloc
<unsigned char> (len
);
28579 memcpy (array
, TREE_STRING_POINTER (t
), len
);
28580 l
= new_loc_descr (DW_OP_implicit_value
, len
, 0);
28581 l
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
28582 l
->dw_loc_oprnd2
.v
.val_vec
.length
= len
;
28583 l
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 1;
28584 l
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
28585 add_AT_loc (ref
, DW_AT_location
, l
);
28586 equate_decl_number_to_die (decl
, ref
);
28591 /* Helper function of resolve_addr_in_expr. LOC is
28592 a DW_OP_addr followed by DW_OP_stack_value, either at the start
28593 of exprloc or after DW_OP_{,bit_}piece, and val_addr can't be
28594 resolved. Replace it (both DW_OP_addr and DW_OP_stack_value)
28595 with DW_OP_implicit_pointer if possible
28596 and return true, if unsuccessful, return false. */
28599 optimize_one_addr_into_implicit_ptr (dw_loc_descr_ref loc
)
28601 rtx rtl
= loc
->dw_loc_oprnd1
.v
.val_addr
;
28602 HOST_WIDE_INT offset
= 0;
28603 dw_die_ref ref
= NULL
;
28606 if (GET_CODE (rtl
) == CONST
28607 && GET_CODE (XEXP (rtl
, 0)) == PLUS
28608 && CONST_INT_P (XEXP (XEXP (rtl
, 0), 1)))
28610 offset
= INTVAL (XEXP (XEXP (rtl
, 0), 1));
28611 rtl
= XEXP (XEXP (rtl
, 0), 0);
28613 if (GET_CODE (rtl
) == CONST_STRING
)
28615 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
28616 tree t
= build_string (len
, XSTR (rtl
, 0));
28617 tree tlen
= size_int (len
- 1);
28620 = build_array_type (char_type_node
, build_index_type (tlen
));
28621 rtl
= string_cst_pool_decl (t
);
28625 if (GET_CODE (rtl
) == SYMBOL_REF
&& SYMBOL_REF_DECL (rtl
))
28627 decl
= SYMBOL_REF_DECL (rtl
);
28628 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
28630 ref
= lookup_decl_die (decl
);
28631 if (ref
&& (get_AT (ref
, DW_AT_location
)
28632 || get_AT (ref
, DW_AT_const_value
)))
28634 loc
->dw_loc_opc
= dwarf_OP (DW_OP_implicit_pointer
);
28635 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
28636 loc
->dw_loc_oprnd1
.val_entry
= NULL
;
28637 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
28638 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
28639 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
28640 loc
->dw_loc_oprnd2
.v
.val_int
= offset
;
28648 /* Helper function for resolve_addr, handle one location
28649 expression, return false if at least one CONST_STRING or SYMBOL_REF in
28650 the location list couldn't be resolved. */
28653 resolve_addr_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
28655 dw_loc_descr_ref keep
= NULL
;
28656 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= loc
->dw_loc_next
)
28657 switch (loc
->dw_loc_opc
)
28660 if (!resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
28663 || prev
->dw_loc_opc
== DW_OP_piece
28664 || prev
->dw_loc_opc
== DW_OP_bit_piece
)
28665 && loc
->dw_loc_next
28666 && loc
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
28667 && (!dwarf_strict
|| dwarf_version
>= 5)
28668 && optimize_one_addr_into_implicit_ptr (loc
))
28673 case DW_OP_GNU_addr_index
:
28674 case DW_OP_GNU_const_index
:
28675 if (loc
->dw_loc_opc
== DW_OP_GNU_addr_index
28676 || (loc
->dw_loc_opc
== DW_OP_GNU_const_index
&& loc
->dtprel
))
28678 rtx rtl
= loc
->dw_loc_oprnd1
.val_entry
->addr
.rtl
;
28679 if (!resolve_one_addr (&rtl
))
28681 remove_addr_table_entry (loc
->dw_loc_oprnd1
.val_entry
);
28682 loc
->dw_loc_oprnd1
.val_entry
28683 = add_addr_table_entry (rtl
, ate_kind_rtx
);
28686 case DW_OP_const4u
:
28687 case DW_OP_const8u
:
28689 && !resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
))
28692 case DW_OP_plus_uconst
:
28693 if (size_of_loc_descr (loc
)
28694 > size_of_int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
28696 && loc
->dw_loc_oprnd1
.v
.val_unsigned
> 0)
28698 dw_loc_descr_ref repl
28699 = int_loc_descriptor (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
28700 add_loc_descr (&repl
, new_loc_descr (DW_OP_plus
, 0, 0));
28701 add_loc_descr (&repl
, loc
->dw_loc_next
);
28705 case DW_OP_implicit_value
:
28706 if (loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
28707 && !resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
))
28710 case DW_OP_implicit_pointer
:
28711 case DW_OP_GNU_implicit_pointer
:
28712 case DW_OP_GNU_parameter_ref
:
28713 case DW_OP_GNU_variable_value
:
28714 if (loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
28717 = lookup_decl_die (loc
->dw_loc_oprnd1
.v
.val_decl_ref
);
28720 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
28721 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
28722 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
28724 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
)
28727 && loc
->dw_loc_next
== NULL
28728 && AT_class (a
) == dw_val_class_loc
)
28729 switch (a
->dw_attr
)
28731 /* Following attributes allow both exprloc and reference,
28732 so if the whole expression is DW_OP_GNU_variable_value
28733 alone we could transform it into reference. */
28734 case DW_AT_byte_size
:
28735 case DW_AT_bit_size
:
28736 case DW_AT_lower_bound
:
28737 case DW_AT_upper_bound
:
28738 case DW_AT_bit_stride
:
28740 case DW_AT_allocated
:
28741 case DW_AT_associated
:
28742 case DW_AT_byte_stride
:
28743 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
28744 a
->dw_attr_val
.val_entry
= NULL
;
28745 a
->dw_attr_val
.v
.val_die_ref
.die
28746 = loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
28747 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
28756 case DW_OP_const_type
:
28757 case DW_OP_regval_type
:
28758 case DW_OP_deref_type
:
28759 case DW_OP_convert
:
28760 case DW_OP_reinterpret
:
28761 case DW_OP_GNU_const_type
:
28762 case DW_OP_GNU_regval_type
:
28763 case DW_OP_GNU_deref_type
:
28764 case DW_OP_GNU_convert
:
28765 case DW_OP_GNU_reinterpret
:
28766 while (loc
->dw_loc_next
28767 && (loc
->dw_loc_next
->dw_loc_opc
== DW_OP_convert
28768 || loc
->dw_loc_next
->dw_loc_opc
== DW_OP_GNU_convert
))
28770 dw_die_ref base1
, base2
;
28771 unsigned enc1
, enc2
, size1
, size2
;
28772 if (loc
->dw_loc_opc
== DW_OP_regval_type
28773 || loc
->dw_loc_opc
== DW_OP_deref_type
28774 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
28775 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
28776 base1
= loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
;
28777 else if (loc
->dw_loc_oprnd1
.val_class
28778 == dw_val_class_unsigned_const
)
28781 base1
= loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
28782 if (loc
->dw_loc_next
->dw_loc_oprnd1
.val_class
28783 == dw_val_class_unsigned_const
)
28785 base2
= loc
->dw_loc_next
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
28786 gcc_assert (base1
->die_tag
== DW_TAG_base_type
28787 && base2
->die_tag
== DW_TAG_base_type
);
28788 enc1
= get_AT_unsigned (base1
, DW_AT_encoding
);
28789 enc2
= get_AT_unsigned (base2
, DW_AT_encoding
);
28790 size1
= get_AT_unsigned (base1
, DW_AT_byte_size
);
28791 size2
= get_AT_unsigned (base2
, DW_AT_byte_size
);
28793 && (((enc1
== DW_ATE_unsigned
|| enc1
== DW_ATE_signed
)
28794 && (enc2
== DW_ATE_unsigned
|| enc2
== DW_ATE_signed
)
28798 /* Optimize away next DW_OP_convert after
28799 adjusting LOC's base type die reference. */
28800 if (loc
->dw_loc_opc
== DW_OP_regval_type
28801 || loc
->dw_loc_opc
== DW_OP_deref_type
28802 || loc
->dw_loc_opc
== DW_OP_GNU_regval_type
28803 || loc
->dw_loc_opc
== DW_OP_GNU_deref_type
)
28804 loc
->dw_loc_oprnd2
.v
.val_die_ref
.die
= base2
;
28806 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= base2
;
28807 loc
->dw_loc_next
= loc
->dw_loc_next
->dw_loc_next
;
28810 /* Don't change integer DW_OP_convert after e.g. floating
28811 point typed stack entry. */
28812 else if (enc1
!= DW_ATE_unsigned
&& enc1
!= DW_ATE_signed
)
28813 keep
= loc
->dw_loc_next
;
28823 /* Helper function of resolve_addr. DIE had DW_AT_location of
28824 DW_OP_addr alone, which referred to DECL in DW_OP_addr's operand
28825 and DW_OP_addr couldn't be resolved. resolve_addr has already
28826 removed the DW_AT_location attribute. This function attempts to
28827 add a new DW_AT_location attribute with DW_OP_implicit_pointer
28828 to it or DW_AT_const_value attribute, if possible. */
28831 optimize_location_into_implicit_ptr (dw_die_ref die
, tree decl
)
28834 || lookup_decl_die (decl
) != die
28835 || DECL_EXTERNAL (decl
)
28836 || !TREE_STATIC (decl
)
28837 || DECL_INITIAL (decl
) == NULL_TREE
28838 || DECL_P (DECL_INITIAL (decl
))
28839 || get_AT (die
, DW_AT_const_value
))
28842 tree init
= DECL_INITIAL (decl
);
28843 HOST_WIDE_INT offset
= 0;
28844 /* For variables that have been optimized away and thus
28845 don't have a memory location, see if we can emit
28846 DW_AT_const_value instead. */
28847 if (tree_add_const_value_attribute (die
, init
))
28849 if (dwarf_strict
&& dwarf_version
< 5)
28851 /* If init is ADDR_EXPR or POINTER_PLUS_EXPR of ADDR_EXPR,
28852 and ADDR_EXPR refers to a decl that has DW_AT_location or
28853 DW_AT_const_value (but isn't addressable, otherwise
28854 resolving the original DW_OP_addr wouldn't fail), see if
28855 we can add DW_OP_implicit_pointer. */
28857 if (TREE_CODE (init
) == POINTER_PLUS_EXPR
28858 && tree_fits_shwi_p (TREE_OPERAND (init
, 1)))
28860 offset
= tree_to_shwi (TREE_OPERAND (init
, 1));
28861 init
= TREE_OPERAND (init
, 0);
28864 if (TREE_CODE (init
) != ADDR_EXPR
)
28866 if ((TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
28867 && !TREE_ASM_WRITTEN (TREE_OPERAND (init
, 0)))
28868 || (TREE_CODE (TREE_OPERAND (init
, 0)) == VAR_DECL
28869 && !DECL_EXTERNAL (TREE_OPERAND (init
, 0))
28870 && TREE_OPERAND (init
, 0) != decl
))
28873 dw_loc_descr_ref l
;
28875 if (TREE_CODE (TREE_OPERAND (init
, 0)) == STRING_CST
)
28877 rtx rtl
= string_cst_pool_decl (TREE_OPERAND (init
, 0));
28880 decl
= SYMBOL_REF_DECL (rtl
);
28883 decl
= TREE_OPERAND (init
, 0);
28884 ref
= lookup_decl_die (decl
);
28886 || (!get_AT (ref
, DW_AT_location
)
28887 && !get_AT (ref
, DW_AT_const_value
)))
28889 l
= new_loc_descr (dwarf_OP (DW_OP_implicit_pointer
), 0, offset
);
28890 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
28891 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
28892 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
28893 add_AT_loc (die
, DW_AT_location
, l
);
28897 /* Return NULL if l is a DWARF expression, or first op that is not
28898 valid DWARF expression. */
28900 static dw_loc_descr_ref
28901 non_dwarf_expression (dw_loc_descr_ref l
)
28905 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
28907 switch (l
->dw_loc_opc
)
28910 case DW_OP_implicit_value
:
28911 case DW_OP_stack_value
:
28912 case DW_OP_implicit_pointer
:
28913 case DW_OP_GNU_implicit_pointer
:
28914 case DW_OP_GNU_parameter_ref
:
28916 case DW_OP_bit_piece
:
28921 l
= l
->dw_loc_next
;
28926 /* Return adjusted copy of EXPR:
28927 If it is empty DWARF expression, return it.
28928 If it is valid non-empty DWARF expression,
28929 return copy of EXPR with DW_OP_deref appended to it.
28930 If it is DWARF expression followed by DW_OP_reg{N,x}, return
28931 copy of the DWARF expression with DW_OP_breg{N,x} <0> appended.
28932 If it is DWARF expression followed by DW_OP_stack_value, return
28933 copy of the DWARF expression without anything appended.
28934 Otherwise, return NULL. */
28936 static dw_loc_descr_ref
28937 copy_deref_exprloc (dw_loc_descr_ref expr
)
28939 dw_loc_descr_ref tail
= NULL
;
28944 dw_loc_descr_ref l
= non_dwarf_expression (expr
);
28945 if (l
&& l
->dw_loc_next
)
28950 if (l
->dw_loc_opc
>= DW_OP_reg0
&& l
->dw_loc_opc
<= DW_OP_reg31
)
28951 tail
= new_loc_descr ((enum dwarf_location_atom
)
28952 (DW_OP_breg0
+ (l
->dw_loc_opc
- DW_OP_reg0
)),
28955 switch (l
->dw_loc_opc
)
28958 tail
= new_loc_descr (DW_OP_bregx
,
28959 l
->dw_loc_oprnd1
.v
.val_unsigned
, 0);
28961 case DW_OP_stack_value
:
28968 tail
= new_loc_descr (DW_OP_deref
, 0, 0);
28970 dw_loc_descr_ref ret
= NULL
, *p
= &ret
;
28973 *p
= new_loc_descr (expr
->dw_loc_opc
, 0, 0);
28974 (*p
)->dw_loc_oprnd1
= expr
->dw_loc_oprnd1
;
28975 (*p
)->dw_loc_oprnd2
= expr
->dw_loc_oprnd2
;
28976 p
= &(*p
)->dw_loc_next
;
28977 expr
= expr
->dw_loc_next
;
28983 /* For DW_AT_string_length attribute with DW_OP_GNU_variable_value
28984 reference to a variable or argument, adjust it if needed and return:
28985 -1 if the DW_AT_string_length attribute and DW_AT_{string_length_,}byte_size
28986 attribute if present should be removed
28987 0 keep the attribute perhaps with minor modifications, no need to rescan
28988 1 if the attribute has been successfully adjusted. */
28991 optimize_string_length (dw_attr_node
*a
)
28993 dw_loc_descr_ref l
= AT_loc (a
), lv
;
28995 if (l
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
28997 tree decl
= l
->dw_loc_oprnd1
.v
.val_decl_ref
;
28998 die
= lookup_decl_die (decl
);
29001 l
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
29002 l
->dw_loc_oprnd1
.v
.val_die_ref
.die
= die
;
29003 l
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
29009 die
= l
->dw_loc_oprnd1
.v
.val_die_ref
.die
;
29011 /* DWARF5 allows reference class, so we can then reference the DIE.
29012 Only do this for DW_OP_GNU_variable_value DW_OP_stack_value. */
29013 if (l
->dw_loc_next
!= NULL
&& dwarf_version
>= 5)
29015 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
29016 a
->dw_attr_val
.val_entry
= NULL
;
29017 a
->dw_attr_val
.v
.val_die_ref
.die
= die
;
29018 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
29022 dw_attr_node
*av
= get_AT (die
, DW_AT_location
);
29024 bool non_dwarf_expr
= false;
29027 return dwarf_strict
? -1 : 0;
29028 switch (AT_class (av
))
29030 case dw_val_class_loc_list
:
29031 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
29032 if (d
->expr
&& non_dwarf_expression (d
->expr
))
29033 non_dwarf_expr
= true;
29035 case dw_val_class_loc
:
29038 return dwarf_strict
? -1 : 0;
29039 if (non_dwarf_expression (lv
))
29040 non_dwarf_expr
= true;
29043 return dwarf_strict
? -1 : 0;
29046 /* If it is safe to transform DW_OP_GNU_variable_value DW_OP_stack_value
29047 into DW_OP_call4 or DW_OP_GNU_variable_value into
29048 DW_OP_call4 DW_OP_deref, do so. */
29049 if (!non_dwarf_expr
29050 && (l
->dw_loc_next
!= NULL
|| AT_class (av
) == dw_val_class_loc
))
29052 l
->dw_loc_opc
= DW_OP_call4
;
29053 if (l
->dw_loc_next
)
29054 l
->dw_loc_next
= NULL
;
29056 l
->dw_loc_next
= new_loc_descr (DW_OP_deref
, 0, 0);
29060 /* For DW_OP_GNU_variable_value DW_OP_stack_value, we can just
29061 copy over the DW_AT_location attribute from die to a. */
29062 if (l
->dw_loc_next
!= NULL
)
29064 a
->dw_attr_val
= av
->dw_attr_val
;
29068 dw_loc_list_ref list
, *p
;
29069 switch (AT_class (av
))
29071 case dw_val_class_loc_list
:
29074 for (d
= AT_loc_list (av
); d
!= NULL
; d
= d
->dw_loc_next
)
29076 lv
= copy_deref_exprloc (d
->expr
);
29079 *p
= new_loc_list (lv
, d
->begin
, d
->end
, d
->section
);
29080 p
= &(*p
)->dw_loc_next
;
29082 else if (!dwarf_strict
&& d
->expr
)
29086 return dwarf_strict
? -1 : 0;
29087 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
29089 *AT_loc_list_ptr (a
) = list
;
29091 case dw_val_class_loc
:
29092 lv
= copy_deref_exprloc (AT_loc (av
));
29094 return dwarf_strict
? -1 : 0;
29095 a
->dw_attr_val
.v
.val_loc
= lv
;
29098 gcc_unreachable ();
29102 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
29103 an address in .rodata section if the string literal is emitted there,
29104 or remove the containing location list or replace DW_AT_const_value
29105 with DW_AT_location and empty location expression, if it isn't found
29106 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
29107 to something that has been emitted in the current CU. */
29110 resolve_addr (dw_die_ref die
)
29114 dw_loc_list_ref
*curr
, *start
, loc
;
29116 bool remove_AT_byte_size
= false;
29118 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29119 switch (AT_class (a
))
29121 case dw_val_class_loc_list
:
29122 start
= curr
= AT_loc_list_ptr (a
);
29125 /* The same list can be referenced more than once. See if we have
29126 already recorded the result from a previous pass. */
29128 *curr
= loc
->dw_loc_next
;
29129 else if (!loc
->resolved_addr
)
29131 /* As things stand, we do not expect or allow one die to
29132 reference a suffix of another die's location list chain.
29133 References must be identical or completely separate.
29134 There is therefore no need to cache the result of this
29135 pass on any list other than the first; doing so
29136 would lead to unnecessary writes. */
29139 gcc_assert (!(*curr
)->replaced
&& !(*curr
)->resolved_addr
);
29140 if (!resolve_addr_in_expr (a
, (*curr
)->expr
))
29142 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
29143 dw_loc_descr_ref l
= (*curr
)->expr
;
29145 if (next
&& (*curr
)->ll_symbol
)
29147 gcc_assert (!next
->ll_symbol
);
29148 next
->ll_symbol
= (*curr
)->ll_symbol
;
29150 if (dwarf_split_debug_info
)
29151 remove_loc_list_addr_table_entries (l
);
29156 mark_base_types ((*curr
)->expr
);
29157 curr
= &(*curr
)->dw_loc_next
;
29161 loc
->resolved_addr
= 1;
29165 loc
->dw_loc_next
= *start
;
29170 remove_AT (die
, a
->dw_attr
);
29174 case dw_val_class_loc
:
29176 dw_loc_descr_ref l
= AT_loc (a
);
29177 /* DW_OP_GNU_variable_value DW_OP_stack_value or
29178 DW_OP_GNU_variable_value in DW_AT_string_length can be converted
29179 into DW_OP_call4 or DW_OP_call4 DW_OP_deref, which is standard
29180 DWARF4 unlike DW_OP_GNU_variable_value. Or for DWARF5
29181 DW_OP_GNU_variable_value DW_OP_stack_value can be replaced
29182 with DW_FORM_ref referencing the same DIE as
29183 DW_OP_GNU_variable_value used to reference. */
29184 if (a
->dw_attr
== DW_AT_string_length
29186 && l
->dw_loc_opc
== DW_OP_GNU_variable_value
29187 && (l
->dw_loc_next
== NULL
29188 || (l
->dw_loc_next
->dw_loc_next
== NULL
29189 && l
->dw_loc_next
->dw_loc_opc
== DW_OP_stack_value
)))
29191 switch (optimize_string_length (a
))
29194 remove_AT (die
, a
->dw_attr
);
29196 /* If we drop DW_AT_string_length, we need to drop also
29197 DW_AT_{string_length_,}byte_size. */
29198 remove_AT_byte_size
= true;
29203 /* Even if we keep the optimized DW_AT_string_length,
29204 it might have changed AT_class, so process it again. */
29209 /* For -gdwarf-2 don't attempt to optimize
29210 DW_AT_data_member_location containing
29211 DW_OP_plus_uconst - older consumers might
29212 rely on it being that op instead of a more complex,
29213 but shorter, location description. */
29214 if ((dwarf_version
> 2
29215 || a
->dw_attr
!= DW_AT_data_member_location
29217 || l
->dw_loc_opc
!= DW_OP_plus_uconst
29218 || l
->dw_loc_next
!= NULL
)
29219 && !resolve_addr_in_expr (a
, l
))
29221 if (dwarf_split_debug_info
)
29222 remove_loc_list_addr_table_entries (l
);
29224 && l
->dw_loc_next
== NULL
29225 && l
->dw_loc_opc
== DW_OP_addr
29226 && GET_CODE (l
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
29227 && SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
)
29228 && a
->dw_attr
== DW_AT_location
)
29230 tree decl
= SYMBOL_REF_DECL (l
->dw_loc_oprnd1
.v
.val_addr
);
29231 remove_AT (die
, a
->dw_attr
);
29233 optimize_location_into_implicit_ptr (die
, decl
);
29236 if (a
->dw_attr
== DW_AT_string_length
)
29237 /* If we drop DW_AT_string_length, we need to drop also
29238 DW_AT_{string_length_,}byte_size. */
29239 remove_AT_byte_size
= true;
29240 remove_AT (die
, a
->dw_attr
);
29244 mark_base_types (l
);
29247 case dw_val_class_addr
:
29248 if (a
->dw_attr
== DW_AT_const_value
29249 && !resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
))
29251 if (AT_index (a
) != NOT_INDEXED
)
29252 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
29253 remove_AT (die
, a
->dw_attr
);
29256 if ((die
->die_tag
== DW_TAG_call_site
29257 && a
->dw_attr
== DW_AT_call_origin
)
29258 || (die
->die_tag
== DW_TAG_GNU_call_site
29259 && a
->dw_attr
== DW_AT_abstract_origin
))
29261 tree tdecl
= SYMBOL_REF_DECL (a
->dw_attr_val
.v
.val_addr
);
29262 dw_die_ref tdie
= lookup_decl_die (tdecl
);
29265 && DECL_EXTERNAL (tdecl
)
29266 && DECL_ABSTRACT_ORIGIN (tdecl
) == NULL_TREE
29267 && (cdie
= lookup_context_die (DECL_CONTEXT (tdecl
))))
29269 dw_die_ref pdie
= cdie
;
29270 /* Make sure we don't add these DIEs into type units.
29271 We could emit skeleton DIEs for context (namespaces,
29272 outer structs/classes) and a skeleton DIE for the
29273 innermost context with DW_AT_signature pointing to the
29274 type unit. See PR78835. */
29275 while (pdie
&& pdie
->die_tag
!= DW_TAG_type_unit
)
29276 pdie
= pdie
->die_parent
;
29279 /* Creating a full DIE for tdecl is overly expensive and
29280 at this point even wrong when in the LTO phase
29281 as it can end up generating new type DIEs we didn't
29282 output and thus optimize_external_refs will crash. */
29283 tdie
= new_die (DW_TAG_subprogram
, cdie
, NULL_TREE
);
29284 add_AT_flag (tdie
, DW_AT_external
, 1);
29285 add_AT_flag (tdie
, DW_AT_declaration
, 1);
29286 add_linkage_attr (tdie
, tdecl
);
29287 add_name_and_src_coords_attributes (tdie
, tdecl
, true);
29288 equate_decl_number_to_die (tdecl
, tdie
);
29293 a
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
29294 a
->dw_attr_val
.v
.val_die_ref
.die
= tdie
;
29295 a
->dw_attr_val
.v
.val_die_ref
.external
= 0;
29299 if (AT_index (a
) != NOT_INDEXED
)
29300 remove_addr_table_entry (a
->dw_attr_val
.val_entry
);
29301 remove_AT (die
, a
->dw_attr
);
29310 if (remove_AT_byte_size
)
29311 remove_AT (die
, dwarf_version
>= 5
29312 ? DW_AT_string_length_byte_size
29313 : DW_AT_byte_size
);
29315 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
29318 /* Helper routines for optimize_location_lists.
29319 This pass tries to share identical local lists in .debug_loc
29322 /* Iteratively hash operands of LOC opcode into HSTATE. */
29325 hash_loc_operands (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
29327 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
29328 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
29330 switch (loc
->dw_loc_opc
)
29332 case DW_OP_const4u
:
29333 case DW_OP_const8u
:
29337 case DW_OP_const1u
:
29338 case DW_OP_const1s
:
29339 case DW_OP_const2u
:
29340 case DW_OP_const2s
:
29341 case DW_OP_const4s
:
29342 case DW_OP_const8s
:
29346 case DW_OP_plus_uconst
:
29382 case DW_OP_deref_size
:
29383 case DW_OP_xderef_size
:
29384 hstate
.add_object (val1
->v
.val_int
);
29391 gcc_assert (val1
->val_class
== dw_val_class_loc
);
29392 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
29393 hstate
.add_object (offset
);
29396 case DW_OP_implicit_value
:
29397 hstate
.add_object (val1
->v
.val_unsigned
);
29398 switch (val2
->val_class
)
29400 case dw_val_class_const
:
29401 hstate
.add_object (val2
->v
.val_int
);
29403 case dw_val_class_vec
:
29405 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
29406 unsigned int len
= val2
->v
.val_vec
.length
;
29408 hstate
.add_int (elt_size
);
29409 hstate
.add_int (len
);
29410 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
29413 case dw_val_class_const_double
:
29414 hstate
.add_object (val2
->v
.val_double
.low
);
29415 hstate
.add_object (val2
->v
.val_double
.high
);
29417 case dw_val_class_wide_int
:
29418 hstate
.add (val2
->v
.val_wide
->get_val (),
29419 get_full_len (*val2
->v
.val_wide
)
29420 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
29422 case dw_val_class_addr
:
29423 inchash::add_rtx (val2
->v
.val_addr
, hstate
);
29426 gcc_unreachable ();
29430 case DW_OP_bit_piece
:
29431 hstate
.add_object (val1
->v
.val_int
);
29432 hstate
.add_object (val2
->v
.val_int
);
29438 unsigned char dtprel
= 0xd1;
29439 hstate
.add_object (dtprel
);
29441 inchash::add_rtx (val1
->v
.val_addr
, hstate
);
29443 case DW_OP_GNU_addr_index
:
29444 case DW_OP_GNU_const_index
:
29448 unsigned char dtprel
= 0xd1;
29449 hstate
.add_object (dtprel
);
29451 inchash::add_rtx (val1
->val_entry
->addr
.rtl
, hstate
);
29454 case DW_OP_implicit_pointer
:
29455 case DW_OP_GNU_implicit_pointer
:
29456 hstate
.add_int (val2
->v
.val_int
);
29458 case DW_OP_entry_value
:
29459 case DW_OP_GNU_entry_value
:
29460 hstate
.add_object (val1
->v
.val_loc
);
29462 case DW_OP_regval_type
:
29463 case DW_OP_deref_type
:
29464 case DW_OP_GNU_regval_type
:
29465 case DW_OP_GNU_deref_type
:
29467 unsigned int byte_size
29468 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_byte_size
);
29469 unsigned int encoding
29470 = get_AT_unsigned (val2
->v
.val_die_ref
.die
, DW_AT_encoding
);
29471 hstate
.add_object (val1
->v
.val_int
);
29472 hstate
.add_object (byte_size
);
29473 hstate
.add_object (encoding
);
29476 case DW_OP_convert
:
29477 case DW_OP_reinterpret
:
29478 case DW_OP_GNU_convert
:
29479 case DW_OP_GNU_reinterpret
:
29480 if (val1
->val_class
== dw_val_class_unsigned_const
)
29482 hstate
.add_object (val1
->v
.val_unsigned
);
29486 case DW_OP_const_type
:
29487 case DW_OP_GNU_const_type
:
29489 unsigned int byte_size
29490 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_byte_size
);
29491 unsigned int encoding
29492 = get_AT_unsigned (val1
->v
.val_die_ref
.die
, DW_AT_encoding
);
29493 hstate
.add_object (byte_size
);
29494 hstate
.add_object (encoding
);
29495 if (loc
->dw_loc_opc
!= DW_OP_const_type
29496 && loc
->dw_loc_opc
!= DW_OP_GNU_const_type
)
29498 hstate
.add_object (val2
->val_class
);
29499 switch (val2
->val_class
)
29501 case dw_val_class_const
:
29502 hstate
.add_object (val2
->v
.val_int
);
29504 case dw_val_class_vec
:
29506 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
29507 unsigned int len
= val2
->v
.val_vec
.length
;
29509 hstate
.add_object (elt_size
);
29510 hstate
.add_object (len
);
29511 hstate
.add (val2
->v
.val_vec
.array
, len
* elt_size
);
29514 case dw_val_class_const_double
:
29515 hstate
.add_object (val2
->v
.val_double
.low
);
29516 hstate
.add_object (val2
->v
.val_double
.high
);
29518 case dw_val_class_wide_int
:
29519 hstate
.add (val2
->v
.val_wide
->get_val (),
29520 get_full_len (*val2
->v
.val_wide
)
29521 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
);
29524 gcc_unreachable ();
29530 /* Other codes have no operands. */
29535 /* Iteratively hash the whole DWARF location expression LOC into HSTATE. */
29538 hash_locs (dw_loc_descr_ref loc
, inchash::hash
&hstate
)
29540 dw_loc_descr_ref l
;
29541 bool sizes_computed
= false;
29542 /* Compute sizes, so that DW_OP_skip/DW_OP_bra can be checksummed. */
29543 size_of_locs (loc
);
29545 for (l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
29547 enum dwarf_location_atom opc
= l
->dw_loc_opc
;
29548 hstate
.add_object (opc
);
29549 if ((opc
== DW_OP_skip
|| opc
== DW_OP_bra
) && !sizes_computed
)
29551 size_of_locs (loc
);
29552 sizes_computed
= true;
29554 hash_loc_operands (l
, hstate
);
29558 /* Compute hash of the whole location list LIST_HEAD. */
29561 hash_loc_list (dw_loc_list_ref list_head
)
29563 dw_loc_list_ref curr
= list_head
;
29564 inchash::hash hstate
;
29566 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
29568 hstate
.add (curr
->begin
, strlen (curr
->begin
) + 1);
29569 hstate
.add (curr
->end
, strlen (curr
->end
) + 1);
29571 hstate
.add (curr
->section
, strlen (curr
->section
) + 1);
29572 hash_locs (curr
->expr
, hstate
);
29574 list_head
->hash
= hstate
.end ();
29577 /* Return true if X and Y opcodes have the same operands. */
29580 compare_loc_operands (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
29582 dw_val_ref valx1
= &x
->dw_loc_oprnd1
;
29583 dw_val_ref valx2
= &x
->dw_loc_oprnd2
;
29584 dw_val_ref valy1
= &y
->dw_loc_oprnd1
;
29585 dw_val_ref valy2
= &y
->dw_loc_oprnd2
;
29587 switch (x
->dw_loc_opc
)
29589 case DW_OP_const4u
:
29590 case DW_OP_const8u
:
29594 case DW_OP_const1u
:
29595 case DW_OP_const1s
:
29596 case DW_OP_const2u
:
29597 case DW_OP_const2s
:
29598 case DW_OP_const4s
:
29599 case DW_OP_const8s
:
29603 case DW_OP_plus_uconst
:
29639 case DW_OP_deref_size
:
29640 case DW_OP_xderef_size
:
29641 return valx1
->v
.val_int
== valy1
->v
.val_int
;
29644 /* If splitting debug info, the use of DW_OP_GNU_addr_index
29645 can cause irrelevant differences in dw_loc_addr. */
29646 gcc_assert (valx1
->val_class
== dw_val_class_loc
29647 && valy1
->val_class
== dw_val_class_loc
29648 && (dwarf_split_debug_info
29649 || x
->dw_loc_addr
== y
->dw_loc_addr
));
29650 return valx1
->v
.val_loc
->dw_loc_addr
== valy1
->v
.val_loc
->dw_loc_addr
;
29651 case DW_OP_implicit_value
:
29652 if (valx1
->v
.val_unsigned
!= valy1
->v
.val_unsigned
29653 || valx2
->val_class
!= valy2
->val_class
)
29655 switch (valx2
->val_class
)
29657 case dw_val_class_const
:
29658 return valx2
->v
.val_int
== valy2
->v
.val_int
;
29659 case dw_val_class_vec
:
29660 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
29661 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
29662 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
29663 valx2
->v
.val_vec
.elt_size
29664 * valx2
->v
.val_vec
.length
) == 0;
29665 case dw_val_class_const_double
:
29666 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
29667 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
29668 case dw_val_class_wide_int
:
29669 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
29670 case dw_val_class_addr
:
29671 return rtx_equal_p (valx2
->v
.val_addr
, valy2
->v
.val_addr
);
29673 gcc_unreachable ();
29676 case DW_OP_bit_piece
:
29677 return valx1
->v
.val_int
== valy1
->v
.val_int
29678 && valx2
->v
.val_int
== valy2
->v
.val_int
;
29681 return rtx_equal_p (valx1
->v
.val_addr
, valy1
->v
.val_addr
);
29682 case DW_OP_GNU_addr_index
:
29683 case DW_OP_GNU_const_index
:
29685 rtx ax1
= valx1
->val_entry
->addr
.rtl
;
29686 rtx ay1
= valy1
->val_entry
->addr
.rtl
;
29687 return rtx_equal_p (ax1
, ay1
);
29689 case DW_OP_implicit_pointer
:
29690 case DW_OP_GNU_implicit_pointer
:
29691 return valx1
->val_class
== dw_val_class_die_ref
29692 && valx1
->val_class
== valy1
->val_class
29693 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
29694 && valx2
->v
.val_int
== valy2
->v
.val_int
;
29695 case DW_OP_entry_value
:
29696 case DW_OP_GNU_entry_value
:
29697 return compare_loc_operands (valx1
->v
.val_loc
, valy1
->v
.val_loc
);
29698 case DW_OP_const_type
:
29699 case DW_OP_GNU_const_type
:
29700 if (valx1
->v
.val_die_ref
.die
!= valy1
->v
.val_die_ref
.die
29701 || valx2
->val_class
!= valy2
->val_class
)
29703 switch (valx2
->val_class
)
29705 case dw_val_class_const
:
29706 return valx2
->v
.val_int
== valy2
->v
.val_int
;
29707 case dw_val_class_vec
:
29708 return valx2
->v
.val_vec
.elt_size
== valy2
->v
.val_vec
.elt_size
29709 && valx2
->v
.val_vec
.length
== valy2
->v
.val_vec
.length
29710 && memcmp (valx2
->v
.val_vec
.array
, valy2
->v
.val_vec
.array
,
29711 valx2
->v
.val_vec
.elt_size
29712 * valx2
->v
.val_vec
.length
) == 0;
29713 case dw_val_class_const_double
:
29714 return valx2
->v
.val_double
.low
== valy2
->v
.val_double
.low
29715 && valx2
->v
.val_double
.high
== valy2
->v
.val_double
.high
;
29716 case dw_val_class_wide_int
:
29717 return *valx2
->v
.val_wide
== *valy2
->v
.val_wide
;
29719 gcc_unreachable ();
29721 case DW_OP_regval_type
:
29722 case DW_OP_deref_type
:
29723 case DW_OP_GNU_regval_type
:
29724 case DW_OP_GNU_deref_type
:
29725 return valx1
->v
.val_int
== valy1
->v
.val_int
29726 && valx2
->v
.val_die_ref
.die
== valy2
->v
.val_die_ref
.die
;
29727 case DW_OP_convert
:
29728 case DW_OP_reinterpret
:
29729 case DW_OP_GNU_convert
:
29730 case DW_OP_GNU_reinterpret
:
29731 if (valx1
->val_class
!= valy1
->val_class
)
29733 if (valx1
->val_class
== dw_val_class_unsigned_const
)
29734 return valx1
->v
.val_unsigned
== valy1
->v
.val_unsigned
;
29735 return valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
29736 case DW_OP_GNU_parameter_ref
:
29737 return valx1
->val_class
== dw_val_class_die_ref
29738 && valx1
->val_class
== valy1
->val_class
29739 && valx1
->v
.val_die_ref
.die
== valy1
->v
.val_die_ref
.die
;
29741 /* Other codes have no operands. */
29746 /* Return true if DWARF location expressions X and Y are the same. */
29749 compare_locs (dw_loc_descr_ref x
, dw_loc_descr_ref y
)
29751 for (; x
!= NULL
&& y
!= NULL
; x
= x
->dw_loc_next
, y
= y
->dw_loc_next
)
29752 if (x
->dw_loc_opc
!= y
->dw_loc_opc
29753 || x
->dtprel
!= y
->dtprel
29754 || !compare_loc_operands (x
, y
))
29756 return x
== NULL
&& y
== NULL
;
29759 /* Hashtable helpers. */
29761 struct loc_list_hasher
: nofree_ptr_hash
<dw_loc_list_struct
>
29763 static inline hashval_t
hash (const dw_loc_list_struct
*);
29764 static inline bool equal (const dw_loc_list_struct
*,
29765 const dw_loc_list_struct
*);
29768 /* Return precomputed hash of location list X. */
29771 loc_list_hasher::hash (const dw_loc_list_struct
*x
)
29776 /* Return true if location lists A and B are the same. */
29779 loc_list_hasher::equal (const dw_loc_list_struct
*a
,
29780 const dw_loc_list_struct
*b
)
29784 if (a
->hash
!= b
->hash
)
29786 for (; a
!= NULL
&& b
!= NULL
; a
= a
->dw_loc_next
, b
= b
->dw_loc_next
)
29787 if (strcmp (a
->begin
, b
->begin
) != 0
29788 || strcmp (a
->end
, b
->end
) != 0
29789 || (a
->section
== NULL
) != (b
->section
== NULL
)
29790 || (a
->section
&& strcmp (a
->section
, b
->section
) != 0)
29791 || !compare_locs (a
->expr
, b
->expr
))
29793 return a
== NULL
&& b
== NULL
;
29796 typedef hash_table
<loc_list_hasher
> loc_list_hash_type
;
29799 /* Recursively optimize location lists referenced from DIE
29800 children and share them whenever possible. */
29803 optimize_location_lists_1 (dw_die_ref die
, loc_list_hash_type
*htab
)
29808 dw_loc_list_struct
**slot
;
29810 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29811 if (AT_class (a
) == dw_val_class_loc_list
)
29813 dw_loc_list_ref list
= AT_loc_list (a
);
29814 /* TODO: perform some optimizations here, before hashing
29815 it and storing into the hash table. */
29816 hash_loc_list (list
);
29817 slot
= htab
->find_slot_with_hash (list
, list
->hash
, INSERT
);
29821 a
->dw_attr_val
.v
.val_loc_list
= *slot
;
29824 FOR_EACH_CHILD (die
, c
, optimize_location_lists_1 (c
, htab
));
29828 /* Recursively assign each location list a unique index into the debug_addr
29832 index_location_lists (dw_die_ref die
)
29838 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
29839 if (AT_class (a
) == dw_val_class_loc_list
)
29841 dw_loc_list_ref list
= AT_loc_list (a
);
29842 dw_loc_list_ref curr
;
29843 for (curr
= list
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
29845 /* Don't index an entry that has already been indexed
29846 or won't be output. */
29847 if (curr
->begin_entry
!= NULL
29848 || (strcmp (curr
->begin
, curr
->end
) == 0 && !curr
->force
))
29852 = add_addr_table_entry (xstrdup (curr
->begin
), ate_kind_label
);
29856 FOR_EACH_CHILD (die
, c
, index_location_lists (c
));
29859 /* Optimize location lists referenced from DIE
29860 children and share them whenever possible. */
29863 optimize_location_lists (dw_die_ref die
)
29865 loc_list_hash_type
htab (500);
29866 optimize_location_lists_1 (die
, &htab
);
29869 /* Traverse the limbo die list, and add parent/child links. The only
29870 dies without parents that should be here are concrete instances of
29871 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
29872 For concrete instances, we can get the parent die from the abstract
29876 flush_limbo_die_list (void)
29878 limbo_die_node
*node
;
29880 /* get_context_die calls force_decl_die, which can put new DIEs on the
29881 limbo list in LTO mode when nested functions are put in a different
29882 partition than that of their parent function. */
29883 while ((node
= limbo_die_list
))
29885 dw_die_ref die
= node
->die
;
29886 limbo_die_list
= node
->next
;
29888 if (die
->die_parent
== NULL
)
29890 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
29892 if (origin
&& origin
->die_parent
)
29893 add_child_die (origin
->die_parent
, die
);
29894 else if (is_cu_die (die
))
29896 else if (seen_error ())
29897 /* It's OK to be confused by errors in the input. */
29898 add_child_die (comp_unit_die (), die
);
29901 /* In certain situations, the lexical block containing a
29902 nested function can be optimized away, which results
29903 in the nested function die being orphaned. Likewise
29904 with the return type of that nested function. Force
29905 this to be a child of the containing function.
29907 It may happen that even the containing function got fully
29908 inlined and optimized out. In that case we are lost and
29909 assign the empty child. This should not be big issue as
29910 the function is likely unreachable too. */
29911 gcc_assert (node
->created_for
);
29913 if (DECL_P (node
->created_for
))
29914 origin
= get_context_die (DECL_CONTEXT (node
->created_for
));
29915 else if (TYPE_P (node
->created_for
))
29916 origin
= scope_die_for (node
->created_for
, comp_unit_die ());
29918 origin
= comp_unit_die ();
29920 add_child_die (origin
, die
);
29926 /* Reset DIEs so we can output them again. */
29929 reset_dies (dw_die_ref die
)
29933 /* Remove stuff we re-generate. */
29935 die
->die_offset
= 0;
29936 die
->die_abbrev
= 0;
29937 remove_AT (die
, DW_AT_sibling
);
29939 FOR_EACH_CHILD (die
, c
, reset_dies (c
));
29942 /* Output stuff that dwarf requires at the end of every file,
29943 and generate the DWARF-2 debugging info. */
29946 dwarf2out_finish (const char *)
29948 comdat_type_node
*ctnode
;
29949 dw_die_ref main_comp_unit_die
;
29950 unsigned char checksum
[16];
29951 char dl_section_ref
[MAX_ARTIFICIAL_LABEL_BYTES
];
29953 /* Flush out any latecomers to the limbo party. */
29954 flush_limbo_die_list ();
29958 verify_die (comp_unit_die ());
29959 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
29960 verify_die (node
->die
);
29963 /* We shouldn't have any symbols with delayed asm names for
29964 DIEs generated after early finish. */
29965 gcc_assert (deferred_asm_name
== NULL
);
29967 gen_remaining_tmpl_value_param_die_attribute ();
29969 if (flag_generate_lto
|| flag_generate_offload
)
29971 gcc_assert (flag_fat_lto_objects
|| flag_generate_offload
);
29973 /* Prune stuff so that dwarf2out_finish runs successfully
29974 for the fat part of the object. */
29975 reset_dies (comp_unit_die ());
29976 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
29977 reset_dies (node
->die
);
29979 hash_table
<comdat_type_hasher
> comdat_type_table (100);
29980 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
29982 comdat_type_node
**slot
29983 = comdat_type_table
.find_slot (ctnode
, INSERT
);
29985 /* Don't reset types twice. */
29986 if (*slot
!= HTAB_EMPTY_ENTRY
)
29989 /* Add a pointer to the line table for the main compilation unit
29990 so that the debugger can make sense of DW_AT_decl_file
29992 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
29993 reset_dies (ctnode
->root_die
);
29998 /* Reset die CU symbol so we don't output it twice. */
29999 comp_unit_die ()->die_id
.die_symbol
= NULL
;
30001 /* Remove DW_AT_macro from the early output. */
30003 remove_AT (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
);
30005 /* Remove indirect string decisions. */
30006 debug_str_hash
->traverse
<void *, reset_indirect_string
> (NULL
);
30009 #if ENABLE_ASSERT_CHECKING
30011 dw_die_ref die
= comp_unit_die (), c
;
30012 FOR_EACH_CHILD (die
, c
, gcc_assert (! c
->die_mark
));
30015 resolve_addr (comp_unit_die ());
30016 move_marked_base_types ();
30018 /* Initialize sections and labels used for actual assembler output. */
30019 unsigned generation
= init_sections_and_labels (false);
30021 /* Traverse the DIE's and add sibling attributes to those DIE's that
30023 add_sibling_attributes (comp_unit_die ());
30024 limbo_die_node
*node
;
30025 for (node
= cu_die_list
; node
; node
= node
->next
)
30026 add_sibling_attributes (node
->die
);
30027 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
30028 add_sibling_attributes (ctnode
->root_die
);
30030 /* When splitting DWARF info, we put some attributes in the
30031 skeleton compile_unit DIE that remains in the .o, while
30032 most attributes go in the DWO compile_unit_die. */
30033 if (dwarf_split_debug_info
)
30035 limbo_die_node
*cu
;
30036 main_comp_unit_die
= gen_compile_unit_die (NULL
);
30037 if (dwarf_version
>= 5)
30038 main_comp_unit_die
->die_tag
= DW_TAG_skeleton_unit
;
30039 cu
= limbo_die_list
;
30040 gcc_assert (cu
->die
== main_comp_unit_die
);
30041 limbo_die_list
= limbo_die_list
->next
;
30042 cu
->next
= cu_die_list
;
30046 main_comp_unit_die
= comp_unit_die ();
30048 /* Output a terminator label for the .text section. */
30049 switch_to_section (text_section
);
30050 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
30051 if (cold_text_section
)
30053 switch_to_section (cold_text_section
);
30054 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
30057 /* We can only use the low/high_pc attributes if all of the code was
30059 if (!have_multiple_function_sections
30060 || (dwarf_version
< 3 && dwarf_strict
))
30062 /* Don't add if the CU has no associated code. */
30063 if (text_section_used
)
30064 add_AT_low_high_pc (main_comp_unit_die
, text_section_label
,
30065 text_end_label
, true);
30071 bool range_list_added
= false;
30073 if (text_section_used
)
30074 add_ranges_by_labels (main_comp_unit_die
, text_section_label
,
30075 text_end_label
, &range_list_added
, true);
30076 if (cold_text_section_used
)
30077 add_ranges_by_labels (main_comp_unit_die
, cold_text_section_label
,
30078 cold_end_label
, &range_list_added
, true);
30080 FOR_EACH_VEC_ELT (*fde_vec
, fde_idx
, fde
)
30082 if (DECL_IGNORED_P (fde
->decl
))
30084 if (!fde
->in_std_section
)
30085 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_begin
,
30086 fde
->dw_fde_end
, &range_list_added
,
30088 if (fde
->dw_fde_second_begin
&& !fde
->second_in_std_section
)
30089 add_ranges_by_labels (main_comp_unit_die
, fde
->dw_fde_second_begin
,
30090 fde
->dw_fde_second_end
, &range_list_added
,
30094 if (range_list_added
)
30096 /* We need to give .debug_loc and .debug_ranges an appropriate
30097 "base address". Use zero so that these addresses become
30098 absolute. Historically, we've emitted the unexpected
30099 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
30100 Emit both to give time for other tools to adapt. */
30101 add_AT_addr (main_comp_unit_die
, DW_AT_low_pc
, const0_rtx
, true);
30102 if (! dwarf_strict
&& dwarf_version
< 4)
30103 add_AT_addr (main_comp_unit_die
, DW_AT_entry_pc
, const0_rtx
, true);
30109 /* AIX Assembler inserts the length, so adjust the reference to match the
30110 offset expected by debuggers. */
30111 strcpy (dl_section_ref
, debug_line_section_label
);
30112 if (XCOFF_DEBUGGING_INFO
)
30113 strcat (dl_section_ref
, DWARF_INITIAL_LENGTH_SIZE_STR
);
30115 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
30116 add_AT_lineptr (main_comp_unit_die
, DW_AT_stmt_list
,
30120 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
30121 macinfo_section_label
);
30123 if (dwarf_split_debug_info
)
30125 if (have_location_lists
)
30127 if (dwarf_version
>= 5)
30128 add_AT_loclistsptr (comp_unit_die (), DW_AT_loclists_base
,
30129 loc_section_label
);
30130 /* optimize_location_lists calculates the size of the lists,
30131 so index them first, and assign indices to the entries.
30132 Although optimize_location_lists will remove entries from
30133 the table, it only does so for duplicates, and therefore
30134 only reduces ref_counts to 1. */
30135 index_location_lists (comp_unit_die ());
30138 if (addr_index_table
!= NULL
)
30140 unsigned int index
= 0;
30142 ->traverse_noresize
<unsigned int *, index_addr_table_entry
>
30148 if (have_location_lists
)
30150 optimize_location_lists (comp_unit_die ());
30151 /* And finally assign indexes to the entries for -gsplit-dwarf. */
30152 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
30153 assign_location_list_indexes (comp_unit_die ());
30156 save_macinfo_strings ();
30158 if (dwarf_split_debug_info
)
30160 unsigned int index
= 0;
30162 /* Add attributes common to skeleton compile_units and
30163 type_units. Because these attributes include strings, it
30164 must be done before freezing the string table. Top-level
30165 skeleton die attrs are added when the skeleton type unit is
30166 created, so ensure it is created by this point. */
30167 add_top_level_skeleton_die_attrs (main_comp_unit_die
);
30168 debug_str_hash
->traverse_noresize
<unsigned int *, index_string
> (&index
);
30171 /* Output all of the compilation units. We put the main one last so that
30172 the offsets are available to output_pubnames. */
30173 for (node
= cu_die_list
; node
; node
= node
->next
)
30174 output_comp_unit (node
->die
, 0, NULL
);
30176 hash_table
<comdat_type_hasher
> comdat_type_table (100);
30177 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
30179 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
30181 /* Don't output duplicate types. */
30182 if (*slot
!= HTAB_EMPTY_ENTRY
)
30185 /* Add a pointer to the line table for the main compilation unit
30186 so that the debugger can make sense of DW_AT_decl_file
30188 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
30189 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
30190 (!dwarf_split_debug_info
30192 : debug_skeleton_line_section_label
));
30194 output_comdat_type_unit (ctnode
);
30198 if (dwarf_split_debug_info
)
30201 struct md5_ctx ctx
;
30203 if (dwarf_version
>= 5 && !vec_safe_is_empty (ranges_table
))
30206 /* Compute a checksum of the comp_unit to use as the dwo_id. */
30207 md5_init_ctx (&ctx
);
30209 die_checksum (comp_unit_die (), &ctx
, &mark
);
30210 unmark_all_dies (comp_unit_die ());
30211 md5_finish_ctx (&ctx
, checksum
);
30213 if (dwarf_version
< 5)
30215 /* Use the first 8 bytes of the checksum as the dwo_id,
30216 and add it to both comp-unit DIEs. */
30217 add_AT_data8 (main_comp_unit_die
, DW_AT_GNU_dwo_id
, checksum
);
30218 add_AT_data8 (comp_unit_die (), DW_AT_GNU_dwo_id
, checksum
);
30221 /* Add the base offset of the ranges table to the skeleton
30223 if (!vec_safe_is_empty (ranges_table
))
30225 if (dwarf_version
>= 5)
30226 add_AT_lineptr (main_comp_unit_die
, DW_AT_rnglists_base
,
30227 ranges_base_label
);
30229 add_AT_lineptr (main_comp_unit_die
, DW_AT_GNU_ranges_base
,
30230 ranges_section_label
);
30233 switch_to_section (debug_addr_section
);
30234 ASM_OUTPUT_LABEL (asm_out_file
, debug_addr_section_label
);
30235 output_addr_table ();
30238 /* Output the main compilation unit if non-empty or if .debug_macinfo
30239 or .debug_macro will be emitted. */
30240 output_comp_unit (comp_unit_die (), have_macinfo
,
30241 dwarf_split_debug_info
? checksum
: NULL
);
30243 if (dwarf_split_debug_info
&& info_section_emitted
)
30244 output_skeleton_debug_sections (main_comp_unit_die
, checksum
);
30246 /* Output the abbreviation table. */
30247 if (vec_safe_length (abbrev_die_table
) != 1)
30249 switch_to_section (debug_abbrev_section
);
30250 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
30251 output_abbrev_section ();
30254 /* Output location list section if necessary. */
30255 if (have_location_lists
)
30257 char l1
[MAX_ARTIFICIAL_LABEL_BYTES
];
30258 char l2
[MAX_ARTIFICIAL_LABEL_BYTES
];
30259 /* Output the location lists info. */
30260 switch_to_section (debug_loc_section
);
30261 if (dwarf_version
>= 5)
30263 ASM_GENERATE_INTERNAL_LABEL (l1
, DEBUG_LOC_SECTION_LABEL
, 1);
30264 ASM_GENERATE_INTERNAL_LABEL (l2
, DEBUG_LOC_SECTION_LABEL
, 2);
30265 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
30266 dw2_asm_output_data (4, 0xffffffff,
30267 "Initial length escape value indicating "
30268 "64-bit DWARF extension");
30269 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
30270 "Length of Location Lists");
30271 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
30272 dw2_asm_output_data (2, dwarf_version
, "DWARF Version");
30273 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Address Size");
30274 dw2_asm_output_data (1, 0, "Segment Size");
30275 dw2_asm_output_data (4, dwarf_split_debug_info
? loc_list_idx
: 0,
30276 "Offset Entry Count");
30278 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
30279 if (dwarf_version
>= 5 && dwarf_split_debug_info
)
30281 unsigned int save_loc_list_idx
= loc_list_idx
;
30283 output_loclists_offsets (comp_unit_die ());
30284 gcc_assert (save_loc_list_idx
== loc_list_idx
);
30286 output_location_lists (comp_unit_die ());
30287 if (dwarf_version
>= 5)
30288 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
30291 output_pubtables ();
30293 /* Output the address range information if a CU (.debug_info section)
30294 was emitted. We output an empty table even if we had no functions
30295 to put in it. This because the consumer has no way to tell the
30296 difference between an empty table that we omitted and failure to
30297 generate a table that would have contained data. */
30298 if (info_section_emitted
)
30300 switch_to_section (debug_aranges_section
);
30304 /* Output ranges section if necessary. */
30305 if (!vec_safe_is_empty (ranges_table
))
30307 if (dwarf_version
>= 5)
30308 output_rnglists (generation
);
30313 /* Have to end the macro section. */
30316 switch_to_section (debug_macinfo_section
);
30317 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
30318 output_macinfo (!dwarf_split_debug_info
? debug_line_section_label
30319 : debug_skeleton_line_section_label
, false);
30320 dw2_asm_output_data (1, 0, "End compilation unit");
30323 /* Output the source line correspondence table. We must do this
30324 even if there is no line information. Otherwise, on an empty
30325 translation unit, we will generate a present, but empty,
30326 .debug_info section. IRIX 6.5 `nm' will then complain when
30327 examining the file. This is done late so that any filenames
30328 used by the debug_info section are marked as 'used'. */
30329 switch_to_section (debug_line_section
);
30330 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
30331 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
30332 output_line_info (false);
30334 if (dwarf_split_debug_info
&& info_section_emitted
)
30336 switch_to_section (debug_skeleton_line_section
);
30337 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
30338 output_line_info (true);
30341 /* If we emitted any indirect strings, output the string table too. */
30342 if (debug_str_hash
|| skeleton_debug_str_hash
)
30343 output_indirect_strings ();
30344 if (debug_line_str_hash
)
30346 switch_to_section (debug_line_str_section
);
30347 const enum dwarf_form form
= DW_FORM_line_strp
;
30348 debug_line_str_hash
->traverse
<enum dwarf_form
,
30349 output_indirect_string
> (form
);
30353 /* Returns a hash value for X (which really is a variable_value_struct). */
30356 variable_value_hasher::hash (variable_value_struct
*x
)
30358 return (hashval_t
) x
->decl_id
;
30361 /* Return nonzero if decl_id of variable_value_struct X is the same as
30365 variable_value_hasher::equal (variable_value_struct
*x
, tree y
)
30367 return x
->decl_id
== DECL_UID (y
);
30370 /* Helper function for resolve_variable_value, handle
30371 DW_OP_GNU_variable_value in one location expression.
30372 Return true if exprloc has been changed into loclist. */
30375 resolve_variable_value_in_expr (dw_attr_node
*a
, dw_loc_descr_ref loc
)
30377 dw_loc_descr_ref next
;
30378 for (dw_loc_descr_ref prev
= NULL
; loc
; prev
= loc
, loc
= next
)
30380 next
= loc
->dw_loc_next
;
30381 if (loc
->dw_loc_opc
!= DW_OP_GNU_variable_value
30382 || loc
->dw_loc_oprnd1
.val_class
!= dw_val_class_decl_ref
)
30385 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
30386 if (DECL_CONTEXT (decl
) != current_function_decl
)
30389 dw_die_ref ref
= lookup_decl_die (decl
);
30392 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30393 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30394 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30397 dw_loc_list_ref l
= loc_list_from_tree (decl
, 0, NULL
);
30400 if (l
->dw_loc_next
)
30402 if (AT_class (a
) != dw_val_class_loc
)
30404 switch (a
->dw_attr
)
30406 /* Following attributes allow both exprloc and loclist
30407 classes, so we can change them into a loclist. */
30408 case DW_AT_location
:
30409 case DW_AT_string_length
:
30410 case DW_AT_return_addr
:
30411 case DW_AT_data_member_location
:
30412 case DW_AT_frame_base
:
30413 case DW_AT_segment
:
30414 case DW_AT_static_link
:
30415 case DW_AT_use_location
:
30416 case DW_AT_vtable_elem_location
:
30419 prev
->dw_loc_next
= NULL
;
30420 prepend_loc_descr_to_each (l
, AT_loc (a
));
30423 add_loc_descr_to_each (l
, next
);
30424 a
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
30425 a
->dw_attr_val
.val_entry
= NULL
;
30426 a
->dw_attr_val
.v
.val_loc_list
= l
;
30427 have_location_lists
= true;
30429 /* Following attributes allow both exprloc and reference,
30430 so if the whole expression is DW_OP_GNU_variable_value alone
30431 we could transform it into reference. */
30432 case DW_AT_byte_size
:
30433 case DW_AT_bit_size
:
30434 case DW_AT_lower_bound
:
30435 case DW_AT_upper_bound
:
30436 case DW_AT_bit_stride
:
30438 case DW_AT_allocated
:
30439 case DW_AT_associated
:
30440 case DW_AT_byte_stride
:
30441 if (prev
== NULL
&& next
== NULL
)
30449 /* Create DW_TAG_variable that we can refer to. */
30450 gen_decl_die (decl
, NULL_TREE
, NULL
,
30451 lookup_decl_die (current_function_decl
));
30452 ref
= lookup_decl_die (decl
);
30455 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30456 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30457 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30463 prev
->dw_loc_next
= l
->expr
;
30464 add_loc_descr (&prev
->dw_loc_next
, next
);
30465 free_loc_descr (loc
, NULL
);
30466 next
= prev
->dw_loc_next
;
30470 memcpy (loc
, l
->expr
, sizeof (dw_loc_descr_node
));
30471 add_loc_descr (&loc
, next
);
30479 /* Attempt to resolve DW_OP_GNU_variable_value using loc_list_from_tree. */
30482 resolve_variable_value (dw_die_ref die
)
30485 dw_loc_list_ref loc
;
30488 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30489 switch (AT_class (a
))
30491 case dw_val_class_loc
:
30492 if (!resolve_variable_value_in_expr (a
, AT_loc (a
)))
30495 case dw_val_class_loc_list
:
30496 loc
= AT_loc_list (a
);
30498 for (; loc
; loc
= loc
->dw_loc_next
)
30499 resolve_variable_value_in_expr (a
, loc
->expr
);
30506 /* Attempt to optimize DW_OP_GNU_variable_value refering to
30507 temporaries in the current function. */
30510 resolve_variable_values (void)
30512 if (!variable_value_hash
|| !current_function_decl
)
30515 struct variable_value_struct
*node
30516 = variable_value_hash
->find_with_hash (current_function_decl
,
30517 DECL_UID (current_function_decl
));
30524 FOR_EACH_VEC_SAFE_ELT (node
->dies
, i
, die
)
30525 resolve_variable_value (die
);
30528 /* Helper function for note_variable_value, handle one location
30532 note_variable_value_in_expr (dw_die_ref die
, dw_loc_descr_ref loc
)
30534 for (; loc
; loc
= loc
->dw_loc_next
)
30535 if (loc
->dw_loc_opc
== DW_OP_GNU_variable_value
30536 && loc
->dw_loc_oprnd1
.val_class
== dw_val_class_decl_ref
)
30538 tree decl
= loc
->dw_loc_oprnd1
.v
.val_decl_ref
;
30539 dw_die_ref ref
= lookup_decl_die (decl
);
30540 if (! ref
&& (flag_generate_lto
|| flag_generate_offload
))
30542 /* ??? This is somewhat a hack because we do not create DIEs
30543 for variables not in BLOCK trees early but when generating
30544 early LTO output we need the dw_val_class_decl_ref to be
30545 fully resolved. For fat LTO objects we'd also like to
30546 undo this after LTO dwarf output. */
30547 gcc_assert (DECL_CONTEXT (decl
));
30548 dw_die_ref ctx
= lookup_decl_die (DECL_CONTEXT (decl
));
30549 gcc_assert (ctx
!= NULL
);
30550 gen_decl_die (decl
, NULL_TREE
, NULL
, ctx
);
30551 ref
= lookup_decl_die (decl
);
30552 gcc_assert (ref
!= NULL
);
30556 loc
->dw_loc_oprnd1
.val_class
= dw_val_class_die_ref
;
30557 loc
->dw_loc_oprnd1
.v
.val_die_ref
.die
= ref
;
30558 loc
->dw_loc_oprnd1
.v
.val_die_ref
.external
= 0;
30562 && DECL_CONTEXT (decl
)
30563 && TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
30564 && lookup_decl_die (DECL_CONTEXT (decl
)))
30566 if (!variable_value_hash
)
30567 variable_value_hash
30568 = hash_table
<variable_value_hasher
>::create_ggc (10);
30570 tree fndecl
= DECL_CONTEXT (decl
);
30571 struct variable_value_struct
*node
;
30572 struct variable_value_struct
**slot
30573 = variable_value_hash
->find_slot_with_hash (fndecl
,
30578 node
= ggc_cleared_alloc
<variable_value_struct
> ();
30579 node
->decl_id
= DECL_UID (fndecl
);
30585 vec_safe_push (node
->dies
, die
);
30590 /* Walk the tree DIE and note DIEs with DW_OP_GNU_variable_value still
30591 with dw_val_class_decl_ref operand. */
30594 note_variable_value (dw_die_ref die
)
30598 dw_loc_list_ref loc
;
30601 FOR_EACH_VEC_SAFE_ELT (die
->die_attr
, ix
, a
)
30602 switch (AT_class (a
))
30604 case dw_val_class_loc_list
:
30605 loc
= AT_loc_list (a
);
30607 if (!loc
->noted_variable_value
)
30609 loc
->noted_variable_value
= 1;
30610 for (; loc
; loc
= loc
->dw_loc_next
)
30611 note_variable_value_in_expr (die
, loc
->expr
);
30614 case dw_val_class_loc
:
30615 note_variable_value_in_expr (die
, AT_loc (a
));
30621 /* Mark children. */
30622 FOR_EACH_CHILD (die
, c
, note_variable_value (c
));
30625 /* Perform any cleanups needed after the early debug generation pass
30629 dwarf2out_early_finish (const char *filename
)
30633 /* PCH might result in DW_AT_producer string being restored from the
30634 header compilation, so always fill it with empty string initially
30635 and overwrite only here. */
30636 dw_attr_node
*producer
= get_AT (comp_unit_die (), DW_AT_producer
);
30637 producer_string
= gen_producer_string ();
30638 producer
->dw_attr_val
.v
.val_str
->refcount
--;
30639 producer
->dw_attr_val
.v
.val_str
= find_AT_string (producer_string
);
30641 /* Add the name for the main input file now. We delayed this from
30642 dwarf2out_init to avoid complications with PCH. */
30643 add_name_attribute (comp_unit_die (), remap_debug_filename (filename
));
30644 add_comp_dir_attribute (comp_unit_die ());
30646 /* When emitting DWARF5 .debug_line_str, move DW_AT_name and
30647 DW_AT_comp_dir into .debug_line_str section. */
30648 if (!DWARF2_ASM_LINE_DEBUG_INFO
30649 && dwarf_version
>= 5
30650 && DWARF5_USE_DEBUG_LINE_STR
)
30652 for (int i
= 0; i
< 2; i
++)
30654 dw_attr_node
*a
= get_AT (comp_unit_die (),
30655 i
? DW_AT_comp_dir
: DW_AT_name
);
30657 || AT_class (a
) != dw_val_class_str
30658 || strlen (AT_string (a
)) + 1 <= DWARF_OFFSET_SIZE
)
30661 if (! debug_line_str_hash
)
30662 debug_line_str_hash
30663 = hash_table
<indirect_string_hasher
>::create_ggc (10);
30665 struct indirect_string_node
*node
30666 = find_AT_string_in_table (AT_string (a
), debug_line_str_hash
);
30667 set_indirect_string (node
);
30668 node
->form
= DW_FORM_line_strp
;
30669 a
->dw_attr_val
.v
.val_str
->refcount
--;
30670 a
->dw_attr_val
.v
.val_str
= node
;
30674 /* With LTO early dwarf was really finished at compile-time, so make
30675 sure to adjust the phase after annotating the LTRANS CU DIE. */
30678 early_dwarf_finished
= true;
30682 /* Walk through the list of incomplete types again, trying once more to
30683 emit full debugging info for them. */
30684 retry_incomplete_types ();
30686 /* The point here is to flush out the limbo list so that it is empty
30687 and we don't need to stream it for LTO. */
30688 flush_limbo_die_list ();
30690 gen_scheduled_generic_parms_dies ();
30691 gen_remaining_tmpl_value_param_die_attribute ();
30693 /* Add DW_AT_linkage_name for all deferred DIEs. */
30694 for (limbo_die_node
*node
= deferred_asm_name
; node
; node
= node
->next
)
30696 tree decl
= node
->created_for
;
30697 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
30698 /* A missing DECL_ASSEMBLER_NAME can be a constant DIE that
30699 ended up in deferred_asm_name before we knew it was
30700 constant and never written to disk. */
30701 && DECL_ASSEMBLER_NAME (decl
))
30703 add_linkage_attr (node
->die
, decl
);
30704 move_linkage_attr (node
->die
);
30707 deferred_asm_name
= NULL
;
30709 if (flag_eliminate_unused_debug_types
)
30710 prune_unused_types ();
30712 /* Generate separate COMDAT sections for type DIEs. */
30713 if (use_debug_types
)
30715 break_out_comdat_types (comp_unit_die ());
30717 /* Each new type_unit DIE was added to the limbo die list when created.
30718 Since these have all been added to comdat_type_list, clear the
30720 limbo_die_list
= NULL
;
30722 /* For each new comdat type unit, copy declarations for incomplete
30723 types to make the new unit self-contained (i.e., no direct
30724 references to the main compile unit). */
30725 for (comdat_type_node
*ctnode
= comdat_type_list
;
30726 ctnode
!= NULL
; ctnode
= ctnode
->next
)
30727 copy_decls_for_unworthy_types (ctnode
->root_die
);
30728 copy_decls_for_unworthy_types (comp_unit_die ());
30730 /* In the process of copying declarations from one unit to another,
30731 we may have left some declarations behind that are no longer
30732 referenced. Prune them. */
30733 prune_unused_types ();
30736 /* Traverse the DIE's and note DIEs with DW_OP_GNU_variable_value still
30737 with dw_val_class_decl_ref operand. */
30738 note_variable_value (comp_unit_die ());
30739 for (limbo_die_node
*node
= cu_die_list
; node
; node
= node
->next
)
30740 note_variable_value (node
->die
);
30741 for (comdat_type_node
*ctnode
= comdat_type_list
; ctnode
!= NULL
;
30742 ctnode
= ctnode
->next
)
30743 note_variable_value (ctnode
->root_die
);
30744 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
30745 note_variable_value (node
->die
);
30747 /* The AT_pubnames attribute needs to go in all skeleton dies, including
30748 both the main_cu and all skeleton TUs. Making this call unconditional
30749 would end up either adding a second copy of the AT_pubnames attribute, or
30750 requiring a special case in add_top_level_skeleton_die_attrs. */
30751 if (!dwarf_split_debug_info
)
30752 add_AT_pubnames (comp_unit_die ());
30754 /* The early debug phase is now finished. */
30755 early_dwarf_finished
= true;
30757 /* Do not generate DWARF assembler now when not producing LTO bytecode. */
30758 if (!flag_generate_lto
&& !flag_generate_offload
)
30761 /* Now as we are going to output for LTO initialize sections and labels
30762 to the LTO variants. We don't need a random-seed postfix as other
30763 LTO sections as linking the LTO debug sections into one in a partial
30765 init_sections_and_labels (true);
30767 /* The output below is modeled after dwarf2out_finish with all
30768 location related output removed and some LTO specific changes.
30769 Some refactoring might make both smaller and easier to match up. */
30771 /* Traverse the DIE's and add add sibling attributes to those DIE's
30772 that have children. */
30773 add_sibling_attributes (comp_unit_die ());
30774 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
30775 add_sibling_attributes (node
->die
);
30776 for (comdat_type_node
*ctnode
= comdat_type_list
;
30777 ctnode
!= NULL
; ctnode
= ctnode
->next
)
30778 add_sibling_attributes (ctnode
->root_die
);
30781 add_AT_macptr (comp_unit_die (), DEBUG_MACRO_ATTRIBUTE
,
30782 macinfo_section_label
);
30784 save_macinfo_strings ();
30786 /* Output all of the compilation units. We put the main one last so that
30787 the offsets are available to output_pubnames. */
30788 for (limbo_die_node
*node
= limbo_die_list
; node
; node
= node
->next
)
30789 output_comp_unit (node
->die
, 0, NULL
);
30791 hash_table
<comdat_type_hasher
> comdat_type_table (100);
30792 for (comdat_type_node
*ctnode
= comdat_type_list
;
30793 ctnode
!= NULL
; ctnode
= ctnode
->next
)
30795 comdat_type_node
**slot
= comdat_type_table
.find_slot (ctnode
, INSERT
);
30797 /* Don't output duplicate types. */
30798 if (*slot
!= HTAB_EMPTY_ENTRY
)
30801 /* Add a pointer to the line table for the main compilation unit
30802 so that the debugger can make sense of DW_AT_decl_file
30804 if (debug_info_level
>= DINFO_LEVEL_TERSE
)
30805 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
30806 (!dwarf_split_debug_info
30807 ? debug_line_section_label
30808 : debug_skeleton_line_section_label
));
30810 output_comdat_type_unit (ctnode
);
30814 /* Stick a unique symbol to the main debuginfo section. */
30815 compute_comp_unit_symbol (comp_unit_die ());
30817 /* Output the main compilation unit. We always need it if only for
30819 output_comp_unit (comp_unit_die (), true, NULL
);
30821 /* Output the abbreviation table. */
30822 if (vec_safe_length (abbrev_die_table
) != 1)
30824 switch_to_section (debug_abbrev_section
);
30825 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
30826 output_abbrev_section ();
30829 /* Have to end the macro section. */
30832 /* We have to save macinfo state if we need to output it again
30833 for the FAT part of the object. */
30834 vec
<macinfo_entry
, va_gc
> *saved_macinfo_table
= macinfo_table
;
30835 if (flag_fat_lto_objects
)
30836 macinfo_table
= macinfo_table
->copy ();
30838 switch_to_section (debug_macinfo_section
);
30839 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
30840 output_macinfo (debug_skeleton_line_section_label
, true);
30841 dw2_asm_output_data (1, 0, "End compilation unit");
30843 /* Emit a skeleton debug_line section. */
30844 switch_to_section (debug_skeleton_line_section
);
30845 ASM_OUTPUT_LABEL (asm_out_file
, debug_skeleton_line_section_label
);
30846 output_line_info (true);
30848 if (flag_fat_lto_objects
)
30850 vec_free (macinfo_table
);
30851 macinfo_table
= saved_macinfo_table
;
30856 /* If we emitted any indirect strings, output the string table too. */
30857 if (debug_str_hash
|| skeleton_debug_str_hash
)
30858 output_indirect_strings ();
30860 /* Switch back to the text section. */
30861 switch_to_section (text_section
);
30864 /* Reset all state within dwarf2out.c so that we can rerun the compiler
30865 within the same process. For use by toplev::finalize. */
30868 dwarf2out_c_finalize (void)
30870 last_var_location_insn
= NULL
;
30871 cached_next_real_insn
= NULL
;
30872 used_rtx_array
= NULL
;
30873 incomplete_types
= NULL
;
30874 decl_scope_table
= NULL
;
30875 debug_info_section
= NULL
;
30876 debug_skeleton_info_section
= NULL
;
30877 debug_abbrev_section
= NULL
;
30878 debug_skeleton_abbrev_section
= NULL
;
30879 debug_aranges_section
= NULL
;
30880 debug_addr_section
= NULL
;
30881 debug_macinfo_section
= NULL
;
30882 debug_line_section
= NULL
;
30883 debug_skeleton_line_section
= NULL
;
30884 debug_loc_section
= NULL
;
30885 debug_pubnames_section
= NULL
;
30886 debug_pubtypes_section
= NULL
;
30887 debug_str_section
= NULL
;
30888 debug_line_str_section
= NULL
;
30889 debug_str_dwo_section
= NULL
;
30890 debug_str_offsets_section
= NULL
;
30891 debug_ranges_section
= NULL
;
30892 debug_frame_section
= NULL
;
30894 debug_str_hash
= NULL
;
30895 debug_line_str_hash
= NULL
;
30896 skeleton_debug_str_hash
= NULL
;
30897 dw2_string_counter
= 0;
30898 have_multiple_function_sections
= false;
30899 text_section_used
= false;
30900 cold_text_section_used
= false;
30901 cold_text_section
= NULL
;
30902 current_unit_personality
= NULL
;
30904 early_dwarf
= false;
30905 early_dwarf_finished
= false;
30907 next_die_offset
= 0;
30908 single_comp_unit_die
= NULL
;
30909 comdat_type_list
= NULL
;
30910 limbo_die_list
= NULL
;
30912 decl_die_table
= NULL
;
30913 common_block_die_table
= NULL
;
30914 decl_loc_table
= NULL
;
30915 call_arg_locations
= NULL
;
30916 call_arg_loc_last
= NULL
;
30917 call_site_count
= -1;
30918 tail_call_site_count
= -1;
30919 cached_dw_loc_list_table
= NULL
;
30920 abbrev_die_table
= NULL
;
30921 delete dwarf_proc_stack_usage_map
;
30922 dwarf_proc_stack_usage_map
= NULL
;
30923 line_info_label_num
= 0;
30924 cur_line_info_table
= NULL
;
30925 text_section_line_info
= NULL
;
30926 cold_text_section_line_info
= NULL
;
30927 separate_line_info
= NULL
;
30928 info_section_emitted
= false;
30929 pubname_table
= NULL
;
30930 pubtype_table
= NULL
;
30931 macinfo_table
= NULL
;
30932 ranges_table
= NULL
;
30933 ranges_by_label
= NULL
;
30935 have_location_lists
= false;
30938 last_emitted_file
= NULL
;
30940 tmpl_value_parm_die_table
= NULL
;
30941 generic_type_instances
= NULL
;
30942 frame_pointer_fb_offset
= 0;
30943 frame_pointer_fb_offset_valid
= false;
30944 base_types
.release ();
30945 XDELETEVEC (producer_string
);
30946 producer_string
= NULL
;
30949 #include "gt-dwarf2out.h"